1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Bus & driver management routines for devices within
4  * a MacIO ASIC. Interface to new driver model mostly
5  * stolen from the PCI version.
6  *
7  *  Copyright (C) 2005 Ben. Herrenschmidt (benh@kernel.crashing.org)
8  *
9  * TODO:
10  *
11  *  - Don't probe below media bay by default, but instead provide
12  *    some hooks for media bay to dynamically add/remove it's own
13  *    sub-devices.
14  */
15 
16 #include <linux/string.h>
17 #include <linux/kernel.h>
18 #include <linux/pci.h>
19 #include <linux/pci_ids.h>
20 #include <linux/init.h>
21 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <linux/of.h>
24 #include <linux/of_address.h>
25 #include <linux/of_device.h>
26 #include <linux/of_irq.h>
27 
28 #include <asm/machdep.h>
29 #include <asm/macio.h>
30 #include <asm/pmac_feature.h>
31 
32 #undef DEBUG
33 
34 #define MAX_NODE_NAME_SIZE (20 - 12)
35 
36 static struct macio_chip      *macio_on_hold;
37 
38 static int macio_bus_match(struct device *dev, struct device_driver *drv)
39 {
40 	const struct of_device_id * matches = drv->of_match_table;
41 
42 	if (!matches)
43 		return 0;
44 
45 	return of_match_device(matches, dev) != NULL;
46 }
47 
48 struct macio_dev *macio_dev_get(struct macio_dev *dev)
49 {
50 	struct device *tmp;
51 
52 	if (!dev)
53 		return NULL;
54 	tmp = get_device(&dev->ofdev.dev);
55 	if (tmp)
56 		return to_macio_device(tmp);
57 	else
58 		return NULL;
59 }
60 
61 void macio_dev_put(struct macio_dev *dev)
62 {
63 	if (dev)
64 		put_device(&dev->ofdev.dev);
65 }
66 
67 
68 static int macio_device_probe(struct device *dev)
69 {
70 	int error = -ENODEV;
71 	struct macio_driver *drv;
72 	struct macio_dev *macio_dev;
73 	const struct of_device_id *match;
74 
75 	drv = to_macio_driver(dev->driver);
76 	macio_dev = to_macio_device(dev);
77 
78 	if (!drv->probe)
79 		return error;
80 
81 	macio_dev_get(macio_dev);
82 
83 	match = of_match_device(drv->driver.of_match_table, dev);
84 	if (match)
85 		error = drv->probe(macio_dev, match);
86 	if (error)
87 		macio_dev_put(macio_dev);
88 
89 	return error;
90 }
91 
92 static void macio_device_remove(struct device *dev)
93 {
94 	struct macio_dev * macio_dev = to_macio_device(dev);
95 	struct macio_driver * drv = to_macio_driver(dev->driver);
96 
97 	if (dev->driver && drv->remove)
98 		drv->remove(macio_dev);
99 	macio_dev_put(macio_dev);
100 }
101 
102 static void macio_device_shutdown(struct device *dev)
103 {
104 	struct macio_dev * macio_dev = to_macio_device(dev);
105 	struct macio_driver * drv = to_macio_driver(dev->driver);
106 
107 	if (dev->driver && drv->shutdown)
108 		drv->shutdown(macio_dev);
109 }
110 
111 static int macio_device_suspend(struct device *dev, pm_message_t state)
112 {
113 	struct macio_dev * macio_dev = to_macio_device(dev);
114 	struct macio_driver * drv = to_macio_driver(dev->driver);
115 
116 	if (dev->driver && drv->suspend)
117 		return drv->suspend(macio_dev, state);
118 	return 0;
119 }
120 
121 static int macio_device_resume(struct device * dev)
122 {
123 	struct macio_dev * macio_dev = to_macio_device(dev);
124 	struct macio_driver * drv = to_macio_driver(dev->driver);
125 
126 	if (dev->driver && drv->resume)
127 		return drv->resume(macio_dev);
128 	return 0;
129 }
130 
131 extern const struct attribute_group *macio_dev_groups[];
132 
133 struct bus_type macio_bus_type = {
134        .name	= "macio",
135        .match	= macio_bus_match,
136        .uevent = of_device_uevent_modalias,
137        .probe	= macio_device_probe,
138        .remove	= macio_device_remove,
139        .shutdown = macio_device_shutdown,
140        .suspend	= macio_device_suspend,
141        .resume	= macio_device_resume,
142        .dev_groups = macio_dev_groups,
143 };
144 
145 static int __init macio_bus_driver_init(void)
146 {
147 	return bus_register(&macio_bus_type);
148 }
149 
150 postcore_initcall(macio_bus_driver_init);
151 
152 
153 /**
154  * macio_release_dev - free a macio device structure when all users of it are
155  * finished.
156  * @dev: device that's been disconnected
157  *
158  * Will be called only by the device core when all users of this macio device
159  * are done. This currently means never as we don't hot remove any macio
160  * device yet, though that will happen with mediabay based devices in a later
161  * implementation.
162  */
163 static void macio_release_dev(struct device *dev)
164 {
165 	struct macio_dev *mdev;
166 
167         mdev = to_macio_device(dev);
168 	kfree(mdev);
169 }
170 
171 /**
172  * macio_resource_quirks - tweak or skip some resources for a device
173  * @np: pointer to the device node
174  * @res: resulting resource
175  * @index: index of resource in node
176  *
177  * If this routine returns non-null, then the resource is completely
178  * skipped.
179  */
180 static int macio_resource_quirks(struct device_node *np, struct resource *res,
181 				 int index)
182 {
183 	/* Only quirks for memory resources for now */
184 	if ((res->flags & IORESOURCE_MEM) == 0)
185 		return 0;
186 
187 	/* Grand Central has too large resource 0 on some machines */
188 	if (index == 0 && of_node_name_eq(np, "gc"))
189 		res->end = res->start + 0x1ffff;
190 
191 	/* Airport has bogus resource 2 */
192 	if (index >= 2 && of_node_name_eq(np, "radio"))
193 		return 1;
194 
195 #ifndef CONFIG_PPC64
196 	/* DBDMAs may have bogus sizes */
197 	if ((res->start & 0x0001f000) == 0x00008000)
198 		res->end = res->start + 0xff;
199 #endif /* CONFIG_PPC64 */
200 
201 	/* ESCC parent eats child resources. We could have added a
202 	 * level of hierarchy, but I don't really feel the need
203 	 * for it
204 	 */
205 	if (of_node_name_eq(np, "escc"))
206 		return 1;
207 
208 	/* ESCC has bogus resources >= 3 */
209 	if (index >= 3 && (of_node_name_eq(np, "ch-a") ||
210 			   of_node_name_eq(np, "ch-b")))
211 		return 1;
212 
213 	/* Media bay has too many resources, keep only first one */
214 	if (index > 0 && of_node_name_eq(np, "media-bay"))
215 		return 1;
216 
217 	/* Some older IDE resources have bogus sizes */
218 	if (of_node_name_eq(np, "IDE") || of_node_name_eq(np, "ATA") ||
219 	    of_node_is_type(np, "ide") || of_node_is_type(np, "ata")) {
220 		if (index == 0 && (res->end - res->start) > 0xfff)
221 			res->end = res->start + 0xfff;
222 		if (index == 1 && (res->end - res->start) > 0xff)
223 			res->end = res->start + 0xff;
224 	}
225 	return 0;
226 }
227 
228 static void macio_create_fixup_irq(struct macio_dev *dev, int index,
229 				   unsigned int line)
230 {
231 	unsigned int irq;
232 
233 	irq = irq_create_mapping(NULL, line);
234 	if (!irq) {
235 		dev->interrupt[index].start = irq;
236 		dev->interrupt[index].flags = IORESOURCE_IRQ;
237 		dev->interrupt[index].name = dev_name(&dev->ofdev.dev);
238 	}
239 	if (dev->n_interrupts <= index)
240 		dev->n_interrupts = index + 1;
241 }
242 
243 static void macio_add_missing_resources(struct macio_dev *dev)
244 {
245 	struct device_node *np = dev->ofdev.dev.of_node;
246 	unsigned int irq_base;
247 
248 	/* Gatwick has some missing interrupts on child nodes */
249 	if (dev->bus->chip->type != macio_gatwick)
250 		return;
251 
252 	/* irq_base is always 64 on gatwick. I have no cleaner way to get
253 	 * that value from here at this point
254 	 */
255 	irq_base = 64;
256 
257 	/* Fix SCC */
258 	if (of_node_name_eq(np, "ch-a")) {
259 		macio_create_fixup_irq(dev, 0, 15 + irq_base);
260 		macio_create_fixup_irq(dev, 1,  4 + irq_base);
261 		macio_create_fixup_irq(dev, 2,  5 + irq_base);
262 		printk(KERN_INFO "macio: fixed SCC irqs on gatwick\n");
263 	}
264 
265 	/* Fix media-bay */
266 	if (of_node_name_eq(np, "media-bay")) {
267 		macio_create_fixup_irq(dev, 0, 29 + irq_base);
268 		printk(KERN_INFO "macio: fixed media-bay irq on gatwick\n");
269 	}
270 
271 	/* Fix left media bay childs */
272 	if (dev->media_bay != NULL && of_node_name_eq(np, "floppy")) {
273 		macio_create_fixup_irq(dev, 0, 19 + irq_base);
274 		macio_create_fixup_irq(dev, 1,  1 + irq_base);
275 		printk(KERN_INFO "macio: fixed left floppy irqs\n");
276 	}
277 	if (dev->media_bay != NULL && of_node_name_eq(np, "ata4")) {
278 		macio_create_fixup_irq(dev, 0, 14 + irq_base);
279 		macio_create_fixup_irq(dev, 0,  3 + irq_base);
280 		printk(KERN_INFO "macio: fixed left ide irqs\n");
281 	}
282 }
283 
284 static void macio_setup_interrupts(struct macio_dev *dev)
285 {
286 	struct device_node *np = dev->ofdev.dev.of_node;
287 	unsigned int irq;
288 	int i = 0, j = 0;
289 
290 	for (;;) {
291 		struct resource *res;
292 
293 		if (j >= MACIO_DEV_COUNT_IRQS)
294 			break;
295 		res = &dev->interrupt[j];
296 		irq = irq_of_parse_and_map(np, i++);
297 		if (!irq)
298 			break;
299 		res->start = irq;
300 		res->flags = IORESOURCE_IRQ;
301 		res->name = dev_name(&dev->ofdev.dev);
302 		if (macio_resource_quirks(np, res, i - 1)) {
303 			memset(res, 0, sizeof(struct resource));
304 			continue;
305 		} else
306 			j++;
307 	}
308 	dev->n_interrupts = j;
309 }
310 
311 static void macio_setup_resources(struct macio_dev *dev,
312 				  struct resource *parent_res)
313 {
314 	struct device_node *np = dev->ofdev.dev.of_node;
315 	struct resource r;
316 	int index;
317 
318 	for (index = 0; of_address_to_resource(np, index, &r) == 0; index++) {
319 		struct resource *res;
320 		if (index >= MACIO_DEV_COUNT_RESOURCES)
321 			break;
322 		res = &dev->resource[index];
323 		*res = r;
324 		res->name = dev_name(&dev->ofdev.dev);
325 
326 		if (macio_resource_quirks(np, res, index)) {
327 			memset(res, 0, sizeof(struct resource));
328 			continue;
329 		}
330 		/* Currently, we consider failure as harmless, this may
331 		 * change in the future, once I've found all the device
332 		 * tree bugs in older machines & worked around them
333 		 */
334 		if (insert_resource(parent_res, res)) {
335 			printk(KERN_WARNING "Can't request resource "
336 			       "%d for MacIO device %s\n",
337 			       index, dev_name(&dev->ofdev.dev));
338 		}
339 	}
340 	dev->n_resources = index;
341 }
342 
343 /**
344  * macio_add_one_device - Add one device from OF node to the device tree
345  * @chip: pointer to the macio_chip holding the device
346  * @np: pointer to the device node in the OF tree
347  * @in_bay: set to 1 if device is part of a media-bay
348  *
349  * When media-bay is changed to hotswap drivers, this function will
350  * be exposed to the bay driver some way...
351  */
352 static struct macio_dev * macio_add_one_device(struct macio_chip *chip,
353 					       struct device *parent,
354 					       struct device_node *np,
355 					       struct macio_dev *in_bay,
356 					       struct resource *parent_res)
357 {
358 	char name[MAX_NODE_NAME_SIZE + 1];
359 	struct macio_dev *dev;
360 	const u32 *reg;
361 
362 	if (np == NULL)
363 		return NULL;
364 
365 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
366 	if (!dev)
367 		return NULL;
368 
369 	dev->bus = &chip->lbus;
370 	dev->media_bay = in_bay;
371 	dev->ofdev.dev.of_node = np;
372 	dev->ofdev.archdata.dma_mask = 0xffffffffUL;
373 	dev->ofdev.dev.dma_mask = &dev->ofdev.archdata.dma_mask;
374 	dev->ofdev.dev.coherent_dma_mask = dev->ofdev.archdata.dma_mask;
375 	dev->ofdev.dev.parent = parent;
376 	dev->ofdev.dev.bus = &macio_bus_type;
377 	dev->ofdev.dev.release = macio_release_dev;
378 	dev->ofdev.dev.dma_parms = &dev->dma_parms;
379 
380 	/* Standard DMA paremeters */
381 	dma_set_max_seg_size(&dev->ofdev.dev, 65536);
382 	dma_set_seg_boundary(&dev->ofdev.dev, 0xffffffff);
383 
384 #if defined(CONFIG_PCI) && defined(CONFIG_DMA_OPS)
385 	/* Set the DMA ops to the ones from the PCI device, this could be
386 	 * fishy if we didn't know that on PowerMac it's always direct ops
387 	 * or iommu ops that will work fine
388 	 *
389 	 * To get all the fields, copy all archdata
390 	 */
391 	dev->ofdev.dev.archdata = chip->lbus.pdev->dev.archdata;
392 	dev->ofdev.dev.dma_ops = chip->lbus.pdev->dev.dma_ops;
393 #endif /* CONFIG_PCI && CONFIG_DMA_OPS */
394 
395 #ifdef DEBUG
396 	printk("preparing mdev @%p, ofdev @%p, dev @%p, kobj @%p\n",
397 	       dev, &dev->ofdev, &dev->ofdev.dev, &dev->ofdev.dev.kobj);
398 #endif
399 
400 	/* MacIO itself has a different reg, we use it's PCI base */
401 	snprintf(name, sizeof(name), "%pOFn", np);
402 	if (np == chip->of_node) {
403 		dev_set_name(&dev->ofdev.dev, "%1d.%08x:%.*s",
404 			     chip->lbus.index,
405 #ifdef CONFIG_PCI
406 			(unsigned int)pci_resource_start(chip->lbus.pdev, 0),
407 #else
408 			0, /* NuBus may want to do something better here */
409 #endif
410 			MAX_NODE_NAME_SIZE, name);
411 	} else {
412 		reg = of_get_property(np, "reg", NULL);
413 		dev_set_name(&dev->ofdev.dev, "%1d.%08x:%.*s",
414 			     chip->lbus.index,
415 			     reg ? *reg : 0, MAX_NODE_NAME_SIZE, name);
416 	}
417 
418 	/* Setup interrupts & resources */
419 	macio_setup_interrupts(dev);
420 	macio_setup_resources(dev, parent_res);
421 	macio_add_missing_resources(dev);
422 
423 	/* Register with core */
424 	if (of_device_register(&dev->ofdev) != 0) {
425 		printk(KERN_DEBUG"macio: device registration error for %s!\n",
426 		       dev_name(&dev->ofdev.dev));
427 		kfree(dev);
428 		return NULL;
429 	}
430 
431 	return dev;
432 }
433 
434 static int macio_skip_device(struct device_node *np)
435 {
436 	return of_node_name_prefix(np, "battery") ||
437 	       of_node_name_prefix(np, "escc-legacy");
438 }
439 
440 /**
441  * macio_pci_add_devices - Adds sub-devices of mac-io to the device tree
442  * @chip: pointer to the macio_chip holding the devices
443  *
444  * This function will do the job of extracting devices from the
445  * Open Firmware device tree, build macio_dev structures and add
446  * them to the Linux device tree.
447  *
448  * For now, childs of media-bay are added now as well. This will
449  * change rsn though.
450  */
451 static void macio_pci_add_devices(struct macio_chip *chip)
452 {
453 	struct device_node *np, *pnode;
454 	struct macio_dev *rdev, *mdev, *mbdev = NULL, *sdev = NULL;
455 	struct device *parent = NULL;
456 	struct resource *root_res = &iomem_resource;
457 
458 	/* Add a node for the macio bus itself */
459 #ifdef CONFIG_PCI
460 	if (chip->lbus.pdev) {
461 		parent = &chip->lbus.pdev->dev;
462 		root_res = &chip->lbus.pdev->resource[0];
463 	}
464 #endif
465 	pnode = of_node_get(chip->of_node);
466 	if (pnode == NULL)
467 		return;
468 
469 	/* Add macio itself to hierarchy */
470 	rdev = macio_add_one_device(chip, parent, pnode, NULL, root_res);
471 	if (rdev == NULL)
472 		return;
473 	root_res = &rdev->resource[0];
474 
475 	/* First scan 1st level */
476 	for_each_child_of_node(pnode, np) {
477 		if (macio_skip_device(np))
478 			continue;
479 		of_node_get(np);
480 		mdev = macio_add_one_device(chip, &rdev->ofdev.dev, np, NULL,
481 					    root_res);
482 		if (mdev == NULL)
483 			of_node_put(np);
484 		else if (of_node_name_prefix(np, "media-bay"))
485 			mbdev = mdev;
486 		else if (of_node_name_prefix(np, "escc"))
487 			sdev = mdev;
488 	}
489 
490 	/* Add media bay devices if any */
491 	if (mbdev) {
492 		pnode = mbdev->ofdev.dev.of_node;
493 		for_each_child_of_node(pnode, np) {
494 			if (macio_skip_device(np))
495 				continue;
496 			of_node_get(np);
497 			if (macio_add_one_device(chip, &mbdev->ofdev.dev, np,
498 						 mbdev,  root_res) == NULL)
499 				of_node_put(np);
500 		}
501 	}
502 
503 	/* Add serial ports if any */
504 	if (sdev) {
505 		pnode = sdev->ofdev.dev.of_node;
506 		for_each_child_of_node(pnode, np) {
507 			if (macio_skip_device(np))
508 				continue;
509 			of_node_get(np);
510 			if (macio_add_one_device(chip, &sdev->ofdev.dev, np,
511 						 NULL, root_res) == NULL)
512 				of_node_put(np);
513 		}
514 	}
515 }
516 
517 
518 /**
519  * macio_register_driver - Registers a new MacIO device driver
520  * @drv: pointer to the driver definition structure
521  */
522 int macio_register_driver(struct macio_driver *drv)
523 {
524 	/* initialize common driver fields */
525 	drv->driver.bus = &macio_bus_type;
526 
527 	/* register with core */
528 	return driver_register(&drv->driver);
529 }
530 
531 /**
532  * macio_unregister_driver - Unregisters a new MacIO device driver
533  * @drv: pointer to the driver definition structure
534  */
535 void macio_unregister_driver(struct macio_driver *drv)
536 {
537 	driver_unregister(&drv->driver);
538 }
539 
540 /* Managed MacIO resources */
541 struct macio_devres {
542 	u32	res_mask;
543 };
544 
545 static void maciom_release(struct device *gendev, void *res)
546 {
547 	struct macio_dev *dev = to_macio_device(gendev);
548 	struct macio_devres *dr = res;
549 	int i, max;
550 
551 	max = min(dev->n_resources, 32);
552 	for (i = 0; i < max; i++) {
553 		if (dr->res_mask & (1 << i))
554 			macio_release_resource(dev, i);
555 	}
556 }
557 
558 int macio_enable_devres(struct macio_dev *dev)
559 {
560 	struct macio_devres *dr;
561 
562 	dr = devres_find(&dev->ofdev.dev, maciom_release, NULL, NULL);
563 	if (!dr) {
564 		dr = devres_alloc(maciom_release, sizeof(*dr), GFP_KERNEL);
565 		if (!dr)
566 			return -ENOMEM;
567 	}
568 	return devres_get(&dev->ofdev.dev, dr, NULL, NULL) != NULL;
569 }
570 
571 static struct macio_devres * find_macio_dr(struct macio_dev *dev)
572 {
573 	return devres_find(&dev->ofdev.dev, maciom_release, NULL, NULL);
574 }
575 
576 /**
577  *	macio_request_resource - Request an MMIO resource
578  * 	@dev: pointer to the device holding the resource
579  *	@resource_no: resource number to request
580  *	@name: resource name
581  *
582  *	Mark  memory region number @resource_no associated with MacIO
583  *	device @dev as being reserved by owner @name.  Do not access
584  *	any address inside the memory regions unless this call returns
585  *	successfully.
586  *
587  *	Returns 0 on success, or %EBUSY on error.  A warning
588  *	message is also printed on failure.
589  */
590 int macio_request_resource(struct macio_dev *dev, int resource_no,
591 			   const char *name)
592 {
593 	struct macio_devres *dr = find_macio_dr(dev);
594 
595 	if (macio_resource_len(dev, resource_no) == 0)
596 		return 0;
597 
598 	if (!request_mem_region(macio_resource_start(dev, resource_no),
599 				macio_resource_len(dev, resource_no),
600 				name))
601 		goto err_out;
602 
603 	if (dr && resource_no < 32)
604 		dr->res_mask |= 1 << resource_no;
605 
606 	return 0;
607 
608 err_out:
609 	printk (KERN_WARNING "MacIO: Unable to reserve resource #%d:%lx@%lx"
610 		" for device %s\n",
611 		resource_no,
612 		macio_resource_len(dev, resource_no),
613 		macio_resource_start(dev, resource_no),
614 		dev_name(&dev->ofdev.dev));
615 	return -EBUSY;
616 }
617 
618 /**
619  * macio_release_resource - Release an MMIO resource
620  * @dev: pointer to the device holding the resource
621  * @resource_no: resource number to release
622  */
623 void macio_release_resource(struct macio_dev *dev, int resource_no)
624 {
625 	struct macio_devres *dr = find_macio_dr(dev);
626 
627 	if (macio_resource_len(dev, resource_no) == 0)
628 		return;
629 	release_mem_region(macio_resource_start(dev, resource_no),
630 			   macio_resource_len(dev, resource_no));
631 	if (dr && resource_no < 32)
632 		dr->res_mask &= ~(1 << resource_no);
633 }
634 
635 /**
636  *	macio_request_resources - Reserve all memory resources
637  *	@dev: MacIO device whose resources are to be reserved
638  *	@name: Name to be associated with resource.
639  *
640  *	Mark all memory regions associated with MacIO device @dev as
641  *	being reserved by owner @name.  Do not access any address inside
642  *	the memory regions unless this call returns successfully.
643  *
644  *	Returns 0 on success, or %EBUSY on error.  A warning
645  *	message is also printed on failure.
646  */
647 int macio_request_resources(struct macio_dev *dev, const char *name)
648 {
649 	int i;
650 
651 	for (i = 0; i < dev->n_resources; i++)
652 		if (macio_request_resource(dev, i, name))
653 			goto err_out;
654 	return 0;
655 
656 err_out:
657 	while(--i >= 0)
658 		macio_release_resource(dev, i);
659 
660 	return -EBUSY;
661 }
662 
663 /**
664  *	macio_release_resources - Release reserved memory resources
665  *	@dev: MacIO device whose resources were previously reserved
666  */
667 
668 void macio_release_resources(struct macio_dev *dev)
669 {
670 	int i;
671 
672 	for (i = 0; i < dev->n_resources; i++)
673 		macio_release_resource(dev, i);
674 }
675 
676 
677 #ifdef CONFIG_PCI
678 
679 static int macio_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
680 {
681 	struct device_node* np;
682 	struct macio_chip* chip;
683 
684 	if (ent->vendor != PCI_VENDOR_ID_APPLE)
685 		return -ENODEV;
686 
687 	/* Note regarding refcounting: We assume pci_device_to_OF_node() is
688 	 * ported to new OF APIs and returns a node with refcount incremented.
689 	 */
690 	np = pci_device_to_OF_node(pdev);
691 	if (np == NULL)
692 		return -ENODEV;
693 
694 	/* The above assumption is wrong !!!
695 	 * fix that here for now until I fix the arch code
696 	 */
697 	of_node_get(np);
698 
699 	/* We also assume that pmac_feature will have done a get() on nodes
700 	 * stored in the macio chips array
701 	 */
702 	chip = macio_find(np, macio_unknown);
703        	of_node_put(np);
704 	if (chip == NULL)
705 		return -ENODEV;
706 
707 	/* XXX Need locking ??? */
708 	if (chip->lbus.pdev == NULL) {
709 		chip->lbus.pdev = pdev;
710 		chip->lbus.chip = chip;
711 		pci_set_drvdata(pdev, &chip->lbus);
712 		pci_set_master(pdev);
713 	}
714 
715 	printk(KERN_INFO "MacIO PCI driver attached to %s chipset\n",
716 		chip->name);
717 
718 	/*
719 	 * HACK ALERT: The WallStreet PowerBook and some OHare based machines
720 	 * have 2 macio ASICs. I must probe the "main" one first or IDE
721 	 * ordering will be incorrect. So I put on "hold" the second one since
722 	 * it seem to appear first on PCI
723 	 */
724 	if (chip->type == macio_gatwick || chip->type == macio_ohareII)
725 		if (macio_chips[0].lbus.pdev == NULL) {
726 			macio_on_hold = chip;
727 			return 0;
728 		}
729 
730 	macio_pci_add_devices(chip);
731 	if (macio_on_hold && macio_chips[0].lbus.pdev != NULL) {
732 		macio_pci_add_devices(macio_on_hold);
733 		macio_on_hold = NULL;
734 	}
735 
736 	return 0;
737 }
738 
739 static void macio_pci_remove(struct pci_dev* pdev)
740 {
741 	panic("removing of macio-asic not supported !\n");
742 }
743 
744 /*
745  * MacIO is matched against any Apple ID, it's probe() function
746  * will then decide wether it applies or not
747  */
748 static const struct pci_device_id pci_ids[] = { {
749 	.vendor		= PCI_VENDOR_ID_APPLE,
750 	.device		= PCI_ANY_ID,
751 	.subvendor	= PCI_ANY_ID,
752 	.subdevice	= PCI_ANY_ID,
753 
754 	}, { /* end: all zeroes */ }
755 };
756 MODULE_DEVICE_TABLE (pci, pci_ids);
757 
758 /* pci driver glue; this is a "new style" PCI driver module */
759 static struct pci_driver macio_pci_driver = {
760 	.name		= "macio",
761 	.id_table	= pci_ids,
762 
763 	.probe		= macio_pci_probe,
764 	.remove		= macio_pci_remove,
765 };
766 
767 #endif /* CONFIG_PCI */
768 
769 static int __init macio_module_init (void)
770 {
771 #ifdef CONFIG_PCI
772 	int rc;
773 
774 	rc = pci_register_driver(&macio_pci_driver);
775 	if (rc)
776 		return rc;
777 #endif /* CONFIG_PCI */
778 	return 0;
779 }
780 
781 module_init(macio_module_init);
782 
783 EXPORT_SYMBOL(macio_register_driver);
784 EXPORT_SYMBOL(macio_unregister_driver);
785 EXPORT_SYMBOL(macio_dev_get);
786 EXPORT_SYMBOL(macio_dev_put);
787 EXPORT_SYMBOL(macio_request_resource);
788 EXPORT_SYMBOL(macio_release_resource);
789 EXPORT_SYMBOL(macio_request_resources);
790 EXPORT_SYMBOL(macio_release_resources);
791 EXPORT_SYMBOL(macio_enable_devres);
792 
793