[ARM] pxa/tosa: add physmap mapping for ROM
[linux-2.6.git] / arch / arm / mach-pxa / tosa.c
1 /*
2  *  Support for Sharp SL-C6000x PDAs
3  *  Model: (Tosa)
4  *
5  *  Copyright (c) 2005 Dirk Opfer
6  *
7  *      Based on code written by Sharp/Lineo for 2.4 kernels
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/delay.h>
22 #include <linux/fb.h>
23 #include <linux/mmc/host.h>
24 #include <linux/mfd/tc6393xb.h>
25 #include <linux/mfd/tmio.h>
26 #include <linux/mtd/nand.h>
27 #include <linux/mtd/partitions.h>
28 #include <linux/mtd/physmap.h>
29 #include <linux/pm.h>
30 #include <linux/gpio_keys.h>
31 #include <linux/input.h>
32 #include <linux/gpio.h>
33 #include <linux/pda_power.h>
34 #include <linux/rfkill.h>
35 #include <linux/spi/spi.h>
36
37 #include <asm/setup.h>
38 #include <asm/mach-types.h>
39 #include <mach/pxa2xx-regs.h>
40 #include <mach/mfp-pxa25x.h>
41 #include <mach/reset.h>
42 #include <mach/irda.h>
43 #include <mach/i2c.h>
44 #include <mach/mmc.h>
45 #include <mach/udc.h>
46 #include <mach/tosa_bt.h>
47 #include <mach/pxa2xx_spi.h>
48
49 #include <asm/mach/arch.h>
50 #include <mach/tosa.h>
51
52 #include <asm/hardware/scoop.h>
53 #include <asm/mach/sharpsl_param.h>
54
55 #include "generic.h"
56 #include "clock.h"
57 #include "devices.h"
58
59 static unsigned long tosa_pin_config[] = {
60         GPIO78_nCS_2, /* Scoop */
61         GPIO80_nCS_4, /* tg6393xb */
62         GPIO33_nCS_5, /* Scoop */
63
64         // GPIO76 CARD_VCC_ON1
65
66         GPIO19_GPIO, /* Reset out */
67         GPIO1_RST | WAKEUP_ON_EDGE_FALL,
68
69         GPIO0_GPIO | WAKEUP_ON_EDGE_FALL, /* WAKE_UP */
70         GPIO2_GPIO | WAKEUP_ON_EDGE_BOTH, /* AC_IN */
71         GPIO3_GPIO | WAKEUP_ON_EDGE_FALL, /* RECORD */
72         GPIO4_GPIO | WAKEUP_ON_EDGE_FALL, /* SYNC */
73         GPIO20_GPIO, /* EAR_IN */
74         GPIO22_GPIO, /* On */
75
76         GPIO5_GPIO, /* USB_IN */
77         GPIO32_GPIO, /* Pen IRQ */
78
79         GPIO7_GPIO, /* Jacket Detect */
80         GPIO14_GPIO, /* BAT0_CRG */
81         GPIO12_GPIO, /* BAT1_CRG */
82         GPIO17_GPIO, /* BAT0_LOW */
83         GPIO84_GPIO, /* BAT1_LOW */
84         GPIO38_GPIO, /* BAT_LOCK */
85
86         GPIO11_3_6MHz,
87         GPIO15_GPIO, /* TC6393XB IRQ */
88         GPIO18_RDY,
89         GPIO27_GPIO, /* LCD Sync */
90
91         /* MMC */
92         GPIO6_MMC_CLK,
93         GPIO8_MMC_CS0,
94         GPIO9_GPIO, /* Detect */
95         GPIO10_GPIO, /* nSD_INT */
96
97         /* CF */
98         GPIO13_GPIO, /* CD_IRQ */
99         GPIO21_GPIO, /* Main Slot IRQ */
100         GPIO36_GPIO, /* Jacket Slot IRQ */
101         GPIO48_nPOE,
102         GPIO49_nPWE,
103         GPIO50_nPIOR,
104         GPIO51_nPIOW,
105         GPIO52_nPCE_1,
106         GPIO53_nPCE_2,
107         GPIO54_nPSKTSEL,
108         GPIO55_nPREG,
109         GPIO56_nPWAIT,
110         GPIO57_nIOIS16,
111
112         /* AC97 */
113         GPIO31_AC97_SYNC,
114         GPIO30_AC97_SDATA_OUT,
115         GPIO28_AC97_BITCLK,
116         GPIO29_AC97_SDATA_IN_0,
117         // GPIO79 nAUD_IRQ
118
119         /* FFUART */
120         GPIO34_FFUART_RXD,
121         GPIO35_FFUART_CTS,
122         GPIO37_FFUART_DSR,
123         GPIO39_FFUART_TXD,
124         GPIO40_FFUART_DTR,
125         GPIO41_FFUART_RTS,
126
127         /* BTUART */
128         GPIO42_BTUART_RXD,
129         GPIO43_BTUART_TXD,
130         GPIO44_BTUART_CTS,
131         GPIO45_BTUART_RTS,
132
133         /* Keybd */
134         GPIO58_GPIO | MFP_LPM_DRIVE_LOW,
135         GPIO59_GPIO | MFP_LPM_DRIVE_LOW,
136         GPIO60_GPIO | MFP_LPM_DRIVE_LOW,
137         GPIO61_GPIO | MFP_LPM_DRIVE_LOW,
138         GPIO62_GPIO | MFP_LPM_DRIVE_LOW,
139         GPIO63_GPIO | MFP_LPM_DRIVE_LOW,
140         GPIO64_GPIO | MFP_LPM_DRIVE_LOW,
141         GPIO65_GPIO | MFP_LPM_DRIVE_LOW,
142         GPIO66_GPIO | MFP_LPM_DRIVE_LOW,
143         GPIO67_GPIO | MFP_LPM_DRIVE_LOW,
144         GPIO68_GPIO | MFP_LPM_DRIVE_LOW,
145         GPIO69_GPIO | MFP_LPM_DRIVE_LOW,
146         GPIO70_GPIO | MFP_LPM_DRIVE_LOW,
147         GPIO71_GPIO | MFP_LPM_DRIVE_LOW,
148         GPIO72_GPIO | MFP_LPM_DRIVE_LOW,
149         GPIO73_GPIO | MFP_LPM_DRIVE_LOW,
150         GPIO74_GPIO | MFP_LPM_DRIVE_LOW,
151         GPIO75_GPIO | MFP_LPM_DRIVE_LOW,
152
153         /* SPI */
154         GPIO81_SSP2_CLK_OUT,
155         GPIO82_SSP2_FRM_OUT,
156         GPIO83_SSP2_TXD,
157
158         /* IrDA is managed in other way */
159         GPIO46_GPIO,
160         GPIO47_GPIO,
161 };
162
163 /*
164  * SCOOP Device
165  */
166 static struct resource tosa_scoop_resources[] = {
167         [0] = {
168                 .start  = TOSA_CF_PHYS,
169                 .end    = TOSA_CF_PHYS + 0xfff,
170                 .flags  = IORESOURCE_MEM,
171         },
172 };
173
174 static struct scoop_config tosa_scoop_setup = {
175         .io_dir         = TOSA_SCOOP_IO_DIR,
176         .gpio_base      = TOSA_SCOOP_GPIO_BASE,
177 };
178
179 static struct platform_device tosascoop_device = {
180         .name           = "sharp-scoop",
181         .id             = 0,
182         .dev            = {
183                 .platform_data  = &tosa_scoop_setup,
184         },
185         .num_resources  = ARRAY_SIZE(tosa_scoop_resources),
186         .resource       = tosa_scoop_resources,
187 };
188
189
190 /*
191  * SCOOP Device Jacket
192  */
193 static struct resource tosa_scoop_jc_resources[] = {
194         [0] = {
195                 .start          = TOSA_SCOOP_PHYS + 0x40,
196                 .end            = TOSA_SCOOP_PHYS + 0xfff,
197                 .flags          = IORESOURCE_MEM,
198         },
199 };
200
201 static struct scoop_config tosa_scoop_jc_setup = {
202         .io_dir         = TOSA_SCOOP_JC_IO_DIR,
203         .gpio_base      = TOSA_SCOOP_JC_GPIO_BASE,
204 };
205
206 static struct platform_device tosascoop_jc_device = {
207         .name           = "sharp-scoop",
208         .id             = 1,
209         .dev            = {
210                 .platform_data  = &tosa_scoop_jc_setup,
211                 .parent         = &tosascoop_device.dev,
212         },
213         .num_resources  = ARRAY_SIZE(tosa_scoop_jc_resources),
214         .resource       = tosa_scoop_jc_resources,
215 };
216
217 /*
218  * PCMCIA
219  */
220 static struct scoop_pcmcia_dev tosa_pcmcia_scoop[] = {
221 {
222         .dev        = &tosascoop_device.dev,
223         .irq        = TOSA_IRQ_GPIO_CF_IRQ,
224         .cd_irq     = TOSA_IRQ_GPIO_CF_CD,
225         .cd_irq_str = "PCMCIA0 CD",
226 },{
227         .dev        = &tosascoop_jc_device.dev,
228         .irq        = TOSA_IRQ_GPIO_JC_CF_IRQ,
229         .cd_irq     = -1,
230 },
231 };
232
233 static struct scoop_pcmcia_config tosa_pcmcia_config = {
234         .devs         = &tosa_pcmcia_scoop[0],
235         .num_devs     = 2,
236 };
237
238 /*
239  * USB Device Controller
240  */
241 static struct pxa2xx_udc_mach_info udc_info __initdata = {
242         .gpio_pullup            = TOSA_GPIO_USB_PULLUP,
243         .gpio_vbus              = TOSA_GPIO_USB_IN,
244         .gpio_vbus_inverted     = 1,
245 };
246
247 /*
248  * MMC/SD Device
249  */
250 static struct pxamci_platform_data tosa_mci_platform_data;
251
252 static int tosa_mci_init(struct device *dev, irq_handler_t tosa_detect_int, void *data)
253 {
254         int err;
255
256         tosa_mci_platform_data.detect_delay = msecs_to_jiffies(250);
257
258         err = gpio_request(TOSA_GPIO_nSD_DETECT, "MMC/SD card detect");
259         if (err) {
260                 printk(KERN_ERR "tosa_mci_init: can't request nSD_DETECT gpio\n");
261                 goto err_gpio_detect;
262         }
263         err = gpio_direction_input(TOSA_GPIO_nSD_DETECT);
264         if (err)
265                 goto err_gpio_detect_dir;
266
267         err = request_irq(TOSA_IRQ_GPIO_nSD_DETECT, tosa_detect_int,
268                           IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
269                                 "MMC/SD card detect", data);
270         if (err) {
271                 printk(KERN_ERR "tosa_mci_init: MMC/SD: can't request MMC card detect IRQ\n");
272                 goto err_irq;
273         }
274
275         err = gpio_request(TOSA_GPIO_SD_WP, "SD Write Protect");
276         if (err) {
277                 printk(KERN_ERR "tosa_mci_init: can't request SD_WP gpio\n");
278                 goto err_gpio_wp;
279         }
280         err = gpio_direction_input(TOSA_GPIO_SD_WP);
281         if (err)
282                 goto err_gpio_wp_dir;
283
284         err = gpio_request(TOSA_GPIO_PWR_ON, "SD Power");
285         if (err) {
286                 printk(KERN_ERR "tosa_mci_init: can't request SD_PWR gpio\n");
287                 goto err_gpio_pwr;
288         }
289         err = gpio_direction_output(TOSA_GPIO_PWR_ON, 0);
290         if (err)
291                 goto err_gpio_pwr_dir;
292
293         err = gpio_request(TOSA_GPIO_nSD_INT, "SD Int");
294         if (err) {
295                 printk(KERN_ERR "tosa_mci_init: can't request SD_PWR gpio\n");
296                 goto err_gpio_int;
297         }
298         err = gpio_direction_input(TOSA_GPIO_nSD_INT);
299         if (err)
300                 goto err_gpio_int_dir;
301
302         return 0;
303
304 err_gpio_int_dir:
305         gpio_free(TOSA_GPIO_nSD_INT);
306 err_gpio_int:
307 err_gpio_pwr_dir:
308         gpio_free(TOSA_GPIO_PWR_ON);
309 err_gpio_pwr:
310 err_gpio_wp_dir:
311         gpio_free(TOSA_GPIO_SD_WP);
312 err_gpio_wp:
313         free_irq(TOSA_IRQ_GPIO_nSD_DETECT, data);
314 err_irq:
315 err_gpio_detect_dir:
316         gpio_free(TOSA_GPIO_nSD_DETECT);
317 err_gpio_detect:
318         return err;
319 }
320
321 static void tosa_mci_setpower(struct device *dev, unsigned int vdd)
322 {
323         struct pxamci_platform_data* p_d = dev->platform_data;
324
325         if (( 1 << vdd) & p_d->ocr_mask) {
326                 gpio_set_value(TOSA_GPIO_PWR_ON, 1);
327         } else {
328                 gpio_set_value(TOSA_GPIO_PWR_ON, 0);
329         }
330 }
331
332 static int tosa_mci_get_ro(struct device *dev)
333 {
334         return gpio_get_value(TOSA_GPIO_SD_WP);
335 }
336
337 static void tosa_mci_exit(struct device *dev, void *data)
338 {
339         gpio_free(TOSA_GPIO_nSD_INT);
340         gpio_free(TOSA_GPIO_PWR_ON);
341         gpio_free(TOSA_GPIO_SD_WP);
342         free_irq(TOSA_IRQ_GPIO_nSD_DETECT, data);
343         gpio_free(TOSA_GPIO_nSD_DETECT);
344 }
345
346 static struct pxamci_platform_data tosa_mci_platform_data = {
347         .ocr_mask       = MMC_VDD_32_33|MMC_VDD_33_34,
348         .init           = tosa_mci_init,
349         .get_ro         = tosa_mci_get_ro,
350         .setpower       = tosa_mci_setpower,
351         .exit           = tosa_mci_exit,
352 };
353
354 /*
355  * Irda
356  */
357 static void tosa_irda_transceiver_mode(struct device *dev, int mode)
358 {
359         if (mode & IR_OFF) {
360                 gpio_set_value(TOSA_GPIO_IR_POWERDWN, 0);
361                 pxa2xx_transceiver_mode(dev, mode);
362                 gpio_direction_output(TOSA_GPIO_IRDA_TX, 0);
363         } else {
364                 pxa2xx_transceiver_mode(dev, mode);
365                 gpio_set_value(TOSA_GPIO_IR_POWERDWN, 1);
366         }
367 }
368
369 static int tosa_irda_startup(struct device *dev)
370 {
371         int ret;
372
373         ret = gpio_request(TOSA_GPIO_IRDA_TX, "IrDA TX");
374         if (ret)
375                 goto err_tx;
376         ret = gpio_direction_output(TOSA_GPIO_IRDA_TX, 0);
377         if (ret)
378                 goto err_tx_dir;
379
380         ret = gpio_request(TOSA_GPIO_IR_POWERDWN, "IrDA powerdown");
381         if (ret)
382                 goto err_pwr;
383
384         ret = gpio_direction_output(TOSA_GPIO_IR_POWERDWN, 0);
385         if (ret)
386                 goto err_pwr_dir;
387
388         tosa_irda_transceiver_mode(dev, IR_SIRMODE | IR_OFF);
389
390         return 0;
391
392 err_pwr_dir:
393         gpio_free(TOSA_GPIO_IR_POWERDWN);
394 err_pwr:
395 err_tx_dir:
396         gpio_free(TOSA_GPIO_IRDA_TX);
397 err_tx:
398         return ret;
399 }
400
401 static void tosa_irda_shutdown(struct device *dev)
402 {
403         tosa_irda_transceiver_mode(dev, IR_SIRMODE | IR_OFF);
404         gpio_free(TOSA_GPIO_IR_POWERDWN);
405         gpio_free(TOSA_GPIO_IRDA_TX);
406 }
407
408 static struct pxaficp_platform_data tosa_ficp_platform_data = {
409         .transceiver_cap  = IR_SIRMODE | IR_OFF,
410         .transceiver_mode = tosa_irda_transceiver_mode,
411         .startup = tosa_irda_startup,
412         .shutdown = tosa_irda_shutdown,
413 };
414
415 /*
416  * Tosa AC IN
417  */
418 static int tosa_power_init(struct device *dev)
419 {
420         int ret = gpio_request(TOSA_GPIO_AC_IN, "ac in");
421         if (ret)
422                 goto err_gpio_req;
423
424         ret = gpio_direction_input(TOSA_GPIO_AC_IN);
425         if (ret)
426                 goto err_gpio_in;
427
428         return 0;
429
430 err_gpio_in:
431         gpio_free(TOSA_GPIO_AC_IN);
432 err_gpio_req:
433         return ret;
434 }
435
436 static void tosa_power_exit(struct device *dev)
437 {
438         gpio_free(TOSA_GPIO_AC_IN);
439 }
440
441 static int tosa_power_ac_online(void)
442 {
443         return gpio_get_value(TOSA_GPIO_AC_IN) == 0;
444 }
445
446 static char *tosa_ac_supplied_to[] = {
447         "main-battery",
448         "backup-battery",
449         "jacket-battery",
450 };
451
452 static struct pda_power_pdata tosa_power_data = {
453         .init                   = tosa_power_init,
454         .is_ac_online           = tosa_power_ac_online,
455         .exit                   = tosa_power_exit,
456         .supplied_to            = tosa_ac_supplied_to,
457         .num_supplicants        = ARRAY_SIZE(tosa_ac_supplied_to),
458 };
459
460 static struct resource tosa_power_resource[] = {
461         {
462                 .name           = "ac",
463                 .start          = gpio_to_irq(TOSA_GPIO_AC_IN),
464                 .end            = gpio_to_irq(TOSA_GPIO_AC_IN),
465                 .flags          = IORESOURCE_IRQ |
466                                   IORESOURCE_IRQ_HIGHEDGE |
467                                   IORESOURCE_IRQ_LOWEDGE,
468         },
469 };
470
471 static struct platform_device tosa_power_device = {
472         .name                   = "pda-power",
473         .id                     = -1,
474         .dev.platform_data      = &tosa_power_data,
475         .resource               = tosa_power_resource,
476         .num_resources          = ARRAY_SIZE(tosa_power_resource),
477 };
478
479 /*
480  * Tosa Keyboard
481  */
482 static struct platform_device tosakbd_device = {
483         .name           = "tosa-keyboard",
484         .id             = -1,
485 };
486
487 static struct gpio_keys_button tosa_gpio_keys[] = {
488         /*
489          * Two following keys are directly tied to "ON" button of tosa. Why?
490          * The first one can be used as a wakeup source, the second can't;
491          * also the first one is OR of ac_powered and on_button.
492          */
493         {
494                 .type   = EV_PWR,
495                 .code   = KEY_RESERVED,
496                 .gpio   = TOSA_GPIO_POWERON,
497                 .desc   = "Poweron",
498                 .wakeup = 1,
499                 .active_low = 1,
500         },
501         {
502                 .type   = EV_PWR,
503                 .code   = KEY_SUSPEND,
504                 .gpio   = TOSA_GPIO_ON_KEY,
505                 .desc   = "On key",
506                 /*
507                  * can't be used as wakeup
508                  * .wakeup      = 1,
509                  */
510                 .active_low = 1,
511         },
512         {
513                 .type   = EV_KEY,
514                 .code   = TOSA_KEY_RECORD,
515                 .gpio   = TOSA_GPIO_RECORD_BTN,
516                 .desc   = "Record Button",
517                 .wakeup = 1,
518                 .active_low = 1,
519         },
520         {
521                 .type   = EV_KEY,
522                 .code   = TOSA_KEY_SYNC,
523                 .gpio   = TOSA_GPIO_SYNC,
524                 .desc   = "Sync Button",
525                 .wakeup = 1,
526                 .active_low = 1,
527         },
528         {
529                 .type   = EV_SW,
530                 .code   = SW_HEADPHONE_INSERT,
531                 .gpio   = TOSA_GPIO_EAR_IN,
532                 .desc   = "HeadPhone insert",
533                 .active_low = 1,
534                 .debounce_interval = 300,
535         },
536 };
537
538 static struct gpio_keys_platform_data tosa_gpio_keys_platform_data = {
539         .buttons        = tosa_gpio_keys,
540         .nbuttons       = ARRAY_SIZE(tosa_gpio_keys),
541 };
542
543 static struct platform_device tosa_gpio_keys_device = {
544         .name   = "gpio-keys",
545         .id     = -1,
546         .dev    = {
547                 .platform_data  = &tosa_gpio_keys_platform_data,
548         },
549 };
550
551 /*
552  * Tosa LEDs
553  */
554 static struct gpio_led tosa_gpio_leds[] = {
555         {
556                 .name                   = "tosa:amber:charge",
557                 .default_trigger        = "main-battery-charging",
558                 .gpio                   = TOSA_GPIO_CHRG_ERR_LED,
559         },
560         {
561                 .name                   = "tosa:green:mail",
562                 .default_trigger        = "nand-disk",
563                 .gpio                   = TOSA_GPIO_NOTE_LED,
564         },
565         {
566                 .name                   = "tosa:dual:wlan",
567                 .default_trigger        = "none",
568                 .gpio                   = TOSA_GPIO_WLAN_LED,
569         },
570         {
571                 .name                   = "tosa:blue:bluetooth",
572                 .default_trigger        = "tosa-bt",
573                 .gpio                   = TOSA_GPIO_BT_LED,
574         },
575 };
576
577 static struct gpio_led_platform_data tosa_gpio_leds_platform_data = {
578         .leds           = tosa_gpio_leds,
579         .num_leds       = ARRAY_SIZE(tosa_gpio_leds),
580 };
581
582 static struct platform_device tosaled_device = {
583         .name   = "leds-gpio",
584         .id     = -1,
585         .dev    = {
586                 .platform_data  = &tosa_gpio_leds_platform_data,
587         },
588 };
589
590 /*
591  * Toshiba Mobile IO Controller
592  */
593 static struct resource tc6393xb_resources[] = {
594         [0] = {
595                 .start  = TOSA_LCDC_PHYS,
596                 .end    = TOSA_LCDC_PHYS + 0x3ffffff,
597                 .flags  = IORESOURCE_MEM,
598         },
599
600         [1] = {
601                 .start  = TOSA_IRQ_GPIO_TC6393XB_INT,
602                 .end    = TOSA_IRQ_GPIO_TC6393XB_INT,
603                 .flags  = IORESOURCE_IRQ,
604         },
605 };
606
607
608 static int tosa_tc6393xb_enable(struct platform_device *dev)
609 {
610         int rc;
611
612         rc = gpio_request(TOSA_GPIO_TC6393XB_REST_IN, "tc6393xb #pclr");
613         if (rc)
614                 goto err_req_pclr;
615         rc = gpio_request(TOSA_GPIO_TC6393XB_SUSPEND, "tc6393xb #suspend");
616         if (rc)
617                 goto err_req_suspend;
618         rc = gpio_request(TOSA_GPIO_TC6393XB_L3V_ON, "tc6393xb l3v");
619         if (rc)
620                 goto err_req_l3v;
621         rc = gpio_direction_output(TOSA_GPIO_TC6393XB_L3V_ON, 0);
622         if (rc)
623                 goto err_dir_l3v;
624         rc = gpio_direction_output(TOSA_GPIO_TC6393XB_SUSPEND, 0);
625         if (rc)
626                 goto err_dir_suspend;
627         rc = gpio_direction_output(TOSA_GPIO_TC6393XB_REST_IN, 0);
628         if (rc)
629                 goto err_dir_pclr;
630
631         mdelay(1);
632
633         gpio_set_value(TOSA_GPIO_TC6393XB_SUSPEND, 1);
634
635         mdelay(10);
636
637         gpio_set_value(TOSA_GPIO_TC6393XB_REST_IN, 1);
638         gpio_set_value(TOSA_GPIO_TC6393XB_L3V_ON, 1);
639
640         return 0;
641 err_dir_pclr:
642 err_dir_suspend:
643 err_dir_l3v:
644         gpio_free(TOSA_GPIO_TC6393XB_L3V_ON);
645 err_req_l3v:
646         gpio_free(TOSA_GPIO_TC6393XB_SUSPEND);
647 err_req_suspend:
648         gpio_free(TOSA_GPIO_TC6393XB_REST_IN);
649 err_req_pclr:
650         return rc;
651 }
652
653 static int tosa_tc6393xb_disable(struct platform_device *dev)
654 {
655         gpio_free(TOSA_GPIO_TC6393XB_L3V_ON);
656         gpio_free(TOSA_GPIO_TC6393XB_SUSPEND);
657         gpio_free(TOSA_GPIO_TC6393XB_REST_IN);
658
659         return 0;
660 }
661
662 static int tosa_tc6393xb_resume(struct platform_device *dev)
663 {
664         gpio_set_value(TOSA_GPIO_TC6393XB_SUSPEND, 1);
665         mdelay(10);
666         gpio_set_value(TOSA_GPIO_TC6393XB_L3V_ON, 1);
667         mdelay(10);
668
669         return 0;
670 }
671
672 static int tosa_tc6393xb_suspend(struct platform_device *dev)
673 {
674         gpio_set_value(TOSA_GPIO_TC6393XB_L3V_ON, 0);
675         gpio_set_value(TOSA_GPIO_TC6393XB_SUSPEND, 0);
676         return 0;
677 }
678
679 static struct mtd_partition tosa_nand_partition[] = {
680         {
681                 .name   = "smf",
682                 .offset = 0,
683                 .size   = 7 * 1024 * 1024,
684         },
685         {
686                 .name   = "root",
687                 .offset = MTDPART_OFS_APPEND,
688                 .size   = 28 * 1024 * 1024,
689         },
690         {
691                 .name   = "home",
692                 .offset = MTDPART_OFS_APPEND,
693                 .size   = MTDPART_SIZ_FULL,
694         },
695 };
696
697 static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
698
699 static struct nand_bbt_descr tosa_tc6393xb_nand_bbt = {
700         .options        = 0,
701         .offs           = 4,
702         .len            = 2,
703         .pattern        = scan_ff_pattern
704 };
705
706 static struct tmio_nand_data tosa_tc6393xb_nand_config = {
707         .num_partitions = ARRAY_SIZE(tosa_nand_partition),
708         .partition      = tosa_nand_partition,
709         .badblock_pattern = &tosa_tc6393xb_nand_bbt,
710 };
711
712 static int tosa_tc6393xb_setup(struct platform_device *dev)
713 {
714         int rc;
715
716         rc = gpio_request(TOSA_GPIO_CARD_VCC_ON, "CARD_VCC_ON");
717         if (rc)
718                 goto err_req;
719
720         rc = gpio_direction_output(TOSA_GPIO_CARD_VCC_ON, 1);
721         if (rc)
722                 goto err_dir;
723
724         return rc;
725
726 err_dir:
727         gpio_free(TOSA_GPIO_CARD_VCC_ON);
728 err_req:
729         return rc;
730 }
731
732 static void tosa_tc6393xb_teardown(struct platform_device *dev)
733 {
734         gpio_free(TOSA_GPIO_CARD_VCC_ON);
735 }
736
737 #ifdef CONFIG_MFD_TC6393XB
738 static struct fb_videomode tosa_tc6393xb_lcd_mode[] = {
739         {
740                 .xres = 480,
741                 .yres = 640,
742                 .pixclock = 0x002cdf00,/* PLL divisor */
743                 .left_margin = 0x004c,
744                 .right_margin = 0x005b,
745                 .upper_margin = 0x0001,
746                 .lower_margin = 0x000d,
747                 .hsync_len = 0x0002,
748                 .vsync_len = 0x0001,
749                 .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
750                 .vmode = FB_VMODE_NONINTERLACED,
751         },{
752                 .xres = 240,
753                 .yres = 320,
754                 .pixclock = 0x00e7f203,/* PLL divisor */
755                 .left_margin = 0x0024,
756                 .right_margin = 0x002f,
757                 .upper_margin = 0x0001,
758                 .lower_margin = 0x000d,
759                 .hsync_len = 0x0002,
760                 .vsync_len = 0x0001,
761                 .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
762                 .vmode = FB_VMODE_NONINTERLACED,
763         }
764 };
765
766 static struct tmio_fb_data tosa_tc6393xb_fb_config = {
767         .lcd_set_power  = tc6393xb_lcd_set_power,
768         .lcd_mode       = tc6393xb_lcd_mode,
769         .num_modes      = ARRAY_SIZE(tosa_tc6393xb_lcd_mode),
770         .modes          = &tosa_tc6393xb_lcd_mode[0],
771         .height         = 82,
772         .width          = 60,
773 };
774 #endif
775
776 static struct tc6393xb_platform_data tosa_tc6393xb_data = {
777         .scr_pll2cr     = 0x0cc1,
778         .scr_gper       = 0x3300,
779
780         .irq_base       = IRQ_BOARD_START,
781         .gpio_base      = TOSA_TC6393XB_GPIO_BASE,
782         .setup          = tosa_tc6393xb_setup,
783         .teardown       = tosa_tc6393xb_teardown,
784
785         .enable         = tosa_tc6393xb_enable,
786         .disable        = tosa_tc6393xb_disable,
787         .suspend        = tosa_tc6393xb_suspend,
788         .resume         = tosa_tc6393xb_resume,
789
790         .nand_data      = &tosa_tc6393xb_nand_config,
791 #ifdef CONFIG_MFD_TC6393XB
792         .fb_data        = &tosa_tc6393xb_fb_config,
793 #endif
794
795         .resume_restore = 1,
796 };
797
798
799 static struct platform_device tc6393xb_device = {
800         .name   = "tc6393xb",
801         .id     = -1,
802         .dev    = {
803                 .platform_data  = &tosa_tc6393xb_data,
804         },
805         .num_resources  = ARRAY_SIZE(tc6393xb_resources),
806         .resource       = tc6393xb_resources,
807 };
808
809 static struct tosa_bt_data tosa_bt_data = {
810         .gpio_pwr       = TOSA_GPIO_BT_PWR_EN,
811         .gpio_reset     = TOSA_GPIO_BT_RESET,
812 };
813
814 static struct platform_device tosa_bt_device = {
815         .name   = "tosa-bt",
816         .id     = -1,
817         .dev.platform_data = &tosa_bt_data,
818 };
819
820 static struct pxa2xx_spi_master pxa_ssp_master_info = {
821         .num_chipselect = 1,
822 };
823
824 static struct spi_board_info spi_board_info[] __initdata = {
825         {
826                 .modalias       = "tosa-lcd",
827                 // .platform_data
828                 .max_speed_hz   = 28750,
829                 .bus_num        = 2,
830                 .chip_select    = 0,
831                 .mode           = SPI_MODE_0,
832         },
833 };
834
835 static struct mtd_partition sharpsl_rom_parts[] = {
836         {
837                 .name   ="Boot PROM Filesystem",
838                 .offset = 0x00160000,
839                 .size   = MTDPART_SIZ_FULL,
840         },
841 };
842
843 static struct physmap_flash_data sharpsl_rom_data = {
844         .width          = 2,
845         .nr_parts       = ARRAY_SIZE(sharpsl_rom_parts),
846         .parts          = sharpsl_rom_parts,
847 };
848
849 static struct resource sharpsl_rom_resources[] = {
850         {
851                 .start  = 0x00000000,
852                 .end    = 0x007fffff,
853                 .flags  = IORESOURCE_MEM,
854         },
855 };
856
857 static struct platform_device sharpsl_rom_device = {
858         .name   = "physmap-flash",
859         .id     = -1,
860         .resource = sharpsl_rom_resources,
861         .num_resources = ARRAY_SIZE(sharpsl_rom_resources),
862         .dev.platform_data = &sharpsl_rom_data,
863 };
864
865 static struct platform_device *devices[] __initdata = {
866         &tosascoop_device,
867         &tosascoop_jc_device,
868         &tc6393xb_device,
869         &tosa_power_device,
870         &tosakbd_device,
871         &tosa_gpio_keys_device,
872         &tosaled_device,
873         &tosa_bt_device,
874         &sharpsl_rom_device,
875 };
876
877 static void tosa_poweroff(void)
878 {
879         arm_machine_restart('g');
880 }
881
882 static void tosa_restart(char mode)
883 {
884         /* Bootloader magic for a reboot */
885         if((MSC0 & 0xffff0000) == 0x7ff00000)
886                 MSC0 = (MSC0 & 0xffff) | 0x7ee00000;
887
888         tosa_poweroff();
889 }
890
891 static void __init tosa_init(void)
892 {
893         int dummy;
894
895         pxa2xx_mfp_config(ARRAY_AND_SIZE(tosa_pin_config));
896         gpio_set_wake(MFP_PIN_GPIO1, 1);
897         /* We can't pass to gpio-keys since it will drop the Reset altfunc */
898
899         init_gpio_reset(TOSA_GPIO_ON_RESET, 0);
900
901         pm_power_off = tosa_poweroff;
902         arm_pm_restart = tosa_restart;
903
904         PCFR |= PCFR_OPDE;
905
906         /* enable batt_fault */
907         PMCR = 0x01;
908
909         dummy = gpiochip_reserve(TOSA_SCOOP_GPIO_BASE, 12);
910         dummy = gpiochip_reserve(TOSA_SCOOP_JC_GPIO_BASE, 12);
911         dummy = gpiochip_reserve(TOSA_TC6393XB_GPIO_BASE, 16);
912
913         pxa_set_mci_info(&tosa_mci_platform_data);
914         pxa_set_udc_info(&udc_info);
915         pxa_set_ficp_info(&tosa_ficp_platform_data);
916         pxa_set_i2c_info(NULL);
917         platform_scoop_config = &tosa_pcmcia_config;
918
919         pxa2xx_set_spi_info(2, &pxa_ssp_master_info);
920         spi_register_board_info(spi_board_info, ARRAY_SIZE(spi_board_info));
921
922         clk_add_alias("CLK_CK3P6MI", &tc6393xb_device.dev, "GPIO11_CLK", NULL);
923
924         platform_add_devices(devices, ARRAY_SIZE(devices));
925 }
926
927 static void __init fixup_tosa(struct machine_desc *desc,
928                 struct tag *tags, char **cmdline, struct meminfo *mi)
929 {
930         sharpsl_save_param();
931         mi->nr_banks=1;
932         mi->bank[0].start = 0xa0000000;
933         mi->bank[0].node = 0;
934         mi->bank[0].size = (64*1024*1024);
935 }
936
937 MACHINE_START(TOSA, "SHARP Tosa")
938         .phys_io        = 0x40000000,
939         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
940         .fixup          = fixup_tosa,
941         .map_io         = pxa_map_io,
942         .init_irq       = pxa25x_init_irq,
943         .init_machine   = tosa_init,
944         .timer          = &pxa_timer,
945 MACHINE_END