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