Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * drivers.c | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or | |
5 | * modify it under the terms of the GNU General Public License | |
6 | * as published by the Free Software Foundation; either version | |
7 | * 2 of the License, or (at your option) any later version. | |
8 | * | |
9 | * Copyright (c) 1999 The Puffin Group | |
10 | * Copyright (c) 2001 Matthew Wilcox for Hewlett Packard | |
11 | * Copyright (c) 2001 Helge Deller <deller@gmx.de> | |
12 | * Copyright (c) 2001,2002 Ryan Bradetich | |
13 | * Copyright (c) 2004-2005 Thibaut VARENE <varenet@parisc-linux.org> | |
14 | * | |
15 | * The file handles registering devices and drivers, then matching them. | |
16 | * It's the closest we get to a dating agency. | |
17 | * | |
18 | * If you're thinking about modifying this file, here are some gotchas to | |
19 | * bear in mind: | |
20 | * - 715/Mirage device paths have a dummy device between Lasi and its children | |
21 | * - The EISA adapter may show up as a sibling or child of Wax | |
22 | * - Dino has an optionally functional serial port. If firmware enables it, | |
23 | * it shows up as a child of Dino. If firmware disables it, the buswalk | |
24 | * finds it and it shows up as a child of Cujo | |
25 | * - Dino has both parisc and pci devices as children | |
26 | * - parisc devices are discovered in a random order, including children | |
27 | * before parents in some cases. | |
28 | */ | |
29 | ||
30 | #include <linux/slab.h> | |
31 | #include <linux/types.h> | |
32 | #include <linux/kernel.h> | |
33 | #include <linux/pci.h> | |
34 | #include <linux/spinlock.h> | |
35 | #include <linux/string.h> | |
36 | #include <asm/hardware.h> | |
37 | #include <asm/io.h> | |
38 | #include <asm/pdc.h> | |
39 | #include <asm/parisc-device.h> | |
40 | ||
41 | /* See comments in include/asm-parisc/pci.h */ | |
8039de10 | 42 | struct hppa_dma_ops *hppa_dma_ops __read_mostly; |
1da177e4 LT |
43 | EXPORT_SYMBOL(hppa_dma_ops); |
44 | ||
45 | static struct device root = { | |
46 | .bus_id = "parisc", | |
47 | }; | |
48 | ||
56583747 MW |
49 | static inline int check_dev(struct device *dev) |
50 | { | |
51 | if (dev->bus == &parisc_bus_type) { | |
52 | struct parisc_device *pdev; | |
53 | pdev = to_parisc_device(dev); | |
54 | return pdev->id.hw_type != HPHW_FAULTY; | |
55 | } | |
56 | return 1; | |
57 | } | |
58 | ||
59 | static struct device * | |
60 | parse_tree_node(struct device *parent, int index, struct hardware_path *modpath); | |
1da177e4 | 61 | |
56583747 MW |
62 | struct recurse_struct { |
63 | void * obj; | |
64 | int (*fn)(struct device *, void *); | |
65 | }; | |
66 | ||
67 | static int descend_children(struct device * dev, void * data) | |
68 | { | |
69 | struct recurse_struct * recurse_data = (struct recurse_struct *)data; | |
70 | ||
71 | if (recurse_data->fn(dev, recurse_data->obj)) | |
72 | return 1; | |
73 | else | |
74 | return device_for_each_child(dev, recurse_data, descend_children); | |
75 | } | |
1da177e4 LT |
76 | |
77 | /** | |
56583747 MW |
78 | * for_each_padev - Iterate over all devices in the tree |
79 | * @fn: Function to call for each device. | |
80 | * @data: Data to pass to the called function. | |
1da177e4 | 81 | * |
56583747 MW |
82 | * This performs a depth-first traversal of the tree, calling the |
83 | * function passed for each node. It calls the function for parents | |
84 | * before children. | |
1da177e4 | 85 | */ |
1da177e4 | 86 | |
56583747 MW |
87 | static int for_each_padev(int (*fn)(struct device *, void *), void * data) |
88 | { | |
89 | struct recurse_struct recurse_data = { | |
90 | .obj = data, | |
91 | .fn = fn, | |
92 | }; | |
93 | return device_for_each_child(&root, &recurse_data, descend_children); | |
1da177e4 LT |
94 | } |
95 | ||
96 | /** | |
97 | * match_device - Report whether this driver can handle this device | |
98 | * @driver: the PA-RISC driver to try | |
99 | * @dev: the PA-RISC device to try | |
100 | */ | |
101 | static int match_device(struct parisc_driver *driver, struct parisc_device *dev) | |
102 | { | |
103 | const struct parisc_device_id *ids; | |
104 | ||
105 | for (ids = driver->id_table; ids->sversion; ids++) { | |
106 | if ((ids->sversion != SVERSION_ANY_ID) && | |
107 | (ids->sversion != dev->id.sversion)) | |
108 | continue; | |
109 | ||
110 | if ((ids->hw_type != HWTYPE_ANY_ID) && | |
111 | (ids->hw_type != dev->id.hw_type)) | |
112 | continue; | |
113 | ||
114 | if ((ids->hversion != HVERSION_ANY_ID) && | |
115 | (ids->hversion != dev->id.hversion)) | |
116 | continue; | |
117 | ||
118 | return 1; | |
119 | } | |
120 | return 0; | |
121 | } | |
122 | ||
1da177e4 LT |
123 | static int parisc_driver_probe(struct device *dev) |
124 | { | |
125 | int rc; | |
126 | struct parisc_device *pa_dev = to_parisc_device(dev); | |
127 | struct parisc_driver *pa_drv = to_parisc_driver(dev->driver); | |
128 | ||
129 | rc = pa_drv->probe(pa_dev); | |
130 | ||
56583747 MW |
131 | if (!rc) |
132 | pa_dev->driver = pa_drv; | |
1da177e4 LT |
133 | |
134 | return rc; | |
135 | } | |
136 | ||
137 | static int parisc_driver_remove(struct device *dev) | |
138 | { | |
139 | struct parisc_device *pa_dev = to_parisc_device(dev); | |
140 | struct parisc_driver *pa_drv = to_parisc_driver(dev->driver); | |
141 | if (pa_drv->remove) | |
142 | pa_drv->remove(pa_dev); | |
1da177e4 LT |
143 | |
144 | return 0; | |
145 | } | |
146 | ||
147 | ||
148 | /** | |
149 | * register_parisc_driver - Register this driver if it can handle a device | |
150 | * @driver: the PA-RISC driver to try | |
151 | */ | |
152 | int register_parisc_driver(struct parisc_driver *driver) | |
153 | { | |
154 | /* FIXME: we need this because apparently the sti | |
155 | * driver can be registered twice */ | |
156 | if(driver->drv.name) { | |
157 | printk(KERN_WARNING | |
158 | "BUG: skipping previously registered driver %s\n", | |
159 | driver->name); | |
160 | return 1; | |
161 | } | |
162 | ||
163 | if (!driver->probe) { | |
164 | printk(KERN_WARNING | |
165 | "BUG: driver %s has no probe routine\n", | |
166 | driver->name); | |
167 | return 1; | |
168 | } | |
169 | ||
170 | driver->drv.bus = &parisc_bus_type; | |
171 | ||
172 | /* We install our own probe and remove routines */ | |
173 | WARN_ON(driver->drv.probe != NULL); | |
174 | WARN_ON(driver->drv.remove != NULL); | |
175 | ||
1da177e4 LT |
176 | driver->drv.name = driver->name; |
177 | ||
178 | return driver_register(&driver->drv); | |
179 | } | |
180 | EXPORT_SYMBOL(register_parisc_driver); | |
181 | ||
56583747 MW |
182 | |
183 | struct match_count { | |
184 | struct parisc_driver * driver; | |
185 | int count; | |
186 | }; | |
187 | ||
188 | static int match_and_count(struct device * dev, void * data) | |
189 | { | |
190 | struct match_count * m = data; | |
191 | struct parisc_device * pdev = to_parisc_device(dev); | |
192 | ||
193 | if (check_dev(dev)) { | |
194 | if (match_device(m->driver, pdev)) | |
195 | m->count++; | |
196 | } | |
197 | return 0; | |
198 | } | |
199 | ||
1da177e4 LT |
200 | /** |
201 | * count_parisc_driver - count # of devices this driver would match | |
202 | * @driver: the PA-RISC driver to try | |
203 | * | |
204 | * Use by IOMMU support to "guess" the right size IOPdir. | |
205 | * Formula is something like memsize/(num_iommu * entry_size). | |
206 | */ | |
207 | int count_parisc_driver(struct parisc_driver *driver) | |
208 | { | |
56583747 MW |
209 | struct match_count m = { |
210 | .driver = driver, | |
211 | .count = 0, | |
212 | }; | |
1da177e4 | 213 | |
56583747 | 214 | for_each_padev(match_and_count, &m); |
1da177e4 | 215 | |
56583747 | 216 | return m.count; |
1da177e4 LT |
217 | } |
218 | ||
219 | ||
220 | ||
221 | /** | |
222 | * unregister_parisc_driver - Unregister this driver from the list of drivers | |
223 | * @driver: the PA-RISC driver to unregister | |
224 | */ | |
225 | int unregister_parisc_driver(struct parisc_driver *driver) | |
226 | { | |
227 | driver_unregister(&driver->drv); | |
228 | return 0; | |
229 | } | |
230 | EXPORT_SYMBOL(unregister_parisc_driver); | |
231 | ||
56583747 MW |
232 | struct find_data { |
233 | unsigned long hpa; | |
234 | struct parisc_device * dev; | |
235 | }; | |
236 | ||
237 | static int find_device(struct device * dev, void * data) | |
1da177e4 | 238 | { |
56583747 MW |
239 | struct parisc_device * pdev = to_parisc_device(dev); |
240 | struct find_data * d = (struct find_data*)data; | |
241 | ||
242 | if (check_dev(dev)) { | |
243 | if (pdev->hpa.start == d->hpa) { | |
244 | d->dev = pdev; | |
245 | return 1; | |
246 | } | |
1da177e4 | 247 | } |
56583747 MW |
248 | return 0; |
249 | } | |
250 | ||
251 | static struct parisc_device *find_device_by_addr(unsigned long hpa) | |
252 | { | |
253 | struct find_data d = { | |
254 | .hpa = hpa, | |
255 | }; | |
256 | int ret; | |
257 | ||
258 | ret = for_each_padev(find_device, &d); | |
259 | return ret ? d.dev : NULL; | |
1da177e4 LT |
260 | } |
261 | ||
262 | /** | |
263 | * find_pa_parent_type - Find a parent of a specific type | |
264 | * @dev: The device to start searching from | |
265 | * @type: The device type to search for. | |
266 | * | |
267 | * Walks up the device tree looking for a device of the specified type. | |
268 | * If it finds it, it returns it. If not, it returns NULL. | |
269 | */ | |
270 | const struct parisc_device * | |
271 | find_pa_parent_type(const struct parisc_device *padev, int type) | |
272 | { | |
273 | const struct device *dev = &padev->dev; | |
274 | while (dev != &root) { | |
275 | struct parisc_device *candidate = to_parisc_device(dev); | |
276 | if (candidate->id.hw_type == type) | |
277 | return candidate; | |
278 | dev = dev->parent; | |
279 | } | |
280 | ||
281 | return NULL; | |
282 | } | |
283 | ||
284 | #ifdef CONFIG_PCI | |
285 | static inline int is_pci_dev(struct device *dev) | |
286 | { | |
287 | return dev->bus == &pci_bus_type; | |
288 | } | |
289 | #else | |
290 | static inline int is_pci_dev(struct device *dev) | |
291 | { | |
292 | return 0; | |
293 | } | |
294 | #endif | |
295 | ||
296 | /* | |
297 | * get_node_path fills in @path with the firmware path to the device. | |
298 | * Note that if @node is a parisc device, we don't fill in the 'mod' field. | |
299 | * This is because both callers pass the parent and fill in the mod | |
300 | * themselves. If @node is a PCI device, we do fill it in, even though this | |
301 | * is inconsistent. | |
302 | */ | |
303 | static void get_node_path(struct device *dev, struct hardware_path *path) | |
304 | { | |
305 | int i = 5; | |
306 | memset(&path->bc, -1, 6); | |
307 | ||
308 | if (is_pci_dev(dev)) { | |
309 | unsigned int devfn = to_pci_dev(dev)->devfn; | |
310 | path->mod = PCI_FUNC(devfn); | |
311 | path->bc[i--] = PCI_SLOT(devfn); | |
312 | dev = dev->parent; | |
313 | } | |
314 | ||
315 | while (dev != &root) { | |
316 | if (is_pci_dev(dev)) { | |
317 | unsigned int devfn = to_pci_dev(dev)->devfn; | |
318 | path->bc[i--] = PCI_SLOT(devfn) | (PCI_FUNC(devfn)<< 5); | |
319 | } else if (dev->bus == &parisc_bus_type) { | |
320 | path->bc[i--] = to_parisc_device(dev)->hw_path; | |
321 | } | |
322 | dev = dev->parent; | |
323 | } | |
324 | } | |
325 | ||
326 | static char *print_hwpath(struct hardware_path *path, char *output) | |
327 | { | |
328 | int i; | |
329 | for (i = 0; i < 6; i++) { | |
330 | if (path->bc[i] == -1) | |
331 | continue; | |
332 | output += sprintf(output, "%u/", (unsigned char) path->bc[i]); | |
333 | } | |
334 | output += sprintf(output, "%u", (unsigned char) path->mod); | |
335 | return output; | |
336 | } | |
337 | ||
338 | /** | |
339 | * print_pa_hwpath - Returns hardware path for PA devices | |
340 | * dev: The device to return the path for | |
341 | * output: Pointer to a previously-allocated array to place the path in. | |
342 | * | |
343 | * This function fills in the output array with a human-readable path | |
344 | * to a PA device. This string is compatible with that used by PDC, and | |
345 | * may be printed on the outside of the box. | |
346 | */ | |
347 | char *print_pa_hwpath(struct parisc_device *dev, char *output) | |
348 | { | |
349 | struct hardware_path path; | |
350 | ||
351 | get_node_path(dev->dev.parent, &path); | |
352 | path.mod = dev->hw_path; | |
353 | return print_hwpath(&path, output); | |
354 | } | |
355 | EXPORT_SYMBOL(print_pa_hwpath); | |
356 | ||
357 | #if defined(CONFIG_PCI) || defined(CONFIG_ISA) | |
358 | /** | |
359 | * get_pci_node_path - Determines the hardware path for a PCI device | |
360 | * @pdev: The device to return the path for | |
361 | * @path: Pointer to a previously-allocated array to place the path in. | |
362 | * | |
363 | * This function fills in the hardware_path structure with the route to | |
364 | * the specified PCI device. This structure is suitable for passing to | |
365 | * PDC calls. | |
366 | */ | |
367 | void get_pci_node_path(struct pci_dev *pdev, struct hardware_path *path) | |
368 | { | |
369 | get_node_path(&pdev->dev, path); | |
370 | } | |
371 | EXPORT_SYMBOL(get_pci_node_path); | |
372 | ||
373 | /** | |
374 | * print_pci_hwpath - Returns hardware path for PCI devices | |
375 | * dev: The device to return the path for | |
376 | * output: Pointer to a previously-allocated array to place the path in. | |
377 | * | |
378 | * This function fills in the output array with a human-readable path | |
379 | * to a PCI device. This string is compatible with that used by PDC, and | |
380 | * may be printed on the outside of the box. | |
381 | */ | |
382 | char *print_pci_hwpath(struct pci_dev *dev, char *output) | |
383 | { | |
384 | struct hardware_path path; | |
385 | ||
386 | get_pci_node_path(dev, &path); | |
387 | return print_hwpath(&path, output); | |
388 | } | |
389 | EXPORT_SYMBOL(print_pci_hwpath); | |
390 | ||
391 | #endif /* defined(CONFIG_PCI) || defined(CONFIG_ISA) */ | |
392 | ||
393 | static void setup_bus_id(struct parisc_device *padev) | |
394 | { | |
395 | struct hardware_path path; | |
396 | char *output = padev->dev.bus_id; | |
397 | int i; | |
398 | ||
399 | get_node_path(padev->dev.parent, &path); | |
400 | ||
401 | for (i = 0; i < 6; i++) { | |
402 | if (path.bc[i] == -1) | |
403 | continue; | |
404 | output += sprintf(output, "%u:", (unsigned char) path.bc[i]); | |
405 | } | |
406 | sprintf(output, "%u", (unsigned char) padev->hw_path); | |
407 | } | |
408 | ||
409 | struct parisc_device * create_tree_node(char id, struct device *parent) | |
410 | { | |
cb6fc18e | 411 | struct parisc_device *dev = kzalloc(sizeof(*dev), GFP_KERNEL); |
1da177e4 LT |
412 | if (!dev) |
413 | return NULL; | |
414 | ||
1da177e4 LT |
415 | dev->hw_path = id; |
416 | dev->id.hw_type = HPHW_FAULTY; | |
417 | ||
418 | dev->dev.parent = parent; | |
419 | setup_bus_id(dev); | |
420 | ||
421 | dev->dev.bus = &parisc_bus_type; | |
422 | dev->dma_mask = 0xffffffffUL; /* PARISC devices are 32-bit */ | |
423 | ||
424 | /* make the generic dma mask a pointer to the parisc one */ | |
425 | dev->dev.dma_mask = &dev->dma_mask; | |
426 | dev->dev.coherent_dma_mask = dev->dma_mask; | |
ba0e427f | 427 | if (device_register(&dev->dev)) { |
1070c965 MW |
428 | kfree(dev); |
429 | return NULL; | |
430 | } | |
1da177e4 LT |
431 | |
432 | return dev; | |
433 | } | |
434 | ||
56583747 MW |
435 | struct match_id_data { |
436 | char id; | |
437 | struct parisc_device * dev; | |
438 | }; | |
439 | ||
440 | static int match_by_id(struct device * dev, void * data) | |
441 | { | |
442 | struct parisc_device * pdev = to_parisc_device(dev); | |
443 | struct match_id_data * d = data; | |
444 | ||
445 | if (pdev->hw_path == d->id) { | |
446 | d->dev = pdev; | |
447 | return 1; | |
448 | } | |
449 | return 0; | |
450 | } | |
451 | ||
1da177e4 LT |
452 | /** |
453 | * alloc_tree_node - returns a device entry in the iotree | |
454 | * @parent: the parent node in the tree | |
455 | * @id: the element of the module path for this entry | |
456 | * | |
457 | * Checks all the children of @parent for a matching @id. If none | |
458 | * found, it allocates a new device and returns it. | |
459 | */ | |
460 | static struct parisc_device * alloc_tree_node(struct device *parent, char id) | |
461 | { | |
56583747 MW |
462 | struct match_id_data d = { |
463 | .id = id, | |
464 | }; | |
465 | if (device_for_each_child(parent, &d, match_by_id)) | |
466 | return d.dev; | |
467 | else | |
468 | return create_tree_node(id, parent); | |
1da177e4 LT |
469 | } |
470 | ||
471 | static struct parisc_device *create_parisc_device(struct hardware_path *modpath) | |
472 | { | |
473 | int i; | |
474 | struct device *parent = &root; | |
475 | for (i = 0; i < 6; i++) { | |
476 | if (modpath->bc[i] == -1) | |
477 | continue; | |
478 | parent = &alloc_tree_node(parent, modpath->bc[i])->dev; | |
479 | } | |
480 | return alloc_tree_node(parent, modpath->mod); | |
481 | } | |
482 | ||
483 | struct parisc_device * | |
484 | alloc_pa_dev(unsigned long hpa, struct hardware_path *mod_path) | |
485 | { | |
486 | int status; | |
487 | unsigned long bytecnt; | |
488 | u8 iodc_data[32]; | |
489 | struct parisc_device *dev; | |
490 | const char *name; | |
491 | ||
492 | /* Check to make sure this device has not already been added - Ryan */ | |
493 | if (find_device_by_addr(hpa) != NULL) | |
494 | return NULL; | |
495 | ||
496 | status = pdc_iodc_read(&bytecnt, hpa, 0, &iodc_data, 32); | |
497 | if (status != PDC_OK) | |
498 | return NULL; | |
499 | ||
500 | dev = create_parisc_device(mod_path); | |
501 | if (dev->id.hw_type != HPHW_FAULTY) { | |
4269b0d3 MW |
502 | printk(KERN_ERR "Two devices have hardware path [%s]. " |
503 | "IODC data for second device: " | |
504 | "%02x%02x%02x%02x%02x%02x\n" | |
505 | "Rearranging GSC cards sometimes helps\n", | |
506 | parisc_pathname(dev), iodc_data[0], iodc_data[1], | |
507 | iodc_data[3], iodc_data[4], iodc_data[5], iodc_data[6]); | |
1da177e4 LT |
508 | return NULL; |
509 | } | |
510 | ||
511 | dev->id.hw_type = iodc_data[3] & 0x1f; | |
512 | dev->id.hversion = (iodc_data[0] << 4) | ((iodc_data[1] & 0xf0) >> 4); | |
513 | dev->id.hversion_rev = iodc_data[1] & 0x0f; | |
514 | dev->id.sversion = ((iodc_data[4] & 0x0f) << 16) | | |
515 | (iodc_data[5] << 8) | iodc_data[6]; | |
56583747 MW |
516 | dev->hpa.name = parisc_pathname(dev); |
517 | dev->hpa.start = hpa; | |
a01c8cb1 MW |
518 | /* This is awkward. The STI spec says that gfx devices may occupy |
519 | * 32MB or 64MB. Unfortunately, we don't know how to tell whether | |
520 | * it's the former or the latter. Assumptions either way can hurt us. | |
521 | */ | |
522 | if (hpa == 0xf4000000 || hpa == 0xf8000000) { | |
523 | dev->hpa.end = hpa + 0x03ffffff; | |
524 | } else if (hpa == 0xf6000000 || hpa == 0xfa000000) { | |
56583747 MW |
525 | dev->hpa.end = hpa + 0x01ffffff; |
526 | } else { | |
527 | dev->hpa.end = hpa + 0xfff; | |
528 | } | |
529 | dev->hpa.flags = IORESOURCE_MEM; | |
1da177e4 LT |
530 | name = parisc_hardware_description(&dev->id); |
531 | if (name) { | |
532 | strlcpy(dev->name, name, sizeof(dev->name)); | |
533 | } | |
534 | ||
56583747 MW |
535 | /* Silently fail things like mouse ports which are subsumed within |
536 | * the keyboard controller | |
537 | */ | |
538 | if ((hpa & 0xfff) == 0 && insert_resource(&iomem_resource, &dev->hpa)) | |
539 | printk("Unable to claim HPA %lx for device %s\n", | |
540 | hpa, name); | |
541 | ||
1da177e4 LT |
542 | return dev; |
543 | } | |
544 | ||
545 | static int parisc_generic_match(struct device *dev, struct device_driver *drv) | |
546 | { | |
547 | return match_device(to_parisc_driver(drv), to_parisc_device(dev)); | |
548 | } | |
549 | ||
550 | #define pa_dev_attr(name, field, format_string) \ | |
ff381d22 | 551 | static ssize_t name##_show(struct device *dev, struct device_attribute *attr, char *buf) \ |
1da177e4 LT |
552 | { \ |
553 | struct parisc_device *padev = to_parisc_device(dev); \ | |
554 | return sprintf(buf, format_string, padev->field); \ | |
555 | } | |
556 | ||
557 | #define pa_dev_attr_id(field, format) pa_dev_attr(field, id.field, format) | |
558 | ||
559 | pa_dev_attr(irq, irq, "%u\n"); | |
560 | pa_dev_attr_id(hw_type, "0x%02x\n"); | |
561 | pa_dev_attr(rev, id.hversion_rev, "0x%x\n"); | |
562 | pa_dev_attr_id(hversion, "0x%03x\n"); | |
563 | pa_dev_attr_id(sversion, "0x%05x\n"); | |
564 | ||
565 | static struct device_attribute parisc_device_attrs[] = { | |
566 | __ATTR_RO(irq), | |
567 | __ATTR_RO(hw_type), | |
568 | __ATTR_RO(rev), | |
569 | __ATTR_RO(hversion), | |
570 | __ATTR_RO(sversion), | |
571 | __ATTR_NULL, | |
572 | }; | |
573 | ||
574 | struct bus_type parisc_bus_type = { | |
575 | .name = "parisc", | |
576 | .match = parisc_generic_match, | |
577 | .dev_attrs = parisc_device_attrs, | |
ad3ed31c RK |
578 | .probe = parisc_driver_probe, |
579 | .remove = parisc_driver_remove, | |
1da177e4 LT |
580 | }; |
581 | ||
582 | /** | |
583 | * register_parisc_device - Locate a driver to manage this device. | |
584 | * @dev: The parisc device. | |
585 | * | |
586 | * Search the driver list for a driver that is willing to manage | |
587 | * this device. | |
588 | */ | |
589 | int register_parisc_device(struct parisc_device *dev) | |
590 | { | |
591 | if (!dev) | |
592 | return 0; | |
593 | ||
594 | if (dev->driver) | |
595 | return 1; | |
596 | ||
597 | return 0; | |
598 | } | |
599 | ||
600 | /** | |
601 | * match_pci_device - Matches a pci device against a given hardware path | |
602 | * entry. | |
603 | * @dev: the generic device (known to be contained by a pci_dev). | |
604 | * @index: the current BC index | |
605 | * @modpath: the hardware path. | |
606 | * @return: true if the device matches the hardware path. | |
607 | */ | |
608 | static int match_pci_device(struct device *dev, int index, | |
609 | struct hardware_path *modpath) | |
610 | { | |
611 | struct pci_dev *pdev = to_pci_dev(dev); | |
612 | int id; | |
613 | ||
614 | if (index == 5) { | |
615 | /* we are at the end of the path, and on the actual device */ | |
616 | unsigned int devfn = pdev->devfn; | |
617 | return ((modpath->bc[5] == PCI_SLOT(devfn)) && | |
618 | (modpath->mod == PCI_FUNC(devfn))); | |
619 | } | |
620 | ||
621 | id = PCI_SLOT(pdev->devfn) | (PCI_FUNC(pdev->devfn) << 5); | |
622 | return (modpath->bc[index] == id); | |
623 | } | |
624 | ||
625 | /** | |
626 | * match_parisc_device - Matches a parisc device against a given hardware | |
627 | * path entry. | |
628 | * @dev: the generic device (known to be contained by a parisc_device). | |
629 | * @index: the current BC index | |
630 | * @modpath: the hardware path. | |
631 | * @return: true if the device matches the hardware path. | |
632 | */ | |
633 | static int match_parisc_device(struct device *dev, int index, | |
634 | struct hardware_path *modpath) | |
635 | { | |
636 | struct parisc_device *curr = to_parisc_device(dev); | |
637 | char id = (index == 6) ? modpath->mod : modpath->bc[index]; | |
638 | ||
639 | return (curr->hw_path == id); | |
640 | } | |
641 | ||
56583747 MW |
642 | struct parse_tree_data { |
643 | int index; | |
644 | struct hardware_path * modpath; | |
645 | struct device * dev; | |
646 | }; | |
647 | ||
648 | static int check_parent(struct device * dev, void * data) | |
649 | { | |
650 | struct parse_tree_data * d = data; | |
651 | ||
652 | if (check_dev(dev)) { | |
653 | if (dev->bus == &parisc_bus_type) { | |
654 | if (match_parisc_device(dev, d->index, d->modpath)) | |
655 | d->dev = dev; | |
656 | } else if (is_pci_dev(dev)) { | |
657 | if (match_pci_device(dev, d->index, d->modpath)) | |
658 | d->dev = dev; | |
659 | } else if (dev->bus == NULL) { | |
660 | /* we are on a bus bridge */ | |
661 | struct device *new = parse_tree_node(dev, d->index, d->modpath); | |
662 | if (new) | |
663 | d->dev = new; | |
664 | } | |
665 | } | |
666 | return d->dev != NULL; | |
667 | } | |
668 | ||
1da177e4 LT |
669 | /** |
670 | * parse_tree_node - returns a device entry in the iotree | |
671 | * @parent: the parent node in the tree | |
672 | * @index: the current BC index | |
673 | * @modpath: the hardware_path struct to match a device against | |
674 | * @return: The corresponding device if found, NULL otherwise. | |
675 | * | |
676 | * Checks all the children of @parent for a matching @id. If none | |
677 | * found, it returns NULL. | |
678 | */ | |
679 | static struct device * | |
680 | parse_tree_node(struct device *parent, int index, struct hardware_path *modpath) | |
681 | { | |
56583747 MW |
682 | struct parse_tree_data d = { |
683 | .index = index, | |
684 | .modpath = modpath, | |
685 | }; | |
1da177e4 | 686 | |
56583747 MW |
687 | struct recurse_struct recurse_data = { |
688 | .obj = &d, | |
689 | .fn = check_parent, | |
690 | }; | |
691 | ||
692 | device_for_each_child(parent, &recurse_data, descend_children); | |
693 | return d.dev; | |
1da177e4 LT |
694 | } |
695 | ||
696 | /** | |
697 | * hwpath_to_device - Finds the generic device corresponding to a given hardware path. | |
698 | * @modpath: the hardware path. | |
699 | * @return: The target device, NULL if not found. | |
700 | */ | |
701 | struct device *hwpath_to_device(struct hardware_path *modpath) | |
702 | { | |
703 | int i; | |
704 | struct device *parent = &root; | |
705 | for (i = 0; i < 6; i++) { | |
706 | if (modpath->bc[i] == -1) | |
707 | continue; | |
708 | parent = parse_tree_node(parent, i, modpath); | |
709 | if (!parent) | |
710 | return NULL; | |
711 | } | |
712 | if (is_pci_dev(parent)) /* pci devices already parse MOD */ | |
713 | return parent; | |
714 | else | |
715 | return parse_tree_node(parent, 6, modpath); | |
716 | } | |
717 | EXPORT_SYMBOL(hwpath_to_device); | |
718 | ||
719 | /** | |
720 | * device_to_hwpath - Populates the hwpath corresponding to the given device. | |
721 | * @param dev the target device | |
722 | * @param path pointer to a previously allocated hwpath struct to be filled in | |
723 | */ | |
724 | void device_to_hwpath(struct device *dev, struct hardware_path *path) | |
725 | { | |
726 | struct parisc_device *padev; | |
727 | if (dev->bus == &parisc_bus_type) { | |
728 | padev = to_parisc_device(dev); | |
729 | get_node_path(dev->parent, path); | |
730 | path->mod = padev->hw_path; | |
731 | } else if (is_pci_dev(dev)) { | |
732 | get_node_path(dev, path); | |
733 | } | |
734 | } | |
735 | EXPORT_SYMBOL(device_to_hwpath); | |
736 | ||
737 | #define BC_PORT_MASK 0x8 | |
738 | #define BC_LOWER_PORT 0x8 | |
739 | ||
740 | #define BUS_CONVERTER(dev) \ | |
741 | ((dev->id.hw_type == HPHW_IOA) || (dev->id.hw_type == HPHW_BCPORT)) | |
742 | ||
743 | #define IS_LOWER_PORT(dev) \ | |
56583747 | 744 | ((gsc_readl(dev->hpa.start + offsetof(struct bc_module, io_status)) \ |
1da177e4 LT |
745 | & BC_PORT_MASK) == BC_LOWER_PORT) |
746 | ||
747 | #define MAX_NATIVE_DEVICES 64 | |
748 | #define NATIVE_DEVICE_OFFSET 0x1000 | |
749 | ||
750 | #define FLEX_MASK F_EXTEND(0xfffc0000) | |
751 | #define IO_IO_LOW offsetof(struct bc_module, io_io_low) | |
752 | #define IO_IO_HIGH offsetof(struct bc_module, io_io_high) | |
56583747 MW |
753 | #define READ_IO_IO_LOW(dev) (unsigned long)(signed int)gsc_readl(dev->hpa.start + IO_IO_LOW) |
754 | #define READ_IO_IO_HIGH(dev) (unsigned long)(signed int)gsc_readl(dev->hpa.start + IO_IO_HIGH) | |
1da177e4 LT |
755 | |
756 | static void walk_native_bus(unsigned long io_io_low, unsigned long io_io_high, | |
757 | struct device *parent); | |
758 | ||
759 | void walk_lower_bus(struct parisc_device *dev) | |
760 | { | |
761 | unsigned long io_io_low, io_io_high; | |
762 | ||
56583747 | 763 | if (!BUS_CONVERTER(dev) || IS_LOWER_PORT(dev)) |
1da177e4 LT |
764 | return; |
765 | ||
56583747 | 766 | if (dev->id.hw_type == HPHW_IOA) { |
1da177e4 LT |
767 | io_io_low = (unsigned long)(signed int)(READ_IO_IO_LOW(dev) << 16); |
768 | io_io_high = io_io_low + MAX_NATIVE_DEVICES * NATIVE_DEVICE_OFFSET; | |
769 | } else { | |
770 | io_io_low = (READ_IO_IO_LOW(dev) + ~FLEX_MASK) & FLEX_MASK; | |
771 | io_io_high = (READ_IO_IO_HIGH(dev)+ ~FLEX_MASK) & FLEX_MASK; | |
772 | } | |
773 | ||
774 | walk_native_bus(io_io_low, io_io_high, &dev->dev); | |
775 | } | |
776 | ||
777 | /** | |
778 | * walk_native_bus -- Probe a bus for devices | |
779 | * @io_io_low: Base address of this bus. | |
780 | * @io_io_high: Last address of this bus. | |
781 | * @parent: The parent bus device. | |
782 | * | |
783 | * A native bus (eg Runway or GSC) may have up to 64 devices on it, | |
784 | * spaced at intervals of 0x1000 bytes. PDC may not inform us of these | |
785 | * devices, so we have to probe for them. Unfortunately, we may find | |
786 | * devices which are not physically connected (such as extra serial & | |
787 | * keyboard ports). This problem is not yet solved. | |
788 | */ | |
789 | static void walk_native_bus(unsigned long io_io_low, unsigned long io_io_high, | |
790 | struct device *parent) | |
791 | { | |
792 | int i, devices_found = 0; | |
793 | unsigned long hpa = io_io_low; | |
794 | struct hardware_path path; | |
795 | ||
796 | get_node_path(parent, &path); | |
797 | do { | |
798 | for(i = 0; i < MAX_NATIVE_DEVICES; i++, hpa += NATIVE_DEVICE_OFFSET) { | |
799 | struct parisc_device *dev; | |
800 | ||
801 | /* Was the device already added by Firmware? */ | |
802 | dev = find_device_by_addr(hpa); | |
803 | if (!dev) { | |
804 | path.mod = i; | |
805 | dev = alloc_pa_dev(hpa, &path); | |
806 | if (!dev) | |
807 | continue; | |
808 | ||
809 | register_parisc_device(dev); | |
810 | devices_found++; | |
811 | } | |
812 | walk_lower_bus(dev); | |
813 | } | |
814 | } while(!devices_found && hpa < io_io_high); | |
815 | } | |
816 | ||
817 | #define CENTRAL_BUS_ADDR F_EXTEND(0xfff80000) | |
818 | ||
819 | /** | |
820 | * walk_central_bus - Find devices attached to the central bus | |
821 | * | |
822 | * PDC doesn't tell us about all devices in the system. This routine | |
823 | * finds devices connected to the central bus. | |
824 | */ | |
825 | void walk_central_bus(void) | |
826 | { | |
827 | walk_native_bus(CENTRAL_BUS_ADDR, | |
828 | CENTRAL_BUS_ADDR + (MAX_NATIVE_DEVICES * NATIVE_DEVICE_OFFSET), | |
829 | &root); | |
830 | } | |
831 | ||
832 | static void print_parisc_device(struct parisc_device *dev) | |
833 | { | |
834 | char hw_path[64]; | |
835 | static int count; | |
836 | ||
837 | print_pa_hwpath(dev, hw_path); | |
838 | printk(KERN_INFO "%d. %s at 0x%lx [%s] { %d, 0x%x, 0x%.3x, 0x%.5x }", | |
56583747 | 839 | ++count, dev->name, dev->hpa.start, hw_path, dev->id.hw_type, |
1da177e4 LT |
840 | dev->id.hversion_rev, dev->id.hversion, dev->id.sversion); |
841 | ||
842 | if (dev->num_addrs) { | |
843 | int k; | |
a01c8cb1 | 844 | printk(", additional addresses: "); |
1da177e4 LT |
845 | for (k = 0; k < dev->num_addrs; k++) |
846 | printk("0x%lx ", dev->addr[k]); | |
847 | } | |
848 | printk("\n"); | |
849 | } | |
850 | ||
851 | /** | |
852 | * init_parisc_bus - Some preparation to be done before inventory | |
853 | */ | |
854 | void init_parisc_bus(void) | |
855 | { | |
ba0e427f | 856 | if (bus_register(&parisc_bus_type)) |
1070c965 | 857 | panic("Could not register PA-RISC bus type\n"); |
ba0e427f | 858 | if (device_register(&root)) |
1070c965 | 859 | panic("Could not register PA-RISC root device\n"); |
1da177e4 LT |
860 | get_device(&root); |
861 | } | |
862 | ||
56583747 MW |
863 | |
864 | static int print_one_device(struct device * dev, void * data) | |
865 | { | |
866 | struct parisc_device * pdev = to_parisc_device(dev); | |
867 | ||
868 | if (check_dev(dev)) | |
869 | print_parisc_device(pdev); | |
870 | return 0; | |
871 | } | |
872 | ||
1da177e4 LT |
873 | /** |
874 | * print_parisc_devices - Print out a list of devices found in this system | |
875 | */ | |
876 | void print_parisc_devices(void) | |
877 | { | |
56583747 | 878 | for_each_padev(print_one_device, NULL); |
1da177e4 | 879 | } |