GNU Linux-libre 4.19.314-gnu1
[releases.git] / arch / arm / mach-w90x900 / dev.c
1 /*
2  * linux/arch/arm/mach-w90x900/dev.c
3  *
4  * Copyright (C) 2009 Nuvoton corporation.
5  *
6  * Wan ZongShun <mcuos.com@gmail.com>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation;version 2 of the License.
11  *
12  */
13
14 #include <linux/kernel.h>
15 #include <linux/types.h>
16 #include <linux/interrupt.h>
17 #include <linux/list.h>
18 #include <linux/timer.h>
19 #include <linux/init.h>
20 #include <linux/platform_device.h>
21 #include <linux/slab.h>
22 #include <linux/cpu.h>
23
24 #include <linux/mtd/physmap.h>
25 #include <linux/mtd/mtd.h>
26 #include <linux/mtd/partitions.h>
27
28 #include <linux/spi/spi.h>
29 #include <linux/spi/flash.h>
30
31 #include <asm/system_misc.h>
32 #include <asm/mach/arch.h>
33 #include <asm/mach/map.h>
34 #include <asm/mach/irq.h>
35 #include <asm/mach-types.h>
36
37 #include <mach/regs-serial.h>
38 #include <linux/platform_data/spi-nuc900.h>
39 #include <mach/map.h>
40 #include <linux/platform_data/video-nuc900fb.h>
41 #include <mach/regs-ldm.h>
42 #include <linux/platform_data/keypad-w90p910.h>
43
44 #include "cpu.h"
45
46 /*NUC900 evb norflash driver data */
47
48 #define NUC900_FLASH_BASE       0xA0000000
49 #define NUC900_FLASH_SIZE       0x400000
50 #define SPIOFFSET               0x200
51 #define SPIOREG_SIZE            0x100
52
53 static struct mtd_partition nuc900_flash_partitions[] = {
54         {
55                 .name   =       "NOR Partition 1 for kernel (960K)",
56                 .size   =       0xF0000,
57                 .offset =       0x10000,
58         },
59         {
60                 .name   =       "NOR Partition 2 for image (1M)",
61                 .size   =       0x100000,
62                 .offset =       0x100000,
63         },
64         {
65                 .name   =       "NOR Partition 3 for user (2M)",
66                 .size   =       0x200000,
67                 .offset =       0x00200000,
68         }
69 };
70
71 static struct physmap_flash_data nuc900_flash_data = {
72         .width          =       2,
73         .parts          =       nuc900_flash_partitions,
74         .nr_parts       =       ARRAY_SIZE(nuc900_flash_partitions),
75 };
76
77 static struct resource nuc900_flash_resources[] = {
78         {
79                 .start  =       NUC900_FLASH_BASE,
80                 .end    =       NUC900_FLASH_BASE + NUC900_FLASH_SIZE - 1,
81                 .flags  =       IORESOURCE_MEM,
82         }
83 };
84
85 static struct platform_device nuc900_flash_device = {
86         .name           =       "physmap-flash",
87         .id             =       0,
88         .dev            = {
89                                 .platform_data = &nuc900_flash_data,
90                         },
91         .resource       =       nuc900_flash_resources,
92         .num_resources  =       ARRAY_SIZE(nuc900_flash_resources),
93 };
94
95 /* USB EHCI Host Controller */
96
97 static struct resource nuc900_usb_ehci_resource[] = {
98         [0] = {
99                 .start = W90X900_PA_USBEHCIHOST,
100                 .end   = W90X900_PA_USBEHCIHOST + W90X900_SZ_USBEHCIHOST - 1,
101                 .flags = IORESOURCE_MEM,
102         },
103         [1] = {
104                 .start = IRQ_USBH,
105                 .end   = IRQ_USBH,
106                 .flags = IORESOURCE_IRQ,
107         }
108 };
109
110 static u64 nuc900_device_usb_ehci_dmamask = 0xffffffffUL;
111
112 static struct platform_device nuc900_device_usb_ehci = {
113         .name             = "nuc900-ehci",
114         .id               = -1,
115         .num_resources    = ARRAY_SIZE(nuc900_usb_ehci_resource),
116         .resource         = nuc900_usb_ehci_resource,
117         .dev              = {
118                 .dma_mask = &nuc900_device_usb_ehci_dmamask,
119                 .coherent_dma_mask = 0xffffffffUL
120         }
121 };
122
123 /* USB OHCI Host Controller */
124
125 static struct resource nuc900_usb_ohci_resource[] = {
126         [0] = {
127                 .start = W90X900_PA_USBOHCIHOST,
128                 .end   = W90X900_PA_USBOHCIHOST + W90X900_SZ_USBOHCIHOST - 1,
129                 .flags = IORESOURCE_MEM,
130         },
131         [1] = {
132                 .start = IRQ_USBH,
133                 .end   = IRQ_USBH,
134                 .flags = IORESOURCE_IRQ,
135         }
136 };
137
138 static u64 nuc900_device_usb_ohci_dmamask = 0xffffffffUL;
139 static struct platform_device nuc900_device_usb_ohci = {
140         .name             = "nuc900-ohci",
141         .id               = -1,
142         .num_resources    = ARRAY_SIZE(nuc900_usb_ohci_resource),
143         .resource         = nuc900_usb_ohci_resource,
144         .dev              = {
145                 .dma_mask = &nuc900_device_usb_ohci_dmamask,
146                 .coherent_dma_mask = 0xffffffffUL
147         }
148 };
149
150 /* USB Device (Gadget)*/
151
152 static struct resource nuc900_usbgadget_resource[] = {
153         [0] = {
154                 .start = W90X900_PA_USBDEV,
155                 .end   = W90X900_PA_USBDEV + W90X900_SZ_USBDEV - 1,
156                 .flags = IORESOURCE_MEM,
157         },
158         [1] = {
159                 .start = IRQ_USBD,
160                 .end   = IRQ_USBD,
161                 .flags = IORESOURCE_IRQ,
162         }
163 };
164
165 static struct platform_device nuc900_device_usbgadget = {
166         .name           = "nuc900-usbgadget",
167         .id             = -1,
168         .num_resources  = ARRAY_SIZE(nuc900_usbgadget_resource),
169         .resource       = nuc900_usbgadget_resource,
170 };
171
172 /* MAC device */
173
174 static struct resource nuc900_emc_resource[] = {
175         [0] = {
176                 .start = W90X900_PA_EMC,
177                 .end   = W90X900_PA_EMC + W90X900_SZ_EMC - 1,
178                 .flags = IORESOURCE_MEM,
179         },
180         [1] = {
181                 .start = IRQ_EMCTX,
182                 .end   = IRQ_EMCTX,
183                 .flags = IORESOURCE_IRQ,
184         },
185         [2] = {
186                 .start = IRQ_EMCRX,
187                 .end   = IRQ_EMCRX,
188                 .flags = IORESOURCE_IRQ,
189         }
190 };
191
192 static u64 nuc900_device_emc_dmamask = 0xffffffffUL;
193 static struct platform_device nuc900_device_emc = {
194         .name           = "nuc900-emc",
195         .id             = -1,
196         .num_resources  = ARRAY_SIZE(nuc900_emc_resource),
197         .resource       = nuc900_emc_resource,
198         .dev              = {
199                 .dma_mask = &nuc900_device_emc_dmamask,
200                 .coherent_dma_mask = 0xffffffffUL
201         }
202 };
203
204 /* SPI device */
205
206 static struct nuc900_spi_info nuc900_spiflash_data = {
207         .num_cs         = 1,
208         .lsb            = 0,
209         .txneg          = 1,
210         .rxneg          = 0,
211         .divider        = 24,
212         .sleep          = 0,
213         .txnum          = 0,
214         .txbitlen       = 8,
215         .bus_num        = 0,
216 };
217
218 static struct resource nuc900_spi_resource[] = {
219         [0] = {
220                 .start = W90X900_PA_I2C + SPIOFFSET,
221                 .end   = W90X900_PA_I2C + SPIOFFSET + SPIOREG_SIZE - 1,
222                 .flags = IORESOURCE_MEM,
223         },
224         [1] = {
225                 .start = IRQ_SSP,
226                 .end   = IRQ_SSP,
227                 .flags = IORESOURCE_IRQ,
228         }
229 };
230
231 static struct platform_device nuc900_device_spi = {
232         .name           = "nuc900-spi",
233         .id             = -1,
234         .num_resources  = ARRAY_SIZE(nuc900_spi_resource),
235         .resource       = nuc900_spi_resource,
236         .dev            = {
237                                 .platform_data = &nuc900_spiflash_data,
238                         }
239 };
240
241 /* spi device, spi flash info */
242
243 static struct mtd_partition nuc900_spi_flash_partitions[] = {
244         {
245                 .name = "bootloader(spi)",
246                 .size = 0x0100000,
247                 .offset = 0,
248         },
249 };
250
251 static struct flash_platform_data nuc900_spi_flash_data = {
252         .name = "m25p80",
253         .parts =  nuc900_spi_flash_partitions,
254         .nr_parts = ARRAY_SIZE(nuc900_spi_flash_partitions),
255         .type = "w25x16",
256 };
257
258 static struct spi_board_info nuc900_spi_board_info[] __initdata = {
259         {
260                 .modalias = "m25p80",
261                 .max_speed_hz = 20000000,
262                 .bus_num = 0,
263                 .chip_select = 0,
264                 .platform_data = &nuc900_spi_flash_data,
265                 .mode = SPI_MODE_0,
266         },
267 };
268
269 /* WDT Device */
270
271 static struct resource nuc900_wdt_resource[] = {
272         [0] = {
273                 .start = W90X900_PA_TIMER,
274                 .end   = W90X900_PA_TIMER + W90X900_SZ_TIMER - 1,
275                 .flags = IORESOURCE_MEM,
276         },
277         [1] = {
278                 .start = IRQ_WDT,
279                 .end   = IRQ_WDT,
280                 .flags = IORESOURCE_IRQ,
281         }
282 };
283
284 static struct platform_device nuc900_device_wdt = {
285         .name           = "nuc900-wdt",
286         .id             = -1,
287         .num_resources  = ARRAY_SIZE(nuc900_wdt_resource),
288         .resource       = nuc900_wdt_resource,
289 };
290
291 /*
292  * public device definition between 910 and 920, or 910
293  * and 950 or 950 and 960...,their dev platform register
294  * should be in specific file such as nuc950, nuc960 c
295  * files rather than the public dev.c file here. so the
296  * corresponding platform_device definition should not be
297  * static.
298 */
299
300 /* RTC controller*/
301
302 static struct resource nuc900_rtc_resource[] = {
303         [0] = {
304                 .start = W90X900_PA_RTC,
305                 .end   = W90X900_PA_RTC + 0xff,
306                 .flags = IORESOURCE_MEM,
307         },
308         [1] = {
309                 .start = IRQ_RTC,
310                 .end   = IRQ_RTC,
311                 .flags = IORESOURCE_IRQ,
312         },
313 };
314
315 struct platform_device nuc900_device_rtc = {
316         .name           = "nuc900-rtc",
317         .id             = -1,
318         .num_resources  = ARRAY_SIZE(nuc900_rtc_resource),
319         .resource       = nuc900_rtc_resource,
320 };
321
322 /*TouchScreen controller*/
323
324 static struct resource nuc900_ts_resource[] = {
325         [0] = {
326                 .start = W90X900_PA_ADC,
327                 .end   = W90X900_PA_ADC + W90X900_SZ_ADC-1,
328                 .flags = IORESOURCE_MEM,
329         },
330         [1] = {
331                 .start = IRQ_ADC,
332                 .end   = IRQ_ADC,
333                 .flags = IORESOURCE_IRQ,
334         },
335 };
336
337 struct platform_device nuc900_device_ts = {
338         .name           = "nuc900-ts",
339         .id             = -1,
340         .resource       = nuc900_ts_resource,
341         .num_resources  = ARRAY_SIZE(nuc900_ts_resource),
342 };
343
344 /* FMI Device */
345
346 static struct resource nuc900_fmi_resource[] = {
347         [0] = {
348                 .start = W90X900_PA_FMI,
349                 .end   = W90X900_PA_FMI + W90X900_SZ_FMI - 1,
350                 .flags = IORESOURCE_MEM,
351         },
352         [1] = {
353                 .start = IRQ_FMI,
354                 .end   = IRQ_FMI,
355                 .flags = IORESOURCE_IRQ,
356         }
357 };
358
359 struct platform_device nuc900_device_fmi = {
360         .name           = "nuc900-fmi",
361         .id             = -1,
362         .num_resources  = ARRAY_SIZE(nuc900_fmi_resource),
363         .resource       = nuc900_fmi_resource,
364 };
365
366 /* KPI controller*/
367
368 static int nuc900_keymap[] = {
369         KEY(0, 0, KEY_A),
370         KEY(0, 1, KEY_B),
371         KEY(0, 2, KEY_C),
372         KEY(0, 3, KEY_D),
373
374         KEY(1, 0, KEY_E),
375         KEY(1, 1, KEY_F),
376         KEY(1, 2, KEY_G),
377         KEY(1, 3, KEY_H),
378
379         KEY(2, 0, KEY_I),
380         KEY(2, 1, KEY_J),
381         KEY(2, 2, KEY_K),
382         KEY(2, 3, KEY_L),
383
384         KEY(3, 0, KEY_M),
385         KEY(3, 1, KEY_N),
386         KEY(3, 2, KEY_O),
387         KEY(3, 3, KEY_P),
388 };
389
390 static struct matrix_keymap_data nuc900_map_data = {
391         .keymap                 = nuc900_keymap,
392         .keymap_size            = ARRAY_SIZE(nuc900_keymap),
393 };
394
395 struct w90p910_keypad_platform_data nuc900_keypad_info = {
396         .keymap_data    = &nuc900_map_data,
397         .prescale       = 0xfa,
398         .debounce       = 0x50,
399 };
400
401 static struct resource nuc900_kpi_resource[] = {
402         [0] = {
403                 .start = W90X900_PA_KPI,
404                 .end   = W90X900_PA_KPI + W90X900_SZ_KPI - 1,
405                 .flags = IORESOURCE_MEM,
406         },
407         [1] = {
408                 .start = IRQ_KPI,
409                 .end   = IRQ_KPI,
410                 .flags = IORESOURCE_IRQ,
411         }
412
413 };
414
415 struct platform_device nuc900_device_kpi = {
416         .name           = "nuc900-kpi",
417         .id             = -1,
418         .num_resources  = ARRAY_SIZE(nuc900_kpi_resource),
419         .resource       = nuc900_kpi_resource,
420         .dev            = {
421                                 .platform_data = &nuc900_keypad_info,
422                         }
423 };
424
425 /* LCD controller*/
426
427 static struct nuc900fb_display nuc900_lcd_info[] = {
428         /* Giantplus Technology GPM1040A0 320x240 Color TFT LCD */
429         [0] = {
430                 .type           = LCM_DCCS_VA_SRC_RGB565,
431                 .width          = 320,
432                 .height         = 240,
433                 .xres           = 320,
434                 .yres           = 240,
435                 .bpp            = 16,
436                 .pixclock       = 200000,
437                 .left_margin    = 34,
438                 .right_margin   = 54,
439                 .hsync_len      = 10,
440                 .upper_margin   = 18,
441                 .lower_margin   = 4,
442                 .vsync_len      = 1,
443                 .dccs           = 0x8e00041a,
444                 .devctl         = 0x060800c0,
445                 .fbctrl         = 0x00a000a0,
446                 .scale          = 0x04000400,
447         },
448 };
449
450 static struct nuc900fb_mach_info nuc900_fb_info = {
451 #if defined(CONFIG_GPM1040A0_320X240)
452         .displays               = &nuc900_lcd_info[0],
453 #else
454         .displays               = nuc900_lcd_info,
455 #endif
456         .num_displays           = ARRAY_SIZE(nuc900_lcd_info),
457         .default_display        = 0,
458         .gpio_dir               = 0x00000004,
459         .gpio_dir_mask          = 0xFFFFFFFD,
460         .gpio_data              = 0x00000004,
461         .gpio_data_mask         = 0xFFFFFFFD,
462 };
463
464 static struct resource nuc900_lcd_resource[] = {
465         [0] = {
466                 .start = W90X900_PA_LCD,
467                 .end   = W90X900_PA_LCD + W90X900_SZ_LCD - 1,
468                 .flags = IORESOURCE_MEM,
469         },
470         [1] = {
471                 .start = IRQ_LCD,
472                 .end   = IRQ_LCD,
473                 .flags = IORESOURCE_IRQ,
474         }
475 };
476
477 static u64 nuc900_device_lcd_dmamask = -1;
478 struct platform_device nuc900_device_lcd = {
479         .name             = "nuc900-lcd",
480         .id               = -1,
481         .num_resources    = ARRAY_SIZE(nuc900_lcd_resource),
482         .resource         = nuc900_lcd_resource,
483         .dev              = {
484                 .dma_mask               = &nuc900_device_lcd_dmamask,
485                 .coherent_dma_mask      = -1,
486                 .platform_data = &nuc900_fb_info,
487         }
488 };
489
490 /* AUDIO controller*/
491 static u64 nuc900_device_audio_dmamask = -1;
492 static struct resource nuc900_ac97_resource[] = {
493         [0] = {
494                 .start = W90X900_PA_ACTL,
495                 .end   = W90X900_PA_ACTL + W90X900_SZ_ACTL - 1,
496                 .flags = IORESOURCE_MEM,
497         },
498         [1] = {
499                 .start = IRQ_ACTL,
500                 .end   = IRQ_ACTL,
501                 .flags = IORESOURCE_IRQ,
502         }
503
504 };
505
506 struct platform_device nuc900_device_ac97 = {
507         .name           = "nuc900-ac97",
508         .id             = -1,
509         .num_resources  = ARRAY_SIZE(nuc900_ac97_resource),
510         .resource       = nuc900_ac97_resource,
511         .dev              = {
512                 .dma_mask               = &nuc900_device_audio_dmamask,
513                 .coherent_dma_mask      = -1,
514         }
515 };
516
517 /*Here should be your evb resourse,such as LCD*/
518
519 static struct platform_device *nuc900_public_dev[] __initdata = {
520         &nuc900_serial_device,
521         &nuc900_flash_device,
522         &nuc900_device_usb_ehci,
523         &nuc900_device_usb_ohci,
524         &nuc900_device_usbgadget,
525         &nuc900_device_emc,
526         &nuc900_device_spi,
527         &nuc900_device_wdt,
528         &nuc900_device_ac97,
529 };
530
531 /* Provide adding specific CPU platform devices API */
532
533 void __init nuc900_board_init(struct platform_device **device, int size)
534 {
535         cpu_idle_poll_ctrl(true);
536         platform_add_devices(device, size);
537         platform_add_devices(nuc900_public_dev, ARRAY_SIZE(nuc900_public_dev));
538         spi_register_board_info(nuc900_spi_board_info,
539                                         ARRAY_SIZE(nuc900_spi_board_info));
540 }
541