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