MIPS: PNX833x: Move code one directory level up.
[linux-2.6.git] / arch / mips / pnx833x / common / platform.c
1 /*
2  *  platform.c: platform support for PNX833X.
3  *
4  *  Copyright 2008 NXP Semiconductors
5  *        Chris Steel <chris.steel@nxp.com>
6  *    Daniel Laird <daniel.j.laird@nxp.com>
7  *
8  *  Based on software written by:
9  *      Nikita Youshchenko <yoush@debian.org>, based on PNX8550 code.
10  *
11  *  This program is free software; you can redistribute it and/or modify
12  *  it under the terms of the GNU General Public License as published by
13  *  the Free Software Foundation; either version 2 of the License, or
14  *  (at your option) any later version.
15  *
16  *  This program is distributed in the hope that it will be useful,
17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  *  GNU General Public License for more details.
20  *
21  *  You should have received a copy of the GNU General Public License
22  *  along with this program; if not, write to the Free Software
23  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24  */
25 #include <linux/device.h>
26 #include <linux/dma-mapping.h>
27 #include <linux/platform_device.h>
28 #include <linux/kernel.h>
29 #include <linux/init.h>
30 #include <linux/resource.h>
31 #include <linux/serial.h>
32 #include <linux/serial_pnx8xxx.h>
33 #include <linux/mtd/nand.h>
34 #include <linux/mtd/partitions.h>
35
36 #ifdef CONFIG_I2C_PNX0105
37 /* Until i2c driver available in kernel.*/
38 #include <linux/i2c-pnx0105.h>
39 #endif
40
41 #include <irq.h>
42 #include <irq-mapping.h>
43 #include <pnx833x.h>
44
45 static u64 uart_dmamask     = DMA_BIT_MASK(32);
46
47 static struct resource pnx833x_uart_resources[] = {
48         [0] = {
49                 .start          = PNX833X_UART0_PORTS_START,
50                 .end            = PNX833X_UART0_PORTS_END,
51                 .flags          = IORESOURCE_MEM,
52         },
53         [1] = {
54                 .start          = PNX833X_PIC_UART0_INT,
55                 .end            = PNX833X_PIC_UART0_INT,
56                 .flags          = IORESOURCE_IRQ,
57         },
58         [2] = {
59                 .start          = PNX833X_UART1_PORTS_START,
60                 .end            = PNX833X_UART1_PORTS_END,
61                 .flags          = IORESOURCE_MEM,
62         },
63         [3] = {
64                 .start          = PNX833X_PIC_UART1_INT,
65                 .end            = PNX833X_PIC_UART1_INT,
66                 .flags          = IORESOURCE_IRQ,
67         },
68 };
69
70 struct pnx8xxx_port pnx8xxx_ports[] = {
71         [0] = {
72                 .port   = {
73                         .type           = PORT_PNX8XXX,
74                         .iotype         = UPIO_MEM,
75                         .membase        = (void __iomem *)PNX833X_UART0_PORTS_START,
76                         .mapbase        = PNX833X_UART0_PORTS_START,
77                         .irq            = PNX833X_PIC_UART0_INT,
78                         .uartclk        = 3692300,
79                         .fifosize       = 16,
80                         .flags          = UPF_BOOT_AUTOCONF,
81                         .line           = 0,
82                 },
83         },
84         [1] = {
85                 .port   = {
86                         .type           = PORT_PNX8XXX,
87                         .iotype         = UPIO_MEM,
88                         .membase        = (void __iomem *)PNX833X_UART1_PORTS_START,
89                         .mapbase        = PNX833X_UART1_PORTS_START,
90                         .irq            = PNX833X_PIC_UART1_INT,
91                         .uartclk        = 3692300,
92                         .fifosize       = 16,
93                         .flags          = UPF_BOOT_AUTOCONF,
94                         .line           = 1,
95                 },
96         },
97 };
98
99 static struct platform_device pnx833x_uart_device = {
100         .name           = "pnx8xxx-uart",
101         .id             = -1,
102         .dev = {
103                 .dma_mask               = &uart_dmamask,
104                 .coherent_dma_mask      = DMA_BIT_MASK(32),
105                 .platform_data          = pnx8xxx_ports,
106         },
107         .num_resources  = ARRAY_SIZE(pnx833x_uart_resources),
108         .resource       = pnx833x_uart_resources,
109 };
110
111 static u64 ehci_dmamask     = DMA_BIT_MASK(32);
112
113 static struct resource pnx833x_usb_ehci_resources[] = {
114         [0] = {
115                 .start          = PNX833X_USB_PORTS_START,
116                 .end            = PNX833X_USB_PORTS_END,
117                 .flags          = IORESOURCE_MEM,
118         },
119         [1] = {
120                 .start          = PNX833X_PIC_USB_INT,
121                 .end            = PNX833X_PIC_USB_INT,
122                 .flags          = IORESOURCE_IRQ,
123         },
124 };
125
126 static struct platform_device pnx833x_usb_ehci_device = {
127         .name           = "pnx833x-ehci",
128         .id             = -1,
129         .dev = {
130                 .dma_mask               = &ehci_dmamask,
131                 .coherent_dma_mask      = DMA_BIT_MASK(32),
132         },
133         .num_resources  = ARRAY_SIZE(pnx833x_usb_ehci_resources),
134         .resource       = pnx833x_usb_ehci_resources,
135 };
136
137 #ifdef CONFIG_I2C_PNX0105
138 static struct resource pnx833x_i2c0_resources[] = {
139         {
140                 .start          = PNX833X_I2C0_PORTS_START,
141                 .end            = PNX833X_I2C0_PORTS_END,
142                 .flags          = IORESOURCE_MEM,
143         },
144         {
145                 .start          = PNX833X_PIC_I2C0_INT,
146                 .end            = PNX833X_PIC_I2C0_INT,
147                 .flags          = IORESOURCE_IRQ,
148         },
149 };
150
151 static struct resource pnx833x_i2c1_resources[] = {
152         {
153                 .start          = PNX833X_I2C1_PORTS_START,
154                 .end            = PNX833X_I2C1_PORTS_END,
155                 .flags          = IORESOURCE_MEM,
156         },
157         {
158                 .start          = PNX833X_PIC_I2C1_INT,
159                 .end            = PNX833X_PIC_I2C1_INT,
160                 .flags          = IORESOURCE_IRQ,
161         },
162 };
163
164 static struct i2c_pnx0105_dev pnx833x_i2c_dev[] = {
165         {
166                 .base = PNX833X_I2C0_PORTS_START,
167                 .irq = -1, /* should be PNX833X_PIC_I2C0_INT but polling is faster */
168                 .clock = 6,     /* 0 == 400 kHz, 4 == 100 kHz(Maximum HDMI), 6 = 50kHz(Prefered HDCP) */
169                 .bus_addr = 0,  /* no slave support */
170         },
171         {
172                 .base = PNX833X_I2C1_PORTS_START,
173                 .irq = -1,      /* on high freq, polling is faster */
174                 /*.irq = PNX833X_PIC_I2C1_INT,*/
175                 .clock = 4,     /* 0 == 400 kHz, 4 == 100 kHz. 100 kHz seems a safe default for now */
176                 .bus_addr = 0,  /* no slave support */
177         },
178 };
179
180 static struct platform_device pnx833x_i2c0_device = {
181         .name           = "i2c-pnx0105",
182         .id             = 0,
183         .dev = {
184                 .platform_data = &pnx833x_i2c_dev[0],
185         },
186         .num_resources  = ARRAY_SIZE(pnx833x_i2c0_resources),
187         .resource       = pnx833x_i2c0_resources,
188 };
189
190 static struct platform_device pnx833x_i2c1_device = {
191         .name           = "i2c-pnx0105",
192         .id             = 1,
193         .dev = {
194                 .platform_data = &pnx833x_i2c_dev[1],
195         },
196         .num_resources  = ARRAY_SIZE(pnx833x_i2c1_resources),
197         .resource       = pnx833x_i2c1_resources,
198 };
199 #endif
200
201 static u64 ethernet_dmamask = DMA_BIT_MASK(32);
202
203 static struct resource pnx833x_ethernet_resources[] = {
204         [0] = {
205                 .start = PNX8335_IP3902_PORTS_START,
206                 .end   = PNX8335_IP3902_PORTS_END,
207                 .flags = IORESOURCE_MEM,
208         },
209         [1] = {
210                 .start = PNX8335_PIC_ETHERNET_INT,
211                 .end   = PNX8335_PIC_ETHERNET_INT,
212                 .flags = IORESOURCE_IRQ,
213         },
214 };
215
216 static struct platform_device pnx833x_ethernet_device = {
217         .name = "ip3902-eth",
218         .id   = -1,
219         .dev  = {
220                 .dma_mask          = &ethernet_dmamask,
221                 .coherent_dma_mask = DMA_BIT_MASK(32),
222         },
223         .num_resources = ARRAY_SIZE(pnx833x_ethernet_resources),
224         .resource      = pnx833x_ethernet_resources,
225 };
226
227 static struct resource pnx833x_sata_resources[] = {
228         [0] = {
229                 .start = PNX8335_SATA_PORTS_START,
230                 .end   = PNX8335_SATA_PORTS_END,
231                 .flags = IORESOURCE_MEM,
232         },
233         [1] = {
234                 .start = PNX8335_PIC_SATA_INT,
235                 .end   = PNX8335_PIC_SATA_INT,
236                 .flags = IORESOURCE_IRQ,
237         },
238 };
239
240 static struct platform_device pnx833x_sata_device = {
241         .name          = "pnx833x-sata",
242         .id            = -1,
243         .num_resources = ARRAY_SIZE(pnx833x_sata_resources),
244         .resource      = pnx833x_sata_resources,
245 };
246
247 static const char *part_probes[] = {
248         "cmdlinepart",
249         NULL
250 };
251
252 static void
253 pnx833x_flash_nand_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
254 {
255         struct nand_chip *this = mtd->priv;
256         unsigned long nandaddr = (unsigned long)this->IO_ADDR_W;
257
258         if (cmd == NAND_CMD_NONE)
259                 return;
260
261         if (ctrl & NAND_CLE)
262                 writeb(cmd, (void __iomem *)(nandaddr + PNX8335_NAND_CLE_MASK));
263         else
264                 writeb(cmd, (void __iomem *)(nandaddr + PNX8335_NAND_ALE_MASK));
265 }
266
267 static struct platform_nand_data pnx833x_flash_nand_data = {
268         .chip = {
269                 .chip_delay             = 25,
270                 .part_probe_types       = part_probes,
271         },
272         .ctrl = {
273                 .cmd_ctrl               = pnx833x_flash_nand_cmd_ctrl
274         }
275 };
276
277 /*
278  * Set start to be the correct address (PNX8335_NAND_BASE with no 0xb!!),
279  * 12 bytes more seems to be the standard that allows for NAND access.
280  */
281 static struct resource pnx833x_flash_nand_resource = {
282         .start  = PNX8335_NAND_BASE,
283         .end    = PNX8335_NAND_BASE + 12,
284         .flags  = IORESOURCE_MEM,
285 };
286
287 static struct platform_device pnx833x_flash_nand = {
288         .name           = "gen_nand",
289         .id                     = -1,
290         .num_resources  = 1,
291         .resource           = &pnx833x_flash_nand_resource,
292         .dev            = {
293                 .platform_data = &pnx833x_flash_nand_data,
294         },
295 };
296
297 static struct platform_device *pnx833x_platform_devices[] __initdata = {
298         &pnx833x_uart_device,
299         &pnx833x_usb_ehci_device,
300 #ifdef CONFIG_I2C_PNX0105
301         &pnx833x_i2c0_device,
302         &pnx833x_i2c1_device,
303 #endif
304         &pnx833x_ethernet_device,
305         &pnx833x_sata_device,
306         &pnx833x_flash_nand,
307 };
308
309 static int __init pnx833x_platform_init(void)
310 {
311         int res;
312
313         res = platform_add_devices(pnx833x_platform_devices,
314                                    ARRAY_SIZE(pnx833x_platform_devices));
315
316         return res;
317 }
318
319 arch_initcall(pnx833x_platform_init);