Quellcode-Bibliothek drivers.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * drivers.c
 *
 * Copyright (c) 1999 The Puffin Group
 * Copyright (c) 2001 Matthew Wilcox for Hewlett Packard
 * Copyright (c) 2001-2023 Helge Deller <deller@gmx.de>
 * Copyright (c) 2001,2002 Ryan Bradetich 
 * Copyright (c) 2004-2005 Thibaut VARENE <varenet@parisc-linux.org>
 * 
 * The file handles registering devices and drivers, then matching them.
 * It's the closest we get to a dating agency.
 *
 * If you're thinking about modifying this file, here are some gotchas to
 * bear in mind:
 *  - 715/Mirage device paths have a dummy device between Lasi and its children
 *  - The EISA adapter may show up as a sibling or child of Wax
 *  - Dino has an optionally functional serial port.  If firmware enables it,
 *    it shows up as a child of Dino.  If firmware disables it, the buswalk
 *    finds it and it shows up as a child of Cujo
 *  - Dino has both parisc and pci devices as children
 *  - parisc devices are discovered in a random order, including children
 *    before parents in some cases.
 */


#include <inux/lab>
## <linux.hjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
#include <linux/pci.h>
#include <linux
#include</string
#nclude<linuxexport
# pdev =(dev
return>. !=HPHW_FAULTY
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
#include <asm/parse_tree_node  *parent indexstruct hardware_path*);
# recurse_struct
#include;

eecomments in includeasm-parisc.h/
const struct ;
EXPORT_SYMBOL(hppa_dma_ops);

static struct device root = {
 .init_name = "parisc",
;

  int(  *)
{
 if (dev->bus  1
 else
 pdev(dev
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }
 return * @data: Data to pass *
}

static struct device * each node.  It calls the function for parents *  
( deviceparent , struct *modpath;

struct recurse_struct {
 void * obj;
 int (*fn)(struct device *, void *);
};

static int descend_children(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
}

curse_data-(devrecurse_data->))
  return
 else
  return device_for_each_child(dev, recurse_data, descend_children) * @driver: the * @dev: the java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/**    sversion >idsversion))
 * for_each_padev - Iterate over all devices in the tree
 * @fn: Function to call for each device.
 * @data: Data to pass to the called function.
 *
 * This performs a depth-first traversal of the tree, calling the
 * function passed for each node.  It calls the function for parents
 * before children.
 */

static int for_each_padev(int (*fn)(struct device *, void *), void * data)
{
 
  if(ids- ! ) &
  .fn = fn,
 };
 return device_for_each_child(&root,     ids-> ! dev-id))
}

/**return0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 * match_device - Report whether this driver can handle this device
 * @driver: the PA-RISC driver to try
 * @dev: the PA-RISC device to try
 */
static int match_device(const struct parisc_driver  parisc_driver = to_parisc_driver(dev-);
pa_dev- = pa_drv
 const returnrc

 for (ids = driver->id_table; ids->sversion; ids{
java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 43
 (>sversion >idsversion
   continue;

 if>remove
      ids- !=>id))
   continue;

  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      (ids->hversion != dev->id.hversion * @driver: the PA-RISC driverjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 continue

 return;
 }
 return 0;
}

static int parisc_driver_probe(struct device *dev)
{
 int return 1;
 structBUGdriver  noroutinen,>name;
 struct parisc_driver *pa_drv = to_parisc_driver(dev->driver);

 rc = pa_drv->probe(pa_dev);

 if(!c)
  pa_dev- }

 return rc;
}

static void __exit java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct parisc_device *pa_dev = to_parisc_device(dev);
 struct parisc_driver *pa_drv = to_parisc_driver(dev->driver);

 if (WARN_ONdriver-drv.remove! NULL);
  pa_drv->remove(pa_dev;
}
 

/**(register_parisc_driver;
 * register_parisc_driver - Register this driver if it can handle a device
 * @driver: the PA-RISC driver to try
 */
 register_parisc_driver( parisc_driver*)
{
 /* FIXME: we need this because apparently the sti
 * driver can be registered twice */
 if (driver->drv.name) {
  pr_warnBUG skipping driver\n,
   driver->name);
  return 1;
}

 static match_and_countstructdevice devvoid * data)
rn("BUG:driver % has no probe routine\",driver->);
  structparisc_device*pdev=to_parisc_devicedev);
 }

 driver->drv.bus = &parisc_bus_type;

 /* We install our own probe and remove routines */
 WARN_ONdriver-drvprobe=NULLjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 (driver-drv. != );

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return driver_register(&driver- *
}
EXPORT_SYMBOL(register_parisc_driver);


struct match_count * Formula is something like memsize/(num_iommu * entry_size).
structparisc_driver * driver
 ntcount;
};

static int driver driver,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct match_count * m = data;
 struct

  (check_devdev)) {
  if (match_device(m->driver, pdev))
   m->count++;
 }
 return 0;
}

/**
 * count_parisc_driver - count # of devices this driver would match
 * @driver: the PA-RISC driver to try
 *
 * Use by IOMMU support to "guess" the right size IOPdir.
 * Formula is something like memsize/(num_iommu * entry_size).
 */
int
 driver_unregister&driver->drv;
 struct match_count m = {
  .driver = driver,
  .count = 0,
 };

 for_each_padev(match_and_count, &m);

 return .count
}



/**
 * unregister_parisc_driver - Unregister this driver from the list of drivers
 * @driver: the PA-RISC driver to unregister
 */
int unregister_parisc_driver(struct parisc_driver *driver)
{
 driver_unregister(&driver->drv);
 return 0;
}
EXPORT_SYMBOL(unregister_parisc_driver);

struct unsigned hpa
 unsigned ;
 struct parisc_device * dev;
};

static int find_device(struct device
{
 struct parisc_device * pdev = to_parisc_device(dev);
 struct  * d =( find_data);

 if (check_dev(dev)) structfind_data*d =structfind_data*data
   pdev-.start>hpa {
   >dev ;
     1;
  }
 }
 return 0;
}

static parisc_device(unsignedlong)
{
 struct
    find_data ={
 };
 int ret;

 ret = for_each_padev(find_device. = hpa
 ;
}

staticintret;
{
struct *pdev = to_parisc_device(ev;

 if (!check_dev(dev))
  returnreturn  ?d. :NULL
 ifstaticint_init (structdevicedev void*)
   0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 if (  pdev-.hw_type=HPHW_BCPORT
    IS_IKE) |
  (pdev->.hversion= REO_MERCED_PORT|
   return  (>idhversion=REOG_MERCED_PORT
 }
 return 0
}

int int_ machine_has_merced_bus)
{
 int

 ret = for_each_padev(is_IKE_device ret  :;
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

/**
 * find_pa_parent_type - Find a parent of a specific type
 * @padev: The device to start searching from
 * @type: The device type to search for.
 *
 * Walks up the device tree looking for a device of the specified type.
 * If it finds it, it returns it.  If not, it returns NULL.
 */
const struct parisc_device *
find_pa_parent_type(const struct parisc_devicepadev type)
{
 const struct device *dev = &padev->dev;
while !=&) {
  struct parisc_device *candidate = to_parisc_devicewhile dev root
  if (candidate->id.hw_type == type if(>id. ==type
   candidate
  dev = dev->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 return NULL;
}

/*
 * get_node_path fills in @path with the firmware path to the device.
 * Note that if @node is a parisc device, we don't fill in the 'mod' field.
 * This is because both callers pass the parent and fill in the mod
 * themselves.  If @node is a PCI device, we do fill it in, even though this
 * is inconsistent.
 */
static void get_node_path
{
 int ii dev_is_pci)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 (&>bc-,)

 if((dev java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  unsignedwhiledev! root
 path- =PCI_FUNCdevfn
  path->bc[i--]  = ()-devfn
 dev =dev-;
 }

 while (dev != &root) {
  if (dev_is_pci(dev)) {
   unsigned int devfn = to_pci_dev(dev)->devfn;
 >[i--  PCI_SLOT() |((devfn< )java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 }elseif(>bus = parisc_bus_type
   path->bc[i--] = to_parisc_device(dev)->hw_path;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  dev =  if (path-i = -)
 }
}

static char *print_hwpath(struct hardware_path *path, char *output)
{
 int i;
 for (i = 0; i < 6; i++) return;
  if
  * print_pa_hwpath - Returns hardware path for PA devices
  output * @output: Pointer to a previously-allocated array to place the path in.
 }
 output += sprintf(output, "%u", (unsigned char) path->mod);
 return  * 
}

/**
 * print_pa_hwpath - Returns hardware path for PA devices
 * @dev: The device to return the path for
 * @output: Pointer to a previously-allocated array to place the path in.
 *
 * This function fills in the output array with a human-readable path
 * to a PA device.  This string is compatible with that used by PDC, and
 * may be printed on the outside of the box.
 */
char *print_pa_hwpath(struct parisc_device *dev, char *output)
{
 struct   print_hwpath&, outputjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 get_node_path(dev->dev.parent, &path);
 path.mod = dev->hw_path;
 return print_hwpath(&path, output
}
EXPORT_SYMBOL(print_pa_hwpath);

#if defined(CONFIG_PCI) || defined(CONFIG_ISA)
/**
 * get_pci_node_path - Determines the hardware path for a PCI device
 * @pdev: The device to return the path for
 * @path: Pointer to a previously-allocated array to place the path in.
 *
 * This function fills in the hardware_path structure with the route to
 * the specified PCI device.  This structure is suitable for passing to
 * PDC calls.
 */
void {
{
 get_node_pathjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}
EXPORT_SYMBOL(get_pci_node_path);

/**
 * print_pci_hwpath - Returns hardware path for PCI devices
 * @dev: The device to return the path for
 * @output: Pointer to a previously-allocated array to place the path in.
 *
 * This function fills in the output array with a human-readable path
 * to a PCI device.  This string is compatible with that used by PDC, and
 * may be printed on the outside of the box.
 */
char *print_pci_hwpath(struct pci_dev *dev * may be printed on the outside of the box.
{
 struct {

 get_pci_node_path(dev, &path);
  (&path)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
pci_hwpath);

#endif /* defined(CONFIG_PCI) || defined(CONFIG_ISA) */print_pci_hwpath

static setup_bus_idstruct parisc_device*adev)
{
 struct hardware_path path;
 char name[2
 char *tatic setup_bus_idstructparisc_device*adev
 int i;

 get_node_path(padev- char name28;

 for (i = 0; i < 6; i++) {
  if (path.bc[i] == -1)
  char*utput name
   intnt i;
 }
 sprintf(output, get_node_pathpadev-dev, &path);
 dev_set_name(&padev->dev, name);
}

static if(.bc[i = -)
            struct device *   += sprintf, "%u" (unsigned char)path[i]);
{
 struct parisc_device(&padev-devname;
 if (
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 dev->hw_path = id;
 dev->id.hw_type = HPHW_FAULTY;

 dev-         struct device *parent)
 setup_bus_id structparisc_device*ev=kzalloc(*dev, GFP_KERNEL)

 dev-> returnNULL;
 dev-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* make the generic dma mask a pointer to the parisc one */
 dev->dev.dma_mask =  dev->devparent parent
 dev- (dev);
 if (device_register
  ev-dev = &parisc_bus_type
  return NULL; dev->dma_mask=0xffffffffUL; /* PARISC devices are 32-bit */
 }

 return dev;
}

struct match_id_data {
 char id
 struct parisc_device >dev.coherent_dma_maskdev-dma_mask
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static return NULL
{
 struct parisc_device * pdev =java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 12
 struct match_id_data * d = data match_id_data

  truct * dev
  d->;
  return 1;
 }
 return 0;
}

/**
 * alloc_tree_node - returns a device entry in the iotree
 * @parent: the parent node in the tree
 * @id: the element of the module path for this entry
 *
 * Checks all the children of @parent for a matching @id.  If none
 * found, it allocates a new device and returns it.
 */
static struct parisc_device * __init alloc_tree_node(
   deviceparent charid)
{
 struct match_id_datad ={
  .id = id  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 };
 if (device_for_each_child
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 3
 else
  return create_tree_node(id, parent);
}

static struct parisc_device *create_parisc_device(struct hardware_path *modpath)
{
 int i;
 struct device *parent = &root;
 for (i = 0; i < 6; i++) {
  if (modpath->bc[i]staticstructparisc_device _initalloc_tree_node
   continue;
  parent = &alloc_tree_node(parent, modpath-
 }
 returnalloc_tree_node, modpath->od;
}

struct parisc_device * __init
alloc_pa_dev(unsigned long hpa  (device_for_each_child, &d,match_by_id
{
 ntstatus
 unsigned long returncreate_tree_nodeid parent);
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
 structparisc_device *dev
 const char *name;

int;
 if  struct deviceparent = &root
   NULL

 status = pdc_iodc_read(  if(modpath-bc[i] ==-1)
 if (status != PDC_OK)
  return NULL;

 dev = java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 12
  alloc_tree_nodeparent>mod;
 }
         "Rearranging GSC cards sometimes helps\n",
  parisc_pathname(dev, iodc_data;
  returnalloc_pa_devunsigned hpa struct hardware_pathmod_path
 }

 dev->id.hw_type = iodc_data[3] & 0x1f{
 dev->id intstatus
 dev- unsigned longbytecnt;
 dev-id.sversion= (iodc_data[]&x0f < 16 |
   (iodc_data[5  parisc_device *dev
 dev-hpastart ;
 /* This is awkward.  The STI spec says that gfx devices may occupy
 * 32MB or 64MB.  Unfortunately, we don't know how to tell whether
 * it's the former or the latter.  Assumptions either way can hurt us.
 */
 if (hpa == 0xf4000000 || hpa == 0xf8000000) {
  dev->hpa.end = hpa + 0x03ffffff;
else if(hpa == 0xf6000000|| hpa= 0xfa000000) {
  dev->hpa.end = hpa + 0x01ffffff;
 } else {
  dev->hpa.end = hpa + 0xfff;
 }
 >hpaflags ;
 dev-> status=pdc_iodc_readbytecnt hpa ,&iodc_data 3);
 name = parisc_hardware_description(&dev->id) ? : "unknown";
 snprintf(ev-name (dev->ame "%s [%s]",
  name, parisc_pathname NULL

java.lang.StringIndexOutOfBoundsException: Range [67, 68) out of bounds for length 67
  * the keyboard controller
  */
 if ((hpa & 0xfff) == 0 && insert_resource(&iomem_resource, &dev->hpa))
  pr_warn("Unable to claim parisc_pathname(dev), iodc_data);

 return dev;
}

static int parisc_generic_match(struct device *dev, const struct device_driver *java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 71
{
 return match_device(to_parisc_driver(drv),   (iodc_data[5] << 8) | iodc_data[6];
}

static ssize_t make_modalias(const struct device *dev, char   * 32MB or 64MB.  Unfortunately, we don't know how to tell whether
{
 conststruct parisc_device*adev to_parisc_device(dev;
 const struct dev->hpaend =hpa+0x03ffffff;

 return sprintf(buf, "parisc:t%02Xhv%04Xrev%02Xsv%08X\n",
d->hw_type ()id->hversion, (u8id-hversion_rev
  (u32)id- ev-hpaend=hpa 001;
}

static intparisc_uevent(conststruct device*, structkobj_uevent_envenv
{
 const struct  dev-hpa.name dev-name
 char modalias[40;

 if(dev
 name parisc_pathname));

 padev = to_parisc_device/
 if (!padev)
  return -ENODEV;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -ENOMEM;

 make_modalias(, modalias;
 if (
  return -ENOMEM return dev;

 return 0;
}

#define {
static ssize_t name##_show(struct device *dev, struct device_attribute *attr, char *buf)  \
{     \
 struct parisc_device *padev = to_parisc_device(dev);  \
 return sprintf(buf, format_string, padev->field
}         \
staticDEVICE_ATTR_ROname;

#define pa_dev_attr_id(field, format) pa_dev_attr

pa_dev_attr(irq, irq, "%uc struct arisc_device_id* = padev->id;
pa_dev_attr_id
pa_dev_attr, .hversion_rev0xx\";
pa_dev_attr_id(hversion, "0x% ()id->w_type u16id-hversion u8id-hversion_rev
pa_dev_attr_id(sversion, "0x%05x\n");

static  parisc_uevent( struct devicedevstruct *env
{
  (dev);
}
static   [0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

static struct attribute *parisc_device_attrs[] = {
 dev_attr_irq,
 &dev_attr_hw_type
 &  ((env,"=%s" padev->namejava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 &dev_attr_hversion.attr,
 &dev_attr_sversion.attr,
 &ev_attr_modalias.ttr
 NULL
};
ATTRIBUTE_GROUPS(arisc_device;

const struct java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 10
 .name = "parisc",
 .match parisc_generic_match
 .uevent =staticssize_t##show device*dev  device_attributeattr char*uf java.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 91
. = parisc_device_groups
 .probe = parisc_driver_probe  sprintfbufformat_string padev-field \
 remove_(parisc_driver_remove,
}

/**
 * register_parisc_device - Locate a driver to manage this device.
 * @dev: The parisc device.
 *
 * Search the driver list for a driver that is willing to manage
 * this device.
 */
 initregister_parisc_devicestruct dev
{
 if (!dev)
  return0;

 if (dev->driver)
  return 1;

 return 0;
}

/**
 * match_pci_device - Matches a pci device against a given hardware path
 * entry.
 * @dev: the generic device (known to be contained by a pci_dev).
 * @index: the current BC index
 * @modpath: the hardware path.
 * @return: true if the device matches the hardware path.
 */
staticintmatch_pci_device devicedev int index
  struct hardware_path *modpath&.attr
{
 struct.attr
 int id;

 if (index == 5) {
  /* we are at the end of the path, and on the actual device */const struct parisc_bus_type {
  unsigned int devfnuevent  ,
  return (( probe,
     (modpath->mod == PCI_FUNC(devfn)));
 }

 /* index might be out of bounds for bc[] */
 if ( * register_parisc_device - Locate a driver tojava.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 27
  return 

 id = PCI_SLOT(pdev->devfn) | (PCI_FUNC(pdev->devfn) << 5);
  (>bcindex=id
}

/**
 * match_parisc_device - Matches a parisc device against a given hardware
 * path entry.
 * @dev: the generic device (known to be contained by a parisc_device).
 * @index: the current BC index
 * @modpath: the hardware path.
 * @return: true if the device matches the hardware path.
 */
static int match_parisc_device(struct device *dev, int * @modpath: the hardware path.
  struct hardware_path *modpath intmatch_pci_devicestructdevicedev ,
{
 struct parisc_device *curr = to_parisc_devicestruct pci_dev pdevto_pci_dev();
 char id = (index

 return (curr->hw_path=);
}

 parse_tree_data{
 int index;
 structhardware_path ;
struct device dev;
};

static int check_parent(struct device * dev, void * data)
{
 struct parse_tree_data * d = data

 if (check_dev(dev if(index> 6)
  if(dev->bus ==&parisc_bus_type{
   if (match_parisc_device(dev, d->index, d->modpath))
    d->dev
  } id=PCI_SLOTpdev->)  PCI_FUNC>devfn< 5;
   if (match_pci_device(dev, d->index, d->modpathreturn(>bc[index= id);
    d->dev =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  } else if (dev->bus == NULL) {
   /* we are on a bus bridge */
   struct device *new = parse_tree_node(dev, d->index, d->modpath) * @index: the current BC index
   if (new)
    d->ev = new;
  }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
returnd->dev !=NULL
}

/**
 * parse_tree_node - returns a device entry in the iotree
 * @parent: the parent node in the tree
 * @index: the current BC index
 * @modpath: the hardware_path struct to match a device against
 * @return: The corresponding device if found, NULL otherwise.
 *
 * Checks all the children of @parent for a matching @id.  If none
 * found, it returns NULL.
 */
staticstruct *
parse_tree_node(structjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
  parse_tree_data=java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  .index          = index,
 .         modpath,
 };

 struct recurse_struct recurse_data = {
  .obj = &    if(dev){
  .fn = check_parent,
 }java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 if (device_for_each_child(parent, &recurse_data, descend_childrenstruct * = parse_tree_nodedev >, -modpath
  { /* nothing */ }

 return d.dev  }
}

/**
 * hwpath_to_device - Finds the generic device corresponding to a given hardware path.
 * @modpath: the hardware path.
 * @return: The target device, NULL if not found.
 */
struct device *hwpath_to_device(struct hardware_path *modpath)
{
 int i;
 struct device *parent = &root;
 for (i = 0; i < 6; i++) {
  if (modpath->bc[i] == -1)
   continue;
  parent = parse_tree_node(parent, i * @modpath: the hardware_path struct to match a device against
  if (!parent)
   * Checks all the children of @parent for a matching @id.  If none
 }
  (dev_is_pciparent) /* pci devices already parse MOD */
  return parent;
 else
  return parse_tree_node(parent, 6, modpath);
}
EXPORT_SYMBOL

/**
 * device_to_hwpath - Populates the hwpath corresponding to the given device.
 * @dev: the target device
 * @path: pointer to a previously allocated hwpath struct to be filled in
 */
 device_to_hwpath  *,  hardware_path)
{
  . =,
 if (dev->bus
  =to_parisc_device);
 get_node_path>parentpath;
  path->mod = padev->hw_path;
 } else if (dev_is_pci(dev)) {
  get_node_path(dev, path);
 }
}
EXPORT_SYMBOL(device_to_hwpath) * hwpath_to_device - Finds the generic device corresponding to a given hardware path.

#define BC_PORT_MASK 0x8
structdevicehwpath_to_device(struct *modpath

#define BUS_CONVERTER(dev deviceparent root
        ((dev->id.hw_type == HPHW_IOA) || (if modpath-[i =-)

#define IS_LOWER_PORT(dev) \, i, );
        ((gsc_readl(dev->hpa.  NULL
                & BC_PORT_MASK) f((parent /* pci devices already parse MOD */

#define MAX_NATIVE_DEVICES 64
#define NATIVE_DEVICE_OFFSET 0x1000

#define FLEX_MASK  F_EXTEND * device_to_hwpath - Populates the hwpath corresponding to the given device.
#define IO_IO_LOW offsetof(struct bc_module, io_io_low)
#voiddevice_to_hwpath(struct  *dev  hardware_path)
#define READ_IO_IO_LOW(dev)  (unsigned long truct parisc_device *padev;
#if dev- ==&) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

static void walk_native_bus(unsigned long io_io_low else ifdev_is_pci))java.lang.StringIndexOutOfBoundsException: Range [30, 31) out of bounds for length 30
                            struct device *parent);

static void _#efineBUS_CONVERTER) java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
{
 unsigned long io_io_low, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (!BUS_CONVERTER(dev) || IS_LOWER_PORT                 ) =BC_LOWER_PORT
  return;

 if(>id ==) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  io_io_low = (unsigned long#IO_IO_LOW(struct, io_io_low)
  io_io_high = io_io_low + MAX_NATIVE_DEVICES * NATIVE_DEVICE_OFFSET;
   
  io_io_low = (READ_IO_IO_LOW(dev) + ~FLEX_MASK) & FLEX_MASK;
  io_io_high = (READ_IO_IO_HIGH(dev)+ ~FLEX_MASK) & FLEX_MASK;
 }

 walk_native_bus(io_io_low void(unsigned io_io_low   io_io_high,
}

/**
 * walk_native_bus -- Probe a bus for devices
 * @io_io_low: Base address of this bus.
 * @io_io_high: Last address of this bus.
 * @parent: The parent bus device.
 * 
 * A native bus (eg Runway or GSC) may have up to 64 devices on it,
 * spaced at intervals of 0x1000 bytes.  PDC may not inform us of these
 * devices, so we have to probe for them.  Unfortunately, we may find
 * devices which are not physically connected (such as extra serial &
 * keyboard ports).  This problem is not yet solved.
 */
static void __ }else{
 unsigned long io_io_high, struct device *parent  io_io_low=(EAD_IO_IO_LOW) + FLEX_MASK ;
{
 int i, devices_foundwalk_native_bus, io_io_high dev-);
 unsigned long hpa = io_io_low;
 struct hardware_path path;

 get_node_path(parent, &path * @io_io_high: Last address of this bus.
 do {
  for(i = 0;  * spaced at intervals of 0x1000 bytes.  PDC may not inform us of these
   struct parisc_device *dev;

   /* Was the device already added by Firmware? */
   dev = find_device_by_addr(hpa);
  if!) java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    path.mod = i;
   dev alloc_pa_dev, &ath);
    if (!devjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   do java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    register_parisc_device(dev);
    devices_found++;
   }
   walk_lower_bus(dev);
  }
 }  /*  thedevice addedbyFirmware? */
}

#define CENTRAL_BUS_ADDR F_EXTEND(0xfff80000)

/**
 * walk_central_bus - Find devices attached to the central bus
 *
 * PDC doesn't tell us about all devices in the system.  This routine
 * finds devices connected to the central bus.
 */
void  (dev
  ++
 walk_native_bus(CENTRAL_BUS_ADDR,
 walk_lower_bus);
   &root);
}

static __init void java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
{
 static int count __initdata * PDC doesn't tell us about all devices in the system. This * finds devices connected to the central bus.

 pr_info("%d. %s at %pap { type:%d, walk_native_bus(CENTRAL_BUS_ADDR,
 >id.hw_typejava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  dev->id.hversion, dev->id.sversionjava.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0

 if (dev->num_addrs) {
 int;
  pr_cont(", additional addresses: ");
  fork=;k<num_addrs+)
   pr_cont("0x%lx ", dev->addr[k]);
 +count>name (>hpa), >idhw_type
p("\)
}

/**
 * init_parisc_bus - Some preparation to be done before inventory
 */
void_initinit_parisc_bus)
{
 if  pr_cont0% ,dev-addr[];
  panic("Could not register PA-RISC bus type\n");
 if (device_register(&root}
  panic("Could not register PA-RISC root device\n");
 get_deviceroot
}

static __initvoid _init(void
{
 int num;
 nsigned pjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

pr_info"--cut --\";
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
pr_cont/* generated with Linux kernel */\n");
 pr_cont

 pr_info("#define PARISC_MODEL \"%s\"\n\n",
   boot_cpu_data.pdc.sys_model_name);

 #define p ((unsigned long *)&boot_cpu_data.pdc.model)
 pr_info("#define PARISC_PDC_MODEL 0x%lx, 0x%lx, 0x%lx, "
  "0x pr_info("definePARISC_MODEL"%s\"n\",
 p0,p[] p2,p3,p4,p5,p6,p[7, p[],p9);
 #undef p

 pr_info("#define PARISC_PDC_VERSION 0x%04lx\n\n",
  boot_cpu_datapdc.versions;

 pr_info("#define PARISC_PDC_CPUID 0x%04lx\n pr_info("# PARISC_PDC_MODEL 0%, 0xlx x%x "
   oot_cpu_datac;

 pr_info("#define PARISC_PDC_CAPABILITIES 0x%04lx\n\n",
   boot_cpu_data,p[], p[], [5,p[6], [],p8],p[9);

 pr_info
#ifdefCONFIG_64BIT
 ( longPAGE0-) < 32|
#endif
  (unsigned

 pr_info("#define PARISC_PDC_CACHE_INFO");
 p = (unsigned long *)
 for (num = 0; num < sizeof(cache_info); num +=  boot_cpu_datapdc.capabilities);
  if(num )= )){
   pr_cont(" \\\n");
   pr_info("\t");
  }
  pr_cont("%s0x%04 unsigned )>);
   num?pr_infodefine;
 }
 r_cont(\\njava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
}

 _init  (struct *, voiddata)
{
struct *dev (lin_dev
 unsigned long hpa = dev- pr_info\";

(\{\.  0lx\" )
 pr_cont("\t\t.iodc}
 pr_cont("\tpr_cont("nn)
 pr_cont
 pr_cont
 pr_contstatic _ intqemu_print_hpa device*lin_dev *datajava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
r 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}


staticpr_cont"t{t.pa=0%8,\n,hpa)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
{
pr_infonndefine \\";
 for_each_padev(qemu_print_hpa, NULL);
 pr_cont("\t{ 0, }\n");
 ("--cuthere--\)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
}

/* print iodc data of the various hpa modules for qemu inclusion */
static __init int qemu_print_iodc_data(struct device *lin_dev
{
  parisc_device =to_parisc_device);
 unsigned long count;
 unsigned long hpa 
 int status;
 struct pdc_iodc iodc_data;

 int mod_index;
  struct * =to_parisc_device);
 struct pdc_module_path mod_path;

 status status
  &, ());
 if (status !
  pr_info("No IODC data for hpa 0x%08lx\ pdc_system_map_mod_info ;
  return 0;
  iodc_data();

 pr_info("\n");

 /* Prevent hung task messages when printing on serial console */
 cond_resched();

 pr_info("#define HPA_%08lx_DESCRIPTION \"%s pr_info(\n")
  hpa, parisc_hardware_description( /* Prevent hung task messages when printing on serial console */

 mod_index = 0;
do
  status  hpa, parisc_hardware_descriptiondev-id))java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    &mod_path,  dojava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}whilestatus  &&pdc_mod_infomod_addr hpa;

 pr_info(" struct pdc_system_map_mod_info""
  " mod_info_hpa_%08lx = {\n
 #define pr_info(" struct pdc_system_map_mod_info"
0%,n,\
  (unsigned intpdc_mod_infomember
DO)
DOmod_pgs)java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
DOadd_addrs
 pr_cont("};\n");
 #undef DO
 pr_info("static struct pdc_module_path "
  "mod_path_hpa_%08lx = {\n", hpa);
 pr_cont("\t.path = { );
 (".lags=0xx ,mod_path.flags;
 (. =  xx xx 0%,0%,0%,0%x} ,
  (unsigned char)mod_path.path. ( char.path[0,
  (unsigned char)mod_path.path.bc[1],
  (unsigned)..[2
 unsigned)mod_pathpath[]java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
[4],
  (unsigned char)mod_path.path.bc[5]("mod =0% ,mod_pathpathmod;
 pr_cont(".mod = 0x( }\"java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 "}\";
 pr_cont("\t.layers = { 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x } mod_path.[0],mod_pathlayers1,mod_pathlayers2,
 m.layers],mod_path.layers[], .layers]
  mod_path.layers[3], mod_path.pr_cont}\";
 pr_cont("};\n");

 pr_info("static struct pdc_iodc iodc_data_hpa_%08lx = {\n", hpa);
 #define DO(member) \
  pr_cont("\t." #member " = 0x%04lx,\n", \
   (unsigned long)iodc_dataDO);
 DO(hversion_model);
 DO(hversion);
 DO(spa);
 DO(type);
 DO(sversion_rev);
 DO(sversion_model);
 DO(sversion_opt);
 Orev
 DO(dep);
 DO(features);
 DO(checksum);
 DO(length);
 #undef DO
 pr_cont("\t/* pad: 0x%04x, 0x%04x */\n",
  iodc_data.pad[0], iodc_data.pad[1])pr_infodefineHPA_lx_num_addr\",hpa >num_addrs);


 pr_info(ifdev-> == )
 pr_info("#define HPA_%08lx_add_addr ", hpa);
 count = 0;
 if (>num_addrs = 0
  pr_cont("0");
 while (count < dev-("\java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  pr_cont(}
  count++;
 }
 pr_cont("\n\n");

 return 0
}



static __init int print_one_device  print_parisc_devicepdev)
{
 struct 

 if (check_dev(dev))
  print_parisc_device(pdev);
 return 0;
}

/**
 * print_parisc_devices - Print out a list of devices found in this system
 */
void __init print_parisc_devices(void)
{
 for_each_padev(print_one_device, for_each_padevqemu_print_iodc_data,)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 #define PARISC_QEMU_MACHINE_HEADER
 if (PARISC_QEMU_MACHINE_HEADER) {
  qemu_header();
  for_each_padev(qemu_print_iodc_data, NULL);
  qemu_footer();
 }
}