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 = { | |
90f67130 | 46 | .init_name = "parisc", |
1da177e4 LT |
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; | |
90f67130 KS |
396 | char name[20]; |
397 | char *output = name; | |
1da177e4 LT |
398 | int i; |
399 | ||
400 | get_node_path(padev->dev.parent, &path); | |
401 | ||
402 | for (i = 0; i < 6; i++) { | |
403 | if (path.bc[i] == -1) | |
404 | continue; | |
405 | output += sprintf(output, "%u:", (unsigned char) path.bc[i]); | |
406 | } | |
407 | sprintf(output, "%u", (unsigned char) padev->hw_path); | |
90f67130 | 408 | dev_set_name(&padev->dev, name); |
1da177e4 LT |
409 | } |
410 | ||
411 | struct parisc_device * create_tree_node(char id, struct device *parent) | |
412 | { | |
cb6fc18e | 413 | struct parisc_device *dev = kzalloc(sizeof(*dev), GFP_KERNEL); |
1da177e4 LT |
414 | if (!dev) |
415 | return NULL; | |
416 | ||
1da177e4 LT |
417 | dev->hw_path = id; |
418 | dev->id.hw_type = HPHW_FAULTY; | |
419 | ||
420 | dev->dev.parent = parent; | |
421 | setup_bus_id(dev); | |
422 | ||
423 | dev->dev.bus = &parisc_bus_type; | |
424 | dev->dma_mask = 0xffffffffUL; /* PARISC devices are 32-bit */ | |
425 | ||
426 | /* make the generic dma mask a pointer to the parisc one */ | |
427 | dev->dev.dma_mask = &dev->dma_mask; | |
428 | dev->dev.coherent_dma_mask = dev->dma_mask; | |
ba0e427f | 429 | if (device_register(&dev->dev)) { |
1070c965 MW |
430 | kfree(dev); |
431 | return NULL; | |
432 | } | |
1da177e4 LT |
433 | |
434 | return dev; | |
435 | } | |
436 | ||
56583747 MW |
437 | struct match_id_data { |
438 | char id; | |
439 | struct parisc_device * dev; | |
440 | }; | |
441 | ||
442 | static int match_by_id(struct device * dev, void * data) | |
443 | { | |
444 | struct parisc_device * pdev = to_parisc_device(dev); | |
445 | struct match_id_data * d = data; | |
446 | ||
447 | if (pdev->hw_path == d->id) { | |
448 | d->dev = pdev; | |
449 | return 1; | |
450 | } | |
451 | return 0; | |
452 | } | |
453 | ||
1da177e4 LT |
454 | /** |
455 | * alloc_tree_node - returns a device entry in the iotree | |
456 | * @parent: the parent node in the tree | |
457 | * @id: the element of the module path for this entry | |
458 | * | |
459 | * Checks all the children of @parent for a matching @id. If none | |
460 | * found, it allocates a new device and returns it. | |
461 | */ | |
462 | static struct parisc_device * alloc_tree_node(struct device *parent, char id) | |
463 | { | |
56583747 MW |
464 | struct match_id_data d = { |
465 | .id = id, | |
466 | }; | |
467 | if (device_for_each_child(parent, &d, match_by_id)) | |
468 | return d.dev; | |
469 | else | |
470 | return create_tree_node(id, parent); | |
1da177e4 LT |
471 | } |
472 | ||
473 | static struct parisc_device *create_parisc_device(struct hardware_path *modpath) | |
474 | { | |
475 | int i; | |
476 | struct device *parent = &root; | |
477 | for (i = 0; i < 6; i++) { | |
478 | if (modpath->bc[i] == -1) | |
479 | continue; | |
480 | parent = &alloc_tree_node(parent, modpath->bc[i])->dev; | |
481 | } | |
482 | return alloc_tree_node(parent, modpath->mod); | |
483 | } | |
484 | ||
485 | struct parisc_device * | |
486 | alloc_pa_dev(unsigned long hpa, struct hardware_path *mod_path) | |
487 | { | |
488 | int status; | |
489 | unsigned long bytecnt; | |
490 | u8 iodc_data[32]; | |
491 | struct parisc_device *dev; | |
492 | const char *name; | |
493 | ||
494 | /* Check to make sure this device has not already been added - Ryan */ | |
495 | if (find_device_by_addr(hpa) != NULL) | |
496 | return NULL; | |
497 | ||
498 | status = pdc_iodc_read(&bytecnt, hpa, 0, &iodc_data, 32); | |
499 | if (status != PDC_OK) | |
500 | return NULL; | |
501 | ||
502 | dev = create_parisc_device(mod_path); | |
503 | if (dev->id.hw_type != HPHW_FAULTY) { | |
4269b0d3 MW |
504 | printk(KERN_ERR "Two devices have hardware path [%s]. " |
505 | "IODC data for second device: " | |
506 | "%02x%02x%02x%02x%02x%02x\n" | |
507 | "Rearranging GSC cards sometimes helps\n", | |
508 | parisc_pathname(dev), iodc_data[0], iodc_data[1], | |
509 | iodc_data[3], iodc_data[4], iodc_data[5], iodc_data[6]); | |
1da177e4 LT |
510 | return NULL; |
511 | } | |
512 | ||
513 | dev->id.hw_type = iodc_data[3] & 0x1f; | |
514 | dev->id.hversion = (iodc_data[0] << 4) | ((iodc_data[1] & 0xf0) >> 4); | |
515 | dev->id.hversion_rev = iodc_data[1] & 0x0f; | |
516 | dev->id.sversion = ((iodc_data[4] & 0x0f) << 16) | | |
517 | (iodc_data[5] << 8) | iodc_data[6]; | |
56583747 MW |
518 | dev->hpa.name = parisc_pathname(dev); |
519 | dev->hpa.start = hpa; | |
a01c8cb1 MW |
520 | /* This is awkward. The STI spec says that gfx devices may occupy |
521 | * 32MB or 64MB. Unfortunately, we don't know how to tell whether | |
522 | * it's the former or the latter. Assumptions either way can hurt us. | |
523 | */ | |
524 | if (hpa == 0xf4000000 || hpa == 0xf8000000) { | |
525 | dev->hpa.end = hpa + 0x03ffffff; | |
526 | } else if (hpa == 0xf6000000 || hpa == 0xfa000000) { | |
56583747 MW |
527 | dev->hpa.end = hpa + 0x01ffffff; |
528 | } else { | |
529 | dev->hpa.end = hpa + 0xfff; | |
530 | } | |
531 | dev->hpa.flags = IORESOURCE_MEM; | |
1da177e4 LT |
532 | name = parisc_hardware_description(&dev->id); |
533 | if (name) { | |
534 | strlcpy(dev->name, name, sizeof(dev->name)); | |
535 | } | |
536 | ||
56583747 MW |
537 | /* Silently fail things like mouse ports which are subsumed within |
538 | * the keyboard controller | |
539 | */ | |
540 | if ((hpa & 0xfff) == 0 && insert_resource(&iomem_resource, &dev->hpa)) | |
541 | printk("Unable to claim HPA %lx for device %s\n", | |
542 | hpa, name); | |
543 | ||
1da177e4 LT |
544 | return dev; |
545 | } | |
546 | ||
547 | static int parisc_generic_match(struct device *dev, struct device_driver *drv) | |
548 | { | |
549 | return match_device(to_parisc_driver(drv), to_parisc_device(dev)); | |
550 | } | |
551 | ||
552 | #define pa_dev_attr(name, field, format_string) \ | |
ff381d22 | 553 | static ssize_t name##_show(struct device *dev, struct device_attribute *attr, char *buf) \ |
1da177e4 LT |
554 | { \ |
555 | struct parisc_device *padev = to_parisc_device(dev); \ | |
556 | return sprintf(buf, format_string, padev->field); \ | |
557 | } | |
558 | ||
559 | #define pa_dev_attr_id(field, format) pa_dev_attr(field, id.field, format) | |
560 | ||
561 | pa_dev_attr(irq, irq, "%u\n"); | |
562 | pa_dev_attr_id(hw_type, "0x%02x\n"); | |
563 | pa_dev_attr(rev, id.hversion_rev, "0x%x\n"); | |
564 | pa_dev_attr_id(hversion, "0x%03x\n"); | |
565 | pa_dev_attr_id(sversion, "0x%05x\n"); | |
566 | ||
a04b0605 KM |
567 | static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) |
568 | { | |
569 | struct parisc_device *padev = to_parisc_device(dev); | |
570 | struct parisc_device_id *id = &padev->id; | |
571 | ||
572 | return sprintf(buf, "parisc:t%02Xhv%04Xrev%02Xsv%08X\n", | |
573 | (u8)id->hw_type, (u16)id->hversion, (u8)id->hversion_rev, | |
574 | (u32)id->sversion); | |
575 | } | |
576 | ||
1da177e4 LT |
577 | static struct device_attribute parisc_device_attrs[] = { |
578 | __ATTR_RO(irq), | |
579 | __ATTR_RO(hw_type), | |
580 | __ATTR_RO(rev), | |
581 | __ATTR_RO(hversion), | |
582 | __ATTR_RO(sversion), | |
a04b0605 | 583 | __ATTR_RO(modalias), |
1da177e4 LT |
584 | __ATTR_NULL, |
585 | }; | |
586 | ||
587 | struct bus_type parisc_bus_type = { | |
588 | .name = "parisc", | |
589 | .match = parisc_generic_match, | |
590 | .dev_attrs = parisc_device_attrs, | |
ad3ed31c RK |
591 | .probe = parisc_driver_probe, |
592 | .remove = parisc_driver_remove, | |
1da177e4 LT |
593 | }; |
594 | ||
595 | /** | |
596 | * register_parisc_device - Locate a driver to manage this device. | |
597 | * @dev: The parisc device. | |
598 | * | |
599 | * Search the driver list for a driver that is willing to manage | |
600 | * this device. | |
601 | */ | |
602 | int register_parisc_device(struct parisc_device *dev) | |
603 | { | |
604 | if (!dev) | |
605 | return 0; | |
606 | ||
607 | if (dev->driver) | |
608 | return 1; | |
609 | ||
610 | return 0; | |
611 | } | |
612 | ||
613 | /** | |
614 | * match_pci_device - Matches a pci device against a given hardware path | |
615 | * entry. | |
616 | * @dev: the generic device (known to be contained by a pci_dev). | |
617 | * @index: the current BC index | |
618 | * @modpath: the hardware path. | |
619 | * @return: true if the device matches the hardware path. | |
620 | */ | |
621 | static int match_pci_device(struct device *dev, int index, | |
622 | struct hardware_path *modpath) | |
623 | { | |
624 | struct pci_dev *pdev = to_pci_dev(dev); | |
625 | int id; | |
626 | ||
627 | if (index == 5) { | |
628 | /* we are at the end of the path, and on the actual device */ | |
629 | unsigned int devfn = pdev->devfn; | |
630 | return ((modpath->bc[5] == PCI_SLOT(devfn)) && | |
631 | (modpath->mod == PCI_FUNC(devfn))); | |
632 | } | |
633 | ||
634 | id = PCI_SLOT(pdev->devfn) | (PCI_FUNC(pdev->devfn) << 5); | |
635 | return (modpath->bc[index] == id); | |
636 | } | |
637 | ||
638 | /** | |
639 | * match_parisc_device - Matches a parisc device against a given hardware | |
640 | * path entry. | |
641 | * @dev: the generic device (known to be contained by a parisc_device). | |
642 | * @index: the current BC index | |
643 | * @modpath: the hardware path. | |
644 | * @return: true if the device matches the hardware path. | |
645 | */ | |
646 | static int match_parisc_device(struct device *dev, int index, | |
647 | struct hardware_path *modpath) | |
648 | { | |
649 | struct parisc_device *curr = to_parisc_device(dev); | |
650 | char id = (index == 6) ? modpath->mod : modpath->bc[index]; | |
651 | ||
652 | return (curr->hw_path == id); | |
653 | } | |
654 | ||
56583747 MW |
655 | struct parse_tree_data { |
656 | int index; | |
657 | struct hardware_path * modpath; | |
658 | struct device * dev; | |
659 | }; | |
660 | ||
661 | static int check_parent(struct device * dev, void * data) | |
662 | { | |
663 | struct parse_tree_data * d = data; | |
664 | ||
665 | if (check_dev(dev)) { | |
666 | if (dev->bus == &parisc_bus_type) { | |
667 | if (match_parisc_device(dev, d->index, d->modpath)) | |
668 | d->dev = dev; | |
669 | } else if (is_pci_dev(dev)) { | |
670 | if (match_pci_device(dev, d->index, d->modpath)) | |
671 | d->dev = dev; | |
672 | } else if (dev->bus == NULL) { | |
673 | /* we are on a bus bridge */ | |
674 | struct device *new = parse_tree_node(dev, d->index, d->modpath); | |
675 | if (new) | |
676 | d->dev = new; | |
677 | } | |
678 | } | |
679 | return d->dev != NULL; | |
680 | } | |
681 | ||
1da177e4 LT |
682 | /** |
683 | * parse_tree_node - returns a device entry in the iotree | |
684 | * @parent: the parent node in the tree | |
685 | * @index: the current BC index | |
686 | * @modpath: the hardware_path struct to match a device against | |
687 | * @return: The corresponding device if found, NULL otherwise. | |
688 | * | |
689 | * Checks all the children of @parent for a matching @id. If none | |
690 | * found, it returns NULL. | |
691 | */ | |
692 | static struct device * | |
693 | parse_tree_node(struct device *parent, int index, struct hardware_path *modpath) | |
694 | { | |
56583747 MW |
695 | struct parse_tree_data d = { |
696 | .index = index, | |
697 | .modpath = modpath, | |
698 | }; | |
1da177e4 | 699 | |
56583747 MW |
700 | struct recurse_struct recurse_data = { |
701 | .obj = &d, | |
702 | .fn = check_parent, | |
703 | }; | |
704 | ||
3ee8f5e2 HD |
705 | if (device_for_each_child(parent, &recurse_data, descend_children)) |
706 | /* nothing */; | |
707 | ||
56583747 | 708 | return d.dev; |
1da177e4 LT |
709 | } |
710 | ||
711 | /** | |
712 | * hwpath_to_device - Finds the generic device corresponding to a given hardware path. | |
713 | * @modpath: the hardware path. | |
714 | * @return: The target device, NULL if not found. | |
715 | */ | |
716 | struct device *hwpath_to_device(struct hardware_path *modpath) | |
717 | { | |
718 | int i; | |
719 | struct device *parent = &root; | |
720 | for (i = 0; i < 6; i++) { | |
721 | if (modpath->bc[i] == -1) | |
722 | continue; | |
723 | parent = parse_tree_node(parent, i, modpath); | |
724 | if (!parent) | |
725 | return NULL; | |
726 | } | |
727 | if (is_pci_dev(parent)) /* pci devices already parse MOD */ | |
728 | return parent; | |
729 | else | |
730 | return parse_tree_node(parent, 6, modpath); | |
731 | } | |
732 | EXPORT_SYMBOL(hwpath_to_device); | |
733 | ||
734 | /** | |
735 | * device_to_hwpath - Populates the hwpath corresponding to the given device. | |
736 | * @param dev the target device | |
737 | * @param path pointer to a previously allocated hwpath struct to be filled in | |
738 | */ | |
739 | void device_to_hwpath(struct device *dev, struct hardware_path *path) | |
740 | { | |
741 | struct parisc_device *padev; | |
742 | if (dev->bus == &parisc_bus_type) { | |
743 | padev = to_parisc_device(dev); | |
744 | get_node_path(dev->parent, path); | |
745 | path->mod = padev->hw_path; | |
746 | } else if (is_pci_dev(dev)) { | |
747 | get_node_path(dev, path); | |
748 | } | |
749 | } | |
750 | EXPORT_SYMBOL(device_to_hwpath); | |
751 | ||
752 | #define BC_PORT_MASK 0x8 | |
753 | #define BC_LOWER_PORT 0x8 | |
754 | ||
755 | #define BUS_CONVERTER(dev) \ | |
756 | ((dev->id.hw_type == HPHW_IOA) || (dev->id.hw_type == HPHW_BCPORT)) | |
757 | ||
758 | #define IS_LOWER_PORT(dev) \ | |
56583747 | 759 | ((gsc_readl(dev->hpa.start + offsetof(struct bc_module, io_status)) \ |
1da177e4 LT |
760 | & BC_PORT_MASK) == BC_LOWER_PORT) |
761 | ||
762 | #define MAX_NATIVE_DEVICES 64 | |
763 | #define NATIVE_DEVICE_OFFSET 0x1000 | |
764 | ||
765 | #define FLEX_MASK F_EXTEND(0xfffc0000) | |
766 | #define IO_IO_LOW offsetof(struct bc_module, io_io_low) | |
767 | #define IO_IO_HIGH offsetof(struct bc_module, io_io_high) | |
56583747 MW |
768 | #define READ_IO_IO_LOW(dev) (unsigned long)(signed int)gsc_readl(dev->hpa.start + IO_IO_LOW) |
769 | #define READ_IO_IO_HIGH(dev) (unsigned long)(signed int)gsc_readl(dev->hpa.start + IO_IO_HIGH) | |
1da177e4 LT |
770 | |
771 | static void walk_native_bus(unsigned long io_io_low, unsigned long io_io_high, | |
772 | struct device *parent); | |
773 | ||
774 | void walk_lower_bus(struct parisc_device *dev) | |
775 | { | |
776 | unsigned long io_io_low, io_io_high; | |
777 | ||
56583747 | 778 | if (!BUS_CONVERTER(dev) || IS_LOWER_PORT(dev)) |
1da177e4 LT |
779 | return; |
780 | ||
56583747 | 781 | if (dev->id.hw_type == HPHW_IOA) { |
1da177e4 LT |
782 | io_io_low = (unsigned long)(signed int)(READ_IO_IO_LOW(dev) << 16); |
783 | io_io_high = io_io_low + MAX_NATIVE_DEVICES * NATIVE_DEVICE_OFFSET; | |
784 | } else { | |
785 | io_io_low = (READ_IO_IO_LOW(dev) + ~FLEX_MASK) & FLEX_MASK; | |
786 | io_io_high = (READ_IO_IO_HIGH(dev)+ ~FLEX_MASK) & FLEX_MASK; | |
787 | } | |
788 | ||
789 | walk_native_bus(io_io_low, io_io_high, &dev->dev); | |
790 | } | |
791 | ||
792 | /** | |
793 | * walk_native_bus -- Probe a bus for devices | |
794 | * @io_io_low: Base address of this bus. | |
795 | * @io_io_high: Last address of this bus. | |
796 | * @parent: The parent bus device. | |
797 | * | |
798 | * A native bus (eg Runway or GSC) may have up to 64 devices on it, | |
799 | * spaced at intervals of 0x1000 bytes. PDC may not inform us of these | |
800 | * devices, so we have to probe for them. Unfortunately, we may find | |
801 | * devices which are not physically connected (such as extra serial & | |
802 | * keyboard ports). This problem is not yet solved. | |
803 | */ | |
804 | static void walk_native_bus(unsigned long io_io_low, unsigned long io_io_high, | |
805 | struct device *parent) | |
806 | { | |
807 | int i, devices_found = 0; | |
808 | unsigned long hpa = io_io_low; | |
809 | struct hardware_path path; | |
810 | ||
811 | get_node_path(parent, &path); | |
812 | do { | |
813 | for(i = 0; i < MAX_NATIVE_DEVICES; i++, hpa += NATIVE_DEVICE_OFFSET) { | |
814 | struct parisc_device *dev; | |
815 | ||
816 | /* Was the device already added by Firmware? */ | |
817 | dev = find_device_by_addr(hpa); | |
818 | if (!dev) { | |
819 | path.mod = i; | |
820 | dev = alloc_pa_dev(hpa, &path); | |
821 | if (!dev) | |
822 | continue; | |
823 | ||
824 | register_parisc_device(dev); | |
825 | devices_found++; | |
826 | } | |
827 | walk_lower_bus(dev); | |
828 | } | |
829 | } while(!devices_found && hpa < io_io_high); | |
830 | } | |
831 | ||
832 | #define CENTRAL_BUS_ADDR F_EXTEND(0xfff80000) | |
833 | ||
834 | /** | |
835 | * walk_central_bus - Find devices attached to the central bus | |
836 | * | |
837 | * PDC doesn't tell us about all devices in the system. This routine | |
838 | * finds devices connected to the central bus. | |
839 | */ | |
840 | void walk_central_bus(void) | |
841 | { | |
842 | walk_native_bus(CENTRAL_BUS_ADDR, | |
843 | CENTRAL_BUS_ADDR + (MAX_NATIVE_DEVICES * NATIVE_DEVICE_OFFSET), | |
844 | &root); | |
845 | } | |
846 | ||
847 | static void print_parisc_device(struct parisc_device *dev) | |
848 | { | |
849 | char hw_path[64]; | |
850 | static int count; | |
851 | ||
852 | print_pa_hwpath(dev, hw_path); | |
3ee8f5e2 HD |
853 | printk(KERN_INFO "%d. %s at 0x%p [%s] { %d, 0x%x, 0x%.3x, 0x%.5x }", |
854 | ++count, dev->name, (void*) dev->hpa.start, hw_path, dev->id.hw_type, | |
1da177e4 LT |
855 | dev->id.hversion_rev, dev->id.hversion, dev->id.sversion); |
856 | ||
857 | if (dev->num_addrs) { | |
858 | int k; | |
a01c8cb1 | 859 | printk(", additional addresses: "); |
1da177e4 LT |
860 | for (k = 0; k < dev->num_addrs; k++) |
861 | printk("0x%lx ", dev->addr[k]); | |
862 | } | |
863 | printk("\n"); | |
864 | } | |
865 | ||
866 | /** | |
867 | * init_parisc_bus - Some preparation to be done before inventory | |
868 | */ | |
869 | void init_parisc_bus(void) | |
870 | { | |
ba0e427f | 871 | if (bus_register(&parisc_bus_type)) |
1070c965 | 872 | panic("Could not register PA-RISC bus type\n"); |
ba0e427f | 873 | if (device_register(&root)) |
1070c965 | 874 | panic("Could not register PA-RISC root device\n"); |
1da177e4 LT |
875 | get_device(&root); |
876 | } | |
877 | ||
56583747 MW |
878 | |
879 | static int print_one_device(struct device * dev, void * data) | |
880 | { | |
881 | struct parisc_device * pdev = to_parisc_device(dev); | |
882 | ||
883 | if (check_dev(dev)) | |
884 | print_parisc_device(pdev); | |
885 | return 0; | |
886 | } | |
887 | ||
1da177e4 LT |
888 | /** |
889 | * print_parisc_devices - Print out a list of devices found in this system | |
890 | */ | |
891 | void print_parisc_devices(void) | |
892 | { | |
56583747 | 893 | for_each_padev(print_one_device, NULL); |
1da177e4 | 894 | } |