Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
drivers.c
Go to the documentation of this file.
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 <[email protected]>
12  * Copyright (c) 2001,2002 Ryan Bradetich
13  * Copyright (c) 2004-2005 Thibaut VARENE <[email protected]>
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 <linux/export.h>
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 */
45 
46 static struct device root = {
47  .init_name = "parisc",
48 };
49 
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);
62 
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 }
77 
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);
95 }
96 
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 
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 
132  if (!rc)
133  pa_dev->driver = pa_drv;
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);
144 
145  return 0;
146 }
147 
148 
154 {
155  /* FIXME: we need this because apparently the sti
156  * driver can be registered twice */
157  if(driver->drv.name) {
159  "BUG: skipping previously registered driver %s\n",
160  driver->name);
161  return 1;
162  }
163 
164  if (!driver->probe) {
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 
177  driver->drv.name = driver->name;
178 
179  return driver_register(&driver->drv);
180 }
182 
183 
184 struct match_count {
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 
209 {
210  struct match_count m = {
211  .driver = driver,
212  .count = 0,
213  };
214 
215  for_each_padev(match_and_count, &m);
216 
217  return m.count;
218 }
219 
220 
221 
227 {
228  driver_unregister(&driver->drv);
229  return 0;
230 }
232 
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)
239 {
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  }
248  }
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;
261 }
262 
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 
285 #ifdef CONFIG_PCI
286 static inline int is_pci_dev(struct device *dev)
287 {
288  return dev->bus == &pci_bus_type;
289 }
290 #else
291 static inline int is_pci_dev(struct device *dev)
292 {
293  return 0;
294 }
295 #endif
296 
297 /*
298  * get_node_path fills in @path with the firmware path to the device.
299  * Note that if @node is a parisc device, we don't fill in the 'mod' field.
300  * This is because both callers pass the parent and fill in the mod
301  * themselves. If @node is a PCI device, we do fill it in, even though this
302  * is inconsistent.
303  */
304 static void get_node_path(struct device *dev, struct hardware_path *path)
305 {
306  int i = 5;
307  memset(&path->bc, -1, 6);
308 
309  if (is_pci_dev(dev)) {
310  unsigned int devfn = to_pci_dev(dev)->devfn;
311  path->mod = PCI_FUNC(devfn);
312  path->bc[i--] = PCI_SLOT(devfn);
313  dev = dev->parent;
314  }
315 
316  while (dev != &root) {
317  if (is_pci_dev(dev)) {
318  unsigned int devfn = to_pci_dev(dev)->devfn;
319  path->bc[i--] = PCI_SLOT(devfn) | (PCI_FUNC(devfn)<< 5);
320  } else if (dev->bus == &parisc_bus_type) {
321  path->bc[i--] = to_parisc_device(dev)->hw_path;
322  }
323  dev = dev->parent;
324  }
325 }
326 
327 static char *print_hwpath(struct hardware_path *path, char *output)
328 {
329  int i;
330  for (i = 0; i < 6; i++) {
331  if (path->bc[i] == -1)
332  continue;
333  output += sprintf(output, "%u/", (unsigned char) path->bc[i]);
334  }
335  output += sprintf(output, "%u", (unsigned char) path->mod);
336  return output;
337 }
338 
348 char *print_pa_hwpath(struct parisc_device *dev, char *output)
349 {
350  struct hardware_path path;
351 
352  get_node_path(dev->dev.parent, &path);
353  path.mod = dev->hw_path;
354  return print_hwpath(&path, output);
355 }
357 
358 #if defined(CONFIG_PCI) || defined(CONFIG_ISA)
359 
368 void get_pci_node_path(struct pci_dev *pdev, struct hardware_path *path)
369 {
370  get_node_path(&pdev->dev, path);
371 }
373 
383 char *print_pci_hwpath(struct pci_dev *dev, char *output)
384 {
385  struct hardware_path path;
386 
387  get_pci_node_path(dev, &path);
388  return print_hwpath(&path, output);
389 }
391 
392 #endif /* defined(CONFIG_PCI) || defined(CONFIG_ISA) */
393 
394 static void setup_bus_id(struct parisc_device *padev)
395 {
396  struct hardware_path path;
397  char name[20];
398  char *output = name;
399  int i;
400 
401  get_node_path(padev->dev.parent, &path);
402 
403  for (i = 0; i < 6; i++) {
404  if (path.bc[i] == -1)
405  continue;
406  output += sprintf(output, "%u:", (unsigned char) path.bc[i]);
407  }
408  sprintf(output, "%u", (unsigned char) padev->hw_path);
409  dev_set_name(&padev->dev, name);
410 }
411 
412 struct parisc_device * create_tree_node(char id, struct device *parent)
413 {
414  struct parisc_device *dev = kzalloc(sizeof(*dev), GFP_KERNEL);
415  if (!dev)
416  return NULL;
417 
418  dev->hw_path = id;
419  dev->id.hw_type = HPHW_FAULTY;
420 
421  dev->dev.parent = parent;
422  setup_bus_id(dev);
423 
424  dev->dev.bus = &parisc_bus_type;
425  dev->dma_mask = 0xffffffffUL; /* PARISC devices are 32-bit */
426 
427  /* make the generic dma mask a pointer to the parisc one */
428  dev->dev.dma_mask = &dev->dma_mask;
429  dev->dev.coherent_dma_mask = dev->dma_mask;
430  if (device_register(&dev->dev)) {
431  kfree(dev);
432  return NULL;
433  }
434 
435  return dev;
436 }
437 
439  char id;
440  struct parisc_device * dev;
441 };
442 
443 static int match_by_id(struct device * dev, void * data)
444 {
445  struct parisc_device * pdev = to_parisc_device(dev);
446  struct match_id_data * d = data;
447 
448  if (pdev->hw_path == d->id) {
449  d->dev = pdev;
450  return 1;
451  }
452  return 0;
453 }
454 
463 static struct parisc_device * alloc_tree_node(struct device *parent, char id)
464 {
465  struct match_id_data d = {
466  .id = id,
467  };
468  if (device_for_each_child(parent, &d, match_by_id))
469  return d.dev;
470  else
471  return create_tree_node(id, parent);
472 }
473 
474 static struct parisc_device *create_parisc_device(struct hardware_path *modpath)
475 {
476  int i;
477  struct device *parent = &root;
478  for (i = 0; i < 6; i++) {
479  if (modpath->bc[i] == -1)
480  continue;
481  parent = &alloc_tree_node(parent, modpath->bc[i])->dev;
482  }
483  return alloc_tree_node(parent, modpath->mod);
484 }
485 
486 struct parisc_device *
487 alloc_pa_dev(unsigned long hpa, struct hardware_path *mod_path)
488 {
489  int status;
490  unsigned long bytecnt;
491  u8 iodc_data[32];
492  struct parisc_device *dev;
493  const char *name;
494 
495  /* Check to make sure this device has not already been added - Ryan */
496  if (find_device_by_addr(hpa) != NULL)
497  return NULL;
498 
499  status = pdc_iodc_read(&bytecnt, hpa, 0, &iodc_data, 32);
500  if (status != PDC_OK)
501  return NULL;
502 
503  dev = create_parisc_device(mod_path);
504  if (dev->id.hw_type != HPHW_FAULTY) {
505  printk(KERN_ERR "Two devices have hardware path [%s]. "
506  "IODC data for second device: "
507  "%02x%02x%02x%02x%02x%02x\n"
508  "Rearranging GSC cards sometimes helps\n",
509  parisc_pathname(dev), iodc_data[0], iodc_data[1],
510  iodc_data[3], iodc_data[4], iodc_data[5], iodc_data[6]);
511  return NULL;
512  }
513 
514  dev->id.hw_type = iodc_data[3] & 0x1f;
515  dev->id.hversion = (iodc_data[0] << 4) | ((iodc_data[1] & 0xf0) >> 4);
516  dev->id.hversion_rev = iodc_data[1] & 0x0f;
517  dev->id.sversion = ((iodc_data[4] & 0x0f) << 16) |
518  (iodc_data[5] << 8) | iodc_data[6];
519  dev->hpa.name = parisc_pathname(dev);
520  dev->hpa.start = hpa;
521  /* This is awkward. The STI spec says that gfx devices may occupy
522  * 32MB or 64MB. Unfortunately, we don't know how to tell whether
523  * it's the former or the latter. Assumptions either way can hurt us.
524  */
525  if (hpa == 0xf4000000 || hpa == 0xf8000000) {
526  dev->hpa.end = hpa + 0x03ffffff;
527  } else if (hpa == 0xf6000000 || hpa == 0xfa000000) {
528  dev->hpa.end = hpa + 0x01ffffff;
529  } else {
530  dev->hpa.end = hpa + 0xfff;
531  }
532  dev->hpa.flags = IORESOURCE_MEM;
533  name = parisc_hardware_description(&dev->id);
534  if (name) {
535  strlcpy(dev->name, name, sizeof(dev->name));
536  }
537 
538  /* Silently fail things like mouse ports which are subsumed within
539  * the keyboard controller
540  */
541  if ((hpa & 0xfff) == 0 && insert_resource(&iomem_resource, &dev->hpa))
542  printk("Unable to claim HPA %lx for device %s\n",
543  hpa, name);
544 
545  return dev;
546 }
547 
548 static int parisc_generic_match(struct device *dev, struct device_driver *drv)
549 {
550  return match_device(to_parisc_driver(drv), to_parisc_device(dev));
551 }
552 
553 static ssize_t make_modalias(struct device *dev, char *buf)
554 {
555  const struct parisc_device *padev = to_parisc_device(dev);
556  const struct parisc_device_id *id = &padev->id;
557 
558  return sprintf(buf, "parisc:t%02Xhv%04Xrev%02Xsv%08X\n",
559  (u8)id->hw_type, (u16)id->hversion, (u8)id->hversion_rev,
560  (u32)id->sversion);
561 }
562 
563 static int parisc_uevent(struct device *dev, struct kobj_uevent_env *env)
564 {
565  const struct parisc_device *padev;
566  char modalias[40];
567 
568  if (!dev)
569  return -ENODEV;
570 
571  padev = to_parisc_device(dev);
572  if (!padev)
573  return -ENODEV;
574 
575  if (add_uevent_var(env, "PARISC_NAME=%s", padev->name))
576  return -ENOMEM;
577 
578  make_modalias(dev, modalias);
579  if (add_uevent_var(env, "MODALIAS=%s", modalias))
580  return -ENOMEM;
581 
582  return 0;
583 }
584 
585 #define pa_dev_attr(name, field, format_string) \
586 static ssize_t name##_show(struct device *dev, struct device_attribute *attr, char *buf) \
587 { \
588  struct parisc_device *padev = to_parisc_device(dev); \
589  return sprintf(buf, format_string, padev->field); \
590 }
591 
592 #define pa_dev_attr_id(field, format) pa_dev_attr(field, id.field, format)
593 
594 pa_dev_attr(irq, irq, "%u\n");
595 pa_dev_attr_id(hw_type, "0x%02x\n");
596 pa_dev_attr(rev, id.hversion_rev, "0x%x\n");
597 pa_dev_attr_id(hversion, "0x%03x\n");
598 pa_dev_attr_id(sversion, "0x%05x\n");
599 
600 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
601 {
602  return make_modalias(dev, buf);
603 }
604 
605 static struct device_attribute parisc_device_attrs[] = {
606  __ATTR_RO(irq),
608  __ATTR_RO(rev),
609  __ATTR_RO(hversion),
610  __ATTR_RO(sversion),
611  __ATTR_RO(modalias),
612  __ATTR_NULL,
613 };
614 
616  .name = "parisc",
617  .match = parisc_generic_match,
618  .uevent = parisc_uevent,
619  .dev_attrs = parisc_device_attrs,
620  .probe = parisc_driver_probe,
621  .remove = parisc_driver_remove,
622 };
623 
632 {
633  if (!dev)
634  return 0;
635 
636  if (dev->driver)
637  return 1;
638 
639  return 0;
640 }
641 
650 static int match_pci_device(struct device *dev, int index,
651  struct hardware_path *modpath)
652 {
653  struct pci_dev *pdev = to_pci_dev(dev);
654  int id;
655 
656  if (index == 5) {
657  /* we are at the end of the path, and on the actual device */
658  unsigned int devfn = pdev->devfn;
659  return ((modpath->bc[5] == PCI_SLOT(devfn)) &&
660  (modpath->mod == PCI_FUNC(devfn)));
661  }
662 
663  id = PCI_SLOT(pdev->devfn) | (PCI_FUNC(pdev->devfn) << 5);
664  return (modpath->bc[index] == id);
665 }
666 
675 static int match_parisc_device(struct device *dev, int index,
676  struct hardware_path *modpath)
677 {
678  struct parisc_device *curr = to_parisc_device(dev);
679  char id = (index == 6) ? modpath->mod : modpath->bc[index];
680 
681  return (curr->hw_path == id);
682 }
683 
685  int index;
687  struct device * dev;
688 };
689 
690 static int check_parent(struct device * dev, void * data)
691 {
692  struct parse_tree_data * d = data;
693 
694  if (check_dev(dev)) {
695  if (dev->bus == &parisc_bus_type) {
696  if (match_parisc_device(dev, d->index, d->modpath))
697  d->dev = dev;
698  } else if (is_pci_dev(dev)) {
699  if (match_pci_device(dev, d->index, d->modpath))
700  d->dev = dev;
701  } else if (dev->bus == NULL) {
702  /* we are on a bus bridge */
703  struct device *new = parse_tree_node(dev, d->index, d->modpath);
704  if (new)
705  d->dev = new;
706  }
707  }
708  return d->dev != NULL;
709 }
710 
721 static struct device *
722 parse_tree_node(struct device *parent, int index, struct hardware_path *modpath)
723 {
724  struct parse_tree_data d = {
725  .index = index,
726  .modpath = modpath,
727  };
728 
729  struct recurse_struct recurse_data = {
730  .obj = &d,
731  .fn = check_parent,
732  };
733 
734  if (device_for_each_child(parent, &recurse_data, descend_children))
735  /* nothing */;
736 
737  return d.dev;
738 }
739 
745 struct device *hwpath_to_device(struct hardware_path *modpath)
746 {
747  int i;
748  struct device *parent = &root;
749  for (i = 0; i < 6; i++) {
750  if (modpath->bc[i] == -1)
751  continue;
752  parent = parse_tree_node(parent, i, modpath);
753  if (!parent)
754  return NULL;
755  }
756  if (is_pci_dev(parent)) /* pci devices already parse MOD */
757  return parent;
758  else
759  return parse_tree_node(parent, 6, modpath);
760 }
762 
768 void device_to_hwpath(struct device *dev, struct hardware_path *path)
769 {
770  struct parisc_device *padev;
771  if (dev->bus == &parisc_bus_type) {
772  padev = to_parisc_device(dev);
773  get_node_path(dev->parent, path);
774  path->mod = padev->hw_path;
775  } else if (is_pci_dev(dev)) {
776  get_node_path(dev, path);
777  }
778 }
780 
781 #define BC_PORT_MASK 0x8
782 #define BC_LOWER_PORT 0x8
783 
784 #define BUS_CONVERTER(dev) \
785  ((dev->id.hw_type == HPHW_IOA) || (dev->id.hw_type == HPHW_BCPORT))
786 
787 #define IS_LOWER_PORT(dev) \
788  ((gsc_readl(dev->hpa.start + offsetof(struct bc_module, io_status)) \
789  & BC_PORT_MASK) == BC_LOWER_PORT)
790 
791 #define MAX_NATIVE_DEVICES 64
792 #define NATIVE_DEVICE_OFFSET 0x1000
793 
794 #define FLEX_MASK F_EXTEND(0xfffc0000)
795 #define IO_IO_LOW offsetof(struct bc_module, io_io_low)
796 #define IO_IO_HIGH offsetof(struct bc_module, io_io_high)
797 #define READ_IO_IO_LOW(dev) (unsigned long)(signed int)gsc_readl(dev->hpa.start + IO_IO_LOW)
798 #define READ_IO_IO_HIGH(dev) (unsigned long)(signed int)gsc_readl(dev->hpa.start + IO_IO_HIGH)
799 
800 static void walk_native_bus(unsigned long io_io_low, unsigned long io_io_high,
801  struct device *parent);
802 
803 void walk_lower_bus(struct parisc_device *dev)
804 {
805  unsigned long io_io_low, io_io_high;
806 
807  if (!BUS_CONVERTER(dev) || IS_LOWER_PORT(dev))
808  return;
809 
810  if (dev->id.hw_type == HPHW_IOA) {
811  io_io_low = (unsigned long)(signed int)(READ_IO_IO_LOW(dev) << 16);
812  io_io_high = io_io_low + MAX_NATIVE_DEVICES * NATIVE_DEVICE_OFFSET;
813  } else {
814  io_io_low = (READ_IO_IO_LOW(dev) + ~FLEX_MASK) & FLEX_MASK;
815  io_io_high = (READ_IO_IO_HIGH(dev)+ ~FLEX_MASK) & FLEX_MASK;
816  }
817 
818  walk_native_bus(io_io_low, io_io_high, &dev->dev);
819 }
820 
833 static void walk_native_bus(unsigned long io_io_low, unsigned long io_io_high,
834  struct device *parent)
835 {
836  int i, devices_found = 0;
837  unsigned long hpa = io_io_low;
838  struct hardware_path path;
839 
840  get_node_path(parent, &path);
841  do {
842  for(i = 0; i < MAX_NATIVE_DEVICES; i++, hpa += NATIVE_DEVICE_OFFSET) {
843  struct parisc_device *dev;
844 
845  /* Was the device already added by Firmware? */
846  dev = find_device_by_addr(hpa);
847  if (!dev) {
848  path.mod = i;
849  dev = alloc_pa_dev(hpa, &path);
850  if (!dev)
851  continue;
852 
854  devices_found++;
855  }
856  walk_lower_bus(dev);
857  }
858  } while(!devices_found && hpa < io_io_high);
859 }
860 
861 #define CENTRAL_BUS_ADDR F_EXTEND(0xfff80000)
862 
870 {
871  walk_native_bus(CENTRAL_BUS_ADDR,
872  CENTRAL_BUS_ADDR + (MAX_NATIVE_DEVICES * NATIVE_DEVICE_OFFSET),
873  &root);
874 }
875 
876 static void print_parisc_device(struct parisc_device *dev)
877 {
878  char hw_path[64];
879  static int count;
880 
881  print_pa_hwpath(dev, hw_path);
882  printk(KERN_INFO "%d. %s at 0x%p [%s] { %d, 0x%x, 0x%.3x, 0x%.5x }",
883  ++count, dev->name, (void*) dev->hpa.start, hw_path, dev->id.hw_type,
884  dev->id.hversion_rev, dev->id.hversion, dev->id.sversion);
885 
886  if (dev->num_addrs) {
887  int k;
888  printk(", additional addresses: ");
889  for (k = 0; k < dev->num_addrs; k++)
890  printk("0x%lx ", dev->addr[k]);
891  }
892  printk("\n");
893 }
894 
898 void init_parisc_bus(void)
899 {
900  if (bus_register(&parisc_bus_type))
901  panic("Could not register PA-RISC bus type\n");
902  if (device_register(&root))
903  panic("Could not register PA-RISC root device\n");
904  get_device(&root);
905 }
906 
907 
908 static int print_one_device(struct device * dev, void * data)
909 {
910  struct parisc_device * pdev = to_parisc_device(dev);
911 
912  if (check_dev(dev))
913  print_parisc_device(pdev);
914  return 0;
915 }
916 
921 {
922  for_each_padev(print_one_device, NULL);
923 }