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/device.h>
  18 #include <linux/major.h>
  19 #include <linux/fs.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/mmc/host.h>
  22
  23 #include <asm/setup.h>
  24 #include <asm/memory.h>
  25 #include <asm/mach-types.h>
  26 #include <asm/hardware.h>
  27 #include <asm/irq.h>
  28 #include <asm/io.h>
  29
  30 #include <asm/mach/arch.h>
  31 #include <asm/mach/map.h>
  32 #include <asm/mach/irq.h>
  33
  34 #include <asm/arch/pxa-regs.h>
  35 #include <asm/arch/irq.h>
  36 #include <asm/arch/mmc.h>
  37 #include <asm/arch/udc.h>
  38 #include <asm/arch/corgi.h>
  39
  40 #include <asm/hardware/scoop.h>
  41 #include <video/w100fb.h>
  42
  43 #include "generic.h"
  44
  45
  46 /*
  47  * Corgi SCOOP Device
  48  */
  49 static struct resource corgi_scoop_resources[] = {
  50         [0] = {
  51                 .start          = 0x10800000,
  52                 .end            = 0x10800fff,
  53                 .flags          = IORESOURCE_MEM,
  54         },
  55 };
  56
  57 static struct scoop_config corgi_scoop_setup = {
  58         .io_dir         = CORGI_SCOOP_IO_DIR,
  59         .io_out         = CORGI_SCOOP_IO_OUT,
  60 };
  61
  62 static struct platform_device corgiscoop_device = {
  63         .name           = "sharp-scoop",
  64         .id             = -1,
  65         .dev            = {
  66                 .platform_data  = &corgi_scoop_setup,
  67         },
  68         .num_resources  = ARRAY_SIZE(corgi_scoop_resources),
  69         .resource       = corgi_scoop_resources,
  70 };
  71
  72
  73 /*
  74  * Corgi SSP Device
  75  *
  76  * Set the parent as the scoop device because a lot of SSP devices
  77  * also use scoop functions and this makes the power up/down order
  78  * work correctly.
  79  */
  80 static struct platform_device corgissp_device = {
  81         .name           = "corgi-ssp",
  82         .dev            = {
  83                 .parent = &corgiscoop_device.dev,
  84         },
  85         .id             = -1,
  86 };
  87
  88
  89 /*
  90  * Corgi w100 Frame Buffer Device
  91  */
  92 static struct w100fb_mach_info corgi_fb_info = {
  93         .w100fb_ssp_send        = corgi_ssp_lcdtg_send,
  94         .comadj                         = -1,
  95         .phadadj                        = -1,
  96 };
  97
  98 static struct resource corgi_fb_resources[] = {
  99         [0] = {
 100                 .start          = 0x08000000,
 101                 .end            = 0x08ffffff,
 102                 .flags          = IORESOURCE_MEM,
 103         },
 104 };
 105
 106 static struct platform_device corgifb_device = {
 107         .name           = "w100fb",
 108         .id             = -1,
 109         .dev            = {
 110                 .platform_data  = &corgi_fb_info,
 111                 .parent = &corgissp_device.dev,
 112         },
 113         .num_resources  = ARRAY_SIZE(corgi_fb_resources),
 114         .resource       = corgi_fb_resources,
 115 };
 116
 117
 118 /*
 119  * Corgi Backlight Device
 120  */
 121 static struct platform_device corgibl_device = {
 122         .name           = "corgi-bl",
 123         .dev            = {
 124                 .parent = &corgifb_device.dev,
 125         },
 126         .id             = -1,
 127 };
 128
 129
 130 /*
 131  * MMC/SD Device
 132  *
 133  * The card detect interrupt isn't debounced so we delay it by HZ/4
 134  * to give the card a chance to fully insert/eject.
 135  */
 136 static struct mmc_detect {
 137         struct timer_list detect_timer;
 138         void *devid;
 139 } mmc_detect;
 140
 141 static void mmc_detect_callback(unsigned long data)
 142 {
 143         mmc_detect_change(mmc_detect.devid);
 144 }
 145
 146 static irqreturn_t corgi_mmc_detect_int(int irq, void *devid, struct pt_regs *regs)
 147 {
 148         mmc_detect.devid=devid;
 149         mod_timer(&mmc_detect.detect_timer, jiffies + HZ/4);
 150         return IRQ_HANDLED;
 151 }
 152
 153 static int corgi_mci_init(struct device *dev, irqreturn_t (*unused_detect_int)(int, void *, struct pt_regs *), void *data)
 154 {
 155         int err;
 156
 157         /* setup GPIO for PXA25x MMC controller */
 158         pxa_gpio_mode(GPIO6_MMCCLK_MD);
 159         pxa_gpio_mode(GPIO8_MMCCS0_MD);
 160         pxa_gpio_mode(CORGI_GPIO_nSD_DETECT | GPIO_IN);
 161         pxa_gpio_mode(CORGI_GPIO_SD_PWR | GPIO_OUT);
 162
 163         init_timer(&mmc_detect.detect_timer);
 164         mmc_detect.detect_timer.function = mmc_detect_callback;
 165         mmc_detect.detect_timer.data = (unsigned long) &mmc_detect;
 166
 167         err = request_irq(CORGI_IRQ_GPIO_nSD_DETECT, corgi_mmc_detect_int, SA_INTERRUPT,
 168                              "MMC card detect", data);
 169         if (err) {
 170                 printk(KERN_ERR "corgi_mci_init: MMC/SD: can't request MMC card detect IRQ\n");
 171                 return -1;
 172         }
 173
 174         set_irq_type(CORGI_IRQ_GPIO_nSD_DETECT, IRQT_BOTHEDGE);
 175
 176         return 0;
 177 }
 178
 179 static void corgi_mci_setpower(struct device *dev, unsigned int vdd)
 180 {
 181         struct pxamci_platform_data* p_d = dev->platform_data;
 182
 183         if (( 1 << vdd) & p_d->ocr_mask) {
 184                 printk(KERN_DEBUG "%s: on\n", __FUNCTION__);
 185                 GPSR1 = GPIO_bit(CORGI_GPIO_SD_PWR);
 186         } else {
 187                 printk(KERN_DEBUG "%s: off\n", __FUNCTION__);
 188                 GPCR1 = GPIO_bit(CORGI_GPIO_SD_PWR);
 189         }
 190 }
 191
 192 static void corgi_mci_exit(struct device *dev, void *data)
 193 {
 194         free_irq(CORGI_IRQ_GPIO_nSD_DETECT, data);
 195         del_timer(&mmc_detect.detect_timer);
 196 }
 197
 198 static struct pxamci_platform_data corgi_mci_platform_data = {
 199         .ocr_mask       = MMC_VDD_32_33|MMC_VDD_33_34,
 200         .init           = corgi_mci_init,
 201         .setpower       = corgi_mci_setpower,
 202         .exit           = corgi_mci_exit,
 203 };
 204
 205
 206 /*
 207  * USB Device Controller
 208  */
 209 static void corgi_udc_command(int cmd)
 210 {
 211         switch(cmd)     {
 212         case PXA2XX_UDC_CMD_CONNECT:
 213                 GPSR(CORGI_GPIO_USB_PULLUP) = GPIO_bit(CORGI_GPIO_USB_PULLUP);
 214                 break;
 215         case PXA2XX_UDC_CMD_DISCONNECT:
 216                 GPCR(CORGI_GPIO_USB_PULLUP) = GPIO_bit(CORGI_GPIO_USB_PULLUP);
 217                 break;
 218         }
 219 }
 220
 221 static struct pxa2xx_udc_mach_info udc_info __initdata = {
 222         /* no connect GPIO; corgi can't tell connection status */
 223         .udc_command            = corgi_udc_command,
 224 };
 225
 226
 227 static struct platform_device *devices[] __initdata = {
 228         &corgiscoop_device,
 229         &corgissp_device,
 230         &corgifb_device,
 231         &corgibl_device,
 232 };
 233
 234 static struct sharpsl_flash_param_info sharpsl_flash_param;
 235
 236 static void corgi_get_param(void)
 237 {
 238         sharpsl_flash_param.comadj_keyword = readl(FLASH_MEM_BASE + FLASH_COMADJ_MAGIC_ADR);
 239         sharpsl_flash_param.comadj = readl(FLASH_MEM_BASE + FLASH_COMADJ_DATA_ADR);
 240
 241         sharpsl_flash_param.phad_keyword = readl(FLASH_MEM_BASE + FLASH_PHAD_MAGIC_ADR);
 242         sharpsl_flash_param.phadadj = readl(FLASH_MEM_BASE + FLASH_PHAD_DATA_ADR);
 243 }
 244
 245 static void __init corgi_init(void)
 246 {
 247         if (sharpsl_flash_param.comadj_keyword == FLASH_COMADJ_MAJIC)
 248                 corgi_fb_info.comadj=sharpsl_flash_param.comadj;
 249         else
 250                 corgi_fb_info.comadj=-1;
 251
 252         if (sharpsl_flash_param.phad_keyword == FLASH_PHAD_MAJIC)
 253                 corgi_fb_info.phadadj=sharpsl_flash_param.phadadj;
 254         else
 255                 corgi_fb_info.phadadj=-1;
 256
 257         pxa_gpio_mode(CORGI_GPIO_USB_PULLUP | GPIO_OUT);
 258         pxa_set_udc_info(&udc_info);
 259         pxa_set_mci_info(&corgi_mci_platform_data);
 260
 261         platform_add_devices(devices, ARRAY_SIZE(devices));
 262 }
 263
 264 static void __init fixup_corgi(struct machine_desc *desc,
 265                 struct tag *tags, char **cmdline, struct meminfo *mi)
 266 {
 267         corgi_get_param();
 268         mi->nr_banks=1;
 269         mi->bank[0].start = 0xa0000000;
 270         mi->bank[0].node = 0;
 271         if (machine_is_corgi())
 272                 mi->bank[0].size = (32*1024*1024);
 273         else
 274                 mi->bank[0].size = (64*1024*1024);
 275 }
 276
 277 static void __init corgi_init_irq(void)
 278 {
 279         pxa_init_irq();
 280 }
 281
 282 static struct map_desc corgi_io_desc[] __initdata = {
 283 /*    virtual     physical    length      */
 284 /*      { 0xf1000000, 0x08000000, 0x01000000, MT_DEVICE },*/ /* LCDC (readable for Qt driver) */
 285 /*      { 0xef700000, 0x10800000, 0x00001000, MT_DEVICE },*/  /* SCOOP */
 286         { 0xef800000, 0x00000000, 0x00800000, MT_DEVICE }, /* Boot Flash */
 287 };
 288
 289 static void __init corgi_map_io(void)
 290 {
 291         pxa_map_io();
 292         iotable_init(corgi_io_desc,ARRAY_SIZE(corgi_io_desc));
 293
 294         /* setup sleep mode values */
 295         PWER  = 0x00000002;
 296         PFER  = 0x00000000;
 297         PRER  = 0x00000002;
 298         PGSR0 = 0x0158C000;
 299         PGSR1 = 0x00FF0080;
 300         PGSR2 = 0x0001C004;
 301         /* Stop 3.6MHz and drive HIGH to PCMCIA and CS */
 302         PCFR |= PCFR_OPDE;
 303 }
 304
 305 #ifdef CONFIG_MACH_CORGI
 306 MACHINE_START(CORGI, "SHARP Corgi")
 307         BOOT_MEM(0xa0000000, 0x40000000, io_p2v(0x40000000))
 308         FIXUP(fixup_corgi)
 309         MAPIO(corgi_map_io)
 310         INITIRQ(corgi_init_irq)
 311         .init_machine = corgi_init,
 312         .timer = &pxa_timer,
 313 MACHINE_END
 314 #endif
 315
 316 #ifdef CONFIG_MACH_SHEPHERD
 317 MACHINE_START(SHEPHERD, "SHARP Shepherd")
 318         BOOT_MEM(0xa0000000, 0x40000000, io_p2v(0x40000000))
 319         FIXUP(fixup_corgi)
 320         MAPIO(corgi_map_io)
 321         INITIRQ(corgi_init_irq)
 322         .init_machine = corgi_init,
 323         .timer = &pxa_timer,
 324 MACHINE_END
 325 #endif
 326
 327 #ifdef CONFIG_MACH_HUSKY
 328 MACHINE_START(HUSKY, "SHARP Husky")
 329         BOOT_MEM(0xa0000000, 0x40000000, io_p2v(0x40000000))
 330         FIXUP(fixup_corgi)
 331         MAPIO(corgi_map_io)
 332         INITIRQ(corgi_init_irq)
 333         .init_machine = corgi_init,
 334         .timer = &pxa_timer,
 335 MACHINE_END
 336 #endif
 337