arch/arm/mach-sa1100/collie.c

   1 /*
   2  * linux/arch/arm/mach-sa1100/collie.c
   3  *
   4  * May be copied or modified under the terms of the GNU General Public
   5  * License.  See linux/COPYING for more information.
   6  *
   7  * This file contains all Collie-specific tweaks.
   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  * ChangeLog:
  14  *  2006 Pavel Machek <pavel@ucw.cz>
  15  *  03-06-2004 John Lenz <lenz@cs.wisc.edu>
  16  *  06-04-2002 Chris Larson <kergoth@digitalnemesis.net>
  17  *  04-16-2001 Lineo Japan,Inc. ...
  18  */
  19
  20 #include <linux/init.h>
  21 #include <linux/kernel.h>
  22 #include <linux/tty.h>
  23 #include <linux/delay.h>
  24 #include <linux/platform_data/sa11x0-serial.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/mfd/ucb1x00.h>
  27 #include <linux/mtd/mtd.h>
  28 #include <linux/mtd/partitions.h>
  29 #include <linux/timer.h>
  30 #include <linux/gpio_keys.h>
  31 #include <linux/input.h>
  32 #include <linux/gpio.h>
  33 #include <linux/gpio/machine.h>
  34 #include <linux/power/gpio-charger.h>
  35
  36 #include <video/sa1100fb.h>
  37
  38 #include <mach/hardware.h>
  39 #include <asm/mach-types.h>
  40 #include <asm/page.h>
  41 #include <asm/setup.h>
  42 #include <mach/collie.h>
  43
  44 #include <asm/mach/arch.h>
  45 #include <asm/mach/flash.h>
  46 #include <asm/mach/map.h>
  47 #include <linux/platform_data/irda-sa11x0.h>
  48
  49 #include <asm/hardware/scoop.h>
  50 #include <asm/mach/sharpsl_param.h>
  51 #include <asm/hardware/locomo.h>
  52 #include <linux/platform_data/mfd-mcp-sa11x0.h>
  53 #include <mach/irqs.h>
  54
  55 #include "generic.h"
  56
  57 static struct resource collie_scoop_resources[] = {
  58         [0] = DEFINE_RES_MEM(0x40800000, SZ_4K),
  59 };
  60
  61 static struct scoop_config collie_scoop_setup = {
  62         .io_dir         = COLLIE_SCOOP_IO_DIR,
  63         .io_out         = COLLIE_SCOOP_IO_OUT,
  64         .gpio_base      = COLLIE_SCOOP_GPIO_BASE,
  65 };
  66
  67 struct platform_device colliescoop_device = {
  68         .name           = "sharp-scoop",
  69         .id             = -1,
  70         .dev            = {
  71                 .platform_data  = &collie_scoop_setup,
  72         },
  73         .num_resources  = ARRAY_SIZE(collie_scoop_resources),
  74         .resource       = collie_scoop_resources,
  75 };
  76
  77 static struct scoop_pcmcia_dev collie_pcmcia_scoop[] = {
  78         {
  79         .dev            = &colliescoop_device.dev,
  80         .irq            = COLLIE_IRQ_GPIO_CF_IRQ,
  81         .cd_irq         = COLLIE_IRQ_GPIO_CF_CD,
  82         .cd_irq_str     = "PCMCIA0 CD",
  83         },
  84 };
  85
  86 static struct scoop_pcmcia_config collie_pcmcia_config = {
  87         .devs           = &collie_pcmcia_scoop[0],
  88         .num_devs       = 1,
  89 };
  90
  91 static struct ucb1x00_plat_data collie_ucb1x00_data = {
  92         .gpio_base      = COLLIE_TC35143_GPIO_BASE,
  93 };
  94
  95 static struct mcp_plat_data collie_mcp_data = {
  96         .mccr0          = MCCR0_ADM | MCCR0_ExtClk,
  97         .sclk_rate      = 9216000,
  98         .codec_pdata    = &collie_ucb1x00_data,
  99 };
 100
 101 /* Battery management GPIOs */
 102 static struct gpiod_lookup_table collie_battery_gpiod_table = {
 103         /* the MCP codec mcp0 has the ucb1x00 as attached device */
 104         .dev_id = "ucb1x00",
 105         .table = {
 106                 /* This is found on the main GPIO on the SA1100 */
 107                 GPIO_LOOKUP("gpio", COLLIE_GPIO_CO,
 108                             "main battery full", GPIO_ACTIVE_HIGH),
 109                 GPIO_LOOKUP("gpio", COLLIE_GPIO_MAIN_BAT_LOW,
 110                             "main battery low", GPIO_ACTIVE_HIGH),
 111                 /*
 112                  * This is GPIO 0 on the Scoop expander, which is registered
 113                  * from common/scoop.c with this gpio chip label.
 114                  */
 115                 GPIO_LOOKUP("sharp-scoop", 0,
 116                             "main charge on", GPIO_ACTIVE_HIGH),
 117                 { },
 118         },
 119 };
 120
 121 static int collie_ir_startup(struct device *dev)
 122 {
 123         int rc = gpio_request(COLLIE_GPIO_IR_ON, "IrDA");
 124         if (rc)
 125                 return rc;
 126         rc = gpio_direction_output(COLLIE_GPIO_IR_ON, 1);
 127
 128         if (!rc)
 129                 return 0;
 130
 131         gpio_free(COLLIE_GPIO_IR_ON);
 132         return rc;
 133 }
 134
 135 static void collie_ir_shutdown(struct device *dev)
 136 {
 137         gpio_free(COLLIE_GPIO_IR_ON);
 138 }
 139
 140 static int collie_ir_set_power(struct device *dev, unsigned int state)
 141 {
 142         gpio_set_value(COLLIE_GPIO_IR_ON, !state);
 143         return 0;
 144 }
 145
 146 static struct irda_platform_data collie_ir_data = {
 147         .startup = collie_ir_startup,
 148         .shutdown = collie_ir_shutdown,
 149         .set_power = collie_ir_set_power,
 150 };
 151
 152 /*
 153  * Collie AC IN
 154  */
 155 static struct gpiod_lookup_table collie_power_gpiod_table = {
 156         .dev_id = "gpio-charger",
 157         .table = {
 158                 GPIO_LOOKUP("gpio", COLLIE_GPIO_AC_IN,
 159                             NULL, GPIO_ACTIVE_HIGH),
 160                 { },
 161         },
 162 };
 163
 164 static char *collie_ac_supplied_to[] = {
 165         "main-battery",
 166         "backup-battery",
 167 };
 168
 169 static struct gpio_charger_platform_data collie_power_data = {
 170         .name                   = "charger",
 171         .type                   = POWER_SUPPLY_TYPE_MAINS,
 172         .supplied_to            = collie_ac_supplied_to,
 173         .num_supplicants        = ARRAY_SIZE(collie_ac_supplied_to),
 174 };
 175
 176 static struct platform_device collie_power_device = {
 177         .name                   = "gpio-charger",
 178         .id                     = -1,
 179         .dev.platform_data      = &collie_power_data,
 180 };
 181
 182 #ifdef CONFIG_SHARP_LOCOMO
 183 /*
 184  * low-level UART features.
 185  */
 186 struct platform_device collie_locomo_device;
 187
 188 static void collie_uart_set_mctrl(struct uart_port *port, u_int mctrl)
 189 {
 190         if (mctrl & TIOCM_RTS)
 191                 locomo_gpio_write(&collie_locomo_device.dev, LOCOMO_GPIO_RTS, 0);
 192         else
 193                 locomo_gpio_write(&collie_locomo_device.dev, LOCOMO_GPIO_RTS, 1);
 194
 195         if (mctrl & TIOCM_DTR)
 196                 locomo_gpio_write(&collie_locomo_device.dev, LOCOMO_GPIO_DTR, 0);
 197         else
 198                 locomo_gpio_write(&collie_locomo_device.dev, LOCOMO_GPIO_DTR, 1);
 199 }
 200
 201 static u_int collie_uart_get_mctrl(struct uart_port *port)
 202 {
 203         int ret = TIOCM_CD;
 204         unsigned int r;
 205
 206         r = locomo_gpio_read_output(&collie_locomo_device.dev, LOCOMO_GPIO_CTS & LOCOMO_GPIO_DSR);
 207         if (r == -ENODEV)
 208                 return ret;
 209         if (r & LOCOMO_GPIO_CTS)
 210                 ret |= TIOCM_CTS;
 211         if (r & LOCOMO_GPIO_DSR)
 212                 ret |= TIOCM_DSR;
 213
 214         return ret;
 215 }
 216
 217 static struct sa1100_port_fns collie_port_fns __initdata = {
 218         .set_mctrl      = collie_uart_set_mctrl,
 219         .get_mctrl      = collie_uart_get_mctrl,
 220 };
 221
 222 static int collie_uart_probe(struct locomo_dev *dev)
 223 {
 224         return 0;
 225 }
 226
 227 static int collie_uart_remove(struct locomo_dev *dev)
 228 {
 229         return 0;
 230 }
 231
 232 static struct locomo_driver collie_uart_driver = {
 233         .drv = {
 234                 .name = "collie_uart",
 235         },
 236         .devid  = LOCOMO_DEVID_UART,
 237         .probe  = collie_uart_probe,
 238         .remove = collie_uart_remove,
 239 };
 240
 241 static int __init collie_uart_init(void)
 242 {
 243         return locomo_driver_register(&collie_uart_driver);
 244 }
 245 device_initcall(collie_uart_init);
 246
 247 #endif
 248
 249
 250 static struct resource locomo_resources[] = {
 251         [0] = DEFINE_RES_MEM(0x40000000, SZ_8K),
 252         [1] = DEFINE_RES_IRQ(IRQ_GPIO25),
 253 };
 254
 255 static struct locomo_platform_data locomo_info = {
 256         .irq_base       = IRQ_BOARD_START,
 257 };
 258
 259 struct platform_device collie_locomo_device = {
 260         .name           = "locomo",
 261         .id             = 0,
 262         .dev            = {
 263                 .platform_data  = &locomo_info,
 264         },
 265         .num_resources  = ARRAY_SIZE(locomo_resources),
 266         .resource       = locomo_resources,
 267 };
 268
 269 static struct gpio_keys_button collie_gpio_keys[] = {
 270         {
 271                 .type   = EV_PWR,
 272                 .code   = KEY_RESERVED,
 273                 .gpio   = COLLIE_GPIO_ON_KEY,
 274                 .desc   = "On key",
 275                 .wakeup = 1,
 276                 .active_low = 1,
 277         },
 278         {
 279                 .type   = EV_PWR,
 280                 .code   = KEY_WAKEUP,
 281                 .gpio   = COLLIE_GPIO_WAKEUP,
 282                 .desc   = "Sync",
 283                 .wakeup = 1,
 284                 .active_low = 1,
 285         },
 286 };
 287
 288 static struct gpio_keys_platform_data collie_gpio_keys_data = {
 289         .buttons        = collie_gpio_keys,
 290         .nbuttons       = ARRAY_SIZE(collie_gpio_keys),
 291 };
 292
 293 static struct platform_device collie_gpio_keys_device = {
 294         .name   = "gpio-keys",
 295         .id     = -1,
 296         .dev    = {
 297                 .platform_data = &collie_gpio_keys_data,
 298         },
 299 };
 300
 301 static struct platform_device *devices[] __initdata = {
 302         &collie_locomo_device,
 303         &colliescoop_device,
 304         &collie_power_device,
 305         &collie_gpio_keys_device,
 306 };
 307
 308 static struct mtd_partition collie_partitions[] = {
 309         {
 310                 .name           = "bootloader",
 311                 .offset         = 0,
 312                 .size           = 0x000C0000,
 313                 .mask_flags     = MTD_WRITEABLE
 314         }, {
 315                 .name           = "kernel",
 316                 .offset         = MTDPART_OFS_APPEND,
 317                 .size           = 0x00100000,
 318         }, {
 319                 .name           = "rootfs",
 320                 .offset         = MTDPART_OFS_APPEND,
 321                 .size           = 0x00e20000,
 322         }, {
 323                 .name           = "bootblock",
 324                 .offset         = MTDPART_OFS_APPEND,
 325                 .size           = 0x00020000,
 326                 .mask_flags     = MTD_WRITEABLE
 327         }
 328 };
 329
 330 static int collie_flash_init(void)
 331 {
 332         int rc = gpio_request(COLLIE_GPIO_VPEN, "flash Vpp enable");
 333         if (rc)
 334                 return rc;
 335
 336         rc = gpio_direction_output(COLLIE_GPIO_VPEN, 1);
 337         if (rc)
 338                 gpio_free(COLLIE_GPIO_VPEN);
 339
 340         return rc;
 341 }
 342
 343 static void collie_set_vpp(int vpp)
 344 {
 345         gpio_set_value(COLLIE_GPIO_VPEN, vpp);
 346 }
 347
 348 static void collie_flash_exit(void)
 349 {
 350         gpio_free(COLLIE_GPIO_VPEN);
 351 }
 352
 353 static struct flash_platform_data collie_flash_data = {
 354         .map_name       = "cfi_probe",
 355         .init           = collie_flash_init,
 356         .set_vpp        = collie_set_vpp,
 357         .exit           = collie_flash_exit,
 358         .parts          = collie_partitions,
 359         .nr_parts       = ARRAY_SIZE(collie_partitions),
 360 };
 361
 362 static struct resource collie_flash_resources[] = {
 363         DEFINE_RES_MEM(SA1100_CS0_PHYS, SZ_32M),
 364 };
 365
 366 static struct sa1100fb_mach_info collie_lcd_info = {
 367         .pixclock       = 171521,       .bpp            = 16,
 368         .xres           = 320,          .yres           = 240,
 369
 370         .hsync_len      = 5,            .vsync_len      = 1,
 371         .left_margin    = 11,           .upper_margin   = 2,
 372         .right_margin   = 30,           .lower_margin   = 0,
 373
 374         .sync           = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
 375
 376         .lccr0          = LCCR0_Color | LCCR0_Sngl | LCCR0_Act,
 377         .lccr3          = LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(2),
 378
 379 #ifdef CONFIG_BACKLIGHT_LOCOMO
 380         .lcd_power      = locomolcd_power
 381 #endif
 382 };
 383
 384 static void __init collie_init(void)
 385 {
 386         int ret = 0;
 387
 388         /* cpu initialize */
 389         GAFR = GPIO_SSP_TXD | GPIO_SSP_SCLK | GPIO_SSP_SFRM | GPIO_SSP_CLK |
 390                 GPIO_MCP_CLK | GPIO_32_768kHz;
 391
 392         GPDR = GPIO_LDD8 | GPIO_LDD9 | GPIO_LDD10 | GPIO_LDD11 | GPIO_LDD12 |
 393                 GPIO_LDD13 | GPIO_LDD14 | GPIO_LDD15 | GPIO_SSP_TXD |
 394                 GPIO_SSP_SCLK | GPIO_SSP_SFRM | GPIO_SDLC_SCLK |
 395                 _COLLIE_GPIO_UCB1x00_RESET | _COLLIE_GPIO_nMIC_ON |
 396                 _COLLIE_GPIO_nREMOCON_ON | GPIO_32_768kHz;
 397
 398         PPDR = PPC_LDD0 | PPC_LDD1 | PPC_LDD2 | PPC_LDD3 | PPC_LDD4 | PPC_LDD5 |
 399                 PPC_LDD6 | PPC_LDD7 | PPC_L_PCLK | PPC_L_LCLK | PPC_L_FCLK | PPC_L_BIAS |
 400                 PPC_TXD1 | PPC_TXD2 | PPC_TXD3 | PPC_TXD4 | PPC_SCLK | PPC_SFRM;
 401
 402         PWER = 0;
 403
 404         PGSR = _COLLIE_GPIO_nREMOCON_ON;
 405
 406         PSDR = PPC_RXD1 | PPC_RXD2 | PPC_RXD3 | PPC_RXD4;
 407
 408         PCFR = PCFR_OPDE;
 409
 410         GPSR |= _COLLIE_GPIO_UCB1x00_RESET;
 411
 412         sa11x0_ppc_configure_mcp();
 413
 414
 415         platform_scoop_config = &collie_pcmcia_config;
 416
 417         gpiod_add_lookup_table(&collie_power_gpiod_table);
 418         gpiod_add_lookup_table(&collie_battery_gpiod_table);
 419
 420         ret = platform_add_devices(devices, ARRAY_SIZE(devices));
 421         if (ret) {
 422                 printk(KERN_WARNING "collie: Unable to register LoCoMo device\n");
 423         }
 424
 425         sa11x0_register_lcd(&collie_lcd_info);
 426         sa11x0_register_mtd(&collie_flash_data, collie_flash_resources,
 427                             ARRAY_SIZE(collie_flash_resources));
 428         sa11x0_register_mcp(&collie_mcp_data);
 429         sa11x0_register_irda(&collie_ir_data);
 430
 431         sharpsl_save_param();
 432 }
 433
 434 static struct map_desc collie_io_desc[] __initdata = {
 435         {       /* 32M main flash (cs0) */
 436                 .virtual        = 0xe8000000,
 437                 .pfn            = __phys_to_pfn(0x00000000),
 438                 .length         = 0x02000000,
 439                 .type           = MT_DEVICE
 440         }, {    /* 32M boot flash (cs1) */
 441                 .virtual        = 0xea000000,
 442                 .pfn            = __phys_to_pfn(0x08000000),
 443                 .length         = 0x02000000,
 444                 .type           = MT_DEVICE
 445         }
 446 };
 447
 448 static void __init collie_map_io(void)
 449 {
 450         sa1100_map_io();
 451         iotable_init(collie_io_desc, ARRAY_SIZE(collie_io_desc));
 452
 453 #ifdef CONFIG_SHARP_LOCOMO
 454         sa1100_register_uart_fns(&collie_port_fns);
 455 #endif
 456         sa1100_register_uart(0, 3);
 457         sa1100_register_uart(1, 1);
 458 }
 459
 460 MACHINE_START(COLLIE, "Sharp-Collie")
 461         .map_io         = collie_map_io,
 462         .nr_irqs        = SA1100_NR_IRQS,
 463         .init_irq       = sa1100_init_irq,
 464         .init_time      = sa1100_timer_init,
 465         .init_machine   = collie_init,
 466         .init_late      = sa11x0_init_late,
 467         .restart        = sa11x0_restart,
 468 MACHINE_END