1/*
2 * board-overo.c (Gumstix Overo)
3 *
4 * Initial code: Steve Sakoman <steve@sakoman.com>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * version 2 as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
18 * 02110-1301 USA
19 *
20 */
21
22#include <linux/clk.h>
23#include <linux/delay.h>
24#include <linux/err.h>
25#include <linux/init.h>
26#include <linux/io.h>
27#include <linux/gpio.h>
28#include <linux/kernel.h>
29#include <linux/platform_device.h>
30#include <linux/i2c/twl.h>
31#include <linux/regulator/machine.h>
32#include <linux/regulator/fixed.h>
33#include <linux/spi/spi.h>
34
35#include <linux/mtd/mtd.h>
36#include <linux/mtd/nand.h>
37#include <linux/mtd/partitions.h>
38#include <linux/mmc/host.h>
39#include <linux/usb/phy.h>
40
41#include <linux/platform_data/mtd-nand-omap2.h>
42#include <linux/platform_data/spi-omap2-mcspi.h>
43
44#include <asm/mach-types.h>
45#include <asm/mach/arch.h>
46#include <asm/mach/flash.h>
47#include <asm/mach/map.h>
48
49#include <video/omapdss.h>
50#include <video/omap-panel-data.h>
51
52#include "common.h"
53#include "mux.h"
54#include "sdram-micron-mt46h32m32lf-6.h"
55#include "gpmc.h"
56#include "hsmmc.h"
57#include "board-flash.h"
58#include "common-board-devices.h"
59
60#define	NAND_CS			0
61
62#define OVERO_GPIO_BT_XGATE	15
63#define OVERO_GPIO_W2W_NRESET	16
64#define OVERO_GPIO_PENDOWN	114
65#define OVERO_GPIO_BT_NRESET	164
66#define OVERO_GPIO_USBH_CPEN	168
67#define OVERO_GPIO_USBH_NRESET	183
68
69#define OVERO_SMSC911X_CS      5
70#define OVERO_SMSC911X_GPIO    176
71#define OVERO_SMSC911X_NRESET  64
72#define OVERO_SMSC911X2_CS     4
73#define OVERO_SMSC911X2_GPIO   65
74
75/* whether to register LCD35 instead of LCD43 */
76static bool overo_use_lcd35;
77
78#if defined(CONFIG_TOUCHSCREEN_ADS7846) || \
79	defined(CONFIG_TOUCHSCREEN_ADS7846_MODULE)
80
81/* fixed regulator for ads7846 */
82static struct regulator_consumer_supply ads7846_supply[] = {
83	REGULATOR_SUPPLY("vcc", "spi1.0"),
84};
85
86static struct regulator_init_data vads7846_regulator = {
87	.constraints = {
88		.valid_ops_mask		= REGULATOR_CHANGE_STATUS,
89	},
90	.num_consumer_supplies	= ARRAY_SIZE(ads7846_supply),
91	.consumer_supplies	= ads7846_supply,
92};
93
94static struct fixed_voltage_config vads7846 = {
95	.supply_name		= "vads7846",
96	.microvolts		= 3300000, /* 3.3V */
97	.gpio			= -EINVAL,
98	.startup_delay		= 0,
99	.init_data		= &vads7846_regulator,
100};
101
102static struct platform_device vads7846_device = {
103	.name		= "reg-fixed-voltage",
104	.id		= 1,
105	.dev = {
106		.platform_data = &vads7846,
107	},
108};
109
110static void __init overo_ads7846_init(void)
111{
112	omap_ads7846_init(1, OVERO_GPIO_PENDOWN, 0, NULL);
113	platform_device_register(&vads7846_device);
114}
115
116#else
117static inline void __init overo_ads7846_init(void) { return; }
118#endif
119
120#if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
121
122#include <linux/smsc911x.h>
123#include "gpmc-smsc911x.h"
124
125static struct omap_smsc911x_platform_data smsc911x_cfg = {
126	.id		= 0,
127	.cs             = OVERO_SMSC911X_CS,
128	.gpio_irq       = OVERO_SMSC911X_GPIO,
129	.gpio_reset     = OVERO_SMSC911X_NRESET,
130	.flags		= SMSC911X_USE_32BIT,
131};
132
133static struct omap_smsc911x_platform_data smsc911x2_cfg = {
134	.id		= 1,
135	.cs             = OVERO_SMSC911X2_CS,
136	.gpio_irq       = OVERO_SMSC911X2_GPIO,
137	.gpio_reset     = -EINVAL,
138	.flags		= SMSC911X_USE_32BIT,
139};
140
141static void __init overo_init_smsc911x(void)
142{
143	gpmc_smsc911x_init(&smsc911x_cfg);
144	gpmc_smsc911x_init(&smsc911x2_cfg);
145}
146
147#else
148static inline void __init overo_init_smsc911x(void) { return; }
149#endif
150
151/* DSS */
152#define OVERO_GPIO_LCD_EN 144
153#define OVERO_GPIO_LCD_BL 145
154
155static struct connector_atv_platform_data overo_tv_pdata = {
156	.name = "tv",
157	.source = "venc.0",
158	.connector_type = OMAP_DSS_VENC_TYPE_SVIDEO,
159	.invert_polarity = false,
160};
161
162static struct platform_device overo_tv_connector_device = {
163	.name                   = "connector-analog-tv",
164	.id                     = 0,
165	.dev.platform_data      = &overo_tv_pdata,
166};
167
168static const struct display_timing overo_lcd43_videomode = {
169	.pixelclock	= { 0, 9200000, 0 },
170
171	.hactive = { 0, 480, 0 },
172	.hfront_porch = { 0, 8, 0 },
173	.hback_porch = { 0, 4, 0 },
174	.hsync_len = { 0, 41, 0 },
175
176	.vactive = { 0, 272, 0 },
177	.vfront_porch = { 0, 4, 0 },
178	.vback_porch = { 0, 2, 0 },
179	.vsync_len = { 0, 10, 0 },
180
181	.flags = DISPLAY_FLAGS_HSYNC_LOW | DISPLAY_FLAGS_VSYNC_LOW |
182		DISPLAY_FLAGS_DE_HIGH | DISPLAY_FLAGS_PIXDATA_POSEDGE,
183};
184
185static struct panel_dpi_platform_data overo_lcd43_pdata = {
186	.name                   = "lcd43",
187	.source                 = "dpi.0",
188
189	.data_lines		= 24,
190
191	.display_timing		= &overo_lcd43_videomode,
192
193	.enable_gpio		= OVERO_GPIO_LCD_EN,
194	.backlight_gpio		= OVERO_GPIO_LCD_BL,
195};
196
197static struct platform_device overo_lcd43_device = {
198	.name                   = "panel-dpi",
199	.id                     = 0,
200	.dev.platform_data      = &overo_lcd43_pdata,
201};
202
203static struct connector_dvi_platform_data overo_dvi_connector_pdata = {
204	.name                   = "dvi",
205	.source                 = "tfp410.0",
206	.i2c_bus_num            = 3,
207};
208
209static struct platform_device overo_dvi_connector_device = {
210	.name                   = "connector-dvi",
211	.id                     = 0,
212	.dev.platform_data      = &overo_dvi_connector_pdata,
213};
214
215static struct encoder_tfp410_platform_data overo_tfp410_pdata = {
216	.name                   = "tfp410.0",
217	.source                 = "dpi.0",
218	.data_lines             = 24,
219	.power_down_gpio        = -1,
220};
221
222static struct platform_device overo_tfp410_device = {
223	.name                   = "tfp410",
224	.id                     = 0,
225	.dev.platform_data      = &overo_tfp410_pdata,
226};
227
228static struct omap_dss_board_info overo_dss_data = {
229	.default_display_name = "lcd43",
230};
231
232static void __init overo_display_init(void)
233{
234	omap_display_init(&overo_dss_data);
235
236	if (!overo_use_lcd35)
237		platform_device_register(&overo_lcd43_device);
238	platform_device_register(&overo_tfp410_device);
239	platform_device_register(&overo_dvi_connector_device);
240	platform_device_register(&overo_tv_connector_device);
241}
242
243static struct mtd_partition overo_nand_partitions[] = {
244	{
245		.name           = "xloader",
246		.offset         = 0,			/* Offset = 0x00000 */
247		.size           = 4 * NAND_BLOCK_SIZE,
248		.mask_flags     = MTD_WRITEABLE
249	},
250	{
251		.name           = "uboot",
252		.offset         = MTDPART_OFS_APPEND,	/* Offset = 0x80000 */
253		.size           = 14 * NAND_BLOCK_SIZE,
254	},
255	{
256		.name           = "uboot environment",
257		.offset         = MTDPART_OFS_APPEND,	/* Offset = 0x240000 */
258		.size           = 2 * NAND_BLOCK_SIZE,
259	},
260	{
261		.name           = "linux",
262		.offset         = MTDPART_OFS_APPEND,	/* Offset = 0x280000 */
263		.size           = 32 * NAND_BLOCK_SIZE,
264	},
265	{
266		.name           = "rootfs",
267		.offset         = MTDPART_OFS_APPEND,	/* Offset = 0x680000 */
268		.size           = MTDPART_SIZ_FULL,
269	},
270};
271
272static struct omap2_hsmmc_info mmc[] = {
273	{
274		.mmc		= 1,
275		.caps		= MMC_CAP_4_BIT_DATA,
276		.gpio_cd	= -EINVAL,
277		.gpio_wp	= -EINVAL,
278	},
279	{
280		.mmc		= 2,
281		.caps		= MMC_CAP_4_BIT_DATA,
282		.gpio_cd	= -EINVAL,
283		.gpio_wp	= -EINVAL,
284		.transceiver	= true,
285		.ocr_mask	= 0x00100000,	/* 3.3V */
286	},
287	{}	/* Terminator */
288};
289
290static struct regulator_consumer_supply overo_vmmc1_supply[] = {
291	REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
292};
293
294#if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
295#include <linux/leds.h>
296
297static struct gpio_led gpio_leds[] = {
298	{
299		.name			= "overo:red:gpio21",
300		.default_trigger	= "heartbeat",
301		.gpio			= 21,
302		.active_low		= true,
303	},
304	{
305		.name			= "overo:blue:gpio22",
306		.default_trigger	= "none",
307		.gpio			= 22,
308		.active_low		= true,
309	},
310	{
311		.name			= "overo:blue:COM",
312		.default_trigger	= "mmc0",
313		.gpio			= -EINVAL,	/* gets replaced */
314		.active_low		= true,
315	},
316};
317
318static struct gpio_led_platform_data gpio_leds_pdata = {
319	.leds		= gpio_leds,
320	.num_leds	= ARRAY_SIZE(gpio_leds),
321};
322
323static struct platform_device gpio_leds_device = {
324	.name	= "leds-gpio",
325	.id	= -1,
326	.dev	= {
327		.platform_data	= &gpio_leds_pdata,
328	},
329};
330
331static void __init overo_init_led(void)
332{
333	platform_device_register(&gpio_leds_device);
334}
335
336#else
337static inline void __init overo_init_led(void) { return; }
338#endif
339
340#if defined(CONFIG_KEYBOARD_GPIO) || defined(CONFIG_KEYBOARD_GPIO_MODULE)
341#include <linux/input.h>
342#include <linux/gpio_keys.h>
343
344static struct gpio_keys_button gpio_buttons[] = {
345	{
346		.code			= BTN_0,
347		.gpio			= 23,
348		.desc			= "button0",
349		.wakeup			= 1,
350	},
351	{
352		.code			= BTN_1,
353		.gpio			= 14,
354		.desc			= "button1",
355		.wakeup			= 1,
356	},
357};
358
359static struct gpio_keys_platform_data gpio_keys_pdata = {
360	.buttons	= gpio_buttons,
361	.nbuttons	= ARRAY_SIZE(gpio_buttons),
362};
363
364static struct platform_device gpio_keys_device = {
365	.name	= "gpio-keys",
366	.id	= -1,
367	.dev	= {
368		.platform_data	= &gpio_keys_pdata,
369	},
370};
371
372static void __init overo_init_keys(void)
373{
374	platform_device_register(&gpio_keys_device);
375}
376
377#else
378static inline void __init overo_init_keys(void) { return; }
379#endif
380
381static int overo_twl_gpio_setup(struct device *dev,
382		unsigned gpio, unsigned ngpio)
383{
384#if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
385	/* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */
386	gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1;
387#endif
388
389	return 0;
390}
391
392static struct twl4030_gpio_platform_data overo_gpio_data = {
393	.use_leds	= true,
394	.setup		= overo_twl_gpio_setup,
395};
396
397static struct regulator_init_data overo_vmmc1 = {
398	.constraints = {
399		.min_uV			= 1850000,
400		.max_uV			= 3150000,
401		.valid_modes_mask	= REGULATOR_MODE_NORMAL
402					| REGULATOR_MODE_STANDBY,
403		.valid_ops_mask		= REGULATOR_CHANGE_VOLTAGE
404					| REGULATOR_CHANGE_MODE
405					| REGULATOR_CHANGE_STATUS,
406	},
407	.num_consumer_supplies	= ARRAY_SIZE(overo_vmmc1_supply),
408	.consumer_supplies	= overo_vmmc1_supply,
409};
410
411static struct twl4030_platform_data overo_twldata = {
412	.gpio		= &overo_gpio_data,
413	.vmmc1		= &overo_vmmc1,
414};
415
416static int __init overo_i2c_init(void)
417{
418	omap3_pmic_get_config(&overo_twldata,
419			TWL_COMMON_PDATA_USB | TWL_COMMON_PDATA_AUDIO,
420			TWL_COMMON_REGULATOR_VDAC | TWL_COMMON_REGULATOR_VPLL2);
421
422	overo_twldata.vpll2->constraints.name = "VDVI";
423
424	omap3_pmic_init("tps65950", &overo_twldata);
425	/* i2c2 pins are used for gpio */
426	omap_register_i2c_bus(3, 400, NULL, 0);
427	return 0;
428}
429
430static struct panel_lb035q02_platform_data overo_lcd35_pdata = {
431	.name                   = "lcd35",
432	.source                 = "dpi.0",
433
434	.data_lines		= 24,
435
436	.enable_gpio		= OVERO_GPIO_LCD_EN,
437	.backlight_gpio		= OVERO_GPIO_LCD_BL,
438};
439
440/*
441 * NOTE: We need to add either the lgphilips panel, or the lcd43 panel. The
442 * selection is done based on the overo_use_lcd35 field. If new SPI
443 * devices are added here, extra work is needed to make only the lgphilips panel
444 * affected by the overo_use_lcd35 field.
445 */
446static struct spi_board_info overo_spi_board_info[] __initdata = {
447	{
448		.modalias		= "panel_lgphilips_lb035q02",
449		.bus_num		= 1,
450		.chip_select		= 1,
451		.max_speed_hz		= 500000,
452		.mode			= SPI_MODE_3,
453		.platform_data		= &overo_lcd35_pdata,
454	},
455};
456
457static int __init overo_spi_init(void)
458{
459	overo_ads7846_init();
460
461	if (overo_use_lcd35) {
462		spi_register_board_info(overo_spi_board_info,
463				ARRAY_SIZE(overo_spi_board_info));
464	}
465	return 0;
466}
467
468static struct usbhs_phy_data phy_data[] __initdata = {
469	{
470		.port = 2,
471		.reset_gpio = OVERO_GPIO_USBH_NRESET,
472		.vcc_gpio = -EINVAL,
473	},
474};
475
476static struct usbhs_omap_platform_data usbhs_bdata __initdata = {
477	.port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
478};
479
480#ifdef CONFIG_OMAP_MUX
481static struct omap_board_mux board_mux[] __initdata = {
482	{ .reg_offset = OMAP_MUX_TERMINATOR },
483};
484#endif
485
486static struct gpio overo_bt_gpios[] __initdata = {
487	{ OVERO_GPIO_BT_XGATE,	GPIOF_OUT_INIT_LOW,	"lcd enable"    },
488	{ OVERO_GPIO_BT_NRESET, GPIOF_OUT_INIT_HIGH,	"lcd bl enable" },
489};
490
491static struct regulator_consumer_supply dummy_supplies[] = {
492	REGULATOR_SUPPLY("vddvario", "smsc911x.0"),
493	REGULATOR_SUPPLY("vdd33a", "smsc911x.0"),
494	REGULATOR_SUPPLY("vddvario", "smsc911x.1"),
495	REGULATOR_SUPPLY("vdd33a", "smsc911x.1"),
496};
497
498static void __init overo_init(void)
499{
500	int ret;
501
502	if (strstr(boot_command_line, "omapdss.def_disp=lcd35"))
503		overo_use_lcd35 = true;
504
505	regulator_register_fixed(0, dummy_supplies, ARRAY_SIZE(dummy_supplies));
506	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
507	overo_i2c_init();
508	omap_hsmmc_init(mmc);
509	omap_serial_init();
510	omap_sdrc_init(mt46h32m32lf6_sdrc_params,
511				  mt46h32m32lf6_sdrc_params);
512	board_nand_init(overo_nand_partitions,
513			ARRAY_SIZE(overo_nand_partitions), NAND_CS, 0, NULL);
514	usb_bind_phy("musb-hdrc.0.auto", 0, "twl4030_usb");
515	usb_musb_init(NULL);
516
517	usbhs_init_phys(phy_data, ARRAY_SIZE(phy_data));
518	usbhs_init(&usbhs_bdata);
519	overo_spi_init();
520	overo_init_smsc911x();
521	overo_init_led();
522	overo_init_keys();
523	omap_twl4030_audio_init("overo", NULL);
524
525	overo_display_init();
526
527	/* Ensure SDRC pins are mux'd for self-refresh */
528	omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
529	omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);
530
531	ret = gpio_request_one(OVERO_GPIO_W2W_NRESET, GPIOF_OUT_INIT_HIGH,
532			       "OVERO_GPIO_W2W_NRESET");
533	if (ret == 0) {
534		gpio_export(OVERO_GPIO_W2W_NRESET, 0);
535		gpio_set_value(OVERO_GPIO_W2W_NRESET, 0);
536		udelay(10);
537		gpio_set_value(OVERO_GPIO_W2W_NRESET, 1);
538	} else {
539		pr_err("could not obtain gpio for OVERO_GPIO_W2W_NRESET\n");
540	}
541
542	ret = gpio_request_array(overo_bt_gpios, ARRAY_SIZE(overo_bt_gpios));
543	if (ret) {
544		pr_err("%s: could not obtain BT gpios\n", __func__);
545	} else {
546		gpio_export(OVERO_GPIO_BT_XGATE, 0);
547		gpio_export(OVERO_GPIO_BT_NRESET, 0);
548		gpio_set_value(OVERO_GPIO_BT_NRESET, 0);
549		mdelay(6);
550		gpio_set_value(OVERO_GPIO_BT_NRESET, 1);
551	}
552
553	ret = gpio_request_one(OVERO_GPIO_USBH_CPEN, GPIOF_OUT_INIT_HIGH,
554			       "OVERO_GPIO_USBH_CPEN");
555	if (ret == 0)
556		gpio_export(OVERO_GPIO_USBH_CPEN, 0);
557	else
558		pr_err("could not obtain gpio for OVERO_GPIO_USBH_CPEN\n");
559}
560
561MACHINE_START(OVERO, "Gumstix Overo")
562	.atag_offset	= 0x100,
563	.reserve	= omap_reserve,
564	.map_io		= omap3_map_io,
565	.init_early	= omap35xx_init_early,
566	.init_irq	= omap3_init_irq,
567	.init_machine	= overo_init,
568	.init_late	= omap35xx_init_late,
569	.init_time	= omap3_sync32k_timer_init,
570	.restart	= omap3xxx_restart,
571MACHINE_END
572