Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6.git] / arch / arm / mach-pxa / corgi.c
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/io.h>
27 #include <linux/spi/spi.h>
28 #include <linux/spi/ads7846.h>
29 #include <linux/spi/corgi_lcd.h>
30 #include <linux/mtd/sharpsl.h>
31 #include <video/w100fb.h>
32
33 #include <asm/setup.h>
34 #include <asm/memory.h>
35 #include <asm/mach-types.h>
36 #include <mach/hardware.h>
37 #include <asm/irq.h>
38 #include <asm/system.h>
39
40 #include <asm/mach/arch.h>
41 #include <asm/mach/map.h>
42 #include <asm/mach/irq.h>
43
44 #include <mach/pxa-regs.h>
45 #include <mach/pxa2xx-regs.h>
46 #include <mach/mfp-pxa25x.h>
47 #include <mach/i2c.h>
48 #include <mach/irda.h>
49 #include <mach/mmc.h>
50 #include <mach/udc.h>
51 #include <mach/pxa2xx_spi.h>
52 #include <mach/corgi.h>
53 #include <mach/sharpsl.h>
54
55 #include <asm/mach/sharpsl_param.h>
56 #include <asm/hardware/scoop.h>
57
58 #include "generic.h"
59 #include "devices.h"
60 #include "sharpsl.h"
61
62 static unsigned long corgi_pin_config[] __initdata = {
63         /* Static Memory I/O */
64         GPIO78_nCS_2,   /* w100fb */
65         GPIO80_nCS_4,   /* scoop */
66
67         /* SSP1 */
68         GPIO23_SSP1_SCLK,
69         GPIO25_SSP1_TXD,
70         GPIO26_SSP1_RXD,
71         GPIO24_GPIO,    /* CORGI_GPIO_ADS7846_CS - SFRM as chip select */
72
73         /* I2S */
74         GPIO28_I2S_BITCLK_OUT,
75         GPIO29_I2S_SDATA_IN,
76         GPIO30_I2S_SDATA_OUT,
77         GPIO31_I2S_SYNC,
78         GPIO32_I2S_SYSCLK,
79
80         /* Infra-Red */
81         GPIO47_FICP_TXD,
82         GPIO46_FICP_RXD,
83
84         /* FFUART */
85         GPIO40_FFUART_DTR,
86         GPIO41_FFUART_RTS,
87         GPIO39_FFUART_TXD,
88         GPIO37_FFUART_DSR,
89         GPIO34_FFUART_RXD,
90         GPIO35_FFUART_CTS,
91
92         /* PC Card */
93         GPIO48_nPOE,
94         GPIO49_nPWE,
95         GPIO50_nPIOR,
96         GPIO51_nPIOW,
97         GPIO52_nPCE_1,
98         GPIO53_nPCE_2,
99         GPIO54_nPSKTSEL,
100         GPIO55_nPREG,
101         GPIO56_nPWAIT,
102         GPIO57_nIOIS16,
103
104         /* MMC */
105         GPIO6_MMC_CLK,
106         GPIO8_MMC_CS0,
107
108         /* GPIO */
109         GPIO9_GPIO,     /* CORGI_GPIO_nSD_DETECT */
110         GPIO7_GPIO,     /* CORGI_GPIO_nSD_WP */
111         GPIO33_GPIO,    /* CORGI_GPIO_SD_PWR */
112         GPIO22_GPIO,    /* CORGI_GPIO_IR_ON */
113         GPIO44_GPIO,    /* CORGI_GPIO_HSYNC */
114
115         GPIO1_GPIO | WAKEUP_ON_EDGE_RISE,
116 };
117
118 /*
119  * Corgi SCOOP Device
120  */
121 static struct resource corgi_scoop_resources[] = {
122         [0] = {
123                 .start          = 0x10800000,
124                 .end            = 0x10800fff,
125                 .flags          = IORESOURCE_MEM,
126         },
127 };
128
129 static struct scoop_config corgi_scoop_setup = {
130         .io_dir         = CORGI_SCOOP_IO_DIR,
131         .io_out         = CORGI_SCOOP_IO_OUT,
132         .gpio_base      = CORGI_SCOOP_GPIO_BASE,
133 };
134
135 struct platform_device corgiscoop_device = {
136         .name           = "sharp-scoop",
137         .id             = -1,
138         .dev            = {
139                 .platform_data  = &corgi_scoop_setup,
140         },
141         .num_resources  = ARRAY_SIZE(corgi_scoop_resources),
142         .resource       = corgi_scoop_resources,
143 };
144
145 static struct scoop_pcmcia_dev corgi_pcmcia_scoop[] = {
146 {
147         .dev        = &corgiscoop_device.dev,
148         .irq        = CORGI_IRQ_GPIO_CF_IRQ,
149         .cd_irq     = CORGI_IRQ_GPIO_CF_CD,
150         .cd_irq_str = "PCMCIA0 CD",
151 },
152 };
153
154 static struct scoop_pcmcia_config corgi_pcmcia_config = {
155         .devs         = &corgi_pcmcia_scoop[0],
156         .num_devs     = 1,
157 };
158
159 EXPORT_SYMBOL(corgiscoop_device);
160
161 static struct w100_mem_info corgi_fb_mem = {
162         .ext_cntl          = 0x00040003,
163         .sdram_mode_reg    = 0x00650021,
164         .ext_timing_cntl   = 0x10002a4a,
165         .io_cntl           = 0x7ff87012,
166         .size              = 0x1fffff,
167 };
168
169 static struct w100_gen_regs corgi_fb_regs = {
170         .lcd_format    = 0x00000003,
171         .lcdd_cntl1    = 0x01CC0000,
172         .lcdd_cntl2    = 0x0003FFFF,
173         .genlcd_cntl1  = 0x00FFFF0D,
174         .genlcd_cntl2  = 0x003F3003,
175         .genlcd_cntl3  = 0x000102aa,
176 };
177
178 static struct w100_gpio_regs corgi_fb_gpio = {
179         .init_data1   = 0x000000bf,
180         .init_data2   = 0x00000000,
181         .gpio_dir1    = 0x00000000,
182         .gpio_oe1     = 0x03c0feff,
183         .gpio_dir2    = 0x00000000,
184         .gpio_oe2     = 0x00000000,
185 };
186
187 static struct w100_mode corgi_fb_modes[] = {
188 {
189         .xres            = 480,
190         .yres            = 640,
191         .left_margin     = 0x56,
192         .right_margin    = 0x55,
193         .upper_margin    = 0x03,
194         .lower_margin    = 0x00,
195         .crtc_ss         = 0x82360056,
196         .crtc_ls         = 0xA0280000,
197         .crtc_gs         = 0x80280028,
198         .crtc_vpos_gs    = 0x02830002,
199         .crtc_rev        = 0x00400008,
200         .crtc_dclk       = 0xA0000000,
201         .crtc_gclk       = 0x8015010F,
202         .crtc_goe        = 0x80100110,
203         .crtc_ps1_active = 0x41060010,
204         .pll_freq        = 75,
205         .fast_pll_freq   = 100,
206         .sysclk_src      = CLK_SRC_PLL,
207         .sysclk_divider  = 0,
208         .pixclk_src      = CLK_SRC_PLL,
209         .pixclk_divider  = 2,
210         .pixclk_divider_rotated = 6,
211 },{
212         .xres            = 240,
213         .yres            = 320,
214         .left_margin     = 0x27,
215         .right_margin    = 0x2e,
216         .upper_margin    = 0x01,
217         .lower_margin    = 0x00,
218         .crtc_ss         = 0x81170027,
219         .crtc_ls         = 0xA0140000,
220         .crtc_gs         = 0xC0140014,
221         .crtc_vpos_gs    = 0x00010141,
222         .crtc_rev        = 0x00400008,
223         .crtc_dclk       = 0xA0000000,
224         .crtc_gclk       = 0x8015010F,
225         .crtc_goe        = 0x80100110,
226         .crtc_ps1_active = 0x41060010,
227         .pll_freq        = 0,
228         .fast_pll_freq   = 0,
229         .sysclk_src      = CLK_SRC_XTAL,
230         .sysclk_divider  = 0,
231         .pixclk_src      = CLK_SRC_XTAL,
232         .pixclk_divider  = 1,
233         .pixclk_divider_rotated = 1,
234 },
235
236 };
237
238 static struct w100fb_mach_info corgi_fb_info = {
239         .init_mode  = INIT_MODE_ROTATED,
240         .mem        = &corgi_fb_mem,
241         .regs       = &corgi_fb_regs,
242         .modelist   = &corgi_fb_modes[0],
243         .num_modes  = 2,
244         .gpio       = &corgi_fb_gpio,
245         .xtal_freq  = 12500000,
246         .xtal_dbl   = 0,
247 };
248
249 static struct resource corgi_fb_resources[] = {
250         [0] = {
251                 .start   = 0x08000000,
252                 .end     = 0x08ffffff,
253                 .flags   = IORESOURCE_MEM,
254         },
255 };
256
257 static struct platform_device corgifb_device = {
258         .name           = "w100fb",
259         .id             = -1,
260         .num_resources  = ARRAY_SIZE(corgi_fb_resources),
261         .resource       = corgi_fb_resources,
262         .dev            = {
263                 .platform_data = &corgi_fb_info,
264         },
265
266 };
267
268 /*
269  * Corgi Keyboard Device
270  */
271 static struct platform_device corgikbd_device = {
272         .name           = "corgi-keyboard",
273         .id             = -1,
274 };
275
276 /*
277  * Corgi LEDs
278  */
279 static struct gpio_led corgi_gpio_leds[] = {
280         {
281                 .name                   = "corgi:amber:charge",
282                 .default_trigger        = "sharpsl-charge",
283                 .gpio                   = CORGI_GPIO_LED_ORANGE,
284         },
285         {
286                 .name                   = "corgi:green:mail",
287                 .default_trigger        = "nand-disk",
288                 .gpio                   = CORGI_GPIO_LED_GREEN,
289         },
290 };
291
292 static struct gpio_led_platform_data corgi_gpio_leds_info = {
293         .leds           = corgi_gpio_leds,
294         .num_leds       = ARRAY_SIZE(corgi_gpio_leds),
295 };
296
297 static struct platform_device corgiled_device = {
298         .name           = "leds-gpio",
299         .id             = -1,
300         .dev            = {
301                 .platform_data = &corgi_gpio_leds_info,
302         },
303 };
304
305 /*
306  * MMC/SD Device
307  *
308  * The card detect interrupt isn't debounced so we delay it by 250ms
309  * to give the card a chance to fully insert/eject.
310  */
311 static struct pxamci_platform_data corgi_mci_platform_data;
312
313 static int corgi_mci_init(struct device *dev, irq_handler_t corgi_detect_int, void *data)
314 {
315         int err;
316
317         err = gpio_request(CORGI_GPIO_nSD_DETECT, "nSD_DETECT");
318         if (err)
319                 goto err_out;
320
321         err = gpio_request(CORGI_GPIO_nSD_WP, "nSD_WP");
322         if (err)
323                 goto err_free_1;
324
325         err = gpio_request(CORGI_GPIO_SD_PWR, "SD_PWR");
326         if (err)
327                 goto err_free_2;
328
329         gpio_direction_input(CORGI_GPIO_nSD_DETECT);
330         gpio_direction_input(CORGI_GPIO_nSD_WP);
331         gpio_direction_output(CORGI_GPIO_SD_PWR, 0);
332
333         corgi_mci_platform_data.detect_delay = msecs_to_jiffies(250);
334
335         err = request_irq(CORGI_IRQ_GPIO_nSD_DETECT, corgi_detect_int,
336                                 IRQF_DISABLED | IRQF_TRIGGER_RISING |
337                                 IRQF_TRIGGER_FALLING,
338                                 "MMC card detect", data);
339         if (err) {
340                 pr_err("%s: MMC/SD: can't request MMC card detect IRQ\n",
341                                 __func__);
342                 goto err_free_3;
343         }
344         return 0;
345
346 err_free_3:
347         gpio_free(CORGI_GPIO_SD_PWR);
348 err_free_2:
349         gpio_free(CORGI_GPIO_nSD_WP);
350 err_free_1:
351         gpio_free(CORGI_GPIO_nSD_DETECT);
352 err_out:
353         return err;
354 }
355
356 static void corgi_mci_setpower(struct device *dev, unsigned int vdd)
357 {
358         struct pxamci_platform_data* p_d = dev->platform_data;
359
360         gpio_set_value(CORGI_GPIO_SD_PWR, ((1 << vdd) & p_d->ocr_mask));
361 }
362
363 static int corgi_mci_get_ro(struct device *dev)
364 {
365         return gpio_get_value(CORGI_GPIO_nSD_WP);
366 }
367
368 static void corgi_mci_exit(struct device *dev, void *data)
369 {
370         free_irq(CORGI_IRQ_GPIO_nSD_DETECT, data);
371         gpio_free(CORGI_GPIO_SD_PWR);
372         gpio_free(CORGI_GPIO_nSD_WP);
373         gpio_free(CORGI_GPIO_nSD_DETECT);
374 }
375
376 static struct pxamci_platform_data corgi_mci_platform_data = {
377         .ocr_mask       = MMC_VDD_32_33|MMC_VDD_33_34,
378         .init           = corgi_mci_init,
379         .get_ro         = corgi_mci_get_ro,
380         .setpower       = corgi_mci_setpower,
381         .exit           = corgi_mci_exit,
382 };
383
384
385 /*
386  * Irda
387  */
388 static void corgi_irda_transceiver_mode(struct device *dev, int mode)
389 {
390         gpio_set_value(CORGI_GPIO_IR_ON, mode & IR_OFF);
391         pxa2xx_transceiver_mode(dev, mode);
392 }
393
394 static int corgi_irda_startup(struct device *dev)
395 {
396         int err;
397
398         err = gpio_request(CORGI_GPIO_IR_ON, "IR_ON");
399         if (err)
400                 return err;
401
402         gpio_direction_output(CORGI_GPIO_IR_ON, 1);
403         return 0;
404 }
405
406 static void corgi_irda_shutdown(struct device *dev)
407 {
408         gpio_free(CORGI_GPIO_IR_ON);
409 }
410
411 static struct pxaficp_platform_data corgi_ficp_platform_data = {
412         .transceiver_cap        = IR_SIRMODE | IR_OFF,
413         .transceiver_mode       = corgi_irda_transceiver_mode,
414         .startup                = corgi_irda_startup,
415         .shutdown               = corgi_irda_shutdown,
416 };
417
418
419 /*
420  * USB Device Controller
421  */
422 static struct pxa2xx_udc_mach_info udc_info __initdata = {
423         /* no connect GPIO; corgi can't tell connection status */
424         .gpio_pullup            = CORGI_GPIO_USB_PULLUP,
425 };
426
427 #if defined(CONFIG_SPI_PXA2XX) || defined(CONFIG_SPI_PXA2XX_MASTER)
428 static struct pxa2xx_spi_master corgi_spi_info = {
429         .num_chipselect = 3,
430 };
431
432 static struct ads7846_platform_data corgi_ads7846_info = {
433         .model                  = 7846,
434         .vref_delay_usecs       = 100,
435         .x_plate_ohms           = 419,
436         .y_plate_ohms           = 486,
437         .gpio_pendown           = CORGI_GPIO_TP_INT,
438 };
439
440 static void corgi_ads7846_cs(u32 command)
441 {
442         gpio_set_value(CORGI_GPIO_ADS7846_CS, !(command == PXA2XX_CS_ASSERT));
443 }
444
445 static struct pxa2xx_spi_chip corgi_ads7846_chip = {
446         .cs_control     = corgi_ads7846_cs,
447 };
448
449 static void corgi_bl_kick_battery(void)
450 {
451         void (*kick_batt)(void);
452
453         kick_batt = symbol_get(sharpsl_battery_kick);
454         if (kick_batt) {
455                 kick_batt();
456                 symbol_put(sharpsl_battery_kick);
457         }
458 }
459
460 static struct corgi_lcd_platform_data corgi_lcdcon_info = {
461         .init_mode              = CORGI_LCD_MODE_VGA,
462         .max_intensity          = 0x2f,
463         .default_intensity      = 0x1f,
464         .limit_mask             = 0x0b,
465         .gpio_backlight_cont    = CORGI_GPIO_BACKLIGHT_CONT,
466         .gpio_backlight_on      = -1,
467         .kick_battery           = corgi_bl_kick_battery,
468 };
469
470 static void corgi_lcdcon_cs(u32 command)
471 {
472         gpio_set_value(CORGI_GPIO_LCDCON_CS, !(command == PXA2XX_CS_ASSERT));
473 }
474
475 static struct pxa2xx_spi_chip corgi_lcdcon_chip = {
476         .cs_control     = corgi_lcdcon_cs,
477 };
478
479 static void corgi_max1111_cs(u32 command)
480 {
481         gpio_set_value(CORGI_GPIO_MAX1111_CS, !(command == PXA2XX_CS_ASSERT));
482 }
483
484 static struct pxa2xx_spi_chip corgi_max1111_chip = {
485         .cs_control     = corgi_max1111_cs,
486 };
487
488 static struct spi_board_info corgi_spi_devices[] = {
489         {
490                 .modalias       = "ads7846",
491                 .max_speed_hz   = 1200000,
492                 .bus_num        = 1,
493                 .chip_select    = 0,
494                 .platform_data  = &corgi_ads7846_info,
495                 .controller_data= &corgi_ads7846_chip,
496                 .irq            = gpio_to_irq(CORGI_GPIO_TP_INT),
497         }, {
498                 .modalias       = "corgi-lcd",
499                 .max_speed_hz   = 50000,
500                 .bus_num        = 1,
501                 .chip_select    = 1,
502                 .platform_data  = &corgi_lcdcon_info,
503                 .controller_data= &corgi_lcdcon_chip,
504         }, {
505                 .modalias       = "max1111",
506                 .max_speed_hz   = 450000,
507                 .bus_num        = 1,
508                 .chip_select    = 2,
509                 .controller_data= &corgi_max1111_chip,
510         },
511 };
512
513 static void __init corgi_init_spi(void)
514 {
515         int err;
516
517         err = gpio_request(CORGI_GPIO_ADS7846_CS, "ADS7846_CS");
518         if (err)
519                 return;
520
521         err = gpio_request(CORGI_GPIO_LCDCON_CS, "LCDCON_CS");
522         if (err)
523                 goto err_free_1;
524
525         err = gpio_request(CORGI_GPIO_MAX1111_CS, "MAX1111_CS");
526         if (err)
527                 goto err_free_2;
528
529         gpio_direction_output(CORGI_GPIO_ADS7846_CS, 1);
530         gpio_direction_output(CORGI_GPIO_LCDCON_CS, 1);
531         gpio_direction_output(CORGI_GPIO_MAX1111_CS, 1);
532
533         pxa2xx_set_spi_info(1, &corgi_spi_info);
534         spi_register_board_info(ARRAY_AND_SIZE(corgi_spi_devices));
535         return;
536
537 err_free_2:
538         gpio_free(CORGI_GPIO_LCDCON_CS);
539 err_free_1:
540         gpio_free(CORGI_GPIO_ADS7846_CS);
541 }
542 #else
543 static inline void corgi_init_spi(void) {}
544 #endif
545
546 static struct mtd_partition sharpsl_nand_partitions[] = {
547         {
548                 .name = "System Area",
549                 .offset = 0,
550                 .size = 7 * 1024 * 1024,
551         },
552         {
553                 .name = "Root Filesystem",
554                 .offset = 7 * 1024 * 1024,
555                 .size = 25 * 1024 * 1024,
556         },
557         {
558                 .name = "Home Filesystem",
559                 .offset = MTDPART_OFS_APPEND,
560                 .size = MTDPART_SIZ_FULL,
561         },
562 };
563
564 static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
565
566 static struct nand_bbt_descr sharpsl_bbt = {
567         .options = 0,
568         .offs = 4,
569         .len = 2,
570         .pattern = scan_ff_pattern
571 };
572
573 static struct sharpsl_nand_platform_data sharpsl_nand_platform_data = {
574         .badblock_pattern       = &sharpsl_bbt,
575         .partitions             = sharpsl_nand_partitions,
576         .nr_partitions          = ARRAY_SIZE(sharpsl_nand_partitions),
577 };
578
579 static struct resource sharpsl_nand_resources[] = {
580         {
581                 .start  = 0x0C000000,
582                 .end    = 0x0C000FFF,
583                 .flags  = IORESOURCE_MEM,
584         },
585 };
586
587 static struct platform_device sharpsl_nand_device = {
588         .name           = "sharpsl-nand",
589         .id             = -1,
590         .resource       = sharpsl_nand_resources,
591         .num_resources  = ARRAY_SIZE(sharpsl_nand_resources),
592         .dev.platform_data      = &sharpsl_nand_platform_data,
593 };
594
595 static struct mtd_partition sharpsl_rom_parts[] = {
596         {
597                 .name   ="Boot PROM Filesystem",
598                 .offset = 0x00120000,
599                 .size   = MTDPART_SIZ_FULL,
600         },
601 };
602
603 static struct physmap_flash_data sharpsl_rom_data = {
604         .width          = 2,
605         .nr_parts       = ARRAY_SIZE(sharpsl_rom_parts),
606         .parts          = sharpsl_rom_parts,
607 };
608
609 static struct resource sharpsl_rom_resources[] = {
610         {
611                 .start  = 0x00000000,
612                 .end    = 0x007fffff,
613                 .flags  = IORESOURCE_MEM,
614         },
615 };
616
617 static struct platform_device sharpsl_rom_device = {
618         .name   = "physmap-flash",
619         .id     = -1,
620         .resource = sharpsl_rom_resources,
621         .num_resources = ARRAY_SIZE(sharpsl_rom_resources),
622         .dev.platform_data = &sharpsl_rom_data,
623 };
624
625 static struct platform_device *devices[] __initdata = {
626         &corgiscoop_device,
627         &corgifb_device,
628         &corgikbd_device,
629         &corgiled_device,
630         &sharpsl_nand_device,
631         &sharpsl_rom_device,
632 };
633
634 static void corgi_poweroff(void)
635 {
636         if (!machine_is_corgi())
637                 /* Green LED off tells the bootloader to halt */
638                 gpio_set_value(CORGI_GPIO_LED_GREEN, 0);
639
640         arm_machine_restart('h');
641 }
642
643 static void corgi_restart(char mode)
644 {
645         if (!machine_is_corgi())
646                 /* Green LED on tells the bootloader to reboot */
647                 gpio_set_value(CORGI_GPIO_LED_GREEN, 1);
648
649         arm_machine_restart('h');
650 }
651
652 static void __init corgi_init(void)
653 {
654         pm_power_off = corgi_poweroff;
655         arm_pm_restart = corgi_restart;
656
657         /* Stop 3.6MHz and drive HIGH to PCMCIA and CS */
658         PCFR |= PCFR_OPDE;
659
660         pxa2xx_mfp_config(ARRAY_AND_SIZE(corgi_pin_config));
661
662         corgi_init_spi();
663
664         pxa_set_udc_info(&udc_info);
665         pxa_set_mci_info(&corgi_mci_platform_data);
666         pxa_set_ficp_info(&corgi_ficp_platform_data);
667         pxa_set_i2c_info(NULL);
668
669         platform_scoop_config = &corgi_pcmcia_config;
670
671         if (machine_is_husky())
672                 sharpsl_nand_partitions[1].size = 53 * 1024 * 1024;
673
674         platform_add_devices(devices, ARRAY_SIZE(devices));
675 }
676
677 static void __init fixup_corgi(struct machine_desc *desc,
678                 struct tag *tags, char **cmdline, struct meminfo *mi)
679 {
680         sharpsl_save_param();
681         mi->nr_banks=1;
682         mi->bank[0].start = 0xa0000000;
683         mi->bank[0].node = 0;
684         if (machine_is_corgi())
685                 mi->bank[0].size = (32*1024*1024);
686         else
687                 mi->bank[0].size = (64*1024*1024);
688 }
689
690 #ifdef CONFIG_MACH_CORGI
691 MACHINE_START(CORGI, "SHARP Corgi")
692         .phys_io        = 0x40000000,
693         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
694         .fixup          = fixup_corgi,
695         .map_io         = pxa_map_io,
696         .init_irq       = pxa25x_init_irq,
697         .init_machine   = corgi_init,
698         .timer          = &pxa_timer,
699 MACHINE_END
700 #endif
701
702 #ifdef CONFIG_MACH_SHEPHERD
703 MACHINE_START(SHEPHERD, "SHARP Shepherd")
704         .phys_io        = 0x40000000,
705         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
706         .fixup          = fixup_corgi,
707         .map_io         = pxa_map_io,
708         .init_irq       = pxa25x_init_irq,
709         .init_machine   = corgi_init,
710         .timer          = &pxa_timer,
711 MACHINE_END
712 #endif
713
714 #ifdef CONFIG_MACH_HUSKY
715 MACHINE_START(HUSKY, "SHARP Husky")
716         .phys_io        = 0x40000000,
717         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
718         .fixup          = fixup_corgi,
719         .map_io         = pxa_map_io,
720         .init_irq       = pxa25x_init_irq,
721         .init_machine   = corgi_init,
722         .timer          = &pxa_timer,
723 MACHINE_END
724 #endif
725