]>
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 */ | |
5299709d | 43 | const struct dma_map_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); \ | |
9b7c6682 GKH |
578 | } \ |
579 | static DEVICE_ATTR_RO(name); | |
1da177e4 LT |
580 | |
581 | #define pa_dev_attr_id(field, format) pa_dev_attr(field, id.field, format) | |
582 | ||
583 | pa_dev_attr(irq, irq, "%u\n"); | |
584 | pa_dev_attr_id(hw_type, "0x%02x\n"); | |
585 | pa_dev_attr(rev, id.hversion_rev, "0x%x\n"); | |
586 | pa_dev_attr_id(hversion, "0x%03x\n"); | |
587 | pa_dev_attr_id(sversion, "0x%05x\n"); | |
588 | ||
a04b0605 KM |
589 | static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) |
590 | { | |
7246c31e | 591 | return make_modalias(dev, buf); |
a04b0605 | 592 | } |
9b7c6682 GKH |
593 | static DEVICE_ATTR_RO(modalias); |
594 | ||
595 | static struct attribute *parisc_device_attrs[] = { | |
596 | &dev_attr_irq.attr, | |
597 | &dev_attr_hw_type.attr, | |
598 | &dev_attr_rev.attr, | |
599 | &dev_attr_hversion.attr, | |
600 | &dev_attr_sversion.attr, | |
601 | &dev_attr_modalias.attr, | |
602 | NULL, | |
1da177e4 | 603 | }; |
9b7c6682 | 604 | ATTRIBUTE_GROUPS(parisc_device); |
1da177e4 LT |
605 | |
606 | struct bus_type parisc_bus_type = { | |
607 | .name = "parisc", | |
608 | .match = parisc_generic_match, | |
7246c31e | 609 | .uevent = parisc_uevent, |
9b7c6682 | 610 | .dev_groups = parisc_device_groups, |
ad3ed31c RK |
611 | .probe = parisc_driver_probe, |
612 | .remove = parisc_driver_remove, | |
1da177e4 LT |
613 | }; |
614 | ||
615 | /** | |
616 | * register_parisc_device - Locate a driver to manage this device. | |
617 | * @dev: The parisc device. | |
618 | * | |
619 | * Search the driver list for a driver that is willing to manage | |
620 | * this device. | |
621 | */ | |
622 | int register_parisc_device(struct parisc_device *dev) | |
623 | { | |
624 | if (!dev) | |
625 | return 0; | |
626 | ||
627 | if (dev->driver) | |
628 | return 1; | |
629 | ||
630 | return 0; | |
631 | } | |
632 | ||
633 | /** | |
634 | * match_pci_device - Matches a pci device against a given hardware path | |
635 | * entry. | |
636 | * @dev: the generic device (known to be contained by a pci_dev). | |
637 | * @index: the current BC index | |
638 | * @modpath: the hardware path. | |
639 | * @return: true if the device matches the hardware path. | |
640 | */ | |
641 | static int match_pci_device(struct device *dev, int index, | |
642 | struct hardware_path *modpath) | |
643 | { | |
644 | struct pci_dev *pdev = to_pci_dev(dev); | |
645 | int id; | |
646 | ||
647 | if (index == 5) { | |
648 | /* we are at the end of the path, and on the actual device */ | |
649 | unsigned int devfn = pdev->devfn; | |
650 | return ((modpath->bc[5] == PCI_SLOT(devfn)) && | |
651 | (modpath->mod == PCI_FUNC(devfn))); | |
652 | } | |
653 | ||
654 | id = PCI_SLOT(pdev->devfn) | (PCI_FUNC(pdev->devfn) << 5); | |
655 | return (modpath->bc[index] == id); | |
656 | } | |
657 | ||
658 | /** | |
659 | * match_parisc_device - Matches a parisc device against a given hardware | |
660 | * path entry. | |
661 | * @dev: the generic device (known to be contained by a parisc_device). | |
662 | * @index: the current BC index | |
663 | * @modpath: the hardware path. | |
664 | * @return: true if the device matches the hardware path. | |
665 | */ | |
666 | static int match_parisc_device(struct device *dev, int index, | |
667 | struct hardware_path *modpath) | |
668 | { | |
669 | struct parisc_device *curr = to_parisc_device(dev); | |
670 | char id = (index == 6) ? modpath->mod : modpath->bc[index]; | |
671 | ||
672 | return (curr->hw_path == id); | |
673 | } | |
674 | ||
56583747 MW |
675 | struct parse_tree_data { |
676 | int index; | |
677 | struct hardware_path * modpath; | |
678 | struct device * dev; | |
679 | }; | |
680 | ||
681 | static int check_parent(struct device * dev, void * data) | |
682 | { | |
683 | struct parse_tree_data * d = data; | |
684 | ||
685 | if (check_dev(dev)) { | |
686 | if (dev->bus == &parisc_bus_type) { | |
687 | if (match_parisc_device(dev, d->index, d->modpath)) | |
688 | d->dev = dev; | |
b0acbb9d | 689 | } else if (dev_is_pci(dev)) { |
56583747 MW |
690 | if (match_pci_device(dev, d->index, d->modpath)) |
691 | d->dev = dev; | |
692 | } else if (dev->bus == NULL) { | |
693 | /* we are on a bus bridge */ | |
694 | struct device *new = parse_tree_node(dev, d->index, d->modpath); | |
695 | if (new) | |
696 | d->dev = new; | |
697 | } | |
698 | } | |
699 | return d->dev != NULL; | |
700 | } | |
701 | ||
1da177e4 LT |
702 | /** |
703 | * parse_tree_node - returns a device entry in the iotree | |
704 | * @parent: the parent node in the tree | |
705 | * @index: the current BC index | |
706 | * @modpath: the hardware_path struct to match a device against | |
707 | * @return: The corresponding device if found, NULL otherwise. | |
708 | * | |
709 | * Checks all the children of @parent for a matching @id. If none | |
710 | * found, it returns NULL. | |
711 | */ | |
712 | static struct device * | |
713 | parse_tree_node(struct device *parent, int index, struct hardware_path *modpath) | |
714 | { | |
56583747 MW |
715 | struct parse_tree_data d = { |
716 | .index = index, | |
717 | .modpath = modpath, | |
718 | }; | |
1da177e4 | 719 | |
56583747 MW |
720 | struct recurse_struct recurse_data = { |
721 | .obj = &d, | |
722 | .fn = check_parent, | |
723 | }; | |
724 | ||
3ee8f5e2 HD |
725 | if (device_for_each_child(parent, &recurse_data, descend_children)) |
726 | /* nothing */; | |
727 | ||
56583747 | 728 | return d.dev; |
1da177e4 LT |
729 | } |
730 | ||
731 | /** | |
732 | * hwpath_to_device - Finds the generic device corresponding to a given hardware path. | |
733 | * @modpath: the hardware path. | |
734 | * @return: The target device, NULL if not found. | |
735 | */ | |
736 | struct device *hwpath_to_device(struct hardware_path *modpath) | |
737 | { | |
738 | int i; | |
739 | struct device *parent = &root; | |
740 | for (i = 0; i < 6; i++) { | |
741 | if (modpath->bc[i] == -1) | |
742 | continue; | |
743 | parent = parse_tree_node(parent, i, modpath); | |
744 | if (!parent) | |
745 | return NULL; | |
746 | } | |
b0acbb9d | 747 | if (dev_is_pci(parent)) /* pci devices already parse MOD */ |
1da177e4 LT |
748 | return parent; |
749 | else | |
750 | return parse_tree_node(parent, 6, modpath); | |
751 | } | |
752 | EXPORT_SYMBOL(hwpath_to_device); | |
753 | ||
754 | /** | |
755 | * device_to_hwpath - Populates the hwpath corresponding to the given device. | |
756 | * @param dev the target device | |
757 | * @param path pointer to a previously allocated hwpath struct to be filled in | |
758 | */ | |
759 | void device_to_hwpath(struct device *dev, struct hardware_path *path) | |
760 | { | |
761 | struct parisc_device *padev; | |
762 | if (dev->bus == &parisc_bus_type) { | |
763 | padev = to_parisc_device(dev); | |
764 | get_node_path(dev->parent, path); | |
765 | path->mod = padev->hw_path; | |
b0acbb9d | 766 | } else if (dev_is_pci(dev)) { |
1da177e4 LT |
767 | get_node_path(dev, path); |
768 | } | |
769 | } | |
770 | EXPORT_SYMBOL(device_to_hwpath); | |
771 | ||
772 | #define BC_PORT_MASK 0x8 | |
773 | #define BC_LOWER_PORT 0x8 | |
774 | ||
775 | #define BUS_CONVERTER(dev) \ | |
776 | ((dev->id.hw_type == HPHW_IOA) || (dev->id.hw_type == HPHW_BCPORT)) | |
777 | ||
778 | #define IS_LOWER_PORT(dev) \ | |
56583747 | 779 | ((gsc_readl(dev->hpa.start + offsetof(struct bc_module, io_status)) \ |
1da177e4 LT |
780 | & BC_PORT_MASK) == BC_LOWER_PORT) |
781 | ||
782 | #define MAX_NATIVE_DEVICES 64 | |
783 | #define NATIVE_DEVICE_OFFSET 0x1000 | |
784 | ||
785 | #define FLEX_MASK F_EXTEND(0xfffc0000) | |
786 | #define IO_IO_LOW offsetof(struct bc_module, io_io_low) | |
787 | #define IO_IO_HIGH offsetof(struct bc_module, io_io_high) | |
56583747 MW |
788 | #define READ_IO_IO_LOW(dev) (unsigned long)(signed int)gsc_readl(dev->hpa.start + IO_IO_LOW) |
789 | #define READ_IO_IO_HIGH(dev) (unsigned long)(signed int)gsc_readl(dev->hpa.start + IO_IO_HIGH) | |
1da177e4 LT |
790 | |
791 | static void walk_native_bus(unsigned long io_io_low, unsigned long io_io_high, | |
792 | struct device *parent); | |
793 | ||
794 | void walk_lower_bus(struct parisc_device *dev) | |
795 | { | |
796 | unsigned long io_io_low, io_io_high; | |
797 | ||
56583747 | 798 | if (!BUS_CONVERTER(dev) || IS_LOWER_PORT(dev)) |
1da177e4 LT |
799 | return; |
800 | ||
56583747 | 801 | if (dev->id.hw_type == HPHW_IOA) { |
1da177e4 LT |
802 | io_io_low = (unsigned long)(signed int)(READ_IO_IO_LOW(dev) << 16); |
803 | io_io_high = io_io_low + MAX_NATIVE_DEVICES * NATIVE_DEVICE_OFFSET; | |
804 | } else { | |
805 | io_io_low = (READ_IO_IO_LOW(dev) + ~FLEX_MASK) & FLEX_MASK; | |
806 | io_io_high = (READ_IO_IO_HIGH(dev)+ ~FLEX_MASK) & FLEX_MASK; | |
807 | } | |
808 | ||
809 | walk_native_bus(io_io_low, io_io_high, &dev->dev); | |
810 | } | |
811 | ||
812 | /** | |
813 | * walk_native_bus -- Probe a bus for devices | |
814 | * @io_io_low: Base address of this bus. | |
815 | * @io_io_high: Last address of this bus. | |
816 | * @parent: The parent bus device. | |
817 | * | |
818 | * A native bus (eg Runway or GSC) may have up to 64 devices on it, | |
819 | * spaced at intervals of 0x1000 bytes. PDC may not inform us of these | |
820 | * devices, so we have to probe for them. Unfortunately, we may find | |
821 | * devices which are not physically connected (such as extra serial & | |
822 | * keyboard ports). This problem is not yet solved. | |
823 | */ | |
824 | static void walk_native_bus(unsigned long io_io_low, unsigned long io_io_high, | |
825 | struct device *parent) | |
826 | { | |
827 | int i, devices_found = 0; | |
828 | unsigned long hpa = io_io_low; | |
829 | struct hardware_path path; | |
830 | ||
831 | get_node_path(parent, &path); | |
832 | do { | |
833 | for(i = 0; i < MAX_NATIVE_DEVICES; i++, hpa += NATIVE_DEVICE_OFFSET) { | |
834 | struct parisc_device *dev; | |
835 | ||
836 | /* Was the device already added by Firmware? */ | |
837 | dev = find_device_by_addr(hpa); | |
838 | if (!dev) { | |
839 | path.mod = i; | |
840 | dev = alloc_pa_dev(hpa, &path); | |
841 | if (!dev) | |
842 | continue; | |
843 | ||
844 | register_parisc_device(dev); | |
845 | devices_found++; | |
846 | } | |
847 | walk_lower_bus(dev); | |
848 | } | |
849 | } while(!devices_found && hpa < io_io_high); | |
850 | } | |
851 | ||
852 | #define CENTRAL_BUS_ADDR F_EXTEND(0xfff80000) | |
853 | ||
854 | /** | |
855 | * walk_central_bus - Find devices attached to the central bus | |
856 | * | |
857 | * PDC doesn't tell us about all devices in the system. This routine | |
858 | * finds devices connected to the central bus. | |
859 | */ | |
860 | void walk_central_bus(void) | |
861 | { | |
862 | walk_native_bus(CENTRAL_BUS_ADDR, | |
863 | CENTRAL_BUS_ADDR + (MAX_NATIVE_DEVICES * NATIVE_DEVICE_OFFSET), | |
864 | &root); | |
865 | } | |
866 | ||
867 | static void print_parisc_device(struct parisc_device *dev) | |
868 | { | |
869 | char hw_path[64]; | |
870 | static int count; | |
871 | ||
872 | print_pa_hwpath(dev, hw_path); | |
0ae60d0c | 873 | printk(KERN_INFO "%d. %s at 0x%px [%s] { %d, 0x%x, 0x%.3x, 0x%.5x }", |
3ee8f5e2 | 874 | ++count, dev->name, (void*) dev->hpa.start, hw_path, dev->id.hw_type, |
1da177e4 LT |
875 | dev->id.hversion_rev, dev->id.hversion, dev->id.sversion); |
876 | ||
877 | if (dev->num_addrs) { | |
878 | int k; | |
6f63d0f6 | 879 | pr_cont(", additional addresses: "); |
1da177e4 | 880 | for (k = 0; k < dev->num_addrs; k++) |
6f63d0f6 | 881 | pr_cont("0x%lx ", dev->addr[k]); |
1da177e4 | 882 | } |
6f63d0f6 | 883 | pr_cont("\n"); |
1da177e4 LT |
884 | } |
885 | ||
886 | /** | |
887 | * init_parisc_bus - Some preparation to be done before inventory | |
888 | */ | |
889 | void init_parisc_bus(void) | |
890 | { | |
ba0e427f | 891 | if (bus_register(&parisc_bus_type)) |
1070c965 | 892 | panic("Could not register PA-RISC bus type\n"); |
ba0e427f | 893 | if (device_register(&root)) |
1070c965 | 894 | panic("Could not register PA-RISC root device\n"); |
1da177e4 LT |
895 | get_device(&root); |
896 | } | |
897 | ||
56583747 MW |
898 | |
899 | static int print_one_device(struct device * dev, void * data) | |
900 | { | |
901 | struct parisc_device * pdev = to_parisc_device(dev); | |
902 | ||
903 | if (check_dev(dev)) | |
904 | print_parisc_device(pdev); | |
905 | return 0; | |
906 | } | |
907 | ||
1da177e4 LT |
908 | /** |
909 | * print_parisc_devices - Print out a list of devices found in this system | |
910 | */ | |
911 | void print_parisc_devices(void) | |
912 | { | |
56583747 | 913 | for_each_padev(print_one_device, NULL); |
1da177e4 | 914 | } |