1/* 2* Freescale STMP37XX/STMP378X platform devices 3* 4* Embedded Alley Solutions, Inc <source@embeddedalley.com> 5* 6* Copyright 2008 Freescale Semiconductor, Inc. All Rights Reserved. 7* Copyright 2008 Embedded Alley Solutions, Inc All Rights Reserved. 8*/ 9 10/* 11* The code contained herein is licensed under the GNU General Public 12* License. You may obtain a copy of the GNU General Public License 13* Version 2 or later at the following locations: 14* 15* http://www.opensource.org/licenses/gpl-license.html 16* http://www.gnu.org/copyleft/gpl.html 17*/ 18#include <linux/kernel.h> 19#include <linux/init.h> 20#include <linux/device.h> 21#include <linux/platform_device.h> 22#include <linux/dma-mapping.h> 23 24#include <mach/dma.h> 25#include <mach/platform.h> 26#include <mach/stmp3xxx.h> 27#include <mach/regs-lcdif.h> 28#include <mach/regs-uartapp.h> 29#include <mach/regs-gpmi.h> 30#include <mach/regs-usbctrl.h> 31#include <mach/regs-ssp.h> 32#include <mach/regs-rtc.h> 33 34static u64 common_dmamask = DMA_BIT_MASK(32); 35 36static struct resource appuart_resources[] = { 37 { 38 .start = IRQ_UARTAPP_INTERNAL, 39 .end = IRQ_UARTAPP_INTERNAL, 40 .flags = IORESOURCE_IRQ, 41 }, { 42 .start = IRQ_UARTAPP_RX_DMA, 43 .end = IRQ_UARTAPP_RX_DMA, 44 .flags = IORESOURCE_IRQ, 45 }, { 46 .start = IRQ_UARTAPP_TX_DMA, 47 .end = IRQ_UARTAPP_TX_DMA, 48 .flags = IORESOURCE_IRQ, 49 }, { 50 .start = REGS_UARTAPP1_PHYS, 51 .end = REGS_UARTAPP1_PHYS + REGS_UARTAPP_SIZE, 52 .flags = IORESOURCE_MEM, 53 }, { 54 /* Rx DMA channel */ 55 .start = STMP3XXX_DMA(6, STMP3XXX_BUS_APBX), 56 .end = STMP3XXX_DMA(6, STMP3XXX_BUS_APBX), 57 .flags = IORESOURCE_DMA, 58 }, { 59 /* Tx DMA channel */ 60 .start = STMP3XXX_DMA(7, STMP3XXX_BUS_APBX), 61 .end = STMP3XXX_DMA(7, STMP3XXX_BUS_APBX), 62 .flags = IORESOURCE_DMA, 63 }, 64}; 65 66struct platform_device stmp3xxx_appuart = { 67 .name = "stmp3xxx-appuart", 68 .id = 0, 69 .resource = appuart_resources, 70 .num_resources = ARRAY_SIZE(appuart_resources), 71 .dev = { 72 .dma_mask = &common_dmamask, 73 .coherent_dma_mask = DMA_BIT_MASK(32), 74 }, 75}; 76 77struct platform_device stmp3xxx_watchdog = { 78 .name = "stmp3xxx_wdt", 79 .id = -1, 80}; 81 82static struct resource ts_resource[] = { 83 { 84 .flags = IORESOURCE_IRQ, 85 .start = IRQ_TOUCH_DETECT, 86 .end = IRQ_TOUCH_DETECT, 87 }, { 88 .flags = IORESOURCE_IRQ, 89 .start = IRQ_LRADC_CH5, 90 .end = IRQ_LRADC_CH5, 91 }, 92}; 93 94struct platform_device stmp3xxx_touchscreen = { 95 .name = "stmp3xxx_ts", 96 .id = -1, 97 .resource = ts_resource, 98 .num_resources = ARRAY_SIZE(ts_resource), 99}; 100 101/* 102* Keypad device 103*/ 104struct platform_device stmp3xxx_keyboard = { 105 .name = "stmp3xxx-keyboard", 106 .id = -1, 107}; 108 109static struct resource gpmi_resources[] = { 110 { 111 .flags = IORESOURCE_MEM, 112 .start = REGS_GPMI_PHYS, 113 .end = REGS_GPMI_PHYS + REGS_GPMI_SIZE, 114 }, { 115 .flags = IORESOURCE_IRQ, 116 .start = IRQ_GPMI_DMA, 117 .end = IRQ_GPMI_DMA, 118 }, { 119 .flags = IORESOURCE_DMA, 120 .start = STMP3XXX_DMA(4, STMP3XXX_BUS_APBH), 121 .end = STMP3XXX_DMA(8, STMP3XXX_BUS_APBH), 122 }, 123}; 124 125struct platform_device stmp3xxx_gpmi = { 126 .name = "gpmi", 127 .id = -1, 128 .dev = { 129 .dma_mask = &common_dmamask, 130 .coherent_dma_mask = DMA_BIT_MASK(32), 131 }, 132 .resource = gpmi_resources, 133 .num_resources = ARRAY_SIZE(gpmi_resources), 134}; 135 136static struct resource mmc1_resource[] = { 137 { 138 .flags = IORESOURCE_MEM, 139 .start = REGS_SSP1_PHYS, 140 .end = REGS_SSP1_PHYS + REGS_SSP_SIZE, 141 }, { 142 .flags = IORESOURCE_DMA, 143 .start = STMP3XXX_DMA(1, STMP3XXX_BUS_APBH), 144 .end = STMP3XXX_DMA(1, STMP3XXX_BUS_APBH), 145 }, { 146 .flags = IORESOURCE_IRQ, 147 .start = IRQ_SSP1_DMA, 148 .end = IRQ_SSP1_DMA, 149 }, { 150 .flags = IORESOURCE_IRQ, 151 .start = IRQ_SSP_ERROR, 152 .end = IRQ_SSP_ERROR, 153 }, 154}; 155 156struct platform_device stmp3xxx_mmc = { 157 .name = "stmp3xxx-mmc", 158 .id = 1, 159 .dev = { 160 .dma_mask = &common_dmamask, 161 .coherent_dma_mask = DMA_BIT_MASK(32), 162 }, 163 .resource = mmc1_resource, 164 .num_resources = ARRAY_SIZE(mmc1_resource), 165}; 166 167static struct resource usb_resources[] = { 168 { 169 .start = REGS_USBCTRL_PHYS, 170 .end = REGS_USBCTRL_PHYS + SZ_4K, 171 .flags = IORESOURCE_MEM, 172 }, { 173 .start = IRQ_USB_CTRL, 174 .end = IRQ_USB_CTRL, 175 .flags = IORESOURCE_IRQ, 176 }, 177}; 178 179struct platform_device stmp3xxx_udc = { 180 .name = "fsl-usb2-udc", 181 .id = -1, 182 .dev = { 183 .dma_mask = &common_dmamask, 184 .coherent_dma_mask = DMA_BIT_MASK(32), 185 }, 186 .resource = usb_resources, 187 .num_resources = ARRAY_SIZE(usb_resources), 188}; 189 190struct platform_device stmp3xxx_ehci = { 191 .name = "fsl-ehci", 192 .id = -1, 193 .dev = { 194 .dma_mask = &common_dmamask, 195 .coherent_dma_mask = DMA_BIT_MASK(32), 196 }, 197 .resource = usb_resources, 198 .num_resources = ARRAY_SIZE(usb_resources), 199}; 200 201static struct resource rtc_resources[] = { 202 { 203 .start = REGS_RTC_PHYS, 204 .end = REGS_RTC_PHYS + REGS_RTC_SIZE, 205 .flags = IORESOURCE_MEM, 206 }, { 207 .start = IRQ_RTC_ALARM, 208 .end = IRQ_RTC_ALARM, 209 .flags = IORESOURCE_IRQ, 210 }, { 211 .start = IRQ_RTC_1MSEC, 212 .end = IRQ_RTC_1MSEC, 213 .flags = IORESOURCE_IRQ, 214 }, 215}; 216 217struct platform_device stmp3xxx_rtc = { 218 .name = "stmp3xxx-rtc", 219 .id = -1, 220 .resource = rtc_resources, 221 .num_resources = ARRAY_SIZE(rtc_resources), 222}; 223 224static struct resource ssp1_resources[] = { 225 { 226 .start = REGS_SSP1_PHYS, 227 .end = REGS_SSP1_PHYS + REGS_SSP_SIZE, 228 .flags = IORESOURCE_MEM, 229 }, { 230 .start = IRQ_SSP1_DMA, 231 .end = IRQ_SSP1_DMA, 232 .flags = IORESOURCE_IRQ, 233 }, { 234 .start = STMP3XXX_DMA(1, STMP3XXX_BUS_APBH), 235 .end = STMP3XXX_DMA(1, STMP3XXX_BUS_APBH), 236 .flags = IORESOURCE_DMA, 237 }, 238}; 239 240static struct resource ssp2_resources[] = { 241 { 242 .start = REGS_SSP2_PHYS, 243 .end = REGS_SSP2_PHYS + REGS_SSP_SIZE, 244 .flags = IORESOURCE_MEM, 245 }, { 246 .start = IRQ_SSP2_DMA, 247 .end = IRQ_SSP2_DMA, 248 .flags = IORESOURCE_IRQ, 249 }, { 250 .start = STMP3XXX_DMA(2, STMP3XXX_BUS_APBH), 251 .end = STMP3XXX_DMA(2, STMP3XXX_BUS_APBH), 252 .flags = IORESOURCE_DMA, 253 }, 254}; 255 256struct platform_device stmp3xxx_spi1 = { 257 .name = "stmp3xxx_ssp", 258 .id = 1, 259 .dev = { 260 .dma_mask = &common_dmamask, 261 .coherent_dma_mask = DMA_BIT_MASK(32), 262 }, 263 .resource = ssp1_resources, 264 .num_resources = ARRAY_SIZE(ssp1_resources), 265}; 266 267struct platform_device stmp3xxx_spi2 = { 268 .name = "stmp3xxx_ssp", 269 .id = 2, 270 .dev = { 271 .dma_mask = &common_dmamask, 272 .coherent_dma_mask = DMA_BIT_MASK(32), 273 }, 274 .resource = ssp2_resources, 275 .num_resources = ARRAY_SIZE(ssp2_resources), 276}; 277 278static struct resource fb_resource[] = { 279 { 280 .flags = IORESOURCE_IRQ, 281 .start = IRQ_LCDIF_DMA, 282 .end = IRQ_LCDIF_DMA, 283 }, { 284 .flags = IORESOURCE_IRQ, 285 .start = IRQ_LCDIF_ERROR, 286 .end = IRQ_LCDIF_ERROR, 287 }, { 288 .flags = IORESOURCE_MEM, 289 .start = REGS_LCDIF_PHYS, 290 .end = REGS_LCDIF_PHYS + REGS_LCDIF_SIZE, 291 }, 292}; 293 294struct platform_device stmp3xxx_framebuffer = { 295 .name = "stmp3xxx-fb", 296 .id = -1, 297 .dev = { 298 .dma_mask = &common_dmamask, 299 .coherent_dma_mask = DMA_BIT_MASK(32), 300 }, 301 .num_resources = ARRAY_SIZE(fb_resource), 302 .resource = fb_resource, 303}; 304 305#define CMDLINE_DEVICE_CHOOSE(name, dev1, dev2) \ 306 static char *cmdline_device_##name; \ 307 static int cmdline_device_##name##_setup(char *dev) \ 308 { \ 309 cmdline_device_##name = dev + 1; \ 310 return 0; \ 311 } \ 312 __setup(#name, cmdline_device_##name##_setup); \ 313 int stmp3xxx_##name##_device_register(void) \ 314 { \ 315 struct platform_device *d = NULL; \ 316 if (!cmdline_device_##name || \ 317 !strcmp(cmdline_device_##name, #dev1)) \ 318 d = &stmp3xxx_##dev1; \ 319 else if (!strcmp(cmdline_device_##name, #dev2)) \ 320 d = &stmp3xxx_##dev2; \ 321 else \ 322 printk(KERN_ERR"Unknown %s assignment '%s'.\n", \ 323 #name, cmdline_device_##name); \ 324 return d ? platform_device_register(d) : -ENOENT; \ 325 } 326 327CMDLINE_DEVICE_CHOOSE(ssp1, mmc, spi1) 328CMDLINE_DEVICE_CHOOSE(ssp2, gpmi, spi2) 329 330struct platform_device stmp3xxx_backlight = { 331 .name = "stmp3xxx-bl", 332 .id = -1, 333}; 334 335struct platform_device stmp3xxx_rotdec = { 336 .name = "stmp3xxx-rotdec", 337 .id = -1, 338}; 339 340struct platform_device stmp3xxx_persistent = { 341 .name = "stmp3xxx-persistent", 342 .id = -1, 343}; 344 345struct platform_device stmp3xxx_dcp_bootstream = { 346 .name = "stmp3xxx-dcpboot", 347 .id = -1, 348 .dev = { 349 .dma_mask = &common_dmamask, 350 .coherent_dma_mask = DMA_BIT_MASK(32), 351 }, 352}; 353 354static struct resource dcp_resources[] = { 355 { 356 .start = IRQ_DCP_VMI, 357 .end = IRQ_DCP_VMI, 358 .flags = IORESOURCE_IRQ, 359 }, { 360 .start = IRQ_DCP, 361 .end = IRQ_DCP, 362 .flags = IORESOURCE_IRQ, 363 }, 364}; 365 366struct platform_device stmp3xxx_dcp = { 367 .name = "stmp3xxx-dcp", 368 .id = -1, 369 .resource = dcp_resources, 370 .num_resources = ARRAY_SIZE(dcp_resources), 371 .dev = { 372 .dma_mask = &common_dmamask, 373 .coherent_dma_mask = DMA_BIT_MASK(32), 374 }, 375}; 376 377static struct resource battery_resource[] = { 378 { 379 .flags = IORESOURCE_IRQ, 380 .start = IRQ_VDD5V, 381 .end = IRQ_VDD5V, 382 }, 383}; 384 385struct platform_device stmp3xxx_battery = { 386 .name = "stmp3xxx-battery", 387 .resource = battery_resource, 388 .num_resources = ARRAY_SIZE(battery_resource), 389}; 390