Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * linux/arch/arm/mach-pxa/idp.c |
| 3 | * |
| 4 | * This program is free software; you can redistribute it and/or modify |
| 5 | * it under the terms of the GNU General Public License version 2 as |
| 6 | * published by the Free Software Foundation. |
| 7 | * |
| 8 | * Copyright (c) 2001 Cliff Brake, Accelent Systems Inc. |
| 9 | * |
| 10 | * 2001-09-13: Cliff Brake <cbrake@accelent.com> |
| 11 | * Initial code |
| 12 | * |
| 13 | * 2005-02-15: Cliff Brake <cliff.brake@gmail.com> |
| 14 | * <http://www.vibren.com> <http://bec-systems.com> |
| 15 | * Updated for 2.6 kernel |
| 16 | * |
| 17 | */ |
| 18 | |
| 19 | #include <linux/init.h> |
| 20 | #include <linux/interrupt.h> |
Thomas Gleixner | 1623dee | 2006-07-01 22:32:20 +0100 | [diff] [blame] | 21 | #include <linux/irq.h> |
Russell King | d052d1b | 2005-10-29 19:07:23 +0100 | [diff] [blame] | 22 | #include <linux/platform_device.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | #include <linux/fb.h> |
| 24 | |
| 25 | #include <asm/setup.h> |
| 26 | #include <asm/memory.h> |
| 27 | #include <asm/mach-types.h> |
Russell King | a09e64f | 2008-08-05 16:14:15 +0100 | [diff] [blame] | 28 | #include <mach/hardware.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | #include <asm/irq.h> |
| 30 | |
| 31 | #include <asm/mach/arch.h> |
| 32 | #include <asm/mach/map.h> |
| 33 | |
Eric Miao | 51c6298 | 2009-01-02 23:17:22 +0800 | [diff] [blame] | 34 | #include <mach/pxa25x.h> |
Russell King | a09e64f | 2008-08-05 16:14:15 +0100 | [diff] [blame] | 35 | #include <mach/idp.h> |
| 36 | #include <mach/pxafb.h> |
| 37 | #include <mach/bitfield.h> |
| 38 | #include <mach/mmc.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | |
| 40 | #include "generic.h" |
Russell King | 46c41e6 | 2007-05-15 15:39:36 +0100 | [diff] [blame] | 41 | #include "devices.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 42 | |
| 43 | /* TODO: |
| 44 | * - add pxa2xx_audio_ops_t device structure |
| 45 | * - Ethernet interrupt |
| 46 | */ |
| 47 | |
Eric Miao | 399ba62 | 2008-08-08 13:33:31 +0800 | [diff] [blame] | 48 | static unsigned long idp_pin_config[] __initdata = { |
Eric Miao | bea95d2 | 2008-08-08 14:17:57 +0800 | [diff] [blame] | 49 | /* LCD */ |
Eric Miao | 07bae6c | 2010-01-04 11:25:10 +0800 | [diff] [blame] | 50 | GPIOxx_LCD_DSTN_16BPP, |
Eric Miao | bea95d2 | 2008-08-08 14:17:57 +0800 | [diff] [blame] | 51 | |
Eric Miao | 399ba62 | 2008-08-08 13:33:31 +0800 | [diff] [blame] | 52 | /* BTUART */ |
| 53 | GPIO42_BTUART_RXD, |
| 54 | GPIO43_BTUART_TXD, |
| 55 | GPIO44_BTUART_CTS, |
| 56 | GPIO45_BTUART_RTS, |
| 57 | |
| 58 | /* STUART */ |
| 59 | GPIO46_STUART_RXD, |
| 60 | GPIO47_STUART_TXD, |
| 61 | |
| 62 | /* MMC */ |
| 63 | GPIO6_MMC_CLK, |
| 64 | GPIO8_MMC_CS0, |
| 65 | |
| 66 | /* Ethernet */ |
| 67 | GPIO33_nCS_5, /* Ethernet CS */ |
| 68 | GPIO4_GPIO, /* Ethernet IRQ */ |
| 69 | }; |
| 70 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | static struct resource smc91x_resources[] = { |
| 72 | [0] = { |
| 73 | .start = (IDP_ETH_PHYS + 0x300), |
| 74 | .end = (IDP_ETH_PHYS + 0xfffff), |
| 75 | .flags = IORESOURCE_MEM, |
| 76 | }, |
| 77 | [1] = { |
Haojian Zhuang | 6384fda | 2011-10-10 14:21:08 +0800 | [diff] [blame] | 78 | .start = PXA_GPIO_TO_IRQ(4), |
| 79 | .end = PXA_GPIO_TO_IRQ(4), |
Russell King | e7b3dc7 | 2008-01-14 22:30:10 +0000 | [diff] [blame] | 80 | .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | } |
| 82 | }; |
| 83 | |
| 84 | static struct platform_device smc91x_device = { |
| 85 | .name = "smc91x", |
| 86 | .id = 0, |
| 87 | .num_resources = ARRAY_SIZE(smc91x_resources), |
| 88 | .resource = smc91x_resources, |
| 89 | }; |
| 90 | |
| 91 | static void idp_backlight_power(int on) |
| 92 | { |
| 93 | if (on) { |
| 94 | IDP_CPLD_LCD |= (1<<1); |
| 95 | } else { |
| 96 | IDP_CPLD_LCD &= ~(1<<1); |
| 97 | } |
| 98 | } |
| 99 | |
| 100 | static void idp_vlcd(int on) |
| 101 | { |
| 102 | if (on) { |
| 103 | IDP_CPLD_LCD |= (1<<2); |
| 104 | } else { |
| 105 | IDP_CPLD_LCD &= ~(1<<2); |
| 106 | } |
| 107 | } |
| 108 | |
Richard Purdie | d14b272 | 2006-09-20 22:54:21 +0100 | [diff] [blame] | 109 | static void idp_lcd_power(int on, struct fb_var_screeninfo *var) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 110 | { |
| 111 | if (on) { |
| 112 | IDP_CPLD_LCD |= (1<<0); |
| 113 | } else { |
| 114 | IDP_CPLD_LCD &= ~(1<<0); |
| 115 | } |
| 116 | |
| 117 | /* call idp_vlcd for now as core driver does not support |
| 118 | * both power and vlcd hooks. Note, this is not technically |
| 119 | * the correct sequence, but seems to work. Disclaimer: |
| 120 | * this may eventually damage the display. |
| 121 | */ |
| 122 | |
| 123 | idp_vlcd(on); |
| 124 | } |
| 125 | |
Richard Purdie | d14b272 | 2006-09-20 22:54:21 +0100 | [diff] [blame] | 126 | static struct pxafb_mode_info sharp_lm8v31_mode = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 127 | .pixclock = 270000, |
| 128 | .xres = 640, |
| 129 | .yres = 480, |
| 130 | .bpp = 16, |
| 131 | .hsync_len = 1, |
| 132 | .left_margin = 3, |
| 133 | .right_margin = 3, |
| 134 | .vsync_len = 1, |
| 135 | .upper_margin = 0, |
| 136 | .lower_margin = 0, |
| 137 | .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, |
| 138 | .cmap_greyscale = 0, |
Richard Purdie | d14b272 | 2006-09-20 22:54:21 +0100 | [diff] [blame] | 139 | }; |
| 140 | |
| 141 | static struct pxafb_mach_info sharp_lm8v31 = { |
| 142 | .modes = &sharp_lm8v31_mode, |
| 143 | .num_modes = 1, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | .cmap_inverse = 0, |
| 145 | .cmap_static = 0, |
Eric Miao | bea95d2 | 2008-08-08 14:17:57 +0800 | [diff] [blame] | 146 | .lcd_conn = LCD_COLOR_DSTN_16BPP | LCD_PCLK_EDGE_FALL | |
| 147 | LCD_AC_BIAS_FREQ(255), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | .pxafb_backlight_power = &idp_backlight_power, |
| 149 | .pxafb_lcd_power = &idp_lcd_power |
| 150 | }; |
| 151 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 152 | static struct pxamci_platform_data idp_mci_platform_data = { |
Robert Jarzmik | 7a64825 | 2009-07-06 22:16:42 +0200 | [diff] [blame] | 153 | .ocr_mask = MMC_VDD_32_33|MMC_VDD_33_34, |
| 154 | .gpio_card_detect = -1, |
| 155 | .gpio_card_ro = -1, |
| 156 | .gpio_power = -1, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 157 | }; |
| 158 | |
| 159 | static void __init idp_init(void) |
| 160 | { |
| 161 | printk("idp_init()\n"); |
| 162 | |
Eric Miao | 399ba62 | 2008-08-08 13:33:31 +0800 | [diff] [blame] | 163 | pxa2xx_mfp_config(ARRAY_AND_SIZE(idp_pin_config)); |
Russell King | cc155c6 | 2009-11-09 13:34:08 +0800 | [diff] [blame] | 164 | pxa_set_ffuart_info(NULL); |
| 165 | pxa_set_btuart_info(NULL); |
| 166 | pxa_set_stuart_info(NULL); |
Eric Miao | 399ba62 | 2008-08-08 13:33:31 +0800 | [diff] [blame] | 167 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | platform_device_register(&smc91x_device); |
| 169 | //platform_device_register(&mst_audio_device); |
Russell King - ARM Linux | 4321e1a | 2011-02-15 15:37:30 +0800 | [diff] [blame] | 170 | pxa_set_fb_info(NULL, &sharp_lm8v31); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 171 | pxa_set_mci_info(&idp_mci_platform_data); |
| 172 | } |
| 173 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 174 | static struct map_desc idp_io_desc[] __initdata = { |
Deepak Saxena | 6f9182e | 2005-10-28 15:19:01 +0100 | [diff] [blame] | 175 | { |
| 176 | .virtual = IDP_COREVOLT_VIRT, |
| 177 | .pfn = __phys_to_pfn(IDP_COREVOLT_PHYS), |
| 178 | .length = IDP_COREVOLT_SIZE, |
| 179 | .type = MT_DEVICE |
| 180 | }, { |
| 181 | .virtual = IDP_CPLD_VIRT, |
| 182 | .pfn = __phys_to_pfn(IDP_CPLD_PHYS), |
| 183 | .length = IDP_CPLD_SIZE, |
| 184 | .type = MT_DEVICE |
| 185 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | }; |
| 187 | |
| 188 | static void __init idp_map_io(void) |
| 189 | { |
Marek Vasut | 851982c | 2010-10-11 02:20:19 +0200 | [diff] [blame] | 190 | pxa25x_map_io(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 191 | iotable_init(idp_io_desc, ARRAY_SIZE(idp_io_desc)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | } |
| 193 | |
Bryan Wu | 55f5d8e | 2012-03-14 02:07:58 +0800 | [diff] [blame^] | 194 | /* LEDs */ |
| 195 | #if defined(CONFIG_NEW_LEDS) && defined(CONFIG_LEDS_CLASS) |
| 196 | struct idp_led { |
| 197 | struct led_classdev cdev; |
| 198 | u8 mask; |
| 199 | }; |
| 200 | |
| 201 | /* |
| 202 | * The triggers lines up below will only be used if the |
| 203 | * LED triggers are compiled in. |
| 204 | */ |
| 205 | static const struct { |
| 206 | const char *name; |
| 207 | const char *trigger; |
| 208 | } idp_leds[] = { |
| 209 | { "idp:green", "heartbeat", }, |
| 210 | { "idp:red", "cpu0", }, |
| 211 | }; |
| 212 | |
| 213 | static void idp_led_set(struct led_classdev *cdev, |
| 214 | enum led_brightness b) |
| 215 | { |
| 216 | struct idp_led *led = container_of(cdev, |
| 217 | struct idp_led, cdev); |
| 218 | u32 reg = IDP_CPLD_LED_CONTROL; |
| 219 | |
| 220 | if (b != LED_OFF) |
| 221 | reg &= ~led->mask; |
| 222 | else |
| 223 | reg |= led->mask; |
| 224 | |
| 225 | IDP_CPLD_LED_CONTROL = reg; |
| 226 | } |
| 227 | |
| 228 | static enum led_brightness idp_led_get(struct led_classdev *cdev) |
| 229 | { |
| 230 | struct idp_led *led = container_of(cdev, |
| 231 | struct idp_led, cdev); |
| 232 | |
| 233 | return (IDP_CPLD_LED_CONTROL & led->mask) ? LED_OFF : LED_FULL; |
| 234 | } |
| 235 | |
| 236 | static int __init idp_leds_init(void) |
| 237 | { |
| 238 | int i; |
| 239 | |
| 240 | if (!machine_is_pxa_idp()) |
| 241 | return -ENODEV; |
| 242 | |
| 243 | for (i = 0; i < ARRAY_SIZE(idp_leds); i++) { |
| 244 | struct idp_led *led; |
| 245 | |
| 246 | led = kzalloc(sizeof(*led), GFP_KERNEL); |
| 247 | if (!led) |
| 248 | break; |
| 249 | |
| 250 | led->cdev.name = idp_leds[i].name; |
| 251 | led->cdev.brightness_set = idp_led_set; |
| 252 | led->cdev.brightness_get = idp_led_get; |
| 253 | led->cdev.default_trigger = idp_leds[i].trigger; |
| 254 | |
| 255 | if (i == 0) |
| 256 | led->mask = IDP_HB_LED; |
| 257 | else |
| 258 | led->mask = IDP_BUSY_LED; |
| 259 | |
| 260 | if (led_classdev_register(NULL, &led->cdev) < 0) { |
| 261 | kfree(led); |
| 262 | break; |
| 263 | } |
| 264 | } |
| 265 | |
| 266 | return 0; |
| 267 | } |
| 268 | |
| 269 | /* |
| 270 | * Since we may have triggers on any subsystem, defer registration |
| 271 | * until after subsystem_init. |
| 272 | */ |
| 273 | fs_initcall(idp_leds_init); |
| 274 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 275 | |
| 276 | MACHINE_START(PXA_IDP, "Vibren PXA255 IDP") |
Russell King | e9dea0c | 2005-07-03 17:38:58 +0100 | [diff] [blame] | 277 | /* Maintainer: Vibren Technologies */ |
Russell King | e9dea0c | 2005-07-03 17:38:58 +0100 | [diff] [blame] | 278 | .map_io = idp_map_io, |
Rob Herring | 4e61109 | 2012-01-03 16:53:48 -0600 | [diff] [blame] | 279 | .nr_irqs = PXA_NR_IRQS, |
Eric Miao | b40c676 | 2008-08-08 14:33:29 +0800 | [diff] [blame] | 280 | .init_irq = pxa25x_init_irq, |
Eric Miao | 8a97ae2 | 2011-05-18 21:30:04 +0800 | [diff] [blame] | 281 | .handle_irq = pxa25x_handle_irq, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 282 | .timer = &pxa_timer, |
Russell King | e9dea0c | 2005-07-03 17:38:58 +0100 | [diff] [blame] | 283 | .init_machine = idp_init, |
Russell King | 271a74f | 2011-11-04 14:15:53 +0000 | [diff] [blame] | 284 | .restart = pxa_restart, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 285 | MACHINE_END |