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