Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1/*
2 * Platform device support for Au1x00 SoCs.
3 *
4 * Copyright 2004, Matt Porter <mporter@kernel.crashing.org>
5 *
6 * (C) Copyright Embedded Alley Solutions, Inc 2005
7 * Author: Pantelis Antoniou <pantelis@embeddedalley.com>
8 *
9 * This file is licensed under the terms of the GNU General Public
10 * License version 2. This program is licensed "as is" without any
11 * warranty of any kind, whether express or implied.
12 */
13
14#include <linux/dma-mapping.h>
15#include <linux/etherdevice.h>
16#include <linux/platform_device.h>
17#include <linux/serial_8250.h>
18#include <linux/init.h>
19
20#include <asm/mach-au1x00/au1xxx.h>
21#include <asm/mach-au1x00/au1xxx_dbdma.h>
22#include <asm/mach-au1x00/au1100_mmc.h>
23#include <asm/mach-au1x00/au1xxx_eth.h>
24
25#include <prom.h>
26
27static void alchemy_8250_pm(struct uart_port *port, unsigned int state,
28 unsigned int old_state)
29{
30#ifdef CONFIG_SERIAL_8250
31 switch (state) {
32 case 0:
33 if ((__raw_readl(port->membase + UART_MOD_CNTRL) & 3) != 3) {
34 /* power-on sequence as suggested in the databooks */
35 __raw_writel(0, port->membase + UART_MOD_CNTRL);
36 wmb();
37 __raw_writel(1, port->membase + UART_MOD_CNTRL);
38 wmb();
39 }
40 __raw_writel(3, port->membase + UART_MOD_CNTRL); /* full on */
41 wmb();
42 serial8250_do_pm(port, state, old_state);
43 break;
44 case 3: /* power off */
45 serial8250_do_pm(port, state, old_state);
46 __raw_writel(0, port->membase + UART_MOD_CNTRL);
47 wmb();
48 break;
49 default:
50 serial8250_do_pm(port, state, old_state);
51 break;
52 }
53#endif
54}
55
56#define PORT(_base, _irq) \
57 { \
58 .mapbase = _base, \
59 .irq = _irq, \
60 .regshift = 2, \
61 .iotype = UPIO_AU, \
62 .flags = UPF_SKIP_TEST | UPF_IOREMAP | \
63 UPF_FIXED_TYPE, \
64 .type = PORT_16550A, \
65 .pm = alchemy_8250_pm, \
66 }
67
68static struct plat_serial8250_port au1x00_uart_data[] = {
69#if defined(CONFIG_SOC_AU1000)
70 PORT(UART0_PHYS_ADDR, AU1000_UART0_INT),
71 PORT(UART1_PHYS_ADDR, AU1000_UART1_INT),
72 PORT(UART2_PHYS_ADDR, AU1000_UART2_INT),
73 PORT(UART3_PHYS_ADDR, AU1000_UART3_INT),
74#elif defined(CONFIG_SOC_AU1500)
75 PORT(UART0_PHYS_ADDR, AU1500_UART0_INT),
76 PORT(UART3_PHYS_ADDR, AU1500_UART3_INT),
77#elif defined(CONFIG_SOC_AU1100)
78 PORT(UART0_PHYS_ADDR, AU1100_UART0_INT),
79 PORT(UART1_PHYS_ADDR, AU1100_UART1_INT),
80 PORT(UART3_PHYS_ADDR, AU1100_UART3_INT),
81#elif defined(CONFIG_SOC_AU1550)
82 PORT(UART0_PHYS_ADDR, AU1550_UART0_INT),
83 PORT(UART1_PHYS_ADDR, AU1550_UART1_INT),
84 PORT(UART3_PHYS_ADDR, AU1550_UART3_INT),
85#elif defined(CONFIG_SOC_AU1200)
86 PORT(UART0_PHYS_ADDR, AU1200_UART0_INT),
87 PORT(UART1_PHYS_ADDR, AU1200_UART1_INT),
88#endif
89 { },
90};
91
92static struct platform_device au1xx0_uart_device = {
93 .name = "serial8250",
94 .id = PLAT8250_DEV_AU1X00,
95 .dev = {
96 .platform_data = au1x00_uart_data,
97 },
98};
99
100/* OHCI (USB full speed host controller) */
101static struct resource au1xxx_usb_ohci_resources[] = {
102 [0] = {
103 .start = USB_OHCI_BASE,
104 .end = USB_OHCI_BASE + USB_OHCI_LEN - 1,
105 .flags = IORESOURCE_MEM,
106 },
107 [1] = {
108 .start = FOR_PLATFORM_C_USB_HOST_INT,
109 .end = FOR_PLATFORM_C_USB_HOST_INT,
110 .flags = IORESOURCE_IRQ,
111 },
112};
113
114/* The dmamask must be set for OHCI to work */
115static u64 ohci_dmamask = DMA_BIT_MASK(32);
116
117static struct platform_device au1xxx_usb_ohci_device = {
118 .name = "au1xxx-ohci",
119 .id = 0,
120 .dev = {
121 .dma_mask = &ohci_dmamask,
122 .coherent_dma_mask = DMA_BIT_MASK(32),
123 },
124 .num_resources = ARRAY_SIZE(au1xxx_usb_ohci_resources),
125 .resource = au1xxx_usb_ohci_resources,
126};
127
128/*** AU1100 LCD controller ***/
129
130#ifdef CONFIG_FB_AU1100
131static struct resource au1100_lcd_resources[] = {
132 [0] = {
133 .start = LCD_PHYS_ADDR,
134 .end = LCD_PHYS_ADDR + 0x800 - 1,
135 .flags = IORESOURCE_MEM,
136 },
137 [1] = {
138 .start = AU1100_LCD_INT,
139 .end = AU1100_LCD_INT,
140 .flags = IORESOURCE_IRQ,
141 }
142};
143
144static u64 au1100_lcd_dmamask = DMA_BIT_MASK(32);
145
146static struct platform_device au1100_lcd_device = {
147 .name = "au1100-lcd",
148 .id = 0,
149 .dev = {
150 .dma_mask = &au1100_lcd_dmamask,
151 .coherent_dma_mask = DMA_BIT_MASK(32),
152 },
153 .num_resources = ARRAY_SIZE(au1100_lcd_resources),
154 .resource = au1100_lcd_resources,
155};
156#endif
157
158#ifdef CONFIG_SOC_AU1200
159/* EHCI (USB high speed host controller) */
160static struct resource au1xxx_usb_ehci_resources[] = {
161 [0] = {
162 .start = USB_EHCI_BASE,
163 .end = USB_EHCI_BASE + USB_EHCI_LEN - 1,
164 .flags = IORESOURCE_MEM,
165 },
166 [1] = {
167 .start = AU1200_USB_INT,
168 .end = AU1200_USB_INT,
169 .flags = IORESOURCE_IRQ,
170 },
171};
172
173static u64 ehci_dmamask = DMA_BIT_MASK(32);
174
175static struct platform_device au1xxx_usb_ehci_device = {
176 .name = "au1xxx-ehci",
177 .id = 0,
178 .dev = {
179 .dma_mask = &ehci_dmamask,
180 .coherent_dma_mask = DMA_BIT_MASK(32),
181 },
182 .num_resources = ARRAY_SIZE(au1xxx_usb_ehci_resources),
183 .resource = au1xxx_usb_ehci_resources,
184};
185
186/* Au1200 UDC (USB gadget controller) */
187static struct resource au1xxx_usb_gdt_resources[] = {
188 [0] = {
189 .start = USB_UDC_BASE,
190 .end = USB_UDC_BASE + USB_UDC_LEN - 1,
191 .flags = IORESOURCE_MEM,
192 },
193 [1] = {
194 .start = AU1200_USB_INT,
195 .end = AU1200_USB_INT,
196 .flags = IORESOURCE_IRQ,
197 },
198};
199
200static u64 udc_dmamask = DMA_BIT_MASK(32);
201
202static struct platform_device au1xxx_usb_gdt_device = {
203 .name = "au1xxx-udc",
204 .id = 0,
205 .dev = {
206 .dma_mask = &udc_dmamask,
207 .coherent_dma_mask = DMA_BIT_MASK(32),
208 },
209 .num_resources = ARRAY_SIZE(au1xxx_usb_gdt_resources),
210 .resource = au1xxx_usb_gdt_resources,
211};
212
213/* Au1200 UOC (USB OTG controller) */
214static struct resource au1xxx_usb_otg_resources[] = {
215 [0] = {
216 .start = USB_UOC_BASE,
217 .end = USB_UOC_BASE + USB_UOC_LEN - 1,
218 .flags = IORESOURCE_MEM,
219 },
220 [1] = {
221 .start = AU1200_USB_INT,
222 .end = AU1200_USB_INT,
223 .flags = IORESOURCE_IRQ,
224 },
225};
226
227static u64 uoc_dmamask = DMA_BIT_MASK(32);
228
229static struct platform_device au1xxx_usb_otg_device = {
230 .name = "au1xxx-uoc",
231 .id = 0,
232 .dev = {
233 .dma_mask = &uoc_dmamask,
234 .coherent_dma_mask = DMA_BIT_MASK(32),
235 },
236 .num_resources = ARRAY_SIZE(au1xxx_usb_otg_resources),
237 .resource = au1xxx_usb_otg_resources,
238};
239
240static struct resource au1200_lcd_resources[] = {
241 [0] = {
242 .start = LCD_PHYS_ADDR,
243 .end = LCD_PHYS_ADDR + 0x800 - 1,
244 .flags = IORESOURCE_MEM,
245 },
246 [1] = {
247 .start = AU1200_LCD_INT,
248 .end = AU1200_LCD_INT,
249 .flags = IORESOURCE_IRQ,
250 }
251};
252
253static u64 au1200_lcd_dmamask = DMA_BIT_MASK(32);
254
255static struct platform_device au1200_lcd_device = {
256 .name = "au1200-lcd",
257 .id = 0,
258 .dev = {
259 .dma_mask = &au1200_lcd_dmamask,
260 .coherent_dma_mask = DMA_BIT_MASK(32),
261 },
262 .num_resources = ARRAY_SIZE(au1200_lcd_resources),
263 .resource = au1200_lcd_resources,
264};
265
266static u64 au1xxx_mmc_dmamask = DMA_BIT_MASK(32);
267
268extern struct au1xmmc_platform_data au1xmmc_platdata[2];
269
270static struct resource au1200_mmc0_resources[] = {
271 [0] = {
272 .start = SD0_PHYS_ADDR,
273 .end = SD0_PHYS_ADDR + 0x7ffff,
274 .flags = IORESOURCE_MEM,
275 },
276 [1] = {
277 .start = AU1200_SD_INT,
278 .end = AU1200_SD_INT,
279 .flags = IORESOURCE_IRQ,
280 },
281 [2] = {
282 .start = DSCR_CMD0_SDMS_TX0,
283 .end = DSCR_CMD0_SDMS_TX0,
284 .flags = IORESOURCE_DMA,
285 },
286 [3] = {
287 .start = DSCR_CMD0_SDMS_RX0,
288 .end = DSCR_CMD0_SDMS_RX0,
289 .flags = IORESOURCE_DMA,
290 }
291};
292
293static struct platform_device au1200_mmc0_device = {
294 .name = "au1xxx-mmc",
295 .id = 0,
296 .dev = {
297 .dma_mask = &au1xxx_mmc_dmamask,
298 .coherent_dma_mask = DMA_BIT_MASK(32),
299 .platform_data = &au1xmmc_platdata[0],
300 },
301 .num_resources = ARRAY_SIZE(au1200_mmc0_resources),
302 .resource = au1200_mmc0_resources,
303};
304
305#ifndef CONFIG_MIPS_DB1200
306static struct resource au1200_mmc1_resources[] = {
307 [0] = {
308 .start = SD1_PHYS_ADDR,
309 .end = SD1_PHYS_ADDR + 0x7ffff,
310 .flags = IORESOURCE_MEM,
311 },
312 [1] = {
313 .start = AU1200_SD_INT,
314 .end = AU1200_SD_INT,
315 .flags = IORESOURCE_IRQ,
316 },
317 [2] = {
318 .start = DSCR_CMD0_SDMS_TX1,
319 .end = DSCR_CMD0_SDMS_TX1,
320 .flags = IORESOURCE_DMA,
321 },
322 [3] = {
323 .start = DSCR_CMD0_SDMS_RX1,
324 .end = DSCR_CMD0_SDMS_RX1,
325 .flags = IORESOURCE_DMA,
326 }
327};
328
329static struct platform_device au1200_mmc1_device = {
330 .name = "au1xxx-mmc",
331 .id = 1,
332 .dev = {
333 .dma_mask = &au1xxx_mmc_dmamask,
334 .coherent_dma_mask = DMA_BIT_MASK(32),
335 .platform_data = &au1xmmc_platdata[1],
336 },
337 .num_resources = ARRAY_SIZE(au1200_mmc1_resources),
338 .resource = au1200_mmc1_resources,
339};
340#endif /* #ifndef CONFIG_MIPS_DB1200 */
341#endif /* #ifdef CONFIG_SOC_AU1200 */
342
343/* All Alchemy demoboards with I2C have this #define in their headers */
344#ifdef SMBUS_PSC_BASE
345static struct resource pbdb_smbus_resources[] = {
346 {
347 .start = CPHYSADDR(SMBUS_PSC_BASE),
348 .end = CPHYSADDR(SMBUS_PSC_BASE + 0xfffff),
349 .flags = IORESOURCE_MEM,
350 },
351};
352
353static struct platform_device pbdb_smbus_device = {
354 .name = "au1xpsc_smbus",
355 .id = 0, /* bus number */
356 .num_resources = ARRAY_SIZE(pbdb_smbus_resources),
357 .resource = pbdb_smbus_resources,
358};
359#endif
360
361/* Macro to help defining the Ethernet MAC resources */
362#define MAC_RES(_base, _enable, _irq) \
363 { \
364 .start = CPHYSADDR(_base), \
365 .end = CPHYSADDR(_base + 0xffff), \
366 .flags = IORESOURCE_MEM, \
367 }, \
368 { \
369 .start = CPHYSADDR(_enable), \
370 .end = CPHYSADDR(_enable + 0x3), \
371 .flags = IORESOURCE_MEM, \
372 }, \
373 { \
374 .start = _irq, \
375 .end = _irq, \
376 .flags = IORESOURCE_IRQ \
377 }
378
379static struct resource au1xxx_eth0_resources[] = {
380#if defined(CONFIG_SOC_AU1000)
381 MAC_RES(AU1000_ETH0_BASE, AU1000_MAC0_ENABLE, AU1000_MAC0_DMA_INT),
382#elif defined(CONFIG_SOC_AU1100)
383 MAC_RES(AU1100_ETH0_BASE, AU1100_MAC0_ENABLE, AU1100_MAC0_DMA_INT),
384#elif defined(CONFIG_SOC_AU1550)
385 MAC_RES(AU1550_ETH0_BASE, AU1550_MAC0_ENABLE, AU1550_MAC0_DMA_INT),
386#elif defined(CONFIG_SOC_AU1500)
387 MAC_RES(AU1500_ETH0_BASE, AU1500_MAC0_ENABLE, AU1500_MAC0_DMA_INT),
388#endif
389};
390
391
392static struct au1000_eth_platform_data au1xxx_eth0_platform_data = {
393 .phy1_search_mac0 = 1,
394};
395
396static struct platform_device au1xxx_eth0_device = {
397 .name = "au1000-eth",
398 .id = 0,
399 .num_resources = ARRAY_SIZE(au1xxx_eth0_resources),
400 .resource = au1xxx_eth0_resources,
401 .dev.platform_data = &au1xxx_eth0_platform_data,
402};
403
404#ifndef CONFIG_SOC_AU1100
405static struct resource au1xxx_eth1_resources[] = {
406#if defined(CONFIG_SOC_AU1000)
407 MAC_RES(AU1000_ETH1_BASE, AU1000_MAC1_ENABLE, AU1000_MAC1_DMA_INT),
408#elif defined(CONFIG_SOC_AU1550)
409 MAC_RES(AU1550_ETH1_BASE, AU1550_MAC1_ENABLE, AU1550_MAC1_DMA_INT),
410#elif defined(CONFIG_SOC_AU1500)
411 MAC_RES(AU1500_ETH1_BASE, AU1500_MAC1_ENABLE, AU1500_MAC1_DMA_INT),
412#endif
413};
414
415static struct au1000_eth_platform_data au1xxx_eth1_platform_data = {
416 .phy1_search_mac0 = 1,
417};
418
419static struct platform_device au1xxx_eth1_device = {
420 .name = "au1000-eth",
421 .id = 1,
422 .num_resources = ARRAY_SIZE(au1xxx_eth1_resources),
423 .resource = au1xxx_eth1_resources,
424 .dev.platform_data = &au1xxx_eth1_platform_data,
425};
426#endif
427
428void __init au1xxx_override_eth_cfg(unsigned int port,
429 struct au1000_eth_platform_data *eth_data)
430{
431 if (!eth_data || port > 1)
432 return;
433
434 if (port == 0)
435 memcpy(&au1xxx_eth0_platform_data, eth_data,
436 sizeof(struct au1000_eth_platform_data));
437#ifndef CONFIG_SOC_AU1100
438 else
439 memcpy(&au1xxx_eth1_platform_data, eth_data,
440 sizeof(struct au1000_eth_platform_data));
441#endif
442}
443
444static struct platform_device *au1xxx_platform_devices[] __initdata = {
445 &au1xx0_uart_device,
446 &au1xxx_usb_ohci_device,
447#ifdef CONFIG_FB_AU1100
448 &au1100_lcd_device,
449#endif
450#ifdef CONFIG_SOC_AU1200
451 &au1xxx_usb_ehci_device,
452 &au1xxx_usb_gdt_device,
453 &au1xxx_usb_otg_device,
454 &au1200_lcd_device,
455 &au1200_mmc0_device,
456#ifndef CONFIG_MIPS_DB1200
457 &au1200_mmc1_device,
458#endif
459#endif
460#ifdef SMBUS_PSC_BASE
461 &pbdb_smbus_device,
462#endif
463 &au1xxx_eth0_device,
464};
465
466static int __init au1xxx_platform_init(void)
467{
468 unsigned int uartclk = get_au1x00_uart_baud_base() * 16;
469 int err, i;
470 unsigned char ethaddr[6];
471
472 /* Fill up uartclk. */
473 for (i = 0; au1x00_uart_data[i].flags; i++)
474 au1x00_uart_data[i].uartclk = uartclk;
475
476 /* use firmware-provided mac addr if available and necessary */
477 i = prom_get_ethernet_addr(ethaddr);
478 if (!i && !is_valid_ether_addr(au1xxx_eth0_platform_data.mac))
479 memcpy(au1xxx_eth0_platform_data.mac, ethaddr, 6);
480
481 err = platform_add_devices(au1xxx_platform_devices,
482 ARRAY_SIZE(au1xxx_platform_devices));
483#ifndef CONFIG_SOC_AU1100
484 ethaddr[5] += 1; /* next addr for 2nd MAC */
485 if (!i && !is_valid_ether_addr(au1xxx_eth1_platform_data.mac))
486 memcpy(au1xxx_eth1_platform_data.mac, ethaddr, 6);
487
488 /* Register second MAC if enabled in pinfunc */
489 if (!err && !(au_readl(SYS_PINFUNC) & (u32)SYS_PF_NI2))
490 err = platform_device_register(&au1xxx_eth1_device);
491#endif
492
493 return err;
494}
495
496arch_initcall(au1xxx_platform_init);