[ARM] tegra: whistler: register scrollwheel
[linux-2.6.git] / arch / arm / mach-tegra / board-whistler.c
1 /*
2  * arch/arm/mach-tegra/board-whistler.c
3  *
4  * Copyright (c) 2010, NVIDIA Corporation.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
14  * more details.
15  *
16  * You should have received a copy of the GNU General Public License along
17  * with this program; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
19  */
20
21 #include <linux/kernel.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/ctype.h>
25 #include <linux/platform_device.h>
26 #include <linux/clk.h>
27 #include <linux/serial_8250.h>
28 #include <linux/i2c.h>
29 #include <linux/i2c/panjit_ts.h>
30 #include <linux/dma-mapping.h>
31 #include <linux/delay.h>
32 #include <linux/i2c-tegra.h>
33 #include <linux/gpio.h>
34 #include <linux/gpio_scrollwheel.h>
35 #include <linux/input.h>
36 #include <linux/memblock.h>
37
38 #include <mach/clk.h>
39 #include <mach/iomap.h>
40 #include <mach/irqs.h>
41 #include <mach/pinmux.h>
42 #include <mach/iomap.h>
43 #include <mach/io.h>
44
45 #include <asm/mach-types.h>
46 #include <asm/mach/arch.h>
47
48 #include "board.h"
49 #include "clock.h"
50 #include "board-whistler.h"
51 #include "devices.h"
52 #include "gpio-names.h"
53 #include "fuse.h"
54
55 static struct plat_serial8250_port debug_uart_platform_data[] = {
56         {
57                 .membase        = IO_ADDRESS(TEGRA_UARTA_BASE),
58                 .mapbase        = TEGRA_UARTA_BASE,
59                 .irq            = INT_UARTA,
60                 .flags          = UPF_BOOT_AUTOCONF,
61                 .iotype         = UPIO_MEM,
62                 .regshift       = 2,
63                 .uartclk        = 216000000,
64         }, {
65                 .flags          = 0,
66         }
67 };
68
69 static struct platform_device debug_uart = {
70         .name = "serial8250",
71         .id = PLAT8250_DEV_PLATFORM,
72         .dev = {
73                 .platform_data = debug_uart_platform_data,
74         },
75 };
76
77 static __initdata struct tegra_clk_init_table whistler_clk_init_table[] = {
78         /* name         parent          rate            enabled */
79         { "uarta",      "pll_p",        216000000,      true},
80         { "pwm",        "clk_32k",      32768,          false},
81         { "kbc",        "clk_32k",      32768,          true},
82         { NULL,         NULL,           0,              0},
83 };
84
85 static struct tegra_i2c_platform_data whistler_i2c1_platform_data = {
86         .adapter_nr     = 0,
87         .bus_count      = 1,
88         .bus_clk_rate   = { 400000, 0 },
89 };
90
91 static struct tegra_i2c_platform_data whistler_i2c2_platform_data = {
92         .adapter_nr     = 1,
93         .bus_count      = 1,
94         .bus_clk_rate   = { 400000, 0 },
95 };
96
97 static struct tegra_i2c_platform_data whistler_i2c3_platform_data = {
98         .adapter_nr     = 3,
99         .bus_count      = 1,
100         .bus_clk_rate   = { 400000, 0 },
101 };
102
103 static struct tegra_i2c_platform_data whistler_dvc_platform_data = {
104         .adapter_nr     = 4,
105         .bus_count      = 1,
106         .bus_clk_rate   = { 400000, 0 },
107         .is_dvc         = true,
108 };
109
110 static void whistler_i2c_init(void)
111 {
112         tegra_i2c_device1.dev.platform_data = &whistler_i2c1_platform_data;
113         tegra_i2c_device2.dev.platform_data = &whistler_i2c2_platform_data;
114         tegra_i2c_device3.dev.platform_data = &whistler_i2c3_platform_data;
115         tegra_i2c_device4.dev.platform_data = &whistler_dvc_platform_data;
116
117         platform_device_register(&tegra_i2c_device4);
118         platform_device_register(&tegra_i2c_device3);
119         platform_device_register(&tegra_i2c_device2);
120         platform_device_register(&tegra_i2c_device1);
121 }
122
123 #define GPIO_SCROLL(_pinaction, _gpio, _desc)   \
124 {       \
125         .pinaction = GPIO_SCROLLWHEEL_PIN_##_pinaction, \
126         .gpio = TEGRA_GPIO_##_gpio,     \
127         .desc = _desc,  \
128         .active_low = 1,        \
129         .debounce_interval = 2, \
130 }
131
132 static struct gpio_scrollwheel_button scroll_keys[] = {
133         [0] = GPIO_SCROLL(ONOFF, PR3, "sw_onoff"),
134         [1] = GPIO_SCROLL(PRESS, PQ5, "sw_press"),
135         [2] = GPIO_SCROLL(ROT1, PQ3, "sw_rot1"),
136         [3] = GPIO_SCROLL(ROT2, PQ4, "sw_rot2"),
137 };
138
139 static struct gpio_scrollwheel_platform_data whistler_scroll_platform_data = {
140         .buttons = scroll_keys,
141         .nbuttons = ARRAY_SIZE(scroll_keys),
142 };
143
144 static struct platform_device whistler_scroll_device = {
145         .name   = "alps-gpio-scrollwheel",
146         .id     = 0,
147         .dev    = {
148                 .platform_data  = &whistler_scroll_platform_data,
149         },
150 };
151
152 static struct platform_device *whistler_devices[] __initdata = {
153         &tegra_otg_device,
154         &debug_uart,
155         &pmu_device,
156         &tegra_udc_device,
157         &tegra_gart_device,
158         &tegra_wdt_device,
159         &tegra_avp_device,
160         &whistler_scroll_device,
161 };
162
163 static int __init whistler_scroll_init(void)
164 {
165         int i;
166         for (i = 0; i < ARRAY_SIZE(scroll_keys); i++)
167                 tegra_gpio_enable(scroll_keys[i].gpio);
168
169         return 0;
170 }
171
172 static void __init tegra_whistler_init(void)
173 {
174         char serial[20];
175
176         tegra_common_init();
177         tegra_clk_init_from_table(whistler_clk_init_table);
178         whistler_pinmux_init();
179
180         platform_add_devices(whistler_devices, ARRAY_SIZE(whistler_devices));
181
182         whistler_sdhci_init();
183         whistler_i2c_init();
184         whistler_regulator_init();
185         whistler_panel_init();
186         whistler_kbc_init();
187         whistler_scroll_init();
188 }
189
190 int __init tegra_whistler_protected_aperture_init(void)
191 {
192         tegra_protected_aperture_init(tegra_grhost_aperture);
193         return 0;
194 }
195
196 void __init tegra_whistler_reserve(void)
197 {
198         if (memblock_reserve(0x0, 4096) < 0)
199                 pr_warn("Cannot reserve first 4K of memory for safety\n");
200
201         tegra_reserve(SZ_128M, SZ_8M, SZ_16M);
202 }
203
204 MACHINE_START(WHISTLER, "whistler")
205         .boot_params    = 0x00000100,
206         .phys_io        = IO_APB_PHYS,
207         .io_pg_offst    = ((IO_APB_VIRT) >> 18) & 0xfffc,
208         .init_irq       = tegra_init_irq,
209         .init_machine   = tegra_whistler_init,
210         .map_io         = tegra_map_common_io,
211         .reserve        = tegra_whistler_reserve,
212         .timer          = &tegra_timer,
213 MACHINE_END