Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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: |
Pavel Machek | a253129 | 2010-07-18 14:27:13 +0200 | [diff] [blame] | 14 | * 2006 Pavel Machek <pavel@ucw.cz> |
Pavel Machek | 50c37e2 | 2006-04-01 12:13:31 +0100 | [diff] [blame] | 15 | * 03-06-2004 John Lenz <lenz@cs.wisc.edu> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 16 | * 06-04-2002 Chris Larson <kergoth@digitalnemesis.net> |
| 17 | * 04-16-2001 Lineo Japan,Inc. ... |
| 18 | */ |
| 19 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | #include <linux/init.h> |
| 21 | #include <linux/kernel.h> |
| 22 | #include <linux/tty.h> |
| 23 | #include <linux/delay.h> |
Russell King | d052d1b | 2005-10-29 19:07:23 +0100 | [diff] [blame] | 24 | #include <linux/platform_device.h> |
Russell King | abe0608 | 2012-01-20 22:13:52 +0000 | [diff] [blame] | 25 | #include <linux/mfd/ucb1x00.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | #include <linux/mtd/mtd.h> |
| 27 | #include <linux/mtd/partitions.h> |
| 28 | #include <linux/timer.h> |
Dmitry Baryshkov | 224be09 | 2009-03-25 10:14:25 +0100 | [diff] [blame] | 29 | #include <linux/gpio.h> |
Thomas Kunze | 9823b2d | 2009-02-10 13:48:32 +0100 | [diff] [blame] | 30 | #include <linux/pda_power.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | |
Russell King | e1b7a72 | 2012-01-14 11:50:04 +0000 | [diff] [blame] | 32 | #include <video/sa1100fb.h> |
| 33 | |
Russell King | a09e64f | 2008-08-05 16:14:15 +0100 | [diff] [blame] | 34 | #include <mach/hardware.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 35 | #include <asm/mach-types.h> |
Paul Gortmaker | 9e54d33 | 2011-07-31 18:38:45 -0400 | [diff] [blame] | 36 | #include <asm/page.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | #include <asm/setup.h> |
Russell King | a09e64f | 2008-08-05 16:14:15 +0100 | [diff] [blame] | 38 | #include <mach/collie.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | |
| 40 | #include <asm/mach/arch.h> |
| 41 | #include <asm/mach/flash.h> |
| 42 | #include <asm/mach/map.h> |
| 43 | #include <asm/mach/serial_sa1100.h> |
| 44 | |
| 45 | #include <asm/hardware/scoop.h> |
| 46 | #include <asm/mach/sharpsl_param.h> |
| 47 | #include <asm/hardware/locomo.h> |
Russell King | a09e64f | 2008-08-05 16:14:15 +0100 | [diff] [blame] | 48 | #include <mach/mcp.h> |
Rob Herring | f314f33 | 2012-02-24 00:06:51 +0100 | [diff] [blame] | 49 | #include <mach/irqs.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 50 | |
| 51 | #include "generic.h" |
| 52 | |
| 53 | static struct resource collie_scoop_resources[] = { |
Russell King | a181099 | 2012-01-12 10:25:29 +0000 | [diff] [blame] | 54 | [0] = DEFINE_RES_MEM(0x40800000, SZ_4K), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 55 | }; |
| 56 | |
| 57 | static struct scoop_config collie_scoop_setup = { |
| 58 | .io_dir = COLLIE_SCOOP_IO_DIR, |
| 59 | .io_out = COLLIE_SCOOP_IO_OUT, |
Thomas Kunze | f151ccf | 2008-10-28 21:41:39 +0300 | [diff] [blame] | 60 | .gpio_base = COLLIE_SCOOP_GPIO_BASE, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | }; |
| 62 | |
| 63 | struct platform_device colliescoop_device = { |
| 64 | .name = "sharp-scoop", |
| 65 | .id = -1, |
| 66 | .dev = { |
| 67 | .platform_data = &collie_scoop_setup, |
| 68 | }, |
| 69 | .num_resources = ARRAY_SIZE(collie_scoop_resources), |
| 70 | .resource = collie_scoop_resources, |
| 71 | }; |
| 72 | |
Pavel Machek | 44575b2 | 2006-03-25 03:07:34 -0800 | [diff] [blame] | 73 | static struct scoop_pcmcia_dev collie_pcmcia_scoop[] = { |
Kristoffer Ericson | 9398253 | 2008-11-26 20:58:43 +0100 | [diff] [blame] | 74 | { |
| 75 | .dev = &colliescoop_device.dev, |
| 76 | .irq = COLLIE_IRQ_GPIO_CF_IRQ, |
| 77 | .cd_irq = COLLIE_IRQ_GPIO_CF_CD, |
| 78 | .cd_irq_str = "PCMCIA0 CD", |
| 79 | }, |
Pavel Machek | 44575b2 | 2006-03-25 03:07:34 -0800 | [diff] [blame] | 80 | }; |
| 81 | |
| 82 | static struct scoop_pcmcia_config collie_pcmcia_config = { |
Kristoffer Ericson | 9398253 | 2008-11-26 20:58:43 +0100 | [diff] [blame] | 83 | .devs = &collie_pcmcia_scoop[0], |
| 84 | .num_devs = 1, |
Pavel Machek | 44575b2 | 2006-03-25 03:07:34 -0800 | [diff] [blame] | 85 | }; |
| 86 | |
Russell King | abe0608 | 2012-01-20 22:13:52 +0000 | [diff] [blame] | 87 | static struct ucb1x00_plat_data collie_ucb1x00_data = { |
| 88 | .gpio_base = COLLIE_TC35143_GPIO_BASE, |
| 89 | }; |
| 90 | |
Pavel Machek | 44575b2 | 2006-03-25 03:07:34 -0800 | [diff] [blame] | 91 | static struct mcp_plat_data collie_mcp_data = { |
Kristoffer Ericson | 9398253 | 2008-11-26 20:58:43 +0100 | [diff] [blame] | 92 | .mccr0 = MCCR0_ADM | MCCR0_ExtClk, |
| 93 | .sclk_rate = 9216000, |
Russell King | abe0608 | 2012-01-20 22:13:52 +0000 | [diff] [blame] | 94 | .codec_pdata = &collie_ucb1x00_data, |
Pavel Machek | 44575b2 | 2006-03-25 03:07:34 -0800 | [diff] [blame] | 95 | }; |
| 96 | |
Thomas Kunze | 9823b2d | 2009-02-10 13:48:32 +0100 | [diff] [blame] | 97 | /* |
| 98 | * Collie AC IN |
| 99 | */ |
| 100 | static int collie_power_init(struct device *dev) |
| 101 | { |
| 102 | int ret = gpio_request(COLLIE_GPIO_AC_IN, "ac in"); |
| 103 | if (ret) |
| 104 | goto err_gpio_req; |
| 105 | |
| 106 | ret = gpio_direction_input(COLLIE_GPIO_AC_IN); |
| 107 | if (ret) |
| 108 | goto err_gpio_in; |
| 109 | |
| 110 | return 0; |
| 111 | |
| 112 | err_gpio_in: |
| 113 | gpio_free(COLLIE_GPIO_AC_IN); |
| 114 | err_gpio_req: |
| 115 | return ret; |
| 116 | } |
| 117 | |
| 118 | static void collie_power_exit(struct device *dev) |
| 119 | { |
| 120 | gpio_free(COLLIE_GPIO_AC_IN); |
| 121 | } |
| 122 | |
| 123 | static int collie_power_ac_online(void) |
| 124 | { |
| 125 | return gpio_get_value(COLLIE_GPIO_AC_IN) == 2; |
| 126 | } |
| 127 | |
| 128 | static char *collie_ac_supplied_to[] = { |
| 129 | "main-battery", |
| 130 | "backup-battery", |
| 131 | }; |
| 132 | |
| 133 | static struct pda_power_pdata collie_power_data = { |
| 134 | .init = collie_power_init, |
| 135 | .is_ac_online = collie_power_ac_online, |
| 136 | .exit = collie_power_exit, |
| 137 | .supplied_to = collie_ac_supplied_to, |
| 138 | .num_supplicants = ARRAY_SIZE(collie_ac_supplied_to), |
| 139 | }; |
| 140 | |
| 141 | static struct resource collie_power_resource[] = { |
| 142 | { |
| 143 | .name = "ac", |
Thomas Kunze | 9823b2d | 2009-02-10 13:48:32 +0100 | [diff] [blame] | 144 | .flags = IORESOURCE_IRQ | |
| 145 | IORESOURCE_IRQ_HIGHEDGE | |
| 146 | IORESOURCE_IRQ_LOWEDGE, |
| 147 | }, |
| 148 | }; |
| 149 | |
| 150 | static struct platform_device collie_power_device = { |
| 151 | .name = "pda-power", |
| 152 | .id = -1, |
| 153 | .dev.platform_data = &collie_power_data, |
| 154 | .resource = collie_power_resource, |
| 155 | .num_resources = ARRAY_SIZE(collie_power_resource), |
Pavel Machek | 44575b2 | 2006-03-25 03:07:34 -0800 | [diff] [blame] | 156 | }; |
| 157 | |
Pavel Machek | 50c37e2 | 2006-04-01 12:13:31 +0100 | [diff] [blame] | 158 | #ifdef CONFIG_SHARP_LOCOMO |
| 159 | /* |
| 160 | * low-level UART features. |
| 161 | */ |
Richard Purdie | 8d48427 | 2006-09-25 20:11:48 +0100 | [diff] [blame] | 162 | struct platform_device collie_locomo_device; |
Pavel Machek | 50c37e2 | 2006-04-01 12:13:31 +0100 | [diff] [blame] | 163 | |
| 164 | static void collie_uart_set_mctrl(struct uart_port *port, u_int mctrl) |
| 165 | { |
Kristoffer Ericson | 9398253 | 2008-11-26 20:58:43 +0100 | [diff] [blame] | 166 | if (mctrl & TIOCM_RTS) |
Richard Purdie | 8d48427 | 2006-09-25 20:11:48 +0100 | [diff] [blame] | 167 | locomo_gpio_write(&collie_locomo_device.dev, LOCOMO_GPIO_RTS, 0); |
Kristoffer Ericson | 9398253 | 2008-11-26 20:58:43 +0100 | [diff] [blame] | 168 | else |
Richard Purdie | 8d48427 | 2006-09-25 20:11:48 +0100 | [diff] [blame] | 169 | locomo_gpio_write(&collie_locomo_device.dev, LOCOMO_GPIO_RTS, 1); |
Pavel Machek | 50c37e2 | 2006-04-01 12:13:31 +0100 | [diff] [blame] | 170 | |
Kristoffer Ericson | 9398253 | 2008-11-26 20:58:43 +0100 | [diff] [blame] | 171 | if (mctrl & TIOCM_DTR) |
Richard Purdie | 8d48427 | 2006-09-25 20:11:48 +0100 | [diff] [blame] | 172 | locomo_gpio_write(&collie_locomo_device.dev, LOCOMO_GPIO_DTR, 0); |
Kristoffer Ericson | 9398253 | 2008-11-26 20:58:43 +0100 | [diff] [blame] | 173 | else |
Richard Purdie | 8d48427 | 2006-09-25 20:11:48 +0100 | [diff] [blame] | 174 | locomo_gpio_write(&collie_locomo_device.dev, LOCOMO_GPIO_DTR, 1); |
Pavel Machek | 50c37e2 | 2006-04-01 12:13:31 +0100 | [diff] [blame] | 175 | } |
| 176 | |
| 177 | static u_int collie_uart_get_mctrl(struct uart_port *port) |
| 178 | { |
| 179 | int ret = TIOCM_CD; |
| 180 | unsigned int r; |
Pavel Machek | 50c37e2 | 2006-04-01 12:13:31 +0100 | [diff] [blame] | 181 | |
Richard Purdie | 8d48427 | 2006-09-25 20:11:48 +0100 | [diff] [blame] | 182 | r = locomo_gpio_read_output(&collie_locomo_device.dev, LOCOMO_GPIO_CTS & LOCOMO_GPIO_DSR); |
| 183 | if (r == -ENODEV) |
| 184 | return ret; |
Pavel Machek | 50c37e2 | 2006-04-01 12:13:31 +0100 | [diff] [blame] | 185 | if (r & LOCOMO_GPIO_CTS) |
| 186 | ret |= TIOCM_CTS; |
| 187 | if (r & LOCOMO_GPIO_DSR) |
| 188 | ret |= TIOCM_DSR; |
| 189 | |
| 190 | return ret; |
| 191 | } |
Pavel Machek | 44575b2 | 2006-03-25 03:07:34 -0800 | [diff] [blame] | 192 | |
| 193 | static struct sa1100_port_fns collie_port_fns __initdata = { |
| 194 | .set_mctrl = collie_uart_set_mctrl, |
| 195 | .get_mctrl = collie_uart_get_mctrl, |
| 196 | }; |
| 197 | |
Pavel Machek | 50c37e2 | 2006-04-01 12:13:31 +0100 | [diff] [blame] | 198 | static int collie_uart_probe(struct locomo_dev *dev) |
| 199 | { |
Pavel Machek | 50c37e2 | 2006-04-01 12:13:31 +0100 | [diff] [blame] | 200 | return 0; |
| 201 | } |
| 202 | |
| 203 | static int collie_uart_remove(struct locomo_dev *dev) |
| 204 | { |
Pavel Machek | 50c37e2 | 2006-04-01 12:13:31 +0100 | [diff] [blame] | 205 | return 0; |
| 206 | } |
| 207 | |
| 208 | static struct locomo_driver collie_uart_driver = { |
| 209 | .drv = { |
| 210 | .name = "collie_uart", |
| 211 | }, |
| 212 | .devid = LOCOMO_DEVID_UART, |
| 213 | .probe = collie_uart_probe, |
| 214 | .remove = collie_uart_remove, |
| 215 | }; |
| 216 | |
Russell King | e63cedb | 2009-03-25 10:15:00 +0000 | [diff] [blame] | 217 | static int __init collie_uart_init(void) |
| 218 | { |
Pavel Machek | 50c37e2 | 2006-04-01 12:13:31 +0100 | [diff] [blame] | 219 | return locomo_driver_register(&collie_uart_driver); |
| 220 | } |
| 221 | device_initcall(collie_uart_init); |
| 222 | |
| 223 | #endif |
| 224 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 225 | |
| 226 | static struct resource locomo_resources[] = { |
Russell King | a181099 | 2012-01-12 10:25:29 +0000 | [diff] [blame] | 227 | [0] = DEFINE_RES_MEM(0x40000000, SZ_8K), |
| 228 | [1] = DEFINE_RES_IRQ(IRQ_GPIO25), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 229 | }; |
| 230 | |
Eric Miao | ac609d2 | 2010-02-04 18:07:33 -0800 | [diff] [blame] | 231 | static struct locomo_platform_data locomo_info = { |
| 232 | .irq_base = IRQ_BOARD_START, |
| 233 | }; |
| 234 | |
Richard Purdie | 8d48427 | 2006-09-25 20:11:48 +0100 | [diff] [blame] | 235 | struct platform_device collie_locomo_device = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | .name = "locomo", |
| 237 | .id = 0, |
Dmitry Eremin-Solenikov | 34cd2d3 | 2011-02-11 16:26:10 +0100 | [diff] [blame] | 238 | .dev = { |
| 239 | .platform_data = &locomo_info, |
| 240 | }, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 241 | .num_resources = ARRAY_SIZE(locomo_resources), |
| 242 | .resource = locomo_resources, |
| 243 | }; |
| 244 | |
| 245 | static struct platform_device *devices[] __initdata = { |
Richard Purdie | 8d48427 | 2006-09-25 20:11:48 +0100 | [diff] [blame] | 246 | &collie_locomo_device, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | &colliescoop_device, |
Thomas Kunze | 9823b2d | 2009-02-10 13:48:32 +0100 | [diff] [blame] | 248 | &collie_power_device, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | }; |
| 250 | |
| 251 | static struct mtd_partition collie_partitions[] = { |
| 252 | { |
| 253 | .name = "bootloader", |
| 254 | .offset = 0, |
| 255 | .size = 0x000C0000, |
| 256 | .mask_flags = MTD_WRITEABLE |
| 257 | }, { |
| 258 | .name = "kernel", |
| 259 | .offset = MTDPART_OFS_APPEND, |
| 260 | .size = 0x00100000, |
| 261 | }, { |
| 262 | .name = "rootfs", |
| 263 | .offset = MTDPART_OFS_APPEND, |
| 264 | .size = 0x00e20000, |
| 265 | } |
| 266 | }; |
| 267 | |
Dmitry Baryshkov | 224be09 | 2009-03-25 10:14:25 +0100 | [diff] [blame] | 268 | static int collie_flash_init(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 269 | { |
Russell King | e63cedb | 2009-03-25 10:15:00 +0000 | [diff] [blame] | 270 | int rc = gpio_request(COLLIE_GPIO_VPEN, "flash Vpp enable"); |
Dmitry Baryshkov | 224be09 | 2009-03-25 10:14:25 +0100 | [diff] [blame] | 271 | if (rc) |
| 272 | return rc; |
| 273 | |
| 274 | rc = gpio_direction_output(COLLIE_GPIO_VPEN, 1); |
| 275 | if (rc) |
| 276 | gpio_free(COLLIE_GPIO_VPEN); |
| 277 | |
| 278 | return rc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 279 | } |
| 280 | |
Dmitry Baryshkov | 224be09 | 2009-03-25 10:14:25 +0100 | [diff] [blame] | 281 | static void collie_set_vpp(int vpp) |
| 282 | { |
| 283 | gpio_set_value(COLLIE_GPIO_VPEN, vpp); |
| 284 | } |
| 285 | |
| 286 | static void collie_flash_exit(void) |
| 287 | { |
| 288 | gpio_free(COLLIE_GPIO_VPEN); |
| 289 | } |
Russell King | e63cedb | 2009-03-25 10:15:00 +0000 | [diff] [blame] | 290 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | static struct flash_platform_data collie_flash_data = { |
| 292 | .map_name = "cfi_probe", |
Dmitry Baryshkov | 224be09 | 2009-03-25 10:14:25 +0100 | [diff] [blame] | 293 | .init = collie_flash_init, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 294 | .set_vpp = collie_set_vpp, |
Dmitry Baryshkov | 224be09 | 2009-03-25 10:14:25 +0100 | [diff] [blame] | 295 | .exit = collie_flash_exit, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 296 | .parts = collie_partitions, |
| 297 | .nr_parts = ARRAY_SIZE(collie_partitions), |
| 298 | }; |
| 299 | |
| 300 | static struct resource collie_flash_resources[] = { |
Russell King | a181099 | 2012-01-12 10:25:29 +0000 | [diff] [blame] | 301 | DEFINE_RES_MEM(SA1100_CS0_PHYS, SZ_32M), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 302 | }; |
| 303 | |
Russell King | e1b7a72 | 2012-01-14 11:50:04 +0000 | [diff] [blame] | 304 | static struct sa1100fb_mach_info collie_lcd_info = { |
| 305 | .pixclock = 171521, .bpp = 16, |
| 306 | .xres = 320, .yres = 240, |
| 307 | |
| 308 | .hsync_len = 5, .vsync_len = 1, |
| 309 | .left_margin = 11, .upper_margin = 2, |
| 310 | .right_margin = 30, .lower_margin = 0, |
| 311 | |
| 312 | .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, |
| 313 | |
| 314 | .lccr0 = LCCR0_Color | LCCR0_Sngl | LCCR0_Act, |
| 315 | .lccr3 = LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(2), |
Paul Gortmaker | beca98c9 | 2012-04-02 18:17:17 -0400 | [diff] [blame] | 316 | |
| 317 | #ifdef CONFIG_BACKLIGHT_LOCOMO |
| 318 | .lcd_power = locomolcd_power |
| 319 | #endif |
Russell King | e1b7a72 | 2012-01-14 11:50:04 +0000 | [diff] [blame] | 320 | }; |
| 321 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 322 | static void __init collie_init(void) |
| 323 | { |
| 324 | int ret = 0; |
| 325 | |
| 326 | /* cpu initialize */ |
Thomas Kunze | 864d0ec | 2008-05-19 22:06:51 +0100 | [diff] [blame] | 327 | GAFR = GPIO_SSP_TXD | GPIO_SSP_SCLK | GPIO_SSP_SFRM | GPIO_SSP_CLK | |
| 328 | GPIO_MCP_CLK | GPIO_32_768kHz; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 329 | |
Thomas Kunze | 864d0ec | 2008-05-19 22:06:51 +0100 | [diff] [blame] | 330 | GPDR = GPIO_LDD8 | GPIO_LDD9 | GPIO_LDD10 | GPIO_LDD11 | GPIO_LDD12 | |
| 331 | GPIO_LDD13 | GPIO_LDD14 | GPIO_LDD15 | GPIO_SSP_TXD | |
| 332 | GPIO_SSP_SCLK | GPIO_SSP_SFRM | GPIO_SDLC_SCLK | |
Thomas Kunze | 1d0ad84 | 2009-10-05 22:05:38 +0200 | [diff] [blame] | 333 | _COLLIE_GPIO_UCB1x00_RESET | _COLLIE_GPIO_nMIC_ON | |
| 334 | _COLLIE_GPIO_nREMOCON_ON | GPIO_32_768kHz; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 335 | |
Thomas Kunze | 864d0ec | 2008-05-19 22:06:51 +0100 | [diff] [blame] | 336 | PPDR = PPC_LDD0 | PPC_LDD1 | PPC_LDD2 | PPC_LDD3 | PPC_LDD4 | PPC_LDD5 | |
| 337 | PPC_LDD6 | PPC_LDD7 | PPC_L_PCLK | PPC_L_LCLK | PPC_L_FCLK | PPC_L_BIAS | |
| 338 | PPC_TXD1 | PPC_TXD2 | PPC_TXD3 | PPC_TXD4 | PPC_SCLK | PPC_SFRM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 339 | |
Thomas Kunze | 1d0ad84 | 2009-10-05 22:05:38 +0200 | [diff] [blame] | 340 | PWER = _COLLIE_GPIO_AC_IN | _COLLIE_GPIO_CO | _COLLIE_GPIO_ON_KEY | |
| 341 | _COLLIE_GPIO_WAKEUP | _COLLIE_GPIO_nREMOCON_INT | PWER_RTC; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 342 | |
Thomas Kunze | 1d0ad84 | 2009-10-05 22:05:38 +0200 | [diff] [blame] | 343 | PGSR = _COLLIE_GPIO_nREMOCON_ON; |
Thomas Kunze | 864d0ec | 2008-05-19 22:06:51 +0100 | [diff] [blame] | 344 | |
| 345 | PSDR = PPC_RXD1 | PPC_RXD2 | PPC_RXD3 | PPC_RXD4; |
| 346 | |
| 347 | PCFR = PCFR_OPDE; |
| 348 | |
Thomas Kunze | 1d0ad84 | 2009-10-05 22:05:38 +0200 | [diff] [blame] | 349 | GPSR |= _COLLIE_GPIO_UCB1x00_RESET; |
| 350 | |
Russell King | 5f76559 | 2012-01-18 23:46:28 +0000 | [diff] [blame] | 351 | collie_power_resource[0].start = gpio_to_irq(COLLIE_GPIO_AC_IN); |
| 352 | collie_power_resource[0].end = gpio_to_irq(COLLIE_GPIO_AC_IN); |
Russell King | 7256ecc | 2012-03-25 23:56:30 +0100 | [diff] [blame] | 353 | |
Russell King | e36e26a | 2012-01-20 22:24:07 +0000 | [diff] [blame] | 354 | sa11x0_ppc_configure_mcp(); |
| 355 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 356 | |
Pavel Machek | 44575b2 | 2006-03-25 03:07:34 -0800 | [diff] [blame] | 357 | platform_scoop_config = &collie_pcmcia_config; |
| 358 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 359 | ret = platform_add_devices(devices, ARRAY_SIZE(devices)); |
| 360 | if (ret) { |
| 361 | printk(KERN_WARNING "collie: Unable to register LoCoMo device\n"); |
| 362 | } |
| 363 | |
Russell King | e1b7a72 | 2012-01-14 11:50:04 +0000 | [diff] [blame] | 364 | sa11x0_register_lcd(&collie_lcd_info); |
Russell King | 7a5b4e1 | 2009-10-06 14:55:53 +0100 | [diff] [blame] | 365 | sa11x0_register_mtd(&collie_flash_data, collie_flash_resources, |
| 366 | ARRAY_SIZE(collie_flash_resources)); |
| 367 | sa11x0_register_mcp(&collie_mcp_data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 368 | |
| 369 | sharpsl_save_param(); |
| 370 | } |
| 371 | |
| 372 | static struct map_desc collie_io_desc[] __initdata = { |
Deepak Saxena | 92519d8 | 2005-10-28 15:19:04 +0100 | [diff] [blame] | 373 | { /* 32M main flash (cs0) */ |
| 374 | .virtual = 0xe8000000, |
| 375 | .pfn = __phys_to_pfn(0x00000000), |
| 376 | .length = 0x02000000, |
| 377 | .type = MT_DEVICE |
| 378 | }, { /* 32M boot flash (cs1) */ |
| 379 | .virtual = 0xea000000, |
| 380 | .pfn = __phys_to_pfn(0x08000000), |
| 381 | .length = 0x02000000, |
| 382 | .type = MT_DEVICE |
| 383 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 384 | }; |
| 385 | |
| 386 | static void __init collie_map_io(void) |
| 387 | { |
| 388 | sa1100_map_io(); |
| 389 | iotable_init(collie_io_desc, ARRAY_SIZE(collie_io_desc)); |
Pavel Machek | 50c37e2 | 2006-04-01 12:13:31 +0100 | [diff] [blame] | 390 | |
| 391 | #ifdef CONFIG_SHARP_LOCOMO |
| 392 | sa1100_register_uart_fns(&collie_port_fns); |
| 393 | #endif |
| 394 | sa1100_register_uart(0, 3); |
| 395 | sa1100_register_uart(1, 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 396 | } |
| 397 | |
| 398 | MACHINE_START(COLLIE, "Sharp-Collie") |
Russell King | e9dea0c | 2005-07-03 17:38:58 +0100 | [diff] [blame] | 399 | .map_io = collie_map_io, |
Rob Herring | f314f33 | 2012-02-24 00:06:51 +0100 | [diff] [blame] | 400 | .nr_irqs = SA1100_NR_IRQS, |
Russell King | e9dea0c | 2005-07-03 17:38:58 +0100 | [diff] [blame] | 401 | .init_irq = sa1100_init_irq, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 402 | .timer = &sa1100_timer, |
| 403 | .init_machine = collie_init, |
Shawn Guo | 7fea1ba | 2012-04-26 21:22:45 +0800 | [diff] [blame^] | 404 | .init_late = sa11x0_init_late, |
Russell King | d9ca583 | 2011-11-05 10:28:50 +0000 | [diff] [blame] | 405 | .restart = sa11x0_restart, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 406 | MACHINE_END |