}	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 * alloc_tree_node(struct device *parent, char id){	struct match_id_data d = {		.id = id,	};	if (device_for_each_child(parent, &d, match_by_id))		return d.dev;	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] == -1)			continue;		parent = &alloc_tree_node(parent, modpath->bc[i])->dev;	}	return alloc_tree_node(parent, modpath->mod);}struct parisc_device *alloc_pa_dev(unsigned long hpa, struct hardware_path *mod_path){	int status;	unsigned long bytecnt;	u8 iodc_data[32];	struct parisc_device *dev;	const char *name;	/* Check to make sure this device has not already been added - Ryan */	if (find_device_by_addr(hpa) != NULL)		return NULL;	status = pdc_iodc_read(&bytecnt, hpa, 0, &iodc_data, 32);	if (status != PDC_OK)		return NULL;	dev = create_parisc_device(mod_path);	if (dev->id.hw_type != HPHW_FAULTY) {		printk(KERN_ERR "Two devices have hardware path [%s].  "				"IODC data for second device: "				"%02x%02x%02x%02x%02x%02x\n"				"Rearranging GSC cards sometimes helps\n",			parisc_pathname(dev), iodc_data[0], iodc_data[1],			iodc_data[3], iodc_data[4], iodc_data[5], iodc_data[6]);		return NULL;	}	dev->id.hw_type = iodc_data[3] & 0x1f;	dev->id.hversion = (iodc_data[0] << 4) | ((iodc_data[1] & 0xf0) >> 4);	dev->id.hversion_rev = iodc_data[1] & 0x0f;	dev->id.sversion = ((iodc_data[4] & 0x0f) << 16) |			(iodc_data[5] << 8) | iodc_data[6];	dev->hpa.name = parisc_pathname(dev);	dev->hpa.start = hpa;	/* 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;	}	dev->hpa.flags = IORESOURCE_MEM;	name = parisc_hardware_description(&dev->id);	if (name) {		strlcpy(dev->name, name, sizeof(dev->name));	}	/* Silently fail things like mouse ports which are subsumed within	 * the keyboard controller	 */	if ((hpa & 0xfff) == 0 && insert_resource(&iomem_resource, &dev->hpa))		printk("Unable to claim HPA %lx for device %s\n",				hpa, name);	return dev;}static int parisc_generic_match(struct device *dev, struct device_driver *drv){	return match_device(to_parisc_driver(drv), to_parisc_device(dev));}#define pa_dev_attr(name, field, format_string)				\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);		\}#define pa_dev_attr_id(field, format) pa_dev_attr(field, id.field, format)pa_dev_attr(irq, irq, "%u\n");pa_dev_attr_id(hw_type, "0x%02x\n");pa_dev_attr(rev, id.hversion_rev, "0x%x\n");pa_dev_attr_id(hversion, "0x%03x\n");pa_dev_attr_id(sversion, "0x%05x\n");static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf){	struct parisc_device *padev = to_parisc_device(dev);	struct parisc_device_id *id = &padev->id;	return sprintf(buf, "parisc:t%02Xhv%04Xrev%02Xsv%08X\n",		(u8)id->hw_type, (u16)id->hversion, (u8)id->hversion_rev,		(u32)id->sversion);}static struct device_attribute parisc_device_attrs[] = {	__ATTR_RO(irq),	__ATTR_RO(hw_type),	__ATTR_RO(rev),	__ATTR_RO(hversion),	__ATTR_RO(sversion),	__ATTR_RO(modalias),	__ATTR_NULL,};struct bus_type parisc_bus_type = {	.name = "parisc",	.match = parisc_generic_match,	.dev_attrs = parisc_device_attrs,	.probe = parisc_driver_probe,	.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. */int register_parisc_device(struct parisc_device *dev){	if (!dev)		return 0;	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. */static int match_pci_device(struct device *dev, int index,		struct hardware_path *modpath){	struct pci_dev *pdev = to_pci_dev(dev);	int id;	if (index == 5) {		/* we are at the end of the path, and on the actual device */		unsigned int devfn = pdev->devfn;		return ((modpath->bc[5] == PCI_SLOT(devfn)) &&					(modpath->mod == PCI_FUNC(devfn)));	}	id = PCI_SLOT(pdev->devfn) | (PCI_FUNC(pdev->devfn) << 5);	return (modpath->bc[index] == 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 index,		struct hardware_path *modpath){	struct parisc_device *curr = to_parisc_device(dev);	char id = (index == 6) ? modpath->mod : modpath->bc[index];	return (curr->hw_path == id);}struct parse_tree_data {	int index;	struct hardware_path * modpath;	struct device * dev;};static int check_parent(struct device * dev, void * data){	struct parse_tree_data * d = data;	if (check_dev(dev)) {		if (dev->bus == &parisc_bus_type) {			if (match_parisc_device(dev, d->index, d->modpath))				d->dev = dev;		} else if (is_pci_dev(dev)) {			if (match_pci_device(dev, d->index, d->modpath))				d->dev = dev;		} else if (dev->bus == NULL) {			/* we are on a bus bridge */			struct device *new = parse_tree_node(dev, d->index, d->modpath);			if (new)				d->dev = new;		}	}	return d->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. */static struct device *parse_tree_node(struct device *parent, int index, struct hardware_path *modpath){	struct parse_tree_data d = {		.index          = index,		.modpath        = modpath,	};	struct recurse_struct recurse_data = {		.obj	= &d,		.fn	= check_parent,	};	if (device_for_each_child(parent, &recurse_data, descend_children))		/* 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);		if (!parent)			return NULL;	}	if (is_pci_dev(parent)) /* pci devices already parse MOD */		return parent;	else		return parse_tree_node(parent, 6, modpath);}EXPORT_SYMBOL(hwpath_to_device);/** * device_to_hwpath - Populates the hwpath corresponding to the given device. * @param dev the target device * @param path pointer to a previously allocated hwpath struct to be filled in */void device_to_hwpath(struct device *dev, struct hardware_path *path){	struct parisc_device *padev;	if (dev->bus == &parisc_bus_type) {		padev = to_parisc_device(dev);		get_node_path(dev->parent, path);		path->mod = padev->hw_path;	} else if (is_pci_dev(dev)) {		get_node_path(dev, path);	}}EXPORT_SYMBOL(device_to_hwpath);#define BC_PORT_MASK 0x8#define BC_LOWER_PORT 0x8#define BUS_CONVERTER(dev) \        ((dev->id.hw_type == HPHW_IOA) || (dev->id.hw_type == HPHW_BCPORT))#define IS_LOWER_PORT(dev) \        ((gsc_readl(dev->hpa.start + offsetof(struct bc_module, io_status)) \                & BC_PORT_MASK) == BC_LOWER_PORT)#define MAX_NATIVE_DEVICES 64#define NATIVE_DEVICE_OFFSET 0x1000#define FLEX_MASK 	F_EXTEND(0xfffc0000)#define IO_IO_LOW	offsetof(struct bc_module, io_io_low)#define IO_IO_HIGH	offsetof(struct bc_module, io_io_high)#define READ_IO_IO_LOW(dev)  (unsigned long)(signed int)gsc_readl(dev->hpa.start + IO_IO_LOW)#define READ_IO_IO_HIGH(dev) (unsigned long)(signed int)gsc_readl(dev->hpa.start + IO_IO_HIGH)static void walk_native_bus(unsigned long io_io_low, unsigned long io_io_high,                            struct device *parent);void walk_lower_bus(struct parisc_device *dev){	unsigned long io_io_low, io_io_high;	if (!BUS_CONVERTER(dev) || IS_LOWER_PORT(dev))		return;	if (dev->id.hw_type == HPHW_IOA) {		io_io_low = (unsigned long)(signed int)(READ_IO_IO_LOW(dev) << 16);		io_io_high = io_io_low + MAX_NATIVE_DEVICES * NATIVE_DEVICE_OFFSET;	} else {		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, io_io_high, &dev->dev);}/** * 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 walk_native_bus(unsigned long io_io_low, unsigned long io_io_high,                            struct device *parent){	int i, devices_found = 0;	unsigned long hpa = io_io_low;	struct hardware_path path;	get_node_path(parent, &path);	do {		for(i = 0; i < MAX_NATIVE_DEVICES; i++, hpa += NATIVE_DEVICE_OFFSET) {			struct parisc_device *dev;			/* Was the device already added by Firmware? */			dev = find_device_by_addr(hpa);			if (!dev) {				path.mod = i;				dev = alloc_pa_dev(hpa, &path);				if (!dev)					continue;				register_parisc_device(dev);				devices_found++;			}			walk_lower_bus(dev);		}	} while(!devices_found && hpa < io_io_high);}#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 walk_central_bus(void){	walk_native_bus(CENTRAL_BUS_ADDR,			CENTRAL_BUS_ADDR + (MAX_NATIVE_DEVICES * NATIVE_DEVICE_OFFSET),			&root);}static void print_parisc_device(struct parisc_device *dev){	char hw_path[64];	static int count;	print_pa_hwpath(dev, hw_path);	printk(KERN_INFO "%d. %s at 0x%p [%s] { %d, 0x%x, 0x%.3x, 0x%.5x }",		++count, dev->name, (void*) dev->hpa.start, hw_path, dev->id.hw_type,		dev->id.hversion_rev, dev->id.hversion, dev->id.sversion);	if (dev->num_addrs) {		int k;		printk(", additional addresses: ");		for (k = 0; k < dev->num_addrs; k++)			printk("0x%lx ", dev->addr[k]);	}	printk("\n");}/** * init_parisc_bus - Some preparation to be done before inventory */void init_parisc_bus(void){	if (bus_register(&parisc_bus_type))		panic("Could not register PA-RISC bus type\n");	if (device_register(&root))		panic("Could not register PA-RISC root device\n");	get_device(&root);}static int print_one_device(struct device * dev, void * data){	struct parisc_device * pdev = to_parisc_device(dev);	if (check_dev(dev))		print_parisc_device(pdev);	return 0;}/** * print_parisc_devices - Print out a list of devices found in this system */void print_parisc_devices(void){	for_each_padev(print_one_device, NULL);}