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