aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorArnd Bergmann <arnd@arndb.de>2016-09-02 12:30:29 -0400
committerArnd Bergmann <arnd@arndb.de>2016-09-02 12:30:29 -0400
commit55d421b40cbb2d8bec71a1b92671e48d2ee7ca98 (patch)
tree1e4bf817b30f105ff61a892a26440f5135c74f5b
parentf5b065693be584813e6233b6e6036080c39cd2b6 (diff)
parente92fc4f04a34a407f5ff8acaa13127c62b7bec07 (diff)
Merge tag 'omap-for-v4.8/legacy-signed' of git://git.kernel.org/pub/scm/linux/kernel/git/tmlind/linux-omap into next/cleanup
Merge "drop last omap3 board files for v4.8" from Tony Lindgren: Remove the last two legacy board-*.c files for omap3 for legacy booting for v4.8 to allow making mach-omap2 device tree only for v4.9. We've had Nokia N900 and omap3 LDP board-*.c files remaining while other omap3 devices have been device tree only for quite a while now. Also N900 and LDP have had device tree based booting working for years now, but few drivers for N900 were still only working in legacy only mode until recently. With the remaining issues out of the way, we discussed on the mailing lists that we're finally OK to remove the remaining board-*.c files. For the timing of this pull request, I wanted to wait until v4.8-rc1 is out to make sure the legacy booting still works fine after the merge window before doing it. And for v4.8, let's not touch any other platform data in case we still need to revert for some reason. This makes the revert just a question of adding back the legacy board-*.c files. Then if no issues, we can remove the unused remaining platform data later on for v4.9. * tag 'omap-for-v4.8/legacy-signed' of git://git.kernel.org/pub/scm/linux/kernel/git/tmlind/linux-omap: ARM: OMAP2+: Drop legacy board file for LDP ARM: OMAP2+: Drop legacy board file for n900
Diffstat
-rw-r--r--arch/arm/mach-omap2/Kconfig12
-rw-r--r--arch/arm/mach-omap2/Makefile4
-rw-r--r--arch/arm/mach-omap2/board-ldp.c430
-rw-r--r--arch/arm/mach-omap2/board-rx51-peripherals.c1312
-rw-r--r--arch/arm/mach-omap2/board-rx51-video.c67
-rw-r--r--arch/arm/mach-omap2/board-rx51.c141
-rw-r--r--arch/arm/mach-omap2/board-rx51.h11
7 files changed, 0 insertions, 1977 deletions
diff --git a/arch/arm/mach-omap2/Kconfig b/arch/arm/mach-omap2/Kconfig
index 5a0b380a8166..a9afeebd59f2 100644
--- a/arch/arm/mach-omap2/Kconfig
+++ b/arch/arm/mach-omap2/Kconfig
@@ -192,12 +192,6 @@ config MACH_OMAP2_TUSB6010
192 depends on ARCH_OMAP2 && SOC_OMAP2420 192 depends on ARCH_OMAP2 && SOC_OMAP2420
193 default y if MACH_NOKIA_N8X0 193 default y if MACH_NOKIA_N8X0
194 194
195config MACH_OMAP_LDP
196 bool "OMAP3 LDP board"
197 depends on ARCH_OMAP3
198 default y
199 select OMAP_PACKAGE_CBB
200
201config MACH_OMAP3517EVM 195config MACH_OMAP3517EVM
202 bool "OMAP3517/ AM3517 EVM board" 196 bool "OMAP3517/ AM3517 EVM board"
203 depends on ARCH_OMAP3 197 depends on ARCH_OMAP3
@@ -222,12 +216,6 @@ config MACH_NOKIA_N8X0
222 select MACH_NOKIA_N810 216 select MACH_NOKIA_N810
223 select MACH_NOKIA_N810_WIMAX 217 select MACH_NOKIA_N810_WIMAX
224 218
225config MACH_NOKIA_RX51
226 bool "Nokia N900 (RX-51) phone"
227 depends on ARCH_OMAP3
228 default y
229 select OMAP_PACKAGE_CBB
230
231config OMAP3_SDRC_AC_TIMING 219config OMAP3_SDRC_AC_TIMING
232 bool "Enable SDRC AC timing register changes" 220 bool "Enable SDRC AC timing register changes"
233 depends on ARCH_OMAP3 221 depends on ARCH_OMAP3
diff --git a/arch/arm/mach-omap2/Makefile b/arch/arm/mach-omap2/Makefile
index a7f2d051f524..5b37ec29996e 100644
--- a/arch/arm/mach-omap2/Makefile
+++ b/arch/arm/mach-omap2/Makefile
@@ -231,11 +231,7 @@ obj-$(CONFIG_SOC_OMAP2420) += msdi.o
231 231
232# Specific board support 232# Specific board support
233obj-$(CONFIG_MACH_OMAP_GENERIC) += board-generic.o pdata-quirks.o 233obj-$(CONFIG_MACH_OMAP_GENERIC) += board-generic.o pdata-quirks.o
234obj-$(CONFIG_MACH_OMAP_LDP) += board-ldp.o
235obj-$(CONFIG_MACH_NOKIA_N8X0) += board-n8x0.o 234obj-$(CONFIG_MACH_NOKIA_N8X0) += board-n8x0.o
236obj-$(CONFIG_MACH_NOKIA_RX51) += board-rx51.o sdram-nokia.o
237obj-$(CONFIG_MACH_NOKIA_RX51) += board-rx51-peripherals.o
238obj-$(CONFIG_MACH_NOKIA_RX51) += board-rx51-video.o
239 235
240# Platform specific device init code 236# Platform specific device init code
241 237
diff --git a/arch/arm/mach-omap2/board-ldp.c b/arch/arm/mach-omap2/board-ldp.c
deleted file mode 100644
index 390795b334c3..000000000000
--- a/arch/arm/mach-omap2/board-ldp.c
+++ /dev/null
@@ -1,430 +0,0 @@
1/*
2 * linux/arch/arm/mach-omap2/board-ldp.c
3 *
4 * Copyright (C) 2008 Texas Instruments Inc.
5 * Nishant Kamat <nskamat@ti.com>
6 *
7 * Modified from mach-omap2/board-3430sdp.c
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 */
13#include <linux/gpio.h>
14#include <linux/kernel.h>
15#include <linux/init.h>
16#include <linux/platform_device.h>
17#include <linux/delay.h>
18#include <linux/input.h>
19#include <linux/input/matrix_keypad.h>
20#include <linux/gpio_keys.h>
21#include <linux/workqueue.h>
22#include <linux/err.h>
23#include <linux/clk.h>
24#include <linux/spi/spi.h>
25#include <linux/regulator/fixed.h>
26#include <linux/regulator/machine.h>
27#include <linux/i2c/twl.h>
28#include <linux/io.h>
29#include <linux/smsc911x.h>
30#include <linux/mmc/host.h>
31#include <linux/usb/phy.h>
32#include <linux/platform_data/spi-omap2-mcspi.h>
33
34#include <asm/mach-types.h>
35#include <asm/mach/arch.h>
36#include <asm/mach/map.h>
37
38#include "common.h"
39#include "gpmc.h"
40#include "gpmc-smsc911x.h"
41
42#include <linux/platform_data/omapdss.h>
43#include <video/omap-panel-data.h>
44
45#include "board-flash.h"
46#include "mux.h"
47#include "hsmmc.h"
48#include "control.h"
49#include "common-board-devices.h"
50#include "display.h"
51
52#define LDP_SMSC911X_CS 1
53#define LDP_SMSC911X_GPIO 152
54#define DEBUG_BASE 0x08000000
55#define LDP_ETHR_START DEBUG_BASE
56
57static uint32_t board_keymap[] = {
58 KEY(0, 0, KEY_1),
59 KEY(1, 0, KEY_2),
60 KEY(2, 0, KEY_3),
61 KEY(0, 1, KEY_4),
62 KEY(1, 1, KEY_5),
63 KEY(2, 1, KEY_6),
64 KEY(3, 1, KEY_F5),
65 KEY(0, 2, KEY_7),
66 KEY(1, 2, KEY_8),
67 KEY(2, 2, KEY_9),
68 KEY(3, 2, KEY_F6),
69 KEY(0, 3, KEY_F7),
70 KEY(1, 3, KEY_0),
71 KEY(2, 3, KEY_F8),
72 PERSISTENT_KEY(4, 5),
73 KEY(4, 4, KEY_VOLUMEUP),
74 KEY(5, 5, KEY_VOLUMEDOWN),
75 0
76};
77
78static struct matrix_keymap_data board_map_data = {
79 .keymap = board_keymap,
80 .keymap_size = ARRAY_SIZE(board_keymap),
81};
82
83static struct twl4030_keypad_data ldp_kp_twl4030_data = {
84 .keymap_data = &board_map_data,
85 .rows = 6,
86 .cols = 6,
87 .rep = 1,
88};
89
90static struct gpio_keys_button ldp_gpio_keys_buttons[] = {
91 [0] = {
92 .code = KEY_ENTER,
93 .gpio = 101,
94 .desc = "enter sw",
95 .active_low = 1,
96 .debounce_interval = 30,
97 },
98 [1] = {
99 .code = KEY_F1,
100 .gpio = 102,
101 .desc = "func 1",
102 .active_low = 1,
103 .debounce_interval = 30,
104 },
105 [2] = {
106 .code = KEY_F2,
107 .gpio = 103,
108 .desc = "func 2",
109 .active_low = 1,
110 .debounce_interval = 30,
111 },
112 [3] = {
113 .code = KEY_F3,
114 .gpio = 104,
115 .desc = "func 3",
116 .active_low = 1,
117 .debounce_interval = 30,
118 },
119 [4] = {
120 .code = KEY_F4,
121 .gpio = 105,
122 .desc = "func 4",
123 .active_low = 1,
124 .debounce_interval = 30,
125 },
126 [5] = {
127 .code = KEY_LEFT,
128 .gpio = 106,
129 .desc = "left sw",
130 .active_low = 1,
131 .debounce_interval = 30,
132 },
133 [6] = {
134 .code = KEY_RIGHT,
135 .gpio = 107,
136 .desc = "right sw",
137 .active_low = 1,
138 .debounce_interval = 30,
139 },
140 [7] = {
141 .code = KEY_UP,
142 .gpio = 108,
143 .desc = "up sw",
144 .active_low = 1,
145 .debounce_interval = 30,
146 },
147 [8] = {
148 .code = KEY_DOWN,
149 .gpio = 109,
150 .desc = "down sw",
151 .active_low = 1,
152 .debounce_interval = 30,
153 },
154};
155
156static struct gpio_keys_platform_data ldp_gpio_keys = {
157 .buttons = ldp_gpio_keys_buttons,
158 .nbuttons = ARRAY_SIZE(ldp_gpio_keys_buttons),
159 .rep = 1,
160};
161
162static struct platform_device ldp_gpio_keys_device = {
163 .name = "gpio-keys",
164 .id = -1,
165 .dev = {
166 .platform_data = &ldp_gpio_keys,
167 },
168};
169
170static struct omap_smsc911x_platform_data smsc911x_cfg = {
171 .cs = LDP_SMSC911X_CS,
172 .gpio_irq = LDP_SMSC911X_GPIO,
173 .gpio_reset = -EINVAL,
174 .flags = SMSC911X_USE_32BIT,
175};
176
177static inline void __init ldp_init_smsc911x(void)
178{
179 gpmc_smsc911x_init(&smsc911x_cfg);
180}
181
182/* LCD */
183
184#define LCD_PANEL_RESET_GPIO 55
185#define LCD_PANEL_QVGA_GPIO 56
186
187static const struct display_timing ldp_lcd_videomode = {
188 .pixelclock = { 0, 5400000, 0 },
189
190 .hactive = { 0, 240, 0 },
191 .hfront_porch = { 0, 3, 0 },
192 .hback_porch = { 0, 39, 0 },
193 .hsync_len = { 0, 3, 0 },
194
195 .vactive = { 0, 320, 0 },
196 .vfront_porch = { 0, 2, 0 },
197 .vback_porch = { 0, 7, 0 },
198 .vsync_len = { 0, 1, 0 },
199
200 .flags = DISPLAY_FLAGS_HSYNC_LOW | DISPLAY_FLAGS_VSYNC_LOW |
201 DISPLAY_FLAGS_DE_HIGH | DISPLAY_FLAGS_PIXDATA_POSEDGE,
202};
203
204static struct panel_dpi_platform_data ldp_lcd_pdata = {
205 .name = "lcd",
206 .source = "dpi.0",
207
208 .data_lines = 18,
209
210 .display_timing = &ldp_lcd_videomode,
211
212 .enable_gpio = -1, /* filled in code */
213 .backlight_gpio = -1, /* filled in code */
214};
215
216static struct platform_device ldp_lcd_device = {
217 .name = "panel-dpi",
218 .id = 0,
219 .dev.platform_data = &ldp_lcd_pdata,
220};
221
222static struct omap_dss_board_info ldp_dss_data = {
223 .default_display_name = "lcd",
224};
225
226static void __init ldp_display_init(void)
227{
228 int r;
229
230 static struct gpio gpios[] __initdata = {
231 {LCD_PANEL_RESET_GPIO, GPIOF_OUT_INIT_HIGH, "LCD RESET"},
232 {LCD_PANEL_QVGA_GPIO, GPIOF_OUT_INIT_HIGH, "LCD QVGA"},
233 };
234
235 r = gpio_request_array(gpios, ARRAY_SIZE(gpios));
236 if (r) {
237 pr_err("Cannot request LCD GPIOs, error %d\n", r);
238 return;
239 }
240
241 omap_display_init(&ldp_dss_data);
242}
243
244static int ldp_twl_gpio_setup(struct device *dev, unsigned gpio, unsigned ngpio)
245{
246 int res;
247
248 /* LCD enable GPIO */
249 ldp_lcd_pdata.enable_gpio = gpio + 7;
250
251 /* Backlight enable GPIO */
252 ldp_lcd_pdata.backlight_gpio = gpio + 15;
253
254 res = platform_device_register(&ldp_lcd_device);
255 if (res)
256 pr_err("Unable to register LCD: %d\n", res);
257
258 return 0;
259}
260
261static struct twl4030_gpio_platform_data ldp_gpio_data = {
262 .setup = ldp_twl_gpio_setup,
263};
264
265static struct regulator_consumer_supply ldp_vmmc1_supply[] = {
266 REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
267};
268
269/* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
270static struct regulator_init_data ldp_vmmc1 = {
271 .constraints = {
272 .min_uV = 1850000,
273 .max_uV = 3150000,
274 .valid_modes_mask = REGULATOR_MODE_NORMAL
275 | REGULATOR_MODE_STANDBY,
276 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
277 | REGULATOR_CHANGE_MODE
278 | REGULATOR_CHANGE_STATUS,
279 },
280 .num_consumer_supplies = ARRAY_SIZE(ldp_vmmc1_supply),
281 .consumer_supplies = ldp_vmmc1_supply,
282};
283
284/* ads7846 on SPI */
285static struct regulator_consumer_supply ldp_vaux1_supplies[] = {
286 REGULATOR_SUPPLY("vcc", "spi1.0"),
287};
288
289/* VAUX1 */
290static struct regulator_init_data ldp_vaux1 = {
291 .constraints = {
292 .min_uV = 3000000,
293 .max_uV = 3000000,
294 .apply_uV = true,
295 .valid_modes_mask = REGULATOR_MODE_NORMAL
296 | REGULATOR_MODE_STANDBY,
297 .valid_ops_mask = REGULATOR_CHANGE_MODE
298 | REGULATOR_CHANGE_STATUS,
299 },
300 .num_consumer_supplies = ARRAY_SIZE(ldp_vaux1_supplies),
301 .consumer_supplies = ldp_vaux1_supplies,
302};
303
304static struct regulator_consumer_supply ldp_vpll2_supplies[] = {
305 REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
306 REGULATOR_SUPPLY("vdds_dsi", "omapdss_dpi.0"),
307 REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.0"),
308};
309
310static struct regulator_init_data ldp_vpll2 = {
311 .constraints = {
312 .name = "VDVI",
313 .min_uV = 1800000,
314 .max_uV = 1800000,
315 .apply_uV = true,
316 .valid_modes_mask = REGULATOR_MODE_NORMAL
317 | REGULATOR_MODE_STANDBY,
318 .valid_ops_mask = REGULATOR_CHANGE_MODE
319 | REGULATOR_CHANGE_STATUS,
320 },
321 .num_consumer_supplies = ARRAY_SIZE(ldp_vpll2_supplies),
322 .consumer_supplies = ldp_vpll2_supplies,
323};
324
325static struct twl4030_platform_data ldp_twldata = {
326 /* platform_data for children goes here */
327 .vmmc1 = &ldp_vmmc1,
328 .vaux1 = &ldp_vaux1,
329 .vpll2 = &ldp_vpll2,
330 .gpio = &ldp_gpio_data,
331 .keypad = &ldp_kp_twl4030_data,
332};
333
334static int __init omap_i2c_init(void)
335{
336 omap3_pmic_get_config(&ldp_twldata,
337 TWL_COMMON_PDATA_USB | TWL_COMMON_PDATA_MADC, 0);
338 omap3_pmic_init("twl4030", &ldp_twldata);
339 omap_register_i2c_bus(2, 400, NULL, 0);
340 omap_register_i2c_bus(3, 400, NULL, 0);
341 return 0;
342}
343
344static struct omap2_hsmmc_info mmc[] __initdata = {
345 {
346 .mmc = 1,
347 .caps = MMC_CAP_4_BIT_DATA,
348 .gpio_cd = -EINVAL,
349 .gpio_wp = -EINVAL,
350 },
351 {} /* Terminator */
352};
353
354static struct platform_device *ldp_devices[] __initdata = {
355 &ldp_gpio_keys_device,
356};
357
358#ifdef CONFIG_OMAP_MUX
359static struct omap_board_mux board_mux[] __initdata = {
360 { .reg_offset = OMAP_MUX_TERMINATOR },
361};
362#endif
363
364static struct mtd_partition ldp_nand_partitions[] = {
365 /* All the partition sizes are listed in terms of NAND block size */
366 {
367 .name = "X-Loader-NAND",
368 .offset = 0,
369 .size = 4 * (64 * 2048), /* 512KB, 0x80000 */
370 .mask_flags = MTD_WRITEABLE, /* force read-only */
371 },
372 {
373 .name = "U-Boot-NAND",
374 .offset = MTDPART_OFS_APPEND, /* Offset = 0x80000 */
375 .size = 10 * (64 * 2048), /* 1.25MB, 0x140000 */
376 .mask_flags = MTD_WRITEABLE, /* force read-only */
377 },
378 {
379 .name = "Boot Env-NAND",
380 .offset = MTDPART_OFS_APPEND, /* Offset = 0x1c0000 */
381 .size = 2 * (64 * 2048), /* 256KB, 0x40000 */
382 },
383 {
384 .name = "Kernel-NAND",
385 .offset = MTDPART_OFS_APPEND, /* Offset = 0x0200000*/
386 .size = 240 * (64 * 2048), /* 30M, 0x1E00000 */
387 },
388 {
389 .name = "File System - NAND",
390 .offset = MTDPART_OFS_APPEND, /* Offset = 0x2000000 */
391 .size = MTDPART_SIZ_FULL, /* 96MB, 0x6000000 */
392 },
393
394};
395
396static struct regulator_consumer_supply dummy_supplies[] = {
397 REGULATOR_SUPPLY("vddvario", "smsc911x.0"),
398 REGULATOR_SUPPLY("vdd33a", "smsc911x.0"),
399};
400
401static void __init omap_ldp_init(void)
402{
403 regulator_register_fixed(0, dummy_supplies, ARRAY_SIZE(dummy_supplies));
404 omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
405 ldp_init_smsc911x();
406 omap_i2c_init();
407 platform_add_devices(ldp_devices, ARRAY_SIZE(ldp_devices));
408 omap_ads7846_init(1, 54, 310, NULL);
409 omap_serial_init();
410 omap_sdrc_init(NULL, NULL);
411 usb_bind_phy("musb-hdrc.0.auto", 0, "twl4030_usb");
412 usb_musb_init(NULL);
413 board_nand_init(ldp_nand_partitions, ARRAY_SIZE(ldp_nand_partitions),
414 0, 0, nand_default_timings);
415
416 omap_hsmmc_init(mmc);
417 ldp_display_init();
418}
419
420MACHINE_START(OMAP_LDP, "OMAP LDP board")
421 .atag_offset = 0x100,
422 .reserve = omap_reserve,
423 .map_io = omap3_map_io,
424 .init_early = omap3430_init_early,
425 .init_irq = omap3_init_irq,
426 .init_machine = omap_ldp_init,
427 .init_late = omap3430_init_late,
428 .init_time = omap_init_time,
429 .restart = omap3xxx_restart,
430MACHINE_END
diff --git a/arch/arm/mach-omap2/board-rx51-peripherals.c b/arch/arm/mach-omap2/board-rx51-peripherals.c
deleted file mode 100644
index a5ab712c1a59..000000000000
--- a/arch/arm/mach-omap2/board-rx51-peripherals.c
+++ /dev/null
@@ -1,1312 +0,0 @@
1/*
2 * linux/arch/arm/mach-omap2/board-rx51-peripherals.c
3 *
4 * Copyright (C) 2008-2009 Nokia
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 version 2 as
8 * published by the Free Software Foundation.
9 */
10
11#include <linux/kernel.h>
12#include <linux/init.h>
13#include <linux/platform_device.h>
14#include <linux/input.h>
15#include <linux/input/matrix_keypad.h>
16#include <linux/spi/spi.h>
17#include <linux/wl12xx.h>
18#include <linux/spi/tsc2005.h>
19#include <linux/i2c.h>
20#include <linux/i2c/twl.h>
21#include <linux/clk.h>
22#include <linux/delay.h>
23#include <linux/regulator/machine.h>
24#include <linux/gpio.h>
25#include <linux/gpio_keys.h>
26#include <linux/gpio/machine.h>
27#include <linux/omap-gpmc.h>
28#include <linux/mmc/host.h>
29#include <linux/power/isp1704_charger.h>
30#include <linux/platform_data/spi-omap2-mcspi.h>
31#include <linux/platform_data/mtd-onenand-omap2.h>
32
33#include <plat/dmtimer.h>
34
35#include <asm/system_info.h>
36
37#include "common.h"
38#include <linux/omap-dma.h>
39
40#include "board-rx51.h"
41
42#include <sound/tlv320aic3x.h>
43#include <sound/tpa6130a2-plat.h>
44#include <linux/platform_data/media/si4713.h>
45#include <linux/platform_data/leds-lp55xx.h>
46
47#include <linux/platform_data/tsl2563.h>
48#include <linux/lis3lv02d.h>
49
50#include <video/omap-panel-data.h>
51
52#include <linux/platform_data/pwm_omap_dmtimer.h>
53#include <linux/platform_data/media/ir-rx51.h>
54
55#include "mux.h"
56#include "omap-pm.h"
57#include "hsmmc.h"
58#include "common-board-devices.h"
59#include "soc.h"
60#include "omap-secure.h"
61
62#define SYSTEM_REV_B_USES_VAUX3 0x1699
63#define SYSTEM_REV_S_USES_VAUX3 0x8
64
65#define RX51_WL1251_POWER_GPIO 87
66#define RX51_WL1251_IRQ_GPIO 42
67#define RX51_FMTX_RESET_GPIO 163
68#define RX51_FMTX_IRQ 53
69#define RX51_LP5523_CHIP_EN_GPIO 41
70
71#define RX51_USB_TRANSCEIVER_RST_GPIO 67
72
73#define RX51_TSC2005_RESET_GPIO 104
74#define RX51_TSC2005_IRQ_GPIO 100
75
76#define LIS302_IRQ1_GPIO 181
77#define LIS302_IRQ2_GPIO 180 /* Not yet in use */
78
79/* List all SPI devices here. Note that the list/probe order seems to matter! */
80enum {
81 RX51_SPI_WL1251,
82 RX51_SPI_TSC2005, /* Touch Controller */
83 RX51_SPI_MIPID, /* LCD panel */
84};
85
86static struct wl1251_platform_data wl1251_pdata;
87static struct tsc2005_platform_data tsc2005_pdata;
88
89#if defined(CONFIG_SENSORS_LIS3_I2C) || defined(CONFIG_SENSORS_LIS3_I2C_MODULE)
90static int lis302_setup(void)
91{
92 int err;
93 int irq1 = LIS302_IRQ1_GPIO;
94 int irq2 = LIS302_IRQ2_GPIO;
95
96 /* gpio for interrupt pin 1 */
97 err = gpio_request(irq1, "lis3lv02dl_irq1");
98 if (err) {
99 printk(KERN_ERR "lis3lv02dl: gpio request failed\n");
100 goto out;
101 }
102
103 /* gpio for interrupt pin 2 */
104 err = gpio_request(irq2, "lis3lv02dl_irq2");
105 if (err) {
106 gpio_free(irq1);
107 printk(KERN_ERR "lis3lv02dl: gpio request failed\n");
108 goto out;
109 }
110
111 gpio_direction_input(irq1);
112 gpio_direction_input(irq2);
113
114out:
115 return err;
116}
117
118static int lis302_release(void)
119{
120 gpio_free(LIS302_IRQ1_GPIO);
121 gpio_free(LIS302_IRQ2_GPIO);
122
123 return 0;
124}
125
126static struct lis3lv02d_platform_data rx51_lis3lv02d_data = {
127 .click_flags = LIS3_CLICK_SINGLE_X | LIS3_CLICK_SINGLE_Y |
128 LIS3_CLICK_SINGLE_Z,
129 /* Limits are 0.5g * value */
130 .click_thresh_x = 8,
131 .click_thresh_y = 8,
132 .click_thresh_z = 10,
133 /* Click must be longer than time limit */
134 .click_time_limit = 9,
135 /* Kind of debounce filter */
136 .click_latency = 50,
137
138 /* Limits for all axis. millig-value / 18 to get HW values */
139 .wakeup_flags = LIS3_WAKEUP_X_HI | LIS3_WAKEUP_Y_HI,
140 .wakeup_thresh = 800 / 18,
141 .wakeup_flags2 = LIS3_WAKEUP_Z_HI ,
142 .wakeup_thresh2 = 900 / 18,
143
144 .hipass_ctrl = LIS3_HIPASS1_DISABLE | LIS3_HIPASS2_DISABLE,
145
146 /* Interrupt line 2 for click detection, line 1 for thresholds */
147 .irq_cfg = LIS3_IRQ2_CLICK | LIS3_IRQ1_FF_WU_12,
148
149 .axis_x = LIS3_DEV_X,
150 .axis_y = LIS3_INV_DEV_Y,
151 .axis_z = LIS3_INV_DEV_Z,
152 .setup_resources = lis302_setup,
153 .release_resources = lis302_release,
154 .st_min_limits = {-32, 3, 3},
155 .st_max_limits = {-3, 32, 32},
156};
157#endif
158
159#if defined(CONFIG_SENSORS_TSL2563) || defined(CONFIG_SENSORS_TSL2563_MODULE)
160static struct tsl2563_platform_data rx51_tsl2563_platform_data = {
161 .cover_comp_gain = 16,
162};
163#endif
164
165#if defined(CONFIG_LEDS_LP5523) || defined(CONFIG_LEDS_LP5523_MODULE)
166static struct lp55xx_led_config rx51_lp5523_led_config[] = {
167 {
168 .name = "lp5523:kb1",
169 .chan_nr = 0,
170 .led_current = 50,
171 .max_current = 100,
172 }, {
173 .name = "lp5523:kb2",
174 .chan_nr = 1,
175 .led_current = 50,
176 .max_current = 100,
177 }, {
178 .name = "lp5523:kb3",
179 .chan_nr = 2,
180 .led_current = 50,
181 .max_current = 100,
182 }, {
183 .name = "lp5523:kb4",
184 .chan_nr = 3,
185 .led_current = 50,
186 .max_current = 100,
187 }, {
188 .name = "lp5523:b",
189 .chan_nr = 4,
190 .led_current = 50,
191 .max_current = 100,
192 }, {
193 .name = "lp5523:g",
194 .chan_nr = 5,
195 .led_current = 50,
196 .max_current = 100,
197 }, {
198 .name = "lp5523:r",
199 .chan_nr = 6,
200 .led_current = 50,
201 .max_current = 100,
202 }, {
203 .name = "lp5523:kb5",
204 .chan_nr = 7,
205 .led_current = 50,
206 .max_current = 100,
207 }, {
208 .name = "lp5523:kb6",
209 .chan_nr = 8,
210 .led_current = 50,
211 .max_current = 100,
212 }
213};
214
215static struct lp55xx_platform_data rx51_lp5523_platform_data = {
216 .led_config = rx51_lp5523_led_config,
217 .num_channels = ARRAY_SIZE(rx51_lp5523_led_config),
218 .clock_mode = LP55XX_CLOCK_AUTO,
219 .enable_gpio = RX51_LP5523_CHIP_EN_GPIO,
220};
221#endif
222
223#define RX51_LCD_RESET_GPIO 90
224
225static struct panel_acx565akm_platform_data acx_pdata = {
226 .name = "lcd",
227 .source = "sdi.0",
228 .reset_gpio = RX51_LCD_RESET_GPIO,
229 .datapairs = 2,
230};
231
232static struct omap2_mcspi_device_config wl1251_mcspi_config = {
233 .turbo_mode = 0,
234};
235
236static struct omap2_mcspi_device_config mipid_mcspi_config = {
237 .turbo_mode = 0,
238};
239
240static struct omap2_mcspi_device_config tsc2005_mcspi_config = {
241 .turbo_mode = 0,
242};
243
244static struct spi_board_info rx51_peripherals_spi_board_info[] __initdata = {
245 [RX51_SPI_WL1251] = {
246 .modalias = "wl1251",
247 .bus_num = 4,
248 .chip_select = 0,
249 .max_speed_hz = 48000000,
250 .mode = SPI_MODE_3,
251 .controller_data = &wl1251_mcspi_config,
252 .platform_data = &wl1251_pdata,
253 },
254 [RX51_SPI_MIPID] = {
255 .modalias = "acx565akm",
256 .bus_num = 1,
257 .chip_select = 2,
258 .max_speed_hz = 6000000,
259 .controller_data = &mipid_mcspi_config,
260 .platform_data = &acx_pdata,
261 },
262 [RX51_SPI_TSC2005] = {
263 .modalias = "tsc2005",
264 .bus_num = 1,
265 .chip_select = 0,
266 .max_speed_hz = 6000000,
267 .controller_data = &tsc2005_mcspi_config,
268 .platform_data = &tsc2005_pdata,
269 },
270};
271
272static struct platform_device rx51_battery_device = {
273 .name = "rx51-battery",
274 .id = -1,
275};
276
277static void rx51_charger_set_power(bool on)
278{
279 gpio_set_value(RX51_USB_TRANSCEIVER_RST_GPIO, on);
280}
281
282static struct isp1704_charger_data rx51_charger_data = {
283 .set_power = rx51_charger_set_power,
284};
285
286static struct platform_device rx51_charger_device = {
287 .name = "isp1704_charger",
288 .dev = {
289 .platform_data = &rx51_charger_data,
290 },
291};
292
293static void __init rx51_charger_init(void)
294{
295 WARN_ON(gpio_request_one(RX51_USB_TRANSCEIVER_RST_GPIO,
296 GPIOF_OUT_INIT_HIGH, "isp1704_reset"));
297
298 platform_device_register(&rx51_battery_device);
299 platform_device_register(&rx51_charger_device);
300}
301
302#if defined(CONFIG_KEYBOARD_GPIO) || defined(CONFIG_KEYBOARD_GPIO_MODULE)
303
304#define RX51_GPIO_CAMERA_LENS_COVER 110
305#define RX51_GPIO_CAMERA_FOCUS 68
306#define RX51_GPIO_CAMERA_CAPTURE 69
307#define RX51_GPIO_KEYPAD_SLIDE 71
308#define RX51_GPIO_LOCK_BUTTON 113
309#define RX51_GPIO_PROXIMITY 89
310
311#define RX51_GPIO_DEBOUNCE_TIMEOUT 10
312
313static struct gpio_keys_button rx51_gpio_keys[] = {
314 {
315 .desc = "Camera Lens Cover",
316 .type = EV_SW,
317 .code = SW_CAMERA_LENS_COVER,
318 .gpio = RX51_GPIO_CAMERA_LENS_COVER,
319 .active_low = 1,
320 .debounce_interval = RX51_GPIO_DEBOUNCE_TIMEOUT,
321 }, {
322 .desc = "Camera Focus",
323 .type = EV_KEY,
324 .code = KEY_CAMERA_FOCUS,
325 .gpio = RX51_GPIO_CAMERA_FOCUS,
326 .active_low = 1,
327 .debounce_interval = RX51_GPIO_DEBOUNCE_TIMEOUT,
328 }, {
329 .desc = "Camera Capture",
330 .type = EV_KEY,
331 .code = KEY_CAMERA,
332 .gpio = RX51_GPIO_CAMERA_CAPTURE,
333 .active_low = 1,
334 .debounce_interval = RX51_GPIO_DEBOUNCE_TIMEOUT,
335 }, {
336 .desc = "Lock Button",
337 .type = EV_KEY,
338 .code = KEY_SCREENLOCK,
339 .gpio = RX51_GPIO_LOCK_BUTTON,
340 .active_low = 1,
341 .debounce_interval = RX51_GPIO_DEBOUNCE_TIMEOUT,
342 }, {
343 .desc = "Keypad Slide",
344 .type = EV_SW,
345 .code = SW_KEYPAD_SLIDE,
346 .gpio = RX51_GPIO_KEYPAD_SLIDE,
347 .active_low = 1,
348 .debounce_interval = RX51_GPIO_DEBOUNCE_TIMEOUT,
349 }, {
350 .desc = "Proximity Sensor",
351 .type = EV_SW,
352 .code = SW_FRONT_PROXIMITY,
353 .gpio = RX51_GPIO_PROXIMITY,
354 .active_low = 0,
355 .debounce_interval = RX51_GPIO_DEBOUNCE_TIMEOUT,
356 }
357};
358
359static struct gpio_keys_platform_data rx51_gpio_keys_data = {
360 .buttons = rx51_gpio_keys,
361 .nbuttons = ARRAY_SIZE(rx51_gpio_keys),
362};
363
364static struct platform_device rx51_gpio_keys_device = {
365 .name = "gpio-keys",
366 .id = -1,
367 .dev = {
368 .platform_data = &rx51_gpio_keys_data,
369 },
370};
371
372static void __init rx51_add_gpio_keys(void)
373{
374 platform_device_register(&rx51_gpio_keys_device);
375}
376#else
377static void __init rx51_add_gpio_keys(void)
378{
379}
380#endif /* CONFIG_KEYBOARD_GPIO || CONFIG_KEYBOARD_GPIO_MODULE */
381
382static uint32_t board_keymap[] = {
383 /*
384 * Note that KEY(x, 8, KEY_XXX) entries represent "entrire row
385 * connected to the ground" matrix state.
386 */
387 KEY(0, 0, KEY_Q),
388 KEY(0, 1, KEY_O),
389 KEY(0, 2, KEY_P),
390 KEY(0, 3, KEY_COMMA),
391 KEY(0, 4, KEY_BACKSPACE),
392 KEY(0, 6, KEY_A),
393 KEY(0, 7, KEY_S),
394
395 KEY(1, 0, KEY_W),
396 KEY(1, 1, KEY_D),
397 KEY(1, 2, KEY_F),
398 KEY(1, 3, KEY_G),
399 KEY(1, 4, KEY_H),
400 KEY(1, 5, KEY_J),
401 KEY(1, 6, KEY_K),
402 KEY(1, 7, KEY_L),
403
404 KEY(2, 0, KEY_E),
405 KEY(2, 1, KEY_DOT),
406 KEY(2, 2, KEY_UP),
407 KEY(2, 3, KEY_ENTER),
408 KEY(2, 5, KEY_Z),
409 KEY(2, 6, KEY_X),
410 KEY(2, 7, KEY_C),
411 KEY(2, 8, KEY_F9),
412
413 KEY(3, 0, KEY_R),
414 KEY(3, 1, KEY_V),
415 KEY(3, 2, KEY_B),
416 KEY(3, 3, KEY_N),
417 KEY(3, 4, KEY_M),
418 KEY(3, 5, KEY_SPACE),
419 KEY(3, 6, KEY_SPACE),
420 KEY(3, 7, KEY_LEFT),
421
422 KEY(4, 0, KEY_T),
423 KEY(4, 1, KEY_DOWN),
424 KEY(4, 2, KEY_RIGHT),
425 KEY(4, 4, KEY_LEFTCTRL),
426 KEY(4, 5, KEY_RIGHTALT),
427 KEY(4, 6, KEY_LEFTSHIFT),
428 KEY(4, 8, KEY_F10),
429
430 KEY(5, 0, KEY_Y),
431 KEY(5, 8, KEY_F11),
432
433 KEY(6, 0, KEY_U),
434
435 KEY(7, 0, KEY_I),
436 KEY(7, 1, KEY_F7),
437 KEY(7, 2, KEY_F8),
438};
439
440static struct matrix_keymap_data board_map_data = {
441 .keymap = board_keymap,
442 .keymap_size = ARRAY_SIZE(board_keymap),
443};
444
445static struct twl4030_keypad_data rx51_kp_data = {
446 .keymap_data = &board_map_data,
447 .rows = 8,
448 .cols = 8,
449 .rep = 1,
450};
451
452/* Enable input logic and pull all lines up when eMMC is on. */
453static struct omap_board_mux rx51_mmc2_on_mux[] = {
454 OMAP3_MUX(SDMMC2_CMD, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
455 OMAP3_MUX(SDMMC2_DAT0, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
456 OMAP3_MUX(SDMMC2_DAT1, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
457 OMAP3_MUX(SDMMC2_DAT2, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
458 OMAP3_MUX(SDMMC2_DAT3, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
459 OMAP3_MUX(SDMMC2_DAT4, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
460 OMAP3_MUX(SDMMC2_DAT5, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
461 OMAP3_MUX(SDMMC2_DAT6, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
462 OMAP3_MUX(SDMMC2_DAT7, OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0),
463 { .reg_offset = OMAP_MUX_TERMINATOR },
464};
465
466/* Disable input logic and pull all lines down when eMMC is off. */
467static struct omap_board_mux rx51_mmc2_off_mux[] = {
468 OMAP3_MUX(SDMMC2_CMD, OMAP_PULL_ENA | OMAP_MUX_MODE0),
469 OMAP3_MUX(SDMMC2_DAT0, OMAP_PULL_ENA | OMAP_MUX_MODE0),
470 OMAP3_MUX(SDMMC2_DAT1, OMAP_PULL_ENA | OMAP_MUX_MODE0),
471 OMAP3_MUX(SDMMC2_DAT2, OMAP_PULL_ENA | OMAP_MUX_MODE0),
472 OMAP3_MUX(SDMMC2_DAT3, OMAP_PULL_ENA | OMAP_MUX_MODE0),
473 OMAP3_MUX(SDMMC2_DAT4, OMAP_PULL_ENA | OMAP_MUX_MODE0),
474 OMAP3_MUX(SDMMC2_DAT5, OMAP_PULL_ENA | OMAP_MUX_MODE0),
475 OMAP3_MUX(SDMMC2_DAT6, OMAP_PULL_ENA | OMAP_MUX_MODE0),
476 OMAP3_MUX(SDMMC2_DAT7, OMAP_PULL_ENA | OMAP_MUX_MODE0),
477 { .reg_offset = OMAP_MUX_TERMINATOR },
478};
479
480static struct omap_mux_partition *partition;
481
482/*
483 * Current flows to eMMC when eMMC is off and the data lines are pulled up,
484 * so pull them down. N.B. we pull 8 lines because we are using 8 lines.
485 */
486static void rx51_mmc2_remux(struct device *dev, int power_on)
487{
488 if (power_on)
489 omap_mux_write_array(partition, rx51_mmc2_on_mux);
490 else
491 omap_mux_write_array(partition, rx51_mmc2_off_mux);
492}
493
494static struct omap2_hsmmc_info mmc[] __initdata = {
495 {
496 .name = "external",
497 .mmc = 1,
498 .caps = MMC_CAP_4_BIT_DATA,
499 .cover_only = true,
500 .gpio_cd = 160,
501 .gpio_wp = -EINVAL,
502 },
503 {
504 .name = "internal",
505 .mmc = 2,
506 .caps = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
507 /* See also rx51_mmc2_remux */
508 .gpio_cd = -EINVAL,
509 .gpio_wp = -EINVAL,
510 .nonremovable = true,
511 .remux = rx51_mmc2_remux,
512 },
513 {} /* Terminator */
514};
515
516static struct regulator_consumer_supply rx51_vmmc1_supply[] = {
517 REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
518};
519
520static struct regulator_consumer_supply rx51_vaux2_supply[] = {
521 REGULATOR_SUPPLY("vdds_csib", "omap3isp"),
522};
523
524static struct regulator_consumer_supply rx51_vaux3_supply[] = {
525 REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1"),
526};
527
528static struct regulator_consumer_supply rx51_vsim_supply[] = {
529 REGULATOR_SUPPLY("vmmc_aux", "omap_hsmmc.1"),
530};
531
532static struct regulator_consumer_supply rx51_vmmc2_supplies[] = {
533 /* tlv320aic3x analog supplies */
534 REGULATOR_SUPPLY("AVDD", "2-0018"),
535 REGULATOR_SUPPLY("DRVDD", "2-0018"),
536 REGULATOR_SUPPLY("AVDD", "2-0019"),
537 REGULATOR_SUPPLY("DRVDD", "2-0019"),
538 /* tpa6130a2 */
539 REGULATOR_SUPPLY("Vdd", "2-0060"),
540 /* Keep vmmc as last item. It is not iterated for newer boards */
541 REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1"),
542};
543
544static struct regulator_consumer_supply rx51_vio_supplies[] = {
545 /* tlv320aic3x digital supplies */
546 REGULATOR_SUPPLY("IOVDD", "2-0018"),
547 REGULATOR_SUPPLY("DVDD", "2-0018"),
548 REGULATOR_SUPPLY("IOVDD", "2-0019"),
549 REGULATOR_SUPPLY("DVDD", "2-0019"),
550 /* Si4713 IO supply */
551 REGULATOR_SUPPLY("vio", "2-0063"),
552 /* lis3lv02d */
553 REGULATOR_SUPPLY("Vdd_IO", "3-001d"),
554};
555
556static struct regulator_consumer_supply rx51_vaux1_consumers[] = {
557 REGULATOR_SUPPLY("vdds_sdi", "omapdss"),
558 REGULATOR_SUPPLY("vdds_sdi", "omapdss_sdi.0"),
559 /* Si4713 supply */
560 REGULATOR_SUPPLY("vdd", "2-0063"),
561 /* lis3lv02d */
562 REGULATOR_SUPPLY("Vdd", "3-001d"),
563};
564
565static struct regulator_init_data rx51_vaux1 = {
566 .constraints = {
567 .name = "V28",
568 .min_uV = 2800000,
569 .max_uV = 2800000,
570 .always_on = true, /* due battery cover sensor */
571 .valid_modes_mask = REGULATOR_MODE_NORMAL
572 | REGULATOR_MODE_STANDBY,
573 .valid_ops_mask = REGULATOR_CHANGE_MODE
574 | REGULATOR_CHANGE_STATUS,
575 },
576 .num_consumer_supplies = ARRAY_SIZE(rx51_vaux1_consumers),
577 .consumer_supplies = rx51_vaux1_consumers,
578};
579
580static struct regulator_init_data rx51_vaux2 = {
581 .constraints = {
582 .name = "VCSI",
583 .min_uV = 1800000,
584 .max_uV = 1800000,
585 .valid_modes_mask = REGULATOR_MODE_NORMAL
586 | REGULATOR_MODE_STANDBY,
587 .valid_ops_mask = REGULATOR_CHANGE_MODE
588 | REGULATOR_CHANGE_STATUS,
589 },
590 .num_consumer_supplies = ARRAY_SIZE(rx51_vaux2_supply),
591 .consumer_supplies = rx51_vaux2_supply,
592};
593
594/* VAUX3 - adds more power to VIO_18 rail */
595static struct regulator_init_data rx51_vaux3_cam = {
596 .constraints = {
597 .name = "VCAM_DIG_18",
598 .min_uV = 1800000,
599 .max_uV = 1800000,
600 .apply_uV = true,
601 .valid_modes_mask = REGULATOR_MODE_NORMAL
602 | REGULATOR_MODE_STANDBY,
603 .valid_ops_mask = REGULATOR_CHANGE_MODE
604 | REGULATOR_CHANGE_STATUS,
605 },
606};
607
608static struct regulator_init_data rx51_vaux3_mmc = {
609 .constraints = {
610 .name = "VMMC2_30",
611 .min_uV = 2800000,
612 .max_uV = 3000000,
613 .apply_uV = true,
614 .valid_modes_mask = REGULATOR_MODE_NORMAL
615 | REGULATOR_MODE_STANDBY,
616 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
617 | REGULATOR_CHANGE_MODE
618 | REGULATOR_CHANGE_STATUS,
619 },
620 .num_consumer_supplies = ARRAY_SIZE(rx51_vaux3_supply),
621 .consumer_supplies = rx51_vaux3_supply,
622};
623
624static struct regulator_init_data rx51_vaux4 = {
625 .constraints = {
626 .name = "VCAM_ANA_28",
627 .min_uV = 2800000,
628 .max_uV = 2800000,
629 .apply_uV = true,
630 .valid_modes_mask = REGULATOR_MODE_NORMAL
631 | REGULATOR_MODE_STANDBY,
632 .valid_ops_mask = REGULATOR_CHANGE_MODE
633 | REGULATOR_CHANGE_STATUS,
634 },
635};
636
637static struct regulator_init_data rx51_vmmc1 = {
638 .constraints = {
639 .min_uV = 1850000,
640 .max_uV = 3150000,
641 .valid_modes_mask = REGULATOR_MODE_NORMAL
642 | REGULATOR_MODE_STANDBY,
643 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
644 | REGULATOR_CHANGE_MODE
645 | REGULATOR_CHANGE_STATUS,
646 },
647 .num_consumer_supplies = ARRAY_SIZE(rx51_vmmc1_supply),
648 .consumer_supplies = rx51_vmmc1_supply,
649};
650
651static struct regulator_init_data rx51_vmmc2 = {
652 .constraints = {
653 .name = "V28_A",
654 .min_uV = 2800000,
655 .max_uV = 3000000,
656 .always_on = true, /* due VIO leak to AIC34 VDDs */
657 .apply_uV = true,
658 .valid_modes_mask = REGULATOR_MODE_NORMAL
659 | REGULATOR_MODE_STANDBY,
660 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
661 | REGULATOR_CHANGE_MODE
662 | REGULATOR_CHANGE_STATUS,
663 },
664 .num_consumer_supplies = ARRAY_SIZE(rx51_vmmc2_supplies),
665 .consumer_supplies = rx51_vmmc2_supplies,
666};
667
668static struct regulator_init_data rx51_vpll1 = {
669 .constraints = {
670 .name = "VPLL",
671 .min_uV = 1800000,
672 .max_uV = 1800000,
673 .apply_uV = true,
674 .always_on = true,
675 .valid_modes_mask = REGULATOR_MODE_NORMAL
676 | REGULATOR_MODE_STANDBY,
677 .valid_ops_mask = REGULATOR_CHANGE_MODE,
678 },
679};
680
681static struct regulator_init_data rx51_vpll2 = {
682 .constraints = {
683 .name = "VSDI_CSI",
684 .min_uV = 1800000,
685 .max_uV = 1800000,
686 .apply_uV = true,
687 .always_on = true,
688 .valid_modes_mask = REGULATOR_MODE_NORMAL
689 | REGULATOR_MODE_STANDBY,
690 .valid_ops_mask = REGULATOR_CHANGE_MODE,
691 },
692};
693
694static struct regulator_init_data rx51_vsim = {
695 .constraints = {
696 .name = "VMMC2_IO_18",
697 .min_uV = 1800000,
698 .max_uV = 1800000,
699 .apply_uV = true,
700 .valid_modes_mask = REGULATOR_MODE_NORMAL
701 | REGULATOR_MODE_STANDBY,
702 .valid_ops_mask = REGULATOR_CHANGE_MODE
703 | REGULATOR_CHANGE_STATUS,
704 },
705 .num_consumer_supplies = ARRAY_SIZE(rx51_vsim_supply),
706 .consumer_supplies = rx51_vsim_supply,
707};
708
709static struct regulator_init_data rx51_vio = {
710 .constraints = {
711 .min_uV = 1800000,
712 .max_uV = 1800000,
713 .valid_modes_mask = REGULATOR_MODE_NORMAL
714 | REGULATOR_MODE_STANDBY,
715 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
716 | REGULATOR_CHANGE_MODE
717 | REGULATOR_CHANGE_STATUS,
718 },
719 .num_consumer_supplies = ARRAY_SIZE(rx51_vio_supplies),
720 .consumer_supplies = rx51_vio_supplies,
721};
722
723static struct regulator_init_data rx51_vintana1 = {
724 .constraints = {
725 .name = "VINTANA1",
726 .min_uV = 1500000,
727 .max_uV = 1500000,
728 .always_on = true,
729 .valid_modes_mask = REGULATOR_MODE_NORMAL
730 | REGULATOR_MODE_STANDBY,
731 .valid_ops_mask = REGULATOR_CHANGE_MODE,
732 },
733};
734
735static struct regulator_init_data rx51_vintana2 = {
736 .constraints = {
737 .name = "VINTANA2",
738 .min_uV = 2750000,
739 .max_uV = 2750000,
740 .apply_uV = true,
741 .always_on = true,
742 .valid_modes_mask = REGULATOR_MODE_NORMAL
743 | REGULATOR_MODE_STANDBY,
744 .valid_ops_mask = REGULATOR_CHANGE_MODE,
745 },
746};
747
748static struct regulator_init_data rx51_vintdig = {
749 .constraints = {
750 .name = "VINTDIG",
751 .min_uV = 1500000,
752 .max_uV = 1500000,
753 .always_on = true,
754 .valid_modes_mask = REGULATOR_MODE_NORMAL
755 | REGULATOR_MODE_STANDBY,
756 .valid_ops_mask = REGULATOR_CHANGE_MODE,
757 },
758};
759
760static struct gpiod_lookup_table rx51_fmtx_gpios_table = {
761 .dev_id = "2-0063",
762 .table = {
763 GPIO_LOOKUP("gpio.6", 3, "reset", GPIO_ACTIVE_HIGH), /* 163 */
764 { },
765 },
766};
767
768static __init void rx51_gpio_init(void)
769{
770 gpiod_add_lookup_table(&rx51_fmtx_gpios_table);
771}
772
773static int rx51_twlgpio_setup(struct device *dev, unsigned gpio, unsigned n)
774{
775 /* FIXME this gpio setup is just a placeholder for now */
776 gpio_request_one(gpio + 6, GPIOF_OUT_INIT_LOW, "backlight_pwm");
777 gpio_request_one(gpio + 7, GPIOF_OUT_INIT_LOW, "speaker_en");
778
779 return 0;
780}
781
782static struct twl4030_gpio_platform_data rx51_gpio_data = {
783 .pulldowns = BIT(0) | BIT(1) | BIT(2) | BIT(3)
784 | BIT(4) | BIT(5)
785 | BIT(8) | BIT(9) | BIT(10) | BIT(11)
786 | BIT(12) | BIT(13) | BIT(14) | BIT(15)
787 | BIT(16) | BIT(17) ,
788 .setup = rx51_twlgpio_setup,
789};
790
791static struct twl4030_ins sleep_on_seq[] __initdata = {
792/*
793 * Turn off everything
794 */
795 {MSG_BROADCAST(DEV_GRP_NULL, RES_GRP_ALL, 1, 0, RES_STATE_SLEEP), 2},
796};
797
798static struct twl4030_script sleep_on_script __initdata = {
799 .script = sleep_on_seq,
800 .size = ARRAY_SIZE(sleep_on_seq),
801 .flags = TWL4030_SLEEP_SCRIPT,
802};
803
804static struct twl4030_ins wakeup_seq[] __initdata = {
805/*
806 * Reenable everything
807 */
808 {MSG_BROADCAST(DEV_GRP_NULL, RES_GRP_ALL, 1, 0, RES_STATE_ACTIVE), 2},
809};
810
811static struct twl4030_script wakeup_script __initdata = {
812 .script = wakeup_seq,
813 .size = ARRAY_SIZE(wakeup_seq),
814 .flags = TWL4030_WAKEUP12_SCRIPT,
815};
816
817static struct twl4030_ins wakeup_p3_seq[] __initdata = {
818/*
819 * Reenable everything
820 */
821 {MSG_BROADCAST(DEV_GRP_NULL, RES_GRP_ALL, 1, 0, RES_STATE_ACTIVE), 2},
822};
823
824static struct twl4030_script wakeup_p3_script __initdata = {
825 .script = wakeup_p3_seq,
826 .size = ARRAY_SIZE(wakeup_p3_seq),
827 .flags = TWL4030_WAKEUP3_SCRIPT,
828};
829
830static struct twl4030_ins wrst_seq[] __initdata = {
831/*
832 * Reset twl4030.
833 * Reset VDD1 regulator.
834 * Reset VDD2 regulator.
835 * Reset VPLL1 regulator.
836 * Enable sysclk output.
837 * Reenable twl4030.
838 */
839 {MSG_SINGULAR(DEV_GRP_NULL, RES_RESET, RES_STATE_OFF), 2},
840 {MSG_BROADCAST(DEV_GRP_NULL, RES_GRP_ALL, 0, 1, RES_STATE_ACTIVE),
841 0x13},
842 {MSG_BROADCAST(DEV_GRP_NULL, RES_GRP_PP, 0, 3, RES_STATE_OFF), 0x13},
843 {MSG_SINGULAR(DEV_GRP_NULL, RES_VDD1, RES_STATE_WRST), 0x13},
844 {MSG_SINGULAR(DEV_GRP_NULL, RES_VDD2, RES_STATE_WRST), 0x13},
845 {MSG_SINGULAR(DEV_GRP_NULL, RES_VPLL1, RES_STATE_WRST), 0x35},
846 {MSG_SINGULAR(DEV_GRP_P3, RES_HFCLKOUT, RES_STATE_ACTIVE), 2},
847 {MSG_SINGULAR(DEV_GRP_NULL, RES_RESET, RES_STATE_ACTIVE), 2},
848};
849
850static struct twl4030_script wrst_script __initdata = {
851 .script = wrst_seq,
852 .size = ARRAY_SIZE(wrst_seq),
853 .flags = TWL4030_WRST_SCRIPT,
854};
855
856static struct twl4030_script *twl4030_scripts[] __initdata = {
857 /* wakeup12 script should be loaded before sleep script, otherwise a
858 board might hit retention before loading of wakeup script is
859 completed. This can cause boot failures depending on timing issues.
860 */
861 &wakeup_script,
862 &sleep_on_script,
863 &wakeup_p3_script,
864 &wrst_script,
865};
866
867static struct twl4030_resconfig twl4030_rconfig[] __initdata = {
868 { .resource = RES_VDD1, .devgroup = -1,
869 .type = 1, .type2 = -1, .remap_off = RES_STATE_OFF,
870 .remap_sleep = RES_STATE_OFF
871 },
872 { .resource = RES_VDD2, .devgroup = -1,
873 .type = 1, .type2 = -1, .remap_off = RES_STATE_OFF,
874 .remap_sleep = RES_STATE_OFF
875 },
876 { .resource = RES_VPLL1, .devgroup = -1,
877 .type = 1, .type2 = -1, .remap_off = RES_STATE_OFF,
878 .remap_sleep = RES_STATE_OFF
879 },
880 { .resource = RES_VPLL2, .devgroup = -1,
881 .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
882 },
883 { .resource = RES_VAUX1, .devgroup = -1,
884 .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
885 },
886 { .resource = RES_VAUX2, .devgroup = -1,
887 .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
888 },
889 { .resource = RES_VAUX3, .devgroup = -1,
890 .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
891 },
892 { .resource = RES_VAUX4, .devgroup = -1,
893 .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
894 },
895 { .resource = RES_VMMC1, .devgroup = -1,
896 .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
897 },
898 { .resource = RES_VMMC2, .devgroup = -1,
899 .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
900 },
901 { .resource = RES_VDAC, .devgroup = -1,
902 .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
903 },
904 { .resource = RES_VSIM, .devgroup = -1,
905 .type = -1, .type2 = 3, .remap_off = -1, .remap_sleep = -1
906 },
907 { .resource = RES_VINTANA1, .devgroup = DEV_GRP_P1 | DEV_GRP_P3,
908 .type = -1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
909 },
910 { .resource = RES_VINTANA2, .devgroup = DEV_GRP_P1 | DEV_GRP_P3,
911 .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
912 },
913 { .resource = RES_VINTDIG, .devgroup = DEV_GRP_P1 | DEV_GRP_P3,
914 .type = -1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
915 },
916 { .resource = RES_VIO, .devgroup = DEV_GRP_P3,
917 .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
918 },
919 { .resource = RES_CLKEN, .devgroup = DEV_GRP_P1 | DEV_GRP_P3,
920 .type = 1, .type2 = -1 , .remap_off = -1, .remap_sleep = -1
921 },
922 { .resource = RES_REGEN, .devgroup = DEV_GRP_P1 | DEV_GRP_P3,
923 .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
924 },
925 { .resource = RES_NRES_PWRON, .devgroup = DEV_GRP_P1 | DEV_GRP_P3,
926 .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
927 },
928 { .resource = RES_SYSEN, .devgroup = DEV_GRP_P1 | DEV_GRP_P3,
929 .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
930 },
931 { .resource = RES_HFCLKOUT, .devgroup = DEV_GRP_P3,
932 .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
933 },
934 { .resource = RES_32KCLKOUT, .devgroup = -1,
935 .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
936 },
937 { .resource = RES_RESET, .devgroup = -1,
938 .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
939 },
940 { .resource = RES_MAIN_REF, .devgroup = -1,
941 .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
942 },
943 { 0, 0},
944};
945
946static struct twl4030_power_data rx51_t2scripts_data __initdata = {
947 .scripts = twl4030_scripts,
948 .num = ARRAY_SIZE(twl4030_scripts),
949 .resource_config = twl4030_rconfig,
950};
951
952static struct twl4030_vibra_data rx51_vibra_data __initdata = {
953 .coexist = 0,
954};
955
956static struct twl4030_audio_data rx51_audio_data __initdata = {
957 .audio_mclk = 26000000,
958 .vibra = &rx51_vibra_data,
959};
960
961static struct twl4030_platform_data rx51_twldata __initdata = {
962 /* platform_data for children goes here */
963 .gpio = &rx51_gpio_data,
964 .keypad = &rx51_kp_data,
965 .power = &rx51_t2scripts_data,
966 .audio = &rx51_audio_data,
967
968 .vaux1 = &rx51_vaux1,
969 .vaux2 = &rx51_vaux2,
970 .vaux4 = &rx51_vaux4,
971 .vmmc1 = &rx51_vmmc1,
972 .vpll1 = &rx51_vpll1,
973 .vpll2 = &rx51_vpll2,
974 .vsim = &rx51_vsim,
975 .vintana1 = &rx51_vintana1,
976 .vintana2 = &rx51_vintana2,
977 .vintdig = &rx51_vintdig,
978 .vio = &rx51_vio,
979};
980
981static struct tpa6130a2_platform_data rx51_tpa6130a2_data __initdata_or_module = {
982 .power_gpio = 98,
983};
984
985/* Audio setup data */
986static struct aic3x_setup_data rx51_aic34_setup = {
987 .gpio_func[0] = AIC3X_GPIO1_FUNC_DISABLED,
988 .gpio_func[1] = AIC3X_GPIO2_FUNC_DIGITAL_MIC_INPUT,
989};
990
991static struct aic3x_pdata rx51_aic3x_data = {
992 .setup = &rx51_aic34_setup,
993 .gpio_reset = 60,
994};
995
996static struct aic3x_pdata rx51_aic3x_data2 = {
997 .gpio_reset = 60,
998};
999
1000#if IS_ENABLED(CONFIG_I2C_SI4713) && IS_ENABLED(CONFIG_PLATFORM_SI4713)
1001static struct si4713_platform_data rx51_si4713_platform_data = {
1002 .is_platform_device = true
1003};
1004#endif
1005
1006static struct i2c_board_info __initdata rx51_peripherals_i2c_board_info_2[] = {
1007#if IS_ENABLED(CONFIG_I2C_SI4713) && IS_ENABLED(CONFIG_PLATFORM_SI4713)
1008 {
1009 I2C_BOARD_INFO("si4713", 0x63),
1010 .platform_data = &rx51_si4713_platform_data,
1011 },
1012#endif
1013 {
1014 I2C_BOARD_INFO("tlv320aic3x", 0x18),
1015 .platform_data = &rx51_aic3x_data,
1016 },
1017 {
1018 I2C_BOARD_INFO("tlv320aic3x", 0x19),
1019 .platform_data = &rx51_aic3x_data2,
1020 },
1021#if defined(CONFIG_SENSORS_TSL2563) || defined(CONFIG_SENSORS_TSL2563_MODULE)
1022 {
1023 I2C_BOARD_INFO("tsl2563", 0x29),
1024 .platform_data = &rx51_tsl2563_platform_data,
1025 },
1026#endif
1027#if defined(CONFIG_LEDS_LP5523) || defined(CONFIG_LEDS_LP5523_MODULE)
1028 {
1029 I2C_BOARD_INFO("lp5523", 0x32),
1030 .platform_data = &rx51_lp5523_platform_data,
1031 },
1032#endif
1033 {
1034 I2C_BOARD_INFO("bq27200", 0x55),
1035 },
1036 {
1037 I2C_BOARD_INFO("tpa6130a2", 0x60),
1038 .platform_data = &rx51_tpa6130a2_data,
1039 }
1040};
1041
1042static struct i2c_board_info __initdata rx51_peripherals_i2c_board_info_3[] = {
1043#if defined(CONFIG_SENSORS_LIS3_I2C) || defined(CONFIG_SENSORS_LIS3_I2C_MODULE)
1044 {
1045 I2C_BOARD_INFO("lis3lv02d", 0x1d),
1046 .platform_data = &rx51_lis3lv02d_data,
1047 },
1048#endif
1049};
1050
1051static int __init rx51_i2c_init(void)
1052{
1053#if IS_ENABLED(CONFIG_I2C_SI4713) && IS_ENABLED(CONFIG_PLATFORM_SI4713)
1054 int err;
1055#endif
1056
1057 if ((system_rev >= SYSTEM_REV_S_USES_VAUX3 && system_rev < 0x100) ||
1058 system_rev >= SYSTEM_REV_B_USES_VAUX3) {
1059 rx51_twldata.vaux3 = &rx51_vaux3_mmc;
1060 /* Only older boards use VMMC2 for internal MMC */
1061 rx51_vmmc2.num_consumer_supplies--;
1062 } else {
1063 rx51_twldata.vaux3 = &rx51_vaux3_cam;
1064 }
1065 rx51_twldata.vmmc2 = &rx51_vmmc2;
1066 omap3_pmic_get_config(&rx51_twldata,
1067 TWL_COMMON_PDATA_USB | TWL_COMMON_PDATA_MADC,
1068 TWL_COMMON_REGULATOR_VDAC);
1069
1070 rx51_twldata.vdac->constraints.apply_uV = true;
1071 rx51_twldata.vdac->constraints.name = "VDAC";
1072
1073 omap_pmic_init(1, 2200, "twl5030", 7 + OMAP_INTC_START, &rx51_twldata);
1074#if IS_ENABLED(CONFIG_I2C_SI4713) && IS_ENABLED(CONFIG_PLATFORM_SI4713)
1075 err = gpio_request_one(RX51_FMTX_IRQ, GPIOF_DIR_IN, "si4713 irq");
1076 if (err) {
1077 printk(KERN_ERR "Cannot request si4713 irq gpio. %d\n", err);
1078 return err;
1079 }
1080 rx51_peripherals_i2c_board_info_2[0].irq = gpio_to_irq(RX51_FMTX_IRQ);
1081#endif
1082 omap_register_i2c_bus(2, 100, rx51_peripherals_i2c_board_info_2,
1083 ARRAY_SIZE(rx51_peripherals_i2c_board_info_2));
1084#if defined(CONFIG_SENSORS_LIS3_I2C) || defined(CONFIG_SENSORS_LIS3_I2C_MODULE)
1085 rx51_lis3lv02d_data.irq2 = gpio_to_irq(LIS302_IRQ2_GPIO);
1086 rx51_peripherals_i2c_board_info_3[0].irq = gpio_to_irq(LIS302_IRQ1_GPIO);
1087#endif
1088 omap_register_i2c_bus(3, 400, rx51_peripherals_i2c_board_info_3,
1089 ARRAY_SIZE(rx51_peripherals_i2c_board_info_3));
1090 return 0;
1091}
1092
1093#if defined(CONFIG_MTD_ONENAND_OMAP2) || \
1094 defined(CONFIG_MTD_ONENAND_OMAP2_MODULE)
1095
1096static struct mtd_partition onenand_partitions[] = {
1097 {
1098 .name = "bootloader",
1099 .offset = 0,
1100 .size = 0x20000,
1101 .mask_flags = MTD_WRITEABLE, /* Force read-only */
1102 },
1103 {
1104 .name = "config",
1105 .offset = MTDPART_OFS_APPEND,
1106 .size = 0x60000,
1107 },
1108 {
1109 .name = "log",
1110 .offset = MTDPART_OFS_APPEND,
1111 .size = 0x40000,
1112 },
1113 {
1114 .name = "kernel",
1115 .offset = MTDPART_OFS_APPEND,
1116 .size = 0x200000,
1117 },
1118 {
1119 .name = "initfs",
1120 .offset = MTDPART_OFS_APPEND,
1121 .size = 0x200000,
1122 },
1123 {
1124 .name = "rootfs",
1125 .offset = MTDPART_OFS_APPEND,
1126 .size = MTDPART_SIZ_FULL,
1127 },
1128};
1129
1130static struct omap_onenand_platform_data board_onenand_data[] = {
1131 {
1132 .cs = 0,
1133 .gpio_irq = 65,
1134 .parts = onenand_partitions,
1135 .nr_parts = ARRAY_SIZE(onenand_partitions),
1136 .flags = ONENAND_SYNC_READWRITE,
1137 }
1138};
1139#endif
1140
1141static struct gpio rx51_wl1251_gpios[] __initdata = {
1142 { RX51_WL1251_IRQ_GPIO, GPIOF_IN, "wl1251 irq" },
1143};
1144
1145static void __init rx51_init_wl1251(void)
1146{
1147 int irq, ret;
1148
1149 ret = gpio_request_array(rx51_wl1251_gpios,
1150 ARRAY_SIZE(rx51_wl1251_gpios));
1151 if (ret < 0)
1152 goto error;
1153
1154 irq = gpio_to_irq(RX51_WL1251_IRQ_GPIO);
1155 if (irq < 0)
1156 goto err_irq;
1157
1158 wl1251_pdata.power_gpio = RX51_WL1251_POWER_GPIO;
1159 rx51_peripherals_spi_board_info[RX51_SPI_WL1251].irq = irq;
1160
1161 return;
1162
1163err_irq:
1164 gpio_free(RX51_WL1251_IRQ_GPIO);
1165error:
1166 printk(KERN_ERR "wl1251 board initialisation failed\n");
1167 wl1251_pdata.power_gpio = -1;
1168
1169 /*
1170 * Now rx51_peripherals_spi_board_info[1].irq is zero and
1171 * set_power is null, and wl1251_probe() will fail.
1172 */
1173}
1174
1175static struct tsc2005_platform_data tsc2005_pdata = {
1176 .ts_pressure_max = 2048,
1177 .ts_pressure_fudge = 2,
1178 .ts_x_max = 4096,
1179 .ts_x_fudge = 4,
1180 .ts_y_max = 4096,
1181 .ts_y_fudge = 7,
1182 .ts_x_plate_ohm = 280,
1183 .esd_timeout_ms = 8000,
1184};
1185
1186static struct gpio rx51_tsc2005_gpios[] __initdata = {
1187 { RX51_TSC2005_IRQ_GPIO, GPIOF_IN, "tsc2005 IRQ" },
1188 { RX51_TSC2005_RESET_GPIO, GPIOF_OUT_INIT_HIGH, "tsc2005 reset" },
1189};
1190
1191static void rx51_tsc2005_set_reset(bool enable)
1192{
1193 gpio_set_value(RX51_TSC2005_RESET_GPIO, enable);
1194}
1195
1196static void __init rx51_init_tsc2005(void)
1197{
1198 int r;
1199
1200 omap_mux_init_gpio(RX51_TSC2005_RESET_GPIO, OMAP_PIN_OUTPUT);
1201 omap_mux_init_gpio(RX51_TSC2005_IRQ_GPIO, OMAP_PIN_INPUT_PULLUP);
1202
1203 r = gpio_request_array(rx51_tsc2005_gpios,
1204 ARRAY_SIZE(rx51_tsc2005_gpios));
1205 if (r < 0) {
1206 printk(KERN_ERR "tsc2005 board initialization failed\n");
1207 tsc2005_pdata.esd_timeout_ms = 0;
1208 return;
1209 }
1210
1211 tsc2005_pdata.set_reset = rx51_tsc2005_set_reset;
1212 rx51_peripherals_spi_board_info[RX51_SPI_TSC2005].irq =
1213 gpio_to_irq(RX51_TSC2005_IRQ_GPIO);
1214}
1215
1216#if IS_ENABLED(CONFIG_OMAP_DM_TIMER)
1217static struct pwm_omap_dmtimer_pdata __maybe_unused pwm_dmtimer_pdata = {
1218 .request_by_node = omap_dm_timer_request_by_node,
1219 .request_specific = omap_dm_timer_request_specific,
1220 .request = omap_dm_timer_request,
1221 .set_source = omap_dm_timer_set_source,
1222 .get_irq = omap_dm_timer_get_irq,
1223 .set_int_enable = omap_dm_timer_set_int_enable,
1224 .set_int_disable = omap_dm_timer_set_int_disable,
1225 .free = omap_dm_timer_free,
1226 .enable = omap_dm_timer_enable,
1227 .disable = omap_dm_timer_disable,
1228 .get_fclk = omap_dm_timer_get_fclk,
1229 .start = omap_dm_timer_start,
1230 .stop = omap_dm_timer_stop,
1231 .set_load = omap_dm_timer_set_load,
1232 .set_match = omap_dm_timer_set_match,
1233 .set_pwm = omap_dm_timer_set_pwm,
1234 .set_prescaler = omap_dm_timer_set_prescaler,
1235 .read_counter = omap_dm_timer_read_counter,
1236 .write_counter = omap_dm_timer_write_counter,
1237 .read_status = omap_dm_timer_read_status,
1238 .write_status = omap_dm_timer_write_status,
1239};
1240#endif
1241
1242#if defined(CONFIG_IR_RX51) || defined(CONFIG_IR_RX51_MODULE)
1243static struct lirc_rx51_platform_data rx51_lirc_data = {
1244 .set_max_mpu_wakeup_lat = omap_pm_set_max_mpu_wakeup_lat,
1245};
1246
1247static struct platform_device rx51_lirc_device = {
1248 .name = "lirc_rx51",
1249 .id = -1,
1250 .dev = {
1251 .platform_data = &rx51_lirc_data,
1252 },
1253};
1254
1255static void __init rx51_init_lirc(void)
1256{
1257 platform_device_register(&rx51_lirc_device);
1258}
1259#else
1260static void __init rx51_init_lirc(void)
1261{
1262}
1263#endif
1264
1265static struct platform_device madc_hwmon = {
1266 .name = "twl4030_madc_hwmon",
1267 .id = -1,
1268};
1269
1270static void __init rx51_init_twl4030_hwmon(void)
1271{
1272 platform_device_register(&madc_hwmon);
1273}
1274
1275static struct platform_device omap3_rom_rng_device = {
1276 .name = "omap3-rom-rng",
1277 .id = -1,
1278 .dev = {
1279 .platform_data = rx51_secure_rng_call,
1280 },
1281};
1282
1283static void __init rx51_init_omap3_rom_rng(void)
1284{
1285 if (omap_type() == OMAP2_DEVICE_TYPE_SEC) {
1286 pr_info("RX-51: Registering OMAP3 HWRNG device\n");
1287 platform_device_register(&omap3_rom_rng_device);
1288 }
1289}
1290
1291void __init rx51_peripherals_init(void)
1292{
1293 rx51_gpio_init();
1294 rx51_i2c_init();
1295 regulator_has_full_constraints();
1296 gpmc_onenand_init(board_onenand_data);
1297 rx51_add_gpio_keys();
1298 rx51_init_wl1251();
1299 rx51_init_tsc2005();
1300 rx51_init_lirc();
1301 spi_register_board_info(rx51_peripherals_spi_board_info,
1302 ARRAY_SIZE(rx51_peripherals_spi_board_info));
1303
1304 partition = omap_mux_get("core");
1305 if (partition)
1306 omap_hsmmc_init(mmc);
1307
1308 rx51_charger_init();
1309 rx51_init_twl4030_hwmon();
1310 rx51_init_omap3_rom_rng();
1311}
1312
diff --git a/arch/arm/mach-omap2/board-rx51-video.c b/arch/arm/mach-omap2/board-rx51-video.c
deleted file mode 100644
index 180c6aa633bd..000000000000
--- a/arch/arm/mach-omap2/board-rx51-video.c
+++ /dev/null
@@ -1,67 +0,0 @@
1/*
2 * linux/arch/arm/mach-omap2/board-rx51-video.c
3 *
4 * Copyright (C) 2010 Nokia
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 version 2 as
8 * published by the Free Software Foundation.
9 */
10
11#include <linux/kernel.h>
12#include <linux/init.h>
13#include <linux/platform_device.h>
14#include <linux/gpio.h>
15#include <linux/spi/spi.h>
16#include <linux/mm.h>
17#include <asm/mach-types.h>
18#include <linux/platform_data/omapdss.h>
19#include <video/omap-panel-data.h>
20
21#include <linux/platform_data/spi-omap2-mcspi.h>
22
23#include "soc.h"
24#include "board-rx51.h"
25#include "display.h"
26
27#include "mux.h"
28
29#define RX51_LCD_RESET_GPIO 90
30
31#if defined(CONFIG_FB_OMAP2) || defined(CONFIG_FB_OMAP2_MODULE)
32
33static struct connector_atv_platform_data rx51_tv_pdata = {
34 .name = "tv",
35 .source = "venc.0",
36 .invert_polarity = false,
37};
38
39static struct platform_device rx51_tv_connector_device = {
40 .name = "connector-analog-tv",
41 .id = 0,
42 .dev.platform_data = &rx51_tv_pdata,
43};
44
45static struct omap_dss_board_info rx51_dss_board_info = {
46 .default_display_name = "lcd",
47};
48
49static int __init rx51_video_init(void)
50{
51 if (!machine_is_nokia_rx51())
52 return 0;
53
54 if (omap_mux_init_gpio(RX51_LCD_RESET_GPIO, OMAP_PIN_OUTPUT)) {
55 pr_err("%s cannot configure MUX for LCD RESET\n", __func__);
56 return 0;
57 }
58
59 omap_display_init(&rx51_dss_board_info);
60
61 platform_device_register(&rx51_tv_connector_device);
62
63 return 0;
64}
65
66omap_subsys_initcall(rx51_video_init);
67#endif /* defined(CONFIG_FB_OMAP2) || defined(CONFIG_FB_OMAP2_MODULE) */
diff --git a/arch/arm/mach-omap2/board-rx51.c b/arch/arm/mach-omap2/board-rx51.c
deleted file mode 100644
index 41161ca97d74..000000000000
--- a/arch/arm/mach-omap2/board-rx51.c
+++ /dev/null
@@ -1,141 +0,0 @@
1/*
2 * Board support file for Nokia N900 (aka RX-51).
3 *
4 * Copyright (C) 2007, 2008 Nokia
5 * Copyright (C) 2012 Ivaylo Dimitrov <freemangordon@abv.bg>
6 * Copyright (C) 2013 Pali Rohár <pali.rohar@gmail.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12
13#include <linux/kernel.h>
14#include <linux/init.h>
15#include <linux/platform_device.h>
16#include <linux/delay.h>
17#include <linux/err.h>
18#include <linux/clk.h>
19#include <linux/io.h>
20#include <linux/gpio.h>
21#include <linux/leds.h>
22#include <linux/usb/phy.h>
23#include <linux/usb/musb.h>
24#include <linux/platform_data/spi-omap2-mcspi.h>
25
26#include <asm/mach-types.h>
27#include <asm/mach/arch.h>
28#include <asm/mach/map.h>
29
30#include <linux/omap-dma.h>
31
32#include "common.h"
33#include "mux.h"
34#include "gpmc.h"
35#include "pm.h"
36#include "soc.h"
37#include "sdram-nokia.h"
38#include "omap-secure.h"
39
40#define RX51_GPIO_SLEEP_IND 162
41
42static struct gpio_led gpio_leds[] = {
43 {
44 .name = "sleep_ind",
45 .gpio = RX51_GPIO_SLEEP_IND,
46 },
47};
48
49static struct gpio_led_platform_data gpio_led_info = {
50 .leds = gpio_leds,
51 .num_leds = ARRAY_SIZE(gpio_leds),
52};
53
54static struct platform_device leds_gpio = {
55 .name = "leds-gpio",
56 .id = -1,
57 .dev = {
58 .platform_data = &gpio_led_info,
59 },
60};
61
62/*
63 * cpuidle C-states definition for rx51.
64 *
65 * The 'exit_latency' field is the sum of sleep
66 * and wake-up latencies.
67
68 ---------------------------------------------
69 | state | exit_latency | target_residency |
70 ---------------------------------------------
71 | C1 | 110 + 162 | 5 |
72 | C2 | 106 + 180 | 309 |
73 | C3 | 107 + 410 | 46057 |
74 | C4 | 121 + 3374 | 46057 |
75 | C5 | 855 + 1146 | 46057 |
76 | C6 | 7580 + 4134 | 484329 |
77 | C7 | 7505 + 15274 | 484329 |
78 ---------------------------------------------
79
80*/
81
82extern void __init rx51_peripherals_init(void);
83
84#ifdef CONFIG_OMAP_MUX
85static struct omap_board_mux board_mux[] __initdata = {
86 { .reg_offset = OMAP_MUX_TERMINATOR },
87};
88#endif
89
90static struct omap_musb_board_data musb_board_data = {
91 .interface_type = MUSB_INTERFACE_ULPI,
92 .mode = MUSB_OTG,
93 .power = 0,
94};
95
96static void __init rx51_init(void)
97{
98 struct omap_sdrc_params *sdrc_params;
99
100 omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
101 omap_serial_init();
102
103 sdrc_params = nokia_get_sdram_timings();
104 omap_sdrc_init(sdrc_params, sdrc_params);
105
106 usb_bind_phy("musb-hdrc.0.auto", 0, "twl4030_usb");
107 usb_musb_init(&musb_board_data);
108 rx51_peripherals_init();
109
110 if (omap_type() == OMAP2_DEVICE_TYPE_SEC) {
111#ifdef CONFIG_ARM_ERRATA_430973
112 pr_info("RX-51: Enabling ARM errata 430973 workaround\n");
113 /* set IBE to 1 */
114 rx51_secure_update_aux_cr(BIT(6), 0);
115#endif
116 }
117
118 /* Ensure SDRC pins are mux'd for self-refresh */
119 omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
120 omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);
121
122 platform_device_register(&leds_gpio);
123}
124
125static void __init rx51_reserve(void)
126{
127 omap_reserve();
128}
129
130MACHINE_START(NOKIA_RX51, "Nokia RX-51 board")
131 /* Maintainer: Lauri Leukkunen <lauri.leukkunen@nokia.com> */
132 .atag_offset = 0x100,
133 .reserve = rx51_reserve,
134 .map_io = omap3_map_io,
135 .init_early = omap3430_init_early,
136 .init_irq = omap3_init_irq,
137 .init_machine = rx51_init,
138 .init_late = omap3430_init_late,
139 .init_time = omap_init_time,
140 .restart = omap3xxx_restart,
141MACHINE_END
diff --git a/arch/arm/mach-omap2/board-rx51.h b/arch/arm/mach-omap2/board-rx51.h
deleted file mode 100644
index b76f49e7eed5..000000000000
--- a/arch/arm/mach-omap2/board-rx51.h
+++ /dev/null
@@ -1,11 +0,0 @@
1/*
2 * Defines for rx51 boards
3 */
4
5#ifndef _OMAP_BOARD_RX51_H
6#define _OMAP_BOARD_RX51_H
7
8extern void __init rx51_peripherals_init(void);
9extern void __init rx51_video_mem_init(void);
10
11#endif
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-13 23:24:29 -0400