USB: add ehci_hcd.ignore_oc parameter
[linux-2.6] / drivers / sbus / sbus.c
1 /* sbus.c: SBus support routines.
2  *
3  * Copyright (C) 1995, 2006 David S. Miller (davem@davemloft.net)
4  */
5
6 #include <linux/kernel.h>
7 #include <linux/slab.h>
8 #include <linux/init.h>
9 #include <linux/pci.h>
10
11 #include <asm/system.h>
12 #include <asm/sbus.h>
13 #include <asm/dma.h>
14 #include <asm/oplib.h>
15 #include <asm/prom.h>
16 #include <asm/of_device.h>
17 #include <asm/bpp.h>
18 #include <asm/irq.h>
19
20 struct sbus_bus *sbus_root;
21
22 static void __init fill_sbus_device(struct device_node *dp, struct sbus_dev *sdev)
23 {
24         unsigned long base;
25         void *pval;
26         int len;
27
28         sdev->prom_node = dp->node;
29         strcpy(sdev->prom_name, dp->name);
30
31         pval = of_get_property(dp, "reg", &len);
32         sdev->num_registers = 0;
33         if (pval) {
34                 memcpy(sdev->reg_addrs, pval, len);
35
36                 sdev->num_registers =
37                         len / sizeof(struct linux_prom_registers);
38
39                 base = (unsigned long) sdev->reg_addrs[0].phys_addr;
40
41                 /* Compute the slot number. */
42                 if (base >= SUN_SBUS_BVADDR && sparc_cpu_model == sun4m)
43                         sdev->slot = sbus_dev_slot(base);
44                 else
45                         sdev->slot = sdev->reg_addrs[0].which_io;
46         }
47
48         pval = of_get_property(dp, "ranges", &len);
49         sdev->num_device_ranges = 0;
50         if (pval) {
51                 memcpy(sdev->device_ranges, pval, len);
52                 sdev->num_device_ranges =
53                         len / sizeof(struct linux_prom_ranges);
54         }
55
56         sbus_fill_device_irq(sdev);
57
58         sdev->ofdev.node = dp;
59         if (sdev->parent)
60                 sdev->ofdev.dev.parent = &sdev->parent->ofdev.dev;
61         else
62                 sdev->ofdev.dev.parent = &sdev->bus->ofdev.dev;
63         sdev->ofdev.dev.bus = &sbus_bus_type;
64         sprintf(sdev->ofdev.dev.bus_id, "sbus[%08x]", dp->node);
65
66         if (of_device_register(&sdev->ofdev) != 0)
67                 printk(KERN_DEBUG "sbus: device registration error for %s!\n",
68                        dp->path_component_name);
69 }
70
71 static void __init sbus_bus_ranges_init(struct device_node *dp, struct sbus_bus *sbus)
72 {
73         void *pval;
74         int len;
75
76         pval = of_get_property(dp, "ranges", &len);
77         sbus->num_sbus_ranges = 0;
78         if (pval) {
79                 memcpy(sbus->sbus_ranges, pval, len);
80                 sbus->num_sbus_ranges =
81                         len / sizeof(struct linux_prom_ranges);
82
83                 sbus_arch_bus_ranges_init(dp->parent, sbus);
84         }
85 }
86
87 static void __init __apply_ranges_to_regs(struct linux_prom_ranges *ranges,
88                                           int num_ranges,
89                                           struct linux_prom_registers *regs,
90                                           int num_regs)
91 {
92         if (num_ranges) {
93                 int regnum;
94
95                 for (regnum = 0; regnum < num_regs; regnum++) {
96                         int rngnum;
97
98                         for (rngnum = 0; rngnum < num_ranges; rngnum++) {
99                                 if (regs[regnum].which_io == ranges[rngnum].ot_child_space)
100                                         break;
101                         }
102                         if (rngnum == num_ranges) {
103                                 /* We used to flag this as an error.  Actually
104                                  * some devices do not report the regs as we expect.
105                                  * For example, see SUNW,pln device.  In that case
106                                  * the reg property is in a format internal to that
107                                  * node, ie. it is not in the SBUS register space
108                                  * per se. -DaveM
109                                  */
110                                 return;
111                         }
112                         regs[regnum].which_io = ranges[rngnum].ot_parent_space;
113                         regs[regnum].phys_addr -= ranges[rngnum].ot_child_base;
114                         regs[regnum].phys_addr += ranges[rngnum].ot_parent_base;
115                 }
116         }
117 }
118
119 static void __init __fixup_regs_sdev(struct sbus_dev *sdev)
120 {
121         if (sdev->num_registers != 0) {
122                 struct sbus_dev *parent = sdev->parent;
123                 int i;
124
125                 while (parent != NULL) {
126                         __apply_ranges_to_regs(parent->device_ranges,
127                                                parent->num_device_ranges,
128                                                sdev->reg_addrs,
129                                                sdev->num_registers);
130
131                         parent = parent->parent;
132                 }
133
134                 __apply_ranges_to_regs(sdev->bus->sbus_ranges,
135                                        sdev->bus->num_sbus_ranges,
136                                        sdev->reg_addrs,
137                                        sdev->num_registers);
138
139                 for (i = 0; i < sdev->num_registers; i++) {
140                         struct resource *res = &sdev->resource[i];
141
142                         res->start = sdev->reg_addrs[i].phys_addr;
143                         res->end = (res->start +
144                                     (unsigned long)sdev->reg_addrs[i].reg_size - 1UL);
145                         res->flags = IORESOURCE_IO |
146                                 (sdev->reg_addrs[i].which_io & 0xff);
147                 }
148         }
149 }
150
151 static void __init sbus_fixup_all_regs(struct sbus_dev *first_sdev)
152 {
153         struct sbus_dev *sdev;
154
155         for (sdev = first_sdev; sdev; sdev = sdev->next) {
156                 if (sdev->child)
157                         sbus_fixup_all_regs(sdev->child);
158                 __fixup_regs_sdev(sdev);
159         }
160 }
161
162 /* We preserve the "probe order" of these bus and device lists to give
163  * the same ordering as the old code.
164  */
165 static void __init sbus_insert(struct sbus_bus *sbus, struct sbus_bus **root)
166 {
167         while (*root)
168                 root = &(*root)->next;
169         *root = sbus;
170         sbus->next = NULL;
171 }
172
173 static void __init sdev_insert(struct sbus_dev *sdev, struct sbus_dev **root)
174 {
175         while (*root)
176                 root = &(*root)->next;
177         *root = sdev;
178         sdev->next = NULL;
179 }
180
181 static void __init walk_children(struct device_node *dp, struct sbus_dev *parent, struct sbus_bus *sbus)
182 {
183         dp = dp->child;
184         while (dp) {
185                 struct sbus_dev *sdev;
186
187                 sdev = kzalloc(sizeof(struct sbus_dev), GFP_ATOMIC);
188                 if (sdev) {
189                         sdev_insert(sdev, &parent->child);
190
191                         sdev->bus = sbus;
192                         sdev->parent = parent;
193
194                         fill_sbus_device(dp, sdev);
195
196                         walk_children(dp, sdev, sbus);
197                 }
198                 dp = dp->sibling;
199         }
200 }
201
202 static void __init build_one_sbus(struct device_node *dp, int num_sbus)
203 {
204         struct sbus_bus *sbus;
205         unsigned int sbus_clock;
206         struct device_node *dev_dp;
207
208         sbus = kzalloc(sizeof(struct sbus_bus), GFP_ATOMIC);
209         if (!sbus)
210                 return;
211
212         sbus_insert(sbus, &sbus_root);
213         sbus->prom_node = dp->node;
214
215         sbus_setup_iommu(sbus, dp);
216
217         printk("sbus%d: ", num_sbus);
218
219         sbus_clock = of_getintprop_default(dp, "clock-frequency",
220                                            (25*1000*1000));
221         sbus->clock_freq = sbus_clock;
222
223         printk("Clock %d.%d MHz\n", (int) ((sbus_clock/1000)/1000),
224                (int) (((sbus_clock/1000)%1000 != 0) ? 
225                       (((sbus_clock/1000)%1000) + 1000) : 0));
226
227         strcpy(sbus->prom_name, dp->name);
228
229         sbus_setup_arch_props(sbus, dp);
230
231         sbus_bus_ranges_init(dp, sbus);
232
233         sbus->ofdev.node = dp;
234         sbus->ofdev.dev.parent = NULL;
235         sbus->ofdev.dev.bus = &sbus_bus_type;
236         sprintf(sbus->ofdev.dev.bus_id, "sbus%d", num_sbus);
237
238         if (of_device_register(&sbus->ofdev) != 0)
239                 printk(KERN_DEBUG "sbus: device registration error for %s!\n",
240                        sbus->ofdev.dev.bus_id);
241
242         dev_dp = dp->child;
243         while (dev_dp) {
244                 struct sbus_dev *sdev;
245
246                 sdev = kzalloc(sizeof(struct sbus_dev), GFP_ATOMIC);
247                 if (sdev) {
248                         sdev_insert(sdev, &sbus->devices);
249
250                         sdev->bus = sbus;
251                         sdev->parent = NULL;
252                         fill_sbus_device(dev_dp, sdev);
253
254                         walk_children(dev_dp, sdev, sbus);
255                 }
256                 dev_dp = dev_dp->sibling;
257         }
258
259         sbus_fixup_all_regs(sbus->devices);
260
261         dvma_init(sbus);
262 }
263
264 static int __init sbus_init(void)
265 {
266         struct device_node *dp;
267         const char *sbus_name = "sbus";
268         int num_sbus = 0;
269
270         if (sbus_arch_preinit())
271                 return 0;
272
273         if (sparc_cpu_model == sun4d)
274                 sbus_name = "sbi";
275
276         for_each_node_by_name(dp, sbus_name) {
277                 build_one_sbus(dp, num_sbus);
278                 num_sbus++;
279
280         }
281
282         sbus_arch_postinit();
283
284         return 0;
285 }
286
287 subsys_initcall(sbus_init);