75c8e9834ae70ad142f2aa8e65e025065a4816de
[linux-3.10.git] / arch / ppc / syslib / mpc83xx_devices.c
1 /*
2  * arch/ppc/platforms/83xx/mpc83xx_devices.c
3  *
4  * MPC83xx Device descriptions
5  *
6  * Maintainer: Kumar Gala <kumar.gala@freescale.com>
7  *
8  * Copyright 2005 Freescale Semiconductor Inc.
9  *
10  * This program is free software; you can redistribute  it and/or modify it
11  * under  the terms of  the GNU General  Public License as published by the
12  * Free Software Foundation;  either version 2 of the  License, or (at your
13  * option) any later version.
14  */
15
16 #include <linux/init.h>
17 #include <linux/module.h>
18 #include <linux/device.h>
19 #include <linux/serial_8250.h>
20 #include <linux/fsl_devices.h>
21 #include <asm/mpc83xx.h>
22 #include <asm/irq.h>
23 #include <asm/ppc_sys.h>
24
25 /* We use offsets for IORESOURCE_MEM since we do not know at compile time
26  * what IMMRBAR is, will get fixed up by mach_mpc83xx_fixup
27  */
28
29 static struct gianfar_platform_data mpc83xx_tsec1_pdata = {
30         .device_flags = FSL_GIANFAR_DEV_HAS_GIGABIT |
31             FSL_GIANFAR_DEV_HAS_COALESCE | FSL_GIANFAR_DEV_HAS_RMON |
32             FSL_GIANFAR_DEV_HAS_MULTI_INTR,
33         .phy_reg_addr = 0x24000,
34 };
35
36 static struct gianfar_platform_data mpc83xx_tsec2_pdata = {
37         .device_flags = FSL_GIANFAR_DEV_HAS_GIGABIT |
38             FSL_GIANFAR_DEV_HAS_COALESCE | FSL_GIANFAR_DEV_HAS_RMON |
39             FSL_GIANFAR_DEV_HAS_MULTI_INTR,
40         .phy_reg_addr = 0x24000,
41 };
42
43 static struct fsl_i2c_platform_data mpc83xx_fsl_i2c1_pdata = {
44         .device_flags = FSL_I2C_DEV_SEPARATE_DFSRR,
45 };
46
47 static struct fsl_i2c_platform_data mpc83xx_fsl_i2c2_pdata = {
48         .device_flags = FSL_I2C_DEV_SEPARATE_DFSRR,
49 };
50
51 static struct plat_serial8250_port serial_platform_data[] = {
52         [0] = {
53                 .mapbase        = 0x4500,
54                 .irq            = MPC83xx_IRQ_UART1,
55                 .iotype         = UPIO_MEM,
56                 .flags          = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST,
57         },
58         [1] = {
59                 .mapbase        = 0x4600,
60                 .irq            = MPC83xx_IRQ_UART2,
61                 .iotype         = UPIO_MEM,
62                 .flags          = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST,
63         },
64         { },
65 };
66
67 struct platform_device ppc_sys_platform_devices[] = {
68         [MPC83xx_TSEC1] = {
69                 .name = "fsl-gianfar",
70                 .id     = 1,
71                 .dev.platform_data = &mpc83xx_tsec1_pdata,
72                 .num_resources   = 4,
73                 .resource = (struct resource[]) {
74                         {
75                                 .start  = 0x24000,
76                                 .end    = 0x24fff,
77                                 .flags  = IORESOURCE_MEM,
78                         },
79                         {
80                                 .name   = "tx",
81                                 .start  = MPC83xx_IRQ_TSEC1_TX,
82                                 .end    = MPC83xx_IRQ_TSEC1_TX,
83                                 .flags  = IORESOURCE_IRQ,
84                         },
85                         {
86                                 .name   = "rx",
87                                 .start  = MPC83xx_IRQ_TSEC1_RX,
88                                 .end    = MPC83xx_IRQ_TSEC1_RX,
89                                 .flags  = IORESOURCE_IRQ,
90                         },
91                         {
92                                 .name   = "error",
93                                 .start  = MPC83xx_IRQ_TSEC1_ERROR,
94                                 .end    = MPC83xx_IRQ_TSEC1_ERROR,
95                                 .flags  = IORESOURCE_IRQ,
96                         },
97                 },
98         },
99         [MPC83xx_TSEC2] = {
100                 .name = "fsl-gianfar",
101                 .id     = 2,
102                 .dev.platform_data = &mpc83xx_tsec2_pdata,
103                 .num_resources   = 4,
104                 .resource = (struct resource[]) {
105                         {
106                                 .start  = 0x25000,
107                                 .end    = 0x25fff,
108                                 .flags  = IORESOURCE_MEM,
109                         },
110                         {
111                                 .name   = "tx",
112                                 .start  = MPC83xx_IRQ_TSEC2_TX,
113                                 .end    = MPC83xx_IRQ_TSEC2_TX,
114                                 .flags  = IORESOURCE_IRQ,
115                         },
116                         {
117                                 .name   = "rx",
118                                 .start  = MPC83xx_IRQ_TSEC2_RX,
119                                 .end    = MPC83xx_IRQ_TSEC2_RX,
120                                 .flags  = IORESOURCE_IRQ,
121                         },
122                         {
123                                 .name   = "error",
124                                 .start  = MPC83xx_IRQ_TSEC2_ERROR,
125                                 .end    = MPC83xx_IRQ_TSEC2_ERROR,
126                                 .flags  = IORESOURCE_IRQ,
127                         },
128                 },
129         },
130         [MPC83xx_IIC1] = {
131                 .name = "fsl-i2c",
132                 .id     = 1,
133                 .dev.platform_data = &mpc83xx_fsl_i2c1_pdata,
134                 .num_resources   = 2,
135                 .resource = (struct resource[]) {
136                         {
137                                 .start  = 0x3000,
138                                 .end    = 0x30ff,
139                                 .flags  = IORESOURCE_MEM,
140                         },
141                         {
142                                 .start  = MPC83xx_IRQ_IIC1,
143                                 .end    = MPC83xx_IRQ_IIC1,
144                                 .flags  = IORESOURCE_IRQ,
145                         },
146                 },
147         },
148         [MPC83xx_IIC2] = {
149                 .name = "fsl-i2c",
150                 .id     = 2,
151                 .dev.platform_data = &mpc83xx_fsl_i2c2_pdata,
152                 .num_resources   = 2,
153                 .resource = (struct resource[]) {
154                         {
155                                 .start  = 0x3100,
156                                 .end    = 0x31ff,
157                                 .flags  = IORESOURCE_MEM,
158                         },
159                         {
160                                 .start  = MPC83xx_IRQ_IIC2,
161                                 .end    = MPC83xx_IRQ_IIC2,
162                                 .flags  = IORESOURCE_IRQ,
163                         },
164                 },
165         },
166         [MPC83xx_DUART] = {
167                 .name = "serial8250",
168                 .id     = 0,
169                 .dev.platform_data = serial_platform_data,
170         },
171         [MPC83xx_SEC2] = {
172                 .name = "fsl-sec2",
173                 .id     = 1,
174                 .num_resources   = 2,
175                 .resource = (struct resource[]) {
176                         {
177                                 .start  = 0x30000,
178                                 .end    = 0x3ffff,
179                                 .flags  = IORESOURCE_MEM,
180                         },
181                         {
182                                 .start  = MPC83xx_IRQ_SEC2,
183                                 .end    = MPC83xx_IRQ_SEC2,
184                                 .flags  = IORESOURCE_IRQ,
185                         },
186                 },
187         },
188         [MPC83xx_USB2_DR] = {
189                 .name = "fsl-usb2-dr",
190                 .id     = 1,
191                 .num_resources   = 2,
192                 .resource = (struct resource[]) {
193                         {
194                                 .start  = 0x22000,
195                                 .end    = 0x22fff,
196                                 .flags  = IORESOURCE_MEM,
197                         },
198                         {
199                                 .start  = MPC83xx_IRQ_USB2_DR,
200                                 .end    = MPC83xx_IRQ_USB2_DR,
201                                 .flags  = IORESOURCE_IRQ,
202                         },
203                 },
204         },
205         [MPC83xx_USB2_MPH] = {
206                 .name = "fsl-usb2-mph",
207                 .id     = 1,
208                 .num_resources   = 2,
209                 .resource = (struct resource[]) {
210                         {
211                                 .start  = 0x23000,
212                                 .end    = 0x23fff,
213                                 .flags  = IORESOURCE_MEM,
214                         },
215                         {
216                                 .start  = MPC83xx_IRQ_USB2_MPH,
217                                 .end    = MPC83xx_IRQ_USB2_MPH,
218                                 .flags  = IORESOURCE_IRQ,
219                         },
220                 },
221         },
222 };
223
224 static int __init mach_mpc83xx_fixup(struct platform_device *pdev)
225 {
226         ppc_sys_fixup_mem_resource(pdev, immrbar);
227         return 0;
228 }
229
230 static int __init mach_mpc83xx_init(void)
231 {
232         if (ppc_md.progress)
233                 ppc_md.progress("mach_mpc83xx_init:enter", 0);
234         ppc_sys_device_fixup = mach_mpc83xx_fixup;
235         return 0;
236 }
237
238 postcore_initcall(mach_mpc83xx_init);