1/*
2 * Support for Sharp SL-C7xx PDAs
3 * Models: SL-C700 (Corgi), SL-C750 (Shepherd), SL-C760 (Husky)
4 *
5 * Copyright (c) 2004-2005 Richard Purdie
6 *
7 * Based on Sharp's 2.4 kernel patches/lubbock.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 */
14
15#include <linux/kernel.h>
16#include <linux/init.h>
17#include <linux/platform_device.h>
18#include <linux/major.h>
19#include <linux/fs.h>
20#include <linux/interrupt.h>
21#include <linux/mmc/host.h>
22#include <linux/mtd/physmap.h>
23#include <linux/pm.h>
24#include <linux/gpio.h>
25#include <linux/backlight.h>
26#include <linux/i2c.h>
27#include <linux/i2c/pxa-i2c.h>
28#include <linux/io.h>
29#include <linux/regulator/machine.h>
30#include <linux/spi/spi.h>
31#include <linux/spi/ads7846.h>
32#include <linux/spi/corgi_lcd.h>
33#include <linux/spi/pxa2xx_spi.h>
34#include <linux/mtd/sharpsl.h>
35#include <linux/input/matrix_keypad.h>
36#include <linux/gpio_keys.h>
37#include <linux/module.h>
38#include <linux/memblock.h>
39#include <video/w100fb.h>
40
41#include <asm/setup.h>
42#include <asm/memory.h>
43#include <asm/mach-types.h>
44#include <mach/hardware.h>
45#include <asm/irq.h>
46
47#include <asm/mach/arch.h>
48#include <asm/mach/map.h>
49#include <asm/mach/irq.h>
50
51#include <mach/pxa25x.h>
52#include <linux/platform_data/irda-pxaficp.h>
53#include <linux/platform_data/mmc-pxamci.h>
54#include <mach/udc.h>
55#include <mach/corgi.h>
56#include <mach/sharpsl_pm.h>
57
58#include <asm/mach/sharpsl_param.h>
59#include <asm/hardware/scoop.h>
60
61#include "generic.h"
62#include "devices.h"
63
64static unsigned long corgi_pin_config[] __initdata = {
65	/* Static Memory I/O */
66	GPIO78_nCS_2,	/* w100fb */
67	GPIO80_nCS_4,	/* scoop */
68
69	/* SSP1 */
70	GPIO23_SSP1_SCLK,
71	GPIO25_SSP1_TXD,
72	GPIO26_SSP1_RXD,
73	GPIO24_GPIO,	/* CORGI_GPIO_ADS7846_CS - SFRM as chip select */
74
75	/* I2S */
76	GPIO28_I2S_BITCLK_OUT,
77	GPIO29_I2S_SDATA_IN,
78	GPIO30_I2S_SDATA_OUT,
79	GPIO31_I2S_SYNC,
80	GPIO32_I2S_SYSCLK,
81
82	/* Infra-Red */
83	GPIO47_FICP_TXD,
84	GPIO46_FICP_RXD,
85
86	/* FFUART */
87	GPIO40_FFUART_DTR,
88	GPIO41_FFUART_RTS,
89	GPIO39_FFUART_TXD,
90	GPIO37_FFUART_DSR,
91	GPIO34_FFUART_RXD,
92	GPIO35_FFUART_CTS,
93
94	/* PC Card */
95	GPIO48_nPOE,
96	GPIO49_nPWE,
97	GPIO50_nPIOR,
98	GPIO51_nPIOW,
99	GPIO52_nPCE_1,
100	GPIO53_nPCE_2,
101	GPIO54_nPSKTSEL,
102	GPIO55_nPREG,
103	GPIO56_nPWAIT,
104	GPIO57_nIOIS16,
105
106	/* MMC */
107	GPIO6_MMC_CLK,
108	GPIO8_MMC_CS0,
109
110	/* GPIO Matrix Keypad */
111	GPIO66_GPIO | MFP_LPM_DRIVE_HIGH,	/* column 0 */
112	GPIO67_GPIO | MFP_LPM_DRIVE_HIGH,	/* column 1 */
113	GPIO68_GPIO | MFP_LPM_DRIVE_HIGH,	/* column 2 */
114	GPIO69_GPIO | MFP_LPM_DRIVE_HIGH,	/* column 3 */
115	GPIO70_GPIO | MFP_LPM_DRIVE_HIGH,	/* column 4 */
116	GPIO71_GPIO | MFP_LPM_DRIVE_HIGH,	/* column 5 */
117	GPIO72_GPIO | MFP_LPM_DRIVE_HIGH,	/* column 6 */
118	GPIO73_GPIO | MFP_LPM_DRIVE_HIGH,	/* column 7 */
119	GPIO74_GPIO | MFP_LPM_DRIVE_HIGH,	/* column 8 */
120	GPIO75_GPIO | MFP_LPM_DRIVE_HIGH,	/* column 9 */
121	GPIO76_GPIO | MFP_LPM_DRIVE_HIGH,	/* column 10 */
122	GPIO77_GPIO | MFP_LPM_DRIVE_HIGH,	/* column 11 */
123	GPIO58_GPIO,	/* row 0 */
124	GPIO59_GPIO,	/* row 1 */
125	GPIO60_GPIO,	/* row 2 */
126	GPIO61_GPIO,	/* row 3 */
127	GPIO62_GPIO,	/* row 4 */
128	GPIO63_GPIO,	/* row 5 */
129	GPIO64_GPIO,	/* row 6 */
130	GPIO65_GPIO,	/* row 7 */
131
132	/* GPIO */
133	GPIO9_GPIO,				/* CORGI_GPIO_nSD_DETECT */
134	GPIO7_GPIO,				/* CORGI_GPIO_nSD_WP */
135	GPIO11_GPIO | WAKEUP_ON_EDGE_BOTH,	/* CORGI_GPIO_MAIN_BAT_{LOW,COVER} */
136	GPIO13_GPIO | MFP_LPM_KEEP_OUTPUT,	/* CORGI_GPIO_LED_ORANGE */
137	GPIO21_GPIO,				/* CORGI_GPIO_ADC_TEMP */
138	GPIO22_GPIO,				/* CORGI_GPIO_IR_ON */
139	GPIO33_GPIO,				/* CORGI_GPIO_SD_PWR */
140	GPIO38_GPIO | MFP_LPM_KEEP_OUTPUT,	/* CORGI_GPIO_CHRG_ON */
141	GPIO43_GPIO | MFP_LPM_KEEP_OUTPUT,	/* CORGI_GPIO_CHRG_UKN */
142	GPIO44_GPIO,				/* CORGI_GPIO_HSYNC */
143
144	GPIO0_GPIO | WAKEUP_ON_EDGE_BOTH,	/* CORGI_GPIO_KEY_INT */
145	GPIO1_GPIO | WAKEUP_ON_EDGE_RISE,	/* CORGI_GPIO_AC_IN */
146	GPIO3_GPIO | WAKEUP_ON_EDGE_BOTH,	/* CORGI_GPIO_WAKEUP */
147};
148
149/*
150 * Corgi SCOOP Device
151 */
152static struct resource corgi_scoop_resources[] = {
153	[0] = {
154		.start		= 0x10800000,
155		.end		= 0x10800fff,
156		.flags		= IORESOURCE_MEM,
157	},
158};
159
160static struct scoop_config corgi_scoop_setup = {
161	.io_dir 	= CORGI_SCOOP_IO_DIR,
162	.io_out		= CORGI_SCOOP_IO_OUT,
163	.gpio_base	= CORGI_SCOOP_GPIO_BASE,
164};
165
166struct platform_device corgiscoop_device = {
167	.name		= "sharp-scoop",
168	.id		= -1,
169	.dev		= {
170 		.platform_data	= &corgi_scoop_setup,
171	},
172	.num_resources	= ARRAY_SIZE(corgi_scoop_resources),
173	.resource	= corgi_scoop_resources,
174};
175
176static struct scoop_pcmcia_dev corgi_pcmcia_scoop[] = {
177{
178	.dev        = &corgiscoop_device.dev,
179	.irq        = CORGI_IRQ_GPIO_CF_IRQ,
180	.cd_irq     = CORGI_IRQ_GPIO_CF_CD,
181	.cd_irq_str = "PCMCIA0 CD",
182},
183};
184
185static struct scoop_pcmcia_config corgi_pcmcia_config = {
186	.devs         = &corgi_pcmcia_scoop[0],
187	.num_devs     = 1,
188};
189
190static struct w100_mem_info corgi_fb_mem = {
191	.ext_cntl          = 0x00040003,
192	.sdram_mode_reg    = 0x00650021,
193	.ext_timing_cntl   = 0x10002a4a,
194	.io_cntl           = 0x7ff87012,
195	.size              = 0x1fffff,
196};
197
198static struct w100_gen_regs corgi_fb_regs = {
199	.lcd_format    = 0x00000003,
200	.lcdd_cntl1    = 0x01CC0000,
201	.lcdd_cntl2    = 0x0003FFFF,
202	.genlcd_cntl1  = 0x00FFFF0D,
203	.genlcd_cntl2  = 0x003F3003,
204	.genlcd_cntl3  = 0x000102aa,
205};
206
207static struct w100_gpio_regs corgi_fb_gpio = {
208	.init_data1   = 0x000000bf,
209	.init_data2   = 0x00000000,
210	.gpio_dir1    = 0x00000000,
211	.gpio_oe1     = 0x03c0feff,
212	.gpio_dir2    = 0x00000000,
213	.gpio_oe2     = 0x00000000,
214};
215
216static struct w100_mode corgi_fb_modes[] = {
217{
218	.xres            = 480,
219	.yres            = 640,
220	.left_margin     = 0x56,
221	.right_margin    = 0x55,
222	.upper_margin    = 0x03,
223	.lower_margin    = 0x00,
224	.crtc_ss         = 0x82360056,
225	.crtc_ls         = 0xA0280000,
226	.crtc_gs         = 0x80280028,
227	.crtc_vpos_gs    = 0x02830002,
228	.crtc_rev        = 0x00400008,
229	.crtc_dclk       = 0xA0000000,
230	.crtc_gclk       = 0x8015010F,
231	.crtc_goe        = 0x80100110,
232	.crtc_ps1_active = 0x41060010,
233	.pll_freq        = 75,
234	.fast_pll_freq   = 100,
235	.sysclk_src      = CLK_SRC_PLL,
236	.sysclk_divider  = 0,
237	.pixclk_src      = CLK_SRC_PLL,
238	.pixclk_divider  = 2,
239	.pixclk_divider_rotated = 6,
240},{
241	.xres            = 240,
242	.yres            = 320,
243	.left_margin     = 0x27,
244	.right_margin    = 0x2e,
245	.upper_margin    = 0x01,
246	.lower_margin    = 0x00,
247	.crtc_ss         = 0x81170027,
248	.crtc_ls         = 0xA0140000,
249	.crtc_gs         = 0xC0140014,
250	.crtc_vpos_gs    = 0x00010141,
251	.crtc_rev        = 0x00400008,
252	.crtc_dclk       = 0xA0000000,
253	.crtc_gclk       = 0x8015010F,
254	.crtc_goe        = 0x80100110,
255	.crtc_ps1_active = 0x41060010,
256	.pll_freq        = 0,
257	.fast_pll_freq   = 0,
258	.sysclk_src      = CLK_SRC_XTAL,
259	.sysclk_divider  = 0,
260	.pixclk_src      = CLK_SRC_XTAL,
261	.pixclk_divider  = 1,
262	.pixclk_divider_rotated = 1,
263},
264
265};
266
267static struct w100fb_mach_info corgi_fb_info = {
268	.init_mode  = INIT_MODE_ROTATED,
269	.mem        = &corgi_fb_mem,
270	.regs       = &corgi_fb_regs,
271	.modelist   = &corgi_fb_modes[0],
272	.num_modes  = 2,
273	.gpio       = &corgi_fb_gpio,
274	.xtal_freq  = 12500000,
275	.xtal_dbl   = 0,
276};
277
278static struct resource corgi_fb_resources[] = {
279	[0] = {
280		.start   = 0x08000000,
281		.end     = 0x08ffffff,
282		.flags   = IORESOURCE_MEM,
283	},
284};
285
286static struct platform_device corgifb_device = {
287	.name           = "w100fb",
288	.id             = -1,
289	.num_resources	= ARRAY_SIZE(corgi_fb_resources),
290	.resource	= corgi_fb_resources,
291	.dev            = {
292		.platform_data = &corgi_fb_info,
293	},
294
295};
296
297/*
298 * Corgi Keyboard Device
299 */
300#define CORGI_KEY_CALENDER	KEY_F1
301#define CORGI_KEY_ADDRESS	KEY_F2
302#define CORGI_KEY_FN		KEY_F3
303#define CORGI_KEY_CANCEL	KEY_F4
304#define CORGI_KEY_OFF		KEY_SUSPEND
305#define CORGI_KEY_EXOK		KEY_F5
306#define CORGI_KEY_EXCANCEL	KEY_F6
307#define CORGI_KEY_EXJOGDOWN	KEY_F7
308#define CORGI_KEY_EXJOGUP	KEY_F8
309#define CORGI_KEY_JAP1		KEY_LEFTCTRL
310#define CORGI_KEY_JAP2		KEY_LEFTALT
311#define CORGI_KEY_MAIL		KEY_F10
312#define CORGI_KEY_OK		KEY_F11
313#define CORGI_KEY_MENU		KEY_F12
314
315static const uint32_t corgikbd_keymap[] = {
316	KEY(0, 1, KEY_1),
317	KEY(0, 2, KEY_3),
318	KEY(0, 3, KEY_5),
319	KEY(0, 4, KEY_6),
320	KEY(0, 5, KEY_7),
321	KEY(0, 6, KEY_9),
322	KEY(0, 7, KEY_0),
323	KEY(0, 8, KEY_BACKSPACE),
324	KEY(1, 1, KEY_2),
325	KEY(1, 2, KEY_4),
326	KEY(1, 3, KEY_R),
327	KEY(1, 4, KEY_Y),
328	KEY(1, 5, KEY_8),
329	KEY(1, 6, KEY_I),
330	KEY(1, 7, KEY_O),
331	KEY(1, 8, KEY_P),
332	KEY(2, 0, KEY_TAB),
333	KEY(2, 1, KEY_Q),
334	KEY(2, 2, KEY_E),
335	KEY(2, 3, KEY_T),
336	KEY(2, 4, KEY_G),
337	KEY(2, 5, KEY_U),
338	KEY(2, 6, KEY_J),
339	KEY(2, 7, KEY_K),
340	KEY(3, 0, CORGI_KEY_CALENDER),
341	KEY(3, 1, KEY_W),
342	KEY(3, 2, KEY_S),
343	KEY(3, 3, KEY_F),
344	KEY(3, 4, KEY_V),
345	KEY(3, 5, KEY_H),
346	KEY(3, 6, KEY_M),
347	KEY(3, 7, KEY_L),
348	KEY(3, 9, KEY_RIGHTSHIFT),
349	KEY(4, 0, CORGI_KEY_ADDRESS),
350	KEY(4, 1, KEY_A),
351	KEY(4, 2, KEY_D),
352	KEY(4, 3, KEY_C),
353	KEY(4, 4, KEY_B),
354	KEY(4, 5, KEY_N),
355	KEY(4, 6, KEY_DOT),
356	KEY(4, 8, KEY_ENTER),
357	KEY(4, 10, KEY_LEFTSHIFT),
358	KEY(5, 0, CORGI_KEY_MAIL),
359	KEY(5, 1, KEY_Z),
360	KEY(5, 2, KEY_X),
361	KEY(5, 3, KEY_MINUS),
362	KEY(5, 4, KEY_SPACE),
363	KEY(5, 5, KEY_COMMA),
364	KEY(5, 7, KEY_UP),
365	KEY(5, 11, CORGI_KEY_FN),
366	KEY(6, 0, KEY_SYSRQ),
367	KEY(6, 1, CORGI_KEY_JAP1),
368	KEY(6, 2, CORGI_KEY_JAP2),
369	KEY(6, 3, CORGI_KEY_CANCEL),
370	KEY(6, 4, CORGI_KEY_OK),
371	KEY(6, 5, CORGI_KEY_MENU),
372	KEY(6, 6, KEY_LEFT),
373	KEY(6, 7, KEY_DOWN),
374	KEY(6, 8, KEY_RIGHT),
375	KEY(7, 0, CORGI_KEY_OFF),
376	KEY(7, 1, CORGI_KEY_EXOK),
377	KEY(7, 2, CORGI_KEY_EXCANCEL),
378	KEY(7, 3, CORGI_KEY_EXJOGDOWN),
379	KEY(7, 4, CORGI_KEY_EXJOGUP),
380};
381
382static struct matrix_keymap_data corgikbd_keymap_data = {
383	.keymap		= corgikbd_keymap,
384	.keymap_size	= ARRAY_SIZE(corgikbd_keymap),
385};
386
387static const int corgikbd_row_gpios[] =
388		{ 58, 59, 60, 61, 62, 63, 64, 65 };
389static const int corgikbd_col_gpios[] =
390		{ 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77 };
391
392static struct matrix_keypad_platform_data corgikbd_pdata = {
393	.keymap_data		= &corgikbd_keymap_data,
394	.row_gpios		= corgikbd_row_gpios,
395	.col_gpios		= corgikbd_col_gpios,
396	.num_row_gpios		= ARRAY_SIZE(corgikbd_row_gpios),
397	.num_col_gpios		= ARRAY_SIZE(corgikbd_col_gpios),
398	.col_scan_delay_us	= 10,
399	.debounce_ms		= 10,
400	.wakeup			= 1,
401};
402
403static struct platform_device corgikbd_device = {
404	.name		= "matrix-keypad",
405	.id		= -1,
406	.dev		= {
407		.platform_data = &corgikbd_pdata,
408	},
409};
410
411static struct gpio_keys_button corgi_gpio_keys[] = {
412	{
413		.type	= EV_SW,
414		.code	= SW_LID,
415		.gpio	= CORGI_GPIO_SWA,
416		.desc	= "Lid close switch",
417		.debounce_interval = 500,
418	},
419	{
420		.type	= EV_SW,
421		.code	= SW_TABLET_MODE,
422		.gpio	= CORGI_GPIO_SWB,
423		.desc	= "Tablet mode switch",
424		.debounce_interval = 500,
425	},
426	{
427		.type	= EV_SW,
428		.code	= SW_HEADPHONE_INSERT,
429		.gpio	= CORGI_GPIO_AK_INT,
430		.desc	= "HeadPhone insert",
431		.debounce_interval = 500,
432	},
433};
434
435static struct gpio_keys_platform_data corgi_gpio_keys_platform_data = {
436	.buttons	= corgi_gpio_keys,
437	.nbuttons	= ARRAY_SIZE(corgi_gpio_keys),
438	.poll_interval	= 250,
439};
440
441static struct platform_device corgi_gpio_keys_device = {
442	.name	= "gpio-keys-polled",
443	.id	= -1,
444	.dev	= {
445		.platform_data	= &corgi_gpio_keys_platform_data,
446	},
447};
448
449/*
450 * Corgi LEDs
451 */
452static struct gpio_led corgi_gpio_leds[] = {
453	{
454		.name			= "corgi:amber:charge",
455		.default_trigger	= "sharpsl-charge",
456		.gpio			= CORGI_GPIO_LED_ORANGE,
457	},
458	{
459		.name			= "corgi:green:mail",
460		.default_trigger	= "nand-disk",
461		.gpio			= CORGI_GPIO_LED_GREEN,
462	},
463};
464
465static struct gpio_led_platform_data corgi_gpio_leds_info = {
466	.leds		= corgi_gpio_leds,
467	.num_leds	= ARRAY_SIZE(corgi_gpio_leds),
468};
469
470static struct platform_device corgiled_device = {
471	.name		= "leds-gpio",
472	.id		= -1,
473	.dev		= {
474		.platform_data = &corgi_gpio_leds_info,
475	},
476};
477
478/*
479 * Corgi Audio
480 */
481static struct platform_device corgi_audio_device = {
482	.name	= "corgi-audio",
483	.id	= -1,
484};
485
486/*
487 * MMC/SD Device
488 *
489 * The card detect interrupt isn't debounced so we delay it by 250ms
490 * to give the card a chance to fully insert/eject.
491 */
492static struct pxamci_platform_data corgi_mci_platform_data = {
493	.detect_delay_ms	= 250,
494	.ocr_mask		= MMC_VDD_32_33|MMC_VDD_33_34,
495	.gpio_card_detect	= CORGI_GPIO_nSD_DETECT,
496	.gpio_card_ro		= CORGI_GPIO_nSD_WP,
497	.gpio_power		= CORGI_GPIO_SD_PWR,
498};
499
500
501/*
502 * Irda
503 */
504static struct pxaficp_platform_data corgi_ficp_platform_data = {
505	.gpio_pwdown		= CORGI_GPIO_IR_ON,
506	.transceiver_cap	= IR_SIRMODE | IR_OFF,
507};
508
509
510/*
511 * USB Device Controller
512 */
513static struct pxa2xx_udc_mach_info udc_info __initdata = {
514	/* no connect GPIO; corgi can't tell connection status */
515	.gpio_pullup		= CORGI_GPIO_USB_PULLUP,
516};
517
518#if IS_ENABLED(CONFIG_SPI_PXA2XX)
519static struct pxa2xx_spi_master corgi_spi_info = {
520	.num_chipselect	= 3,
521};
522
523static void corgi_wait_for_hsync(void)
524{
525	while (gpio_get_value(CORGI_GPIO_HSYNC))
526		cpu_relax();
527
528	while (!gpio_get_value(CORGI_GPIO_HSYNC))
529		cpu_relax();
530}
531
532static struct ads7846_platform_data corgi_ads7846_info = {
533	.model			= 7846,
534	.vref_delay_usecs	= 100,
535	.x_plate_ohms		= 419,
536	.y_plate_ohms		= 486,
537	.gpio_pendown		= CORGI_GPIO_TP_INT,
538	.wait_for_sync		= corgi_wait_for_hsync,
539};
540
541static struct pxa2xx_spi_chip corgi_ads7846_chip = {
542	.gpio_cs	= CORGI_GPIO_ADS7846_CS,
543};
544
545static void corgi_bl_kick_battery(void)
546{
547	void (*kick_batt)(void);
548
549	kick_batt = symbol_get(sharpsl_battery_kick);
550	if (kick_batt) {
551		kick_batt();
552		symbol_put(sharpsl_battery_kick);
553	}
554}
555
556static struct corgi_lcd_platform_data corgi_lcdcon_info = {
557	.init_mode		= CORGI_LCD_MODE_VGA,
558	.max_intensity		= 0x2f,
559	.default_intensity	= 0x1f,
560	.limit_mask		= 0x0b,
561	.gpio_backlight_cont	= CORGI_GPIO_BACKLIGHT_CONT,
562	.gpio_backlight_on	= -1,
563	.kick_battery		= corgi_bl_kick_battery,
564};
565
566static struct pxa2xx_spi_chip corgi_lcdcon_chip = {
567	.gpio_cs	= CORGI_GPIO_LCDCON_CS,
568};
569
570static struct pxa2xx_spi_chip corgi_max1111_chip = {
571	.gpio_cs	= CORGI_GPIO_MAX1111_CS,
572};
573
574static struct spi_board_info corgi_spi_devices[] = {
575	{
576		.modalias	= "ads7846",
577		.max_speed_hz	= 1200000,
578		.bus_num	= 1,
579		.chip_select	= 0,
580		.platform_data	= &corgi_ads7846_info,
581		.controller_data= &corgi_ads7846_chip,
582		.irq		= PXA_GPIO_TO_IRQ(CORGI_GPIO_TP_INT),
583	}, {
584		.modalias	= "corgi-lcd",
585		.max_speed_hz	= 50000,
586		.bus_num	= 1,
587		.chip_select	= 1,
588		.platform_data	= &corgi_lcdcon_info,
589		.controller_data= &corgi_lcdcon_chip,
590	}, {
591		.modalias	= "max1111",
592		.max_speed_hz	= 450000,
593		.bus_num	= 1,
594		.chip_select	= 2,
595		.controller_data= &corgi_max1111_chip,
596	},
597};
598
599static void __init corgi_init_spi(void)
600{
601	pxa2xx_set_spi_info(1, &corgi_spi_info);
602	spi_register_board_info(ARRAY_AND_SIZE(corgi_spi_devices));
603}
604#else
605static inline void corgi_init_spi(void) {}
606#endif
607
608static struct mtd_partition sharpsl_nand_partitions[] = {
609	{
610		.name = "System Area",
611		.offset = 0,
612		.size = 7 * 1024 * 1024,
613	},
614	{
615		.name = "Root Filesystem",
616		.offset = 7 * 1024 * 1024,
617		.size = 25 * 1024 * 1024,
618	},
619	{
620		.name = "Home Filesystem",
621		.offset = MTDPART_OFS_APPEND,
622		.size = MTDPART_SIZ_FULL,
623	},
624};
625
626static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
627
628static struct nand_bbt_descr sharpsl_bbt = {
629	.options = 0,
630	.offs = 4,
631	.len = 2,
632	.pattern = scan_ff_pattern
633};
634
635static struct sharpsl_nand_platform_data sharpsl_nand_platform_data = {
636	.badblock_pattern	= &sharpsl_bbt,
637	.partitions		= sharpsl_nand_partitions,
638	.nr_partitions		= ARRAY_SIZE(sharpsl_nand_partitions),
639};
640
641static struct resource sharpsl_nand_resources[] = {
642	{
643		.start	= 0x0C000000,
644		.end	= 0x0C000FFF,
645		.flags	= IORESOURCE_MEM,
646	},
647};
648
649static struct platform_device sharpsl_nand_device = {
650	.name		= "sharpsl-nand",
651	.id		= -1,
652	.resource	= sharpsl_nand_resources,
653	.num_resources	= ARRAY_SIZE(sharpsl_nand_resources),
654	.dev.platform_data	= &sharpsl_nand_platform_data,
655};
656
657static struct mtd_partition sharpsl_rom_parts[] = {
658	{
659		.name	="Boot PROM Filesystem",
660		.offset	= 0x00120000,
661		.size	= MTDPART_SIZ_FULL,
662	},
663};
664
665static struct physmap_flash_data sharpsl_rom_data = {
666	.width		= 2,
667	.nr_parts	= ARRAY_SIZE(sharpsl_rom_parts),
668	.parts		= sharpsl_rom_parts,
669};
670
671static struct resource sharpsl_rom_resources[] = {
672	{
673		.start	= 0x00000000,
674		.end	= 0x007fffff,
675		.flags	= IORESOURCE_MEM,
676	},
677};
678
679static struct platform_device sharpsl_rom_device = {
680	.name	= "physmap-flash",
681	.id	= -1,
682	.resource = sharpsl_rom_resources,
683	.num_resources = ARRAY_SIZE(sharpsl_rom_resources),
684	.dev.platform_data = &sharpsl_rom_data,
685};
686
687static struct platform_device *devices[] __initdata = {
688	&corgiscoop_device,
689	&corgifb_device,
690	&corgi_gpio_keys_device,
691	&corgikbd_device,
692	&corgiled_device,
693	&corgi_audio_device,
694	&sharpsl_nand_device,
695	&sharpsl_rom_device,
696};
697
698static struct i2c_board_info __initdata corgi_i2c_devices[] = {
699	{ I2C_BOARD_INFO("wm8731", 0x1b) },
700};
701
702static void corgi_poweroff(void)
703{
704	if (!machine_is_corgi())
705		/* Green LED off tells the bootloader to halt */
706		gpio_set_value(CORGI_GPIO_LED_GREEN, 0);
707
708	pxa_restart(REBOOT_HARD, NULL);
709}
710
711static void corgi_restart(enum reboot_mode mode, const char *cmd)
712{
713	if (!machine_is_corgi())
714		/* Green LED on tells the bootloader to reboot */
715		gpio_set_value(CORGI_GPIO_LED_GREEN, 1);
716
717	pxa_restart(REBOOT_HARD, cmd);
718}
719
720static void __init corgi_init(void)
721{
722	pm_power_off = corgi_poweroff;
723
724	/* Stop 3.6MHz and drive HIGH to PCMCIA and CS */
725	PCFR |= PCFR_OPDE;
726
727	pxa2xx_mfp_config(ARRAY_AND_SIZE(corgi_pin_config));
728
729	/* allow wakeup from various GPIOs */
730	gpio_set_wake(CORGI_GPIO_KEY_INT, 1);
731	gpio_set_wake(CORGI_GPIO_WAKEUP, 1);
732	gpio_set_wake(CORGI_GPIO_AC_IN, 1);
733	gpio_set_wake(CORGI_GPIO_CHRG_FULL, 1);
734
735	if (!machine_is_corgi())
736		gpio_set_wake(CORGI_GPIO_MAIN_BAT_LOW, 1);
737
738	pxa_set_ffuart_info(NULL);
739	pxa_set_btuart_info(NULL);
740	pxa_set_stuart_info(NULL);
741
742	corgi_init_spi();
743
744 	pxa_set_udc_info(&udc_info);
745	pxa_set_mci_info(&corgi_mci_platform_data);
746	pxa_set_ficp_info(&corgi_ficp_platform_data);
747	pxa_set_i2c_info(NULL);
748	i2c_register_board_info(0, ARRAY_AND_SIZE(corgi_i2c_devices));
749
750	platform_scoop_config = &corgi_pcmcia_config;
751
752	if (machine_is_husky())
753		sharpsl_nand_partitions[1].size = 53 * 1024 * 1024;
754
755	platform_add_devices(devices, ARRAY_SIZE(devices));
756
757	regulator_has_full_constraints();
758}
759
760static void __init fixup_corgi(struct tag *tags, char **cmdline)
761{
762	sharpsl_save_param();
763	if (machine_is_corgi())
764		memblock_add(0xa0000000, SZ_32M);
765	else
766		memblock_add(0xa0000000, SZ_64M);
767}
768
769#ifdef CONFIG_MACH_CORGI
770MACHINE_START(CORGI, "SHARP Corgi")
771	.fixup		= fixup_corgi,
772	.map_io		= pxa25x_map_io,
773	.nr_irqs	= PXA_NR_IRQS,
774	.init_irq	= pxa25x_init_irq,
775	.handle_irq	= pxa25x_handle_irq,
776	.init_machine	= corgi_init,
777	.init_time	= pxa_timer_init,
778	.restart	= corgi_restart,
779MACHINE_END
780#endif
781
782#ifdef CONFIG_MACH_SHEPHERD
783MACHINE_START(SHEPHERD, "SHARP Shepherd")
784	.fixup		= fixup_corgi,
785	.map_io		= pxa25x_map_io,
786	.nr_irqs	= PXA_NR_IRQS,
787	.init_irq	= pxa25x_init_irq,
788	.handle_irq	= pxa25x_handle_irq,
789	.init_machine	= corgi_init,
790	.init_time	= pxa_timer_init,
791	.restart	= corgi_restart,
792MACHINE_END
793#endif
794
795#ifdef CONFIG_MACH_HUSKY
796MACHINE_START(HUSKY, "SHARP Husky")
797	.fixup		= fixup_corgi,
798	.map_io		= pxa25x_map_io,
799	.nr_irqs	= PXA_NR_IRQS,
800	.init_irq	= pxa25x_init_irq,
801	.handle_irq	= pxa25x_handle_irq,
802	.init_machine	= corgi_init,
803	.init_time	= pxa_timer_init,
804	.restart	= corgi_restart,
805MACHINE_END
806#endif
807
808