1 /*
2 * Standard Hot Plug Controller Driver
3 *
4 * Copyright (C) 1995,2001 Compaq Computer Corporation
5 * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
6 * Copyright (C) 2001 IBM Corp.
7 * Copyright (C) 2003-2004 Intel Corporation
8 *
9 * All rights reserved.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or (at
14 * your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
19 * NON INFRINGEMENT. See the GNU General Public License for more
20 * details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 *
26 * Send feedback to <greg@kroah.com>, <dely.l.sy@intel.com>
27 *
28 */
29
30 #include <linux/config.h>
31 #include <linux/module.h>
32 #include <linux/kernel.h>
33 #include <linux/types.h>
34 #include <linux/slab.h>
35 #include <linux/tqueue.h>
36 #include <linux/proc_fs.h>
37 #include <linux/pci.h>
38 #include "shpchp.h"
39 #ifndef CONFIG_IA64
40 #include "../../arch/i386/kernel/pci-i386.h" /* horrible hack showing how processor dependant we are... */
41 #endif
42
is_pci_dev_in_use(struct pci_dev * dev)43 static int is_pci_dev_in_use(struct pci_dev* dev)
44 {
45 /*
46 * dev->driver will be set if the device is in use by a new-style
47 * driver -- otherwise, check the device's regions to see if any
48 * driver has claimed them
49 */
50
51 int i, inuse=0;
52
53 if (dev->driver) return 1; /* Assume driver feels responsible */
54
55 for (i = 0; !dev->driver && !inuse && (i < 6); i++) {
56 if (!pci_resource_start(dev, i))
57 continue;
58
59 if (pci_resource_flags(dev, i) & IORESOURCE_IO)
60 inuse = check_region(pci_resource_start(dev, i),
61 pci_resource_len(dev, i));
62 else if (pci_resource_flags(dev, i) & IORESOURCE_MEM)
63 inuse = check_mem_region(pci_resource_start(dev, i),
64 pci_resource_len(dev, i));
65 }
66
67 return inuse;
68
69 }
70
71
pci_hp_remove_device(struct pci_dev * dev)72 static int pci_hp_remove_device(struct pci_dev *dev)
73 {
74 if (is_pci_dev_in_use(dev)) {
75 err("***Cannot safely power down device -- "
76 "it appears to be in use***\n");
77 return -EBUSY;
78 }
79 pci_remove_device(dev);
80 return 0;
81 }
82
83
configure_visit_pci_dev(struct pci_dev_wrapped * wrapped_dev,struct pci_bus_wrapped * wrapped_bus)84 static int configure_visit_pci_dev (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus)
85 {
86 struct pci_bus* bus = wrapped_bus->bus;
87 struct pci_dev* dev = wrapped_dev->dev;
88 struct pci_func *temp_func;
89 int i=0;
90
91 dbg("%s: Enter\n", __FUNCTION__);
92 /* We need to fix up the hotplug function representation with the linux representation */
93 do {
94 temp_func = shpchp_slot_find(dev->bus->number, dev->devfn >> 3, i++);
95 dbg("%s: i %d temp_func %p, bus %x dev %x\n", __FUNCTION__, i, temp_func,
96 dev->bus->number, dev->devfn >>3);
97 } while (temp_func && (temp_func->function != (dev->devfn & 0x07)));
98
99 if (temp_func) {
100 temp_func->pci_dev = dev;
101 dbg("%s: dev %p dev->irq %x\n", __FUNCTION__, dev, dev->irq);
102 } else {
103 /* We did not even find a hotplug rep of the function, create it
104 * This code might be taken out if we can guarantee the creation of functions
105 * in parallel (hotplug and Linux at the same time).
106 */
107 dbg("@@@@@@@@@@@ shpchp_slot_create in %s\n", __FUNCTION__);
108 temp_func = shpchp_slot_create(bus->number);
109 if (temp_func == NULL)
110 return -ENOMEM;
111 temp_func->pci_dev = dev;
112 }
113
114 /* Create /proc/bus/pci proc entry for this device and bus device is on */
115 /* Notify the drivers of the change */
116 if (temp_func->pci_dev) {
117 dbg("%s: PCI_ID=%04X:%04X\n", __FUNCTION__, temp_func->pci_dev->vendor,
118 temp_func->pci_dev->device);
119 dbg("%s: PCI BUS %x DEVFN %x\n", __FUNCTION__, temp_func->pci_dev->bus->number,
120 temp_func->pci_dev->devfn);
121 dbg("%s: PCI_SLOT_NAME %s\n", __FUNCTION__,
122 temp_func->pci_dev->slot_name);
123 pci_enable_device(temp_func->pci_dev);
124 pci_proc_attach_device(temp_func->pci_dev);
125 pci_announce_device_to_drivers(temp_func->pci_dev);
126 }
127
128 return 0;
129 }
130
131
unconfigure_visit_pci_dev_phase2(struct pci_dev_wrapped * wrapped_dev,struct pci_bus_wrapped * wrapped_bus)132 static int unconfigure_visit_pci_dev_phase2 (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus)
133 {
134 struct pci_dev* dev = wrapped_dev->dev;
135
136 struct pci_func *temp_func;
137 int i=0;
138
139 /* We need to remove the hotplug function representation with the linux representation */
140 do {
141 temp_func = shpchp_slot_find(dev->bus->number, dev->devfn >> 3, i++);
142 if (temp_func) {
143 dbg("temp_func->function = %d\n", temp_func->function);
144 }
145 } while (temp_func && (temp_func->function != (dev->devfn & 0x07)));
146
147 /* Now, remove the Linux Representation */
148 if (dev) {
149 if (pci_hp_remove_device(dev) == 0) {
150 kfree(dev); /* Now, remove */
151 } else {
152 return -1; /* problems while freeing, abort visitation */
153 }
154 }
155
156 if (temp_func) {
157 temp_func->pci_dev = NULL;
158 } else {
159 dbg("No pci_func representation for bus, devfn = %d, %x\n", dev->bus->number, dev->devfn);
160 }
161
162 return 0;
163 }
164
165
unconfigure_visit_pci_bus_phase2(struct pci_bus_wrapped * wrapped_bus,struct pci_dev_wrapped * wrapped_dev)166 static int unconfigure_visit_pci_bus_phase2 (struct pci_bus_wrapped *wrapped_bus, struct pci_dev_wrapped *wrapped_dev)
167 {
168 struct pci_bus* bus = wrapped_bus->bus;
169
170 /* The cleanup code for proc entries regarding buses should be in the kernel...*/
171 if (bus->procdir)
172 dbg("detach_pci_bus %s\n", bus->procdir->name);
173 pci_proc_detach_bus(bus);
174 /* The cleanup code should live in the kernel... */
175 bus->self->subordinate = NULL;
176 /* Unlink from parent bus */
177 list_del(&bus->node);
178
179 /* Now, remove */
180 if (bus)
181 kfree(bus);
182
183 return 0;
184 }
185
186
unconfigure_visit_pci_dev_phase1(struct pci_dev_wrapped * wrapped_dev,struct pci_bus_wrapped * wrapped_bus)187 static int unconfigure_visit_pci_dev_phase1 (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus)
188 {
189 struct pci_dev* dev = wrapped_dev->dev;
190 int rc;
191
192 dbg("attempting removal of driver for device (%x, %x, %x)\n", dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
193 /* Now, remove the Linux Driver Representation */
194 if (dev->driver) {
195 if (dev->driver->remove) {
196 dev->driver->remove(dev);
197 dbg("driver was properly removed\n");
198 }
199 dev->driver = NULL;
200 }
201
202 rc = is_pci_dev_in_use(dev);
203 if (rc)
204 info("%s: device still in use\n", __FUNCTION__);
205 return rc;
206 }
207
208
209 static struct pci_visit configure_functions = {
210 .visit_pci_dev = configure_visit_pci_dev,
211 };
212
213
214 static struct pci_visit unconfigure_functions_phase1 = {
215 .post_visit_pci_dev = unconfigure_visit_pci_dev_phase1
216 };
217
218 static struct pci_visit unconfigure_functions_phase2 = {
219 .post_visit_pci_bus = unconfigure_visit_pci_bus_phase2,
220 .post_visit_pci_dev = unconfigure_visit_pci_dev_phase2
221 };
222
223
shpchp_configure_device(struct controller * ctrl,struct pci_func * func)224 int shpchp_configure_device (struct controller* ctrl, struct pci_func* func)
225 {
226 unsigned char bus;
227 struct pci_dev dev0;
228 struct pci_bus *child;
229 struct pci_dev* temp;
230 int rc = 0;
231
232 struct pci_dev_wrapped wrapped_dev;
233 struct pci_bus_wrapped wrapped_bus;
234
235 dbg("%s: Enter\n", __FUNCTION__);
236 memset(&wrapped_dev, 0, sizeof(struct pci_dev_wrapped));
237 memset(&wrapped_bus, 0, sizeof(struct pci_bus_wrapped));
238
239 memset(&dev0, 0, sizeof(struct pci_dev));
240
241 dbg("%s: func->pci_dev %p\n", __FUNCTION__, func->pci_dev);
242 if (func->pci_dev != NULL)
243 dbg("%s: func->pci_dev->irq %x\n", __FUNCTION__, func->pci_dev->irq);
244 if (func->pci_dev == NULL)
245 func->pci_dev = pci_find_slot(func->bus, (func->device << 3) | (func->function & 0x7));
246 dbg("%s: after pci_find_slot, func->pci_dev %p\n", __FUNCTION__, func->pci_dev);
247 if (func->pci_dev != NULL)
248 dbg("%s: after pci_find_slot, func->pci_dev->irq %x\n", __FUNCTION__, func->pci_dev->irq);
249
250 /* Still NULL ? Well then scan for it ! */
251 if (func->pci_dev == NULL) {
252 dbg("%s: pci_dev still null. do pci_scan_slot\n", __FUNCTION__);
253 dev0.bus = ctrl->pci_dev->subordinate;
254 dbg("%s: dev0.bus %p\n", __FUNCTION__, dev0.bus);
255 dev0.bus->number = func->bus;
256 dbg("%s: dev0.bus->number %x\n", __FUNCTION__, func->bus);
257 dev0.devfn = PCI_DEVFN(func->device, func->function);
258 dev0.sysdata = ctrl->pci_dev->sysdata;
259
260 /* this will generate pci_dev structures for all functions,
261 * but we will only call this case when lookup fails
262 */
263 dbg("%s: dev0.irq %x\n", __FUNCTION__, dev0.irq);
264 func->pci_dev = pci_scan_slot(&dev0);
265 dbg("%s: func->pci_dev->irq %x\n", __FUNCTION__,
266 func->pci_dev->irq);
267 if (func->pci_dev == NULL) {
268 dbg("ERROR: pci_dev still null\n");
269 return 0;
270 }
271 }
272
273 if (func->pci_dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
274 pci_read_config_byte(func->pci_dev, PCI_SECONDARY_BUS, &bus);
275 child = (struct pci_bus*) pci_add_new_bus(func->pci_dev->bus, (func->pci_dev), bus);
276 dbg("%s: calling pci_do_scan_bus\n", __FUNCTION__);
277 pci_do_scan_bus(child);
278
279 }
280
281 temp = func->pci_dev;
282 dbg("%s: func->pci_dev->irq %x\n", __FUNCTION__, func->pci_dev->irq);
283
284 if (temp) {
285 wrapped_dev.dev = temp;
286 wrapped_bus.bus = temp->bus;
287 rc = pci_visit_dev(&configure_functions, &wrapped_dev, &wrapped_bus);
288 }
289
290 dbg("%s: Exit\n", __FUNCTION__);
291 return rc;
292 }
293
294
shpchp_unconfigure_device(struct pci_func * func)295 int shpchp_unconfigure_device(struct pci_func* func)
296 {
297 int rc = 0;
298 int j;
299 struct pci_dev_wrapped wrapped_dev;
300 struct pci_bus_wrapped wrapped_bus;
301
302 memset(&wrapped_dev, 0, sizeof(struct pci_dev_wrapped));
303 memset(&wrapped_bus, 0, sizeof(struct pci_bus_wrapped));
304
305 dbg("%s: bus/dev/func = %x/%x/%x\n", __FUNCTION__, func->bus, func->device, func->function);
306
307 for (j=0; j<8 ; j++) {
308 struct pci_dev* temp = pci_find_slot(func->bus, (func->device << 3) | j);
309 if (temp) {
310 wrapped_dev.dev = temp;
311 wrapped_bus.bus = temp->bus;
312 rc = pci_visit_dev(&unconfigure_functions_phase1, &wrapped_dev, &wrapped_bus);
313 if (rc)
314 break;
315
316 rc = pci_visit_dev(&unconfigure_functions_phase2, &wrapped_dev, &wrapped_bus);
317 if (rc)
318 break;
319 }
320 }
321 return rc;
322 }
323
324 /*
325 * shpchp_set_irq
326 *
327 * @bus_num: bus number of PCI device
328 * @dev_num: device number of PCI device
329 * @slot: pointer to u8 where slot number will be returned
330 */
shpchp_set_irq(u8 bus_num,u8 dev_num,u8 int_pin,u8 irq_num)331 int shpchp_set_irq (u8 bus_num, u8 dev_num, u8 int_pin, u8 irq_num)
332 {
333 #if defined(CONFIG_X86) && !defined(CONFIG_X86_IO_APIC) && !defined(CONFIG_X86_64)
334 int rc;
335 u16 temp_word;
336 struct pci_dev fakedev;
337 struct pci_bus fakebus;
338
339 fakedev.devfn = dev_num << 3;
340 fakedev.bus = &fakebus;
341 fakebus.number = bus_num;
342 dbg("%s: dev %d, bus %d, pin %d, num %d\n",
343 __FUNCTION__, dev_num, bus_num, int_pin, irq_num);
344 rc = pcibios_set_irq_routing(&fakedev, int_pin - 0x0a, irq_num);
345 dbg("%s: rc %d\n", __FUNCTION__, rc);
346 if (!rc)
347 return !rc;
348
349 /* set the Edge Level Control Register (ELCR) */
350 temp_word = inb(0x4d0);
351 temp_word |= inb(0x4d1) << 8;
352
353 temp_word |= 0x01 << irq_num;
354
355 /* This should only be for x86 as it sets the Edge Level Control Register */
356 outb((u8) (temp_word & 0xFF), 0x4d0);
357 outb((u8) ((temp_word & 0xFF00) >> 8), 0x4d1);
358 #endif
359 return 0;
360 }
361
362 /* More PCI configuration routines; this time centered around hotplug controller */
363
364
365 /*
366 * shpchp_save_config
367 *
368 * Reads configuration for all slots in a PCI bus and saves info.
369 *
370 * Note: For non-hot plug busses, the slot # saved is the device #
371 *
372 * returns 0 if success
373 */
shpchp_save_config(struct controller * ctrl,int busnumber,int num_ctlr_slots,int first_device_num)374 int shpchp_save_config(struct controller *ctrl, int busnumber, int num_ctlr_slots, int first_device_num)
375 {
376 int rc;
377 u8 class_code;
378 u8 header_type;
379 u32 ID;
380 u8 secondary_bus;
381 struct pci_func *new_slot;
382 int sub_bus;
383 int FirstSupported;
384 int LastSupported;
385 int max_functions;
386 int function;
387 u8 DevError;
388 int device = 0;
389 int cloop = 0;
390 int stop_it;
391 int index;
392 int is_hot_plug = num_ctlr_slots || first_device_num;
393 struct pci_bus lpci_bus, *pci_bus;
394
395 dbg("%s: num_ctlr_slots = %d, first_device_num = %d\n", __FUNCTION__, num_ctlr_slots, first_device_num);
396
397 memcpy(&lpci_bus, ctrl->pci_dev->subordinate, sizeof(lpci_bus));
398 pci_bus = &lpci_bus;
399
400 dbg("%s: num_ctlr_slots = %d, first_device_num = %d\n", __FUNCTION__, num_ctlr_slots, first_device_num);
401
402 /* Decide which slots are supported */
403 if (is_hot_plug) {
404 /*********************************
405 * is_hot_plug is the slot mask
406 *********************************/
407 FirstSupported = first_device_num;
408 LastSupported = FirstSupported + num_ctlr_slots - 1;
409 } else {
410 FirstSupported = 0;
411 LastSupported = 0x1F;
412 }
413
414 dbg("FirstSupported = %d, LastSupported = %d\n", FirstSupported, LastSupported);
415
416 /* Save PCI configuration space for all devices in supported slots */
417 pci_bus->number = busnumber;
418 for (device = FirstSupported; device <= LastSupported; device++) {
419 ID = 0xFFFFFFFF;
420 rc = pci_bus_read_config_dword(pci_bus, PCI_DEVFN(device, 0), PCI_VENDOR_ID, &ID);
421
422 if (ID != 0xFFFFFFFF) { /* device in slot */
423 rc = pci_bus_read_config_byte(pci_bus, PCI_DEVFN(device, 0), 0x0B, &class_code);
424 if (rc)
425 return rc;
426
427 rc = pci_bus_read_config_byte(pci_bus, PCI_DEVFN(device, 0), PCI_HEADER_TYPE, &header_type);
428 if (rc)
429 return rc;
430
431 dbg("class_code = %x, header_type = %x\n", class_code, header_type);
432
433 /* If multi-function device, set max_functions to 8 */
434 if (header_type & 0x80)
435 max_functions = 8;
436 else
437 max_functions = 1;
438
439 function = 0;
440
441 do {
442 DevError = 0;
443
444 if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { /* P-P Bridge */
445 /* Recurse the subordinate bus
446 * get the subordinate bus number
447 */
448 rc = pci_bus_read_config_byte(pci_bus, PCI_DEVFN(device, function), PCI_SECONDARY_BUS, &secondary_bus);
449 if (rc) {
450 return rc;
451 } else {
452 sub_bus = (int) secondary_bus;
453
454 /* Save secondary bus cfg spc with this recursive call. */
455 rc = shpchp_save_config(ctrl, sub_bus, 0, 0);
456 if (rc)
457 return rc;
458 }
459 }
460
461 index = 0;
462 new_slot = shpchp_slot_find(busnumber, device, index++);
463
464 dbg("new_slot = %p\n", new_slot);
465
466 while (new_slot && (new_slot->function != (u8) function)) {
467 new_slot = shpchp_slot_find(busnumber, device, index++);
468 dbg("new_slot = %p\n", new_slot);
469 }
470 if (!new_slot) {
471 /* Setup slot structure. */
472 new_slot = shpchp_slot_create(busnumber);
473 dbg("new_slot = %p\n", new_slot);
474
475 if (new_slot == NULL)
476 return(1);
477 }
478
479 new_slot->bus = (u8) busnumber;
480 new_slot->device = (u8) device;
481 new_slot->function = (u8) function;
482 new_slot->is_a_board = 1;
483 new_slot->switch_save = 0x10;
484 new_slot->pwr_save = 1;
485 /* In case of unsupported board */
486 new_slot->status = DevError;
487 new_slot->pci_dev = pci_find_slot(new_slot->bus, (new_slot->device << 3) | new_slot->function);
488 dbg("new_slot->pci_dev = %p\n", new_slot->pci_dev);
489
490 for (cloop = 0; cloop < 0x20; cloop++) {
491 rc = pci_bus_read_config_dword(pci_bus, PCI_DEVFN(device, function), cloop << 2, (u32 *) & (new_slot->config_space [cloop]));
492 dbg("%s: new_slot->config_space[%x] = %x\n", __FUNCTION__, cloop, new_slot->config_space[cloop]);
493 if (rc)
494 return rc;
495 }
496
497 function++;
498
499 stop_it = 0;
500
501 /* This loop skips to the next present function
502 * reading in Class Code and Header type.
503 */
504
505 while ((function < max_functions)&&(!stop_it)) {
506 rc = pci_bus_read_config_dword(pci_bus, PCI_DEVFN(device, function), PCI_VENDOR_ID, &ID);
507
508 if (ID == 0xFFFFFFFF) { /* nothing there. */
509 function++;
510 dbg("Nothing there\n");
511 } else { /* Something there */
512 rc = pci_bus_read_config_byte(pci_bus, PCI_DEVFN(device, function), 0x0B, &class_code);
513 if (rc)
514 return rc;
515
516 rc = pci_bus_read_config_byte(pci_bus, PCI_DEVFN(device, function), PCI_HEADER_TYPE, &header_type);
517 if (rc)
518 return rc;
519
520 dbg("class_code = %x, header_type = %x\n", class_code, header_type);
521 stop_it++;
522 }
523 }
524
525 } while (function < max_functions);
526 } /* End of IF (device in slot?) */
527 else if (is_hot_plug) {
528 /* Setup slot structure with entry for empty slot */
529 new_slot = shpchp_slot_create(busnumber);
530
531 if (new_slot == NULL) {
532 return(1);
533 }
534 dbg("new_slot = %p\n", new_slot);
535
536 new_slot->bus = (u8) busnumber;
537 new_slot->device = (u8) device;
538 new_slot->function = 0;
539 new_slot->is_a_board = 0;
540 new_slot->presence_save = 0;
541 new_slot->switch_save = 0;
542 }
543 } /* End of FOR loop */
544
545 return(0);
546 }
547
548
549 /*
550 * shpchp_save_slot_config
551 *
552 * Saves configuration info for all PCI devices in a given slot
553 * including subordinate busses.
554 *
555 * returns 0 if success
556 */
shpchp_save_slot_config(struct controller * ctrl,struct pci_func * new_slot)557 int shpchp_save_slot_config (struct controller *ctrl, struct pci_func * new_slot)
558 {
559 int rc;
560 u8 class_code;
561 u8 header_type;
562 u32 ID;
563 u8 secondary_bus;
564 int sub_bus;
565 int max_functions;
566 int function;
567 int cloop = 0;
568 int stop_it;
569 struct pci_bus lpci_bus, *pci_bus;
570
571 memcpy(&lpci_bus, ctrl->pci_dev->subordinate, sizeof(lpci_bus));
572 pci_bus = &lpci_bus;
573 pci_bus->number = new_slot->bus;
574
575 ID = 0xFFFFFFFF;
576
577 pci_bus_read_config_dword(pci_bus, PCI_DEVFN(new_slot->device, 0), PCI_VENDOR_ID, &ID);
578
579 if (ID != 0xFFFFFFFF) { /* device in slot */
580 pci_bus_read_config_byte(pci_bus, PCI_DEVFN(new_slot->device, 0), 0x0B, &class_code);
581
582 pci_bus_read_config_byte(pci_bus, PCI_DEVFN(new_slot->device, 0), PCI_HEADER_TYPE, &header_type);
583
584 if (header_type & 0x80) /* Multi-function device */
585 max_functions = 8;
586 else
587 max_functions = 1;
588
589 function = 0;
590
591 do {
592 if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { /* PCI-PCI Bridge */
593 /* Recurse the subordinate bus */
594 pci_bus_read_config_byte(pci_bus, PCI_DEVFN(new_slot->device, function), PCI_SECONDARY_BUS, &secondary_bus);
595
596 sub_bus = (int) secondary_bus;
597
598 /* Save the config headers for the secondary bus. */
599 rc = shpchp_save_config(ctrl, sub_bus, 0, 0);
600
601 if (rc)
602 return(rc);
603
604 } /* End of IF */
605
606 new_slot->status = 0;
607
608 for (cloop = 0; cloop < 0x20; cloop++) {
609 pci_bus_read_config_dword(pci_bus, PCI_DEVFN(new_slot->device, function), cloop << 2, (u32 *) & (new_slot->config_space [cloop]));
610 dbg("%s: new_slot->config_space[%x] = %x\n", __FUNCTION__,cloop, new_slot->config_space[cloop]);
611 }
612
613 function++;
614
615 stop_it = 0;
616
617 /* this loop skips to the next present function
618 * reading in the Class Code and the Header type.
619 */
620
621 while ((function < max_functions) && (!stop_it)) {
622 pci_bus_read_config_dword(pci_bus, PCI_DEVFN(new_slot->device, function), PCI_VENDOR_ID, &ID);
623
624 if (ID == 0xFFFFFFFF) { /* nothing there. */
625 function++;
626 } else { /* Something there */
627 pci_bus_read_config_byte(pci_bus, PCI_DEVFN(new_slot->device, function), 0x0B, &class_code);
628
629 pci_bus_read_config_byte(pci_bus, PCI_DEVFN(new_slot->device, function), PCI_HEADER_TYPE, &header_type);
630
631 stop_it++;
632 }
633 }
634
635 } while (function < max_functions);
636 } /* End of IF (device in slot?) */
637 else {
638 return(2);
639 }
640
641 return(0);
642 }
643
644
645 /*
646 * shpchp_save_used_resources
647 *
648 * Stores used resource information for existing boards. this is
649 * for boards that were in the system when this driver was loaded.
650 * this function is for hot plug ADD
651 *
652 * returns 0 if success
653 * if disable == 1(DISABLE_CARD),
654 * it loops for all functions of the slot and disables them.
655 * else, it just get resources of the function and return.
656 */
shpchp_save_used_resources(struct controller * ctrl,struct pci_func * func,int disable)657 int shpchp_save_used_resources (struct controller *ctrl, struct pci_func *func, int disable)
658 {
659 u8 cloop;
660 u8 header_type;
661 u8 secondary_bus;
662 u8 temp_byte;
663 u16 command;
664 u16 save_command;
665 u16 w_base, w_length;
666 u32 temp_register;
667 u32 save_base;
668 u32 base, length;
669 u64 base64 = 0;
670 int index = 0;
671 unsigned int devfn;
672 struct pci_resource *mem_node = NULL;
673 struct pci_resource *p_mem_node = NULL;
674 struct pci_resource *t_mem_node;
675 struct pci_resource *io_node;
676 struct pci_resource *bus_node;
677 struct pci_bus lpci_bus, *pci_bus;
678
679 memcpy(&lpci_bus, ctrl->pci_dev->subordinate, sizeof(lpci_bus));
680 pci_bus = &lpci_bus;
681
682 if (disable)
683 func = shpchp_slot_find(func->bus, func->device, index++);
684
685 while ((func != NULL) && func->is_a_board) {
686 pci_bus->number = func->bus;
687 devfn = PCI_DEVFN(func->device, func->function);
688
689 /* Save the command register */
690 pci_bus_read_config_word (pci_bus, devfn, PCI_COMMAND, &save_command);
691
692 if (disable) {
693 /* disable card */
694 command = 0x00;
695 pci_bus_write_config_word(pci_bus, devfn, PCI_COMMAND, command);
696 }
697
698 /* Check for Bridge */
699 pci_bus_read_config_byte (pci_bus, devfn, PCI_HEADER_TYPE, &header_type);
700
701 if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { /* PCI-PCI Bridge */
702 dbg("Save_used_res of PCI bridge b:d=0x%x:%x, sc=0x%x\n", func->bus, func->device, save_command);
703 if (disable) {
704 /* Clear Bridge Control Register */
705 command = 0x00;
706 pci_bus_write_config_word(pci_bus, devfn, PCI_BRIDGE_CONTROL, command);
707 }
708
709 pci_bus_read_config_byte (pci_bus, devfn, PCI_SECONDARY_BUS, &secondary_bus);
710 pci_bus_read_config_byte (pci_bus, devfn, PCI_SUBORDINATE_BUS, &temp_byte);
711
712 bus_node =(struct pci_resource *) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
713 if (!bus_node)
714 return -ENOMEM;
715
716 bus_node->base = (ulong)secondary_bus;
717 bus_node->length = (ulong)(temp_byte - secondary_bus + 1);
718
719 bus_node->next = func->bus_head;
720 func->bus_head = bus_node;
721
722 /* Save IO base and Limit registers */
723 pci_bus_read_config_byte (pci_bus, devfn, PCI_IO_BASE, &temp_byte);
724 base = temp_byte;
725 pci_bus_read_config_byte (pci_bus, devfn, PCI_IO_LIMIT, &temp_byte);
726 length = temp_byte;
727
728 if ((base <= length) && (!disable || (save_command & PCI_COMMAND_IO))) {
729 io_node = (struct pci_resource *) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
730 if (!io_node)
731 return -ENOMEM;
732
733 io_node->base = (ulong)(base & PCI_IO_RANGE_MASK) << 8;
734 io_node->length = (ulong)(length - base + 0x10) << 8;
735
736 io_node->next = func->io_head;
737 func->io_head = io_node;
738 }
739
740 /* Save memory base and Limit registers */
741 pci_bus_read_config_word (pci_bus, devfn, PCI_MEMORY_BASE, &w_base);
742 pci_bus_read_config_word (pci_bus, devfn, PCI_MEMORY_LIMIT, &w_length);
743
744 if ((w_base <= w_length) && (!disable || (save_command & PCI_COMMAND_MEMORY))) {
745 mem_node = (struct pci_resource *) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
746 if (!mem_node)
747 return -ENOMEM;
748
749 mem_node->base = (ulong)w_base << 16;
750 mem_node->length = (ulong)(w_length - w_base + 0x10) << 16;
751
752 mem_node->next = func->mem_head;
753 func->mem_head = mem_node;
754 }
755 /* Save prefetchable memory base and Limit registers */
756 pci_bus_read_config_word (pci_bus, devfn, PCI_PREF_MEMORY_BASE, &w_base);
757 pci_bus_read_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, &w_length);
758
759 if ((w_base <= w_length) && (!disable || (save_command & PCI_COMMAND_MEMORY))) {
760 p_mem_node = (struct pci_resource *) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
761 if (!p_mem_node)
762 return -ENOMEM;
763
764 p_mem_node->base = (ulong)w_base << 16;
765 p_mem_node->length = (ulong)(w_length - w_base + 0x10) << 16;
766
767 p_mem_node->next = func->p_mem_head;
768 func->p_mem_head = p_mem_node;
769 }
770 } else if ((header_type & 0x7F) == PCI_HEADER_TYPE_NORMAL) {
771 dbg("Save_used_res of PCI adapter b:d=0x%x:%x, sc=0x%x\n", func->bus, func->device, save_command);
772
773 /* Figure out IO and memory base lengths */
774 for (cloop = PCI_BASE_ADDRESS_0; cloop <= PCI_BASE_ADDRESS_5; cloop += 4) {
775 pci_bus_read_config_dword (pci_bus, devfn, cloop, &save_base);
776
777 temp_register = 0xFFFFFFFF;
778 pci_bus_write_config_dword (pci_bus, devfn, cloop, temp_register);
779 pci_bus_read_config_dword (pci_bus, devfn, cloop, &temp_register);
780
781 if (!disable) {
782 pci_bus_write_config_dword (pci_bus, devfn, cloop, save_base);
783 }
784
785 if (!temp_register)
786 continue;
787
788 base = temp_register;
789
790 if ((base & PCI_BASE_ADDRESS_SPACE_IO) && (!disable || (save_command & PCI_COMMAND_IO))) {
791 /* IO base */
792 /* set temp_register = amount of IO space requested */
793 base = base & 0xFFFFFFFCL;
794 base = (~base) + 1;
795
796 io_node = (struct pci_resource *) kmalloc(sizeof (struct pci_resource), GFP_KERNEL);
797 if (!io_node)
798 return -ENOMEM;
799
800 io_node->base = (ulong)save_base & PCI_BASE_ADDRESS_IO_MASK;
801 io_node->length = (ulong)base;
802 dbg("sur adapter: IO bar=0x%x(length=0x%x)\n", io_node->base, io_node->length);
803
804 io_node->next = func->io_head;
805 func->io_head = io_node;
806 } else { /* map Memory */
807 int prefetchable = 1;
808 /* struct pci_resources **res_node; */
809 char *res_type_str = "PMEM";
810 u32 temp_register2;
811
812 t_mem_node = (struct pci_resource *) kmalloc(sizeof (struct pci_resource), GFP_KERNEL);
813 if (!t_mem_node)
814 return -ENOMEM;
815
816 if (!(base & PCI_BASE_ADDRESS_MEM_PREFETCH) && (!disable || (save_command & PCI_COMMAND_MEMORY))) {
817 prefetchable = 0;
818 mem_node = t_mem_node;
819 res_type_str++;
820 } else
821 p_mem_node = t_mem_node;
822
823 base = base & 0xFFFFFFF0L;
824 base = (~base) + 1;
825
826 switch (temp_register & PCI_BASE_ADDRESS_MEM_TYPE_MASK) {
827 case PCI_BASE_ADDRESS_MEM_TYPE_32:
828 if (prefetchable) {
829 p_mem_node->base = (ulong)save_base & PCI_BASE_ADDRESS_MEM_MASK;
830 p_mem_node->length = (ulong)base;
831 dbg("sur adapter: 32 %s bar=0x%x(length=0x%x)\n", res_type_str, p_mem_node->base, p_mem_node->length);
832
833 p_mem_node->next = func->p_mem_head;
834 func->p_mem_head = p_mem_node;
835 } else {
836 mem_node->base = (ulong)save_base & PCI_BASE_ADDRESS_MEM_MASK;
837 mem_node->length = (ulong)base;
838 dbg("sur adapter: 32 %s bar=0x%x(length=0x%x)\n", res_type_str, mem_node->base, mem_node->length);
839
840 mem_node->next = func->mem_head;
841 func->mem_head = mem_node;
842 }
843 break;
844 case PCI_BASE_ADDRESS_MEM_TYPE_64:
845 pci_bus_read_config_dword(pci_bus, devfn, cloop+4, &temp_register2);
846 base64 = temp_register2;
847 base64 = (base64 << 32) | save_base;
848
849 if (temp_register2) {
850 dbg("sur adapter: 64 %s high dword of base64(0x%x:%x) masked to 0\n", res_type_str, temp_register2, (u32)base64);
851 base64 &= 0x00000000FFFFFFFFL;
852 }
853
854 if (prefetchable) {
855 p_mem_node->base = base64 & PCI_BASE_ADDRESS_MEM_MASK;
856 p_mem_node->length = base;
857 dbg("sur adapter: 64 %s base=0x%x(len=0x%x)\n", res_type_str, p_mem_node->base, p_mem_node->length);
858
859 p_mem_node->next = func->p_mem_head;
860 func->p_mem_head = p_mem_node;
861 } else {
862 mem_node->base = base64 & PCI_BASE_ADDRESS_MEM_MASK;
863 mem_node->length = base;
864 dbg("sur adapter: 64 %s base=0x%x(len=0x%x)\n", res_type_str, mem_node->base, mem_node->length);
865
866 mem_node->next = func->mem_head;
867 func->mem_head = mem_node;
868 }
869 cloop += 4;
870 break;
871 default:
872 dbg("asur: reserved BAR type=0x%x\n", temp_register);
873 break;
874 }
875 }
876 } /* End of base register loop */
877 } else { /* Some other unknown header type */
878 dbg("Save_used_res of PCI unknown type b:d=0x%x:%x. skip.\n", func->bus, func->device);
879 }
880
881 /* find the next device in this slot */
882 if (!disable)
883 break;
884 func = shpchp_slot_find(func->bus, func->device, index++);
885 }
886
887 return(0);
888 }
889
890
891 /*
892 * shpchp_return_board_resources
893 *
894 * this routine returns all resources allocated to a board to
895 * the available pool.
896 *
897 * returns 0 if success
898 */
shpchp_return_board_resources(struct pci_func * func,struct resource_lists * resources)899 int shpchp_return_board_resources(struct pci_func * func, struct resource_lists * resources)
900 {
901 int rc = 0;
902 struct pci_resource *node;
903 struct pci_resource *t_node;
904 dbg("%s\n", __FUNCTION__);
905
906 if (!func)
907 return(1);
908
909 node = func->io_head;
910 func->io_head = NULL;
911 while (node) {
912 t_node = node->next;
913 return_resource(&(resources->io_head), node);
914 node = t_node;
915 }
916
917 node = func->mem_head;
918 func->mem_head = NULL;
919 while (node) {
920 t_node = node->next;
921 return_resource(&(resources->mem_head), node);
922 node = t_node;
923 }
924
925 node = func->p_mem_head;
926 func->p_mem_head = NULL;
927 while (node) {
928 t_node = node->next;
929 return_resource(&(resources->p_mem_head), node);
930 node = t_node;
931 }
932
933 node = func->bus_head;
934 func->bus_head = NULL;
935 while (node) {
936 t_node = node->next;
937 return_resource(&(resources->bus_head), node);
938 node = t_node;
939 }
940
941 rc |= shpchp_resource_sort_and_combine(&(resources->mem_head));
942 rc |= shpchp_resource_sort_and_combine(&(resources->p_mem_head));
943 rc |= shpchp_resource_sort_and_combine(&(resources->io_head));
944 rc |= shpchp_resource_sort_and_combine(&(resources->bus_head));
945
946 return(rc);
947 }
948
949
950 /*
951 * shpchp_destroy_resource_list
952 *
953 * Puts node back in the resource list pointed to by head
954 */
shpchp_destroy_resource_list(struct resource_lists * resources)955 void shpchp_destroy_resource_list (struct resource_lists * resources)
956 {
957 struct pci_resource *res, *tres;
958
959 res = resources->io_head;
960 resources->io_head = NULL;
961
962 while (res) {
963 tres = res;
964 res = res->next;
965 kfree(tres);
966 }
967
968 res = resources->mem_head;
969 resources->mem_head = NULL;
970
971 while (res) {
972 tres = res;
973 res = res->next;
974 kfree(tres);
975 }
976
977 res = resources->p_mem_head;
978 resources->p_mem_head = NULL;
979
980 while (res) {
981 tres = res;
982 res = res->next;
983 kfree(tres);
984 }
985
986 res = resources->bus_head;
987 resources->bus_head = NULL;
988
989 while (res) {
990 tres = res;
991 res = res->next;
992 kfree(tres);
993 }
994 }
995
996
997 /*
998 * shpchp_destroy_board_resources
999 *
1000 * Puts node back in the resource list pointed to by head
1001 */
shpchp_destroy_board_resources(struct pci_func * func)1002 void shpchp_destroy_board_resources (struct pci_func * func)
1003 {
1004 struct pci_resource *res, *tres;
1005
1006 dbg("%s: \n", __FUNCTION__);
1007
1008 res = func->io_head;
1009 func->io_head = NULL;
1010
1011 while (res) {
1012 tres = res;
1013 res = res->next;
1014 kfree(tres);
1015 }
1016
1017 res = func->mem_head;
1018 func->mem_head = NULL;
1019
1020 while (res) {
1021 tres = res;
1022 res = res->next;
1023 kfree(tres);
1024 }
1025
1026 res = func->p_mem_head;
1027 func->p_mem_head = NULL;
1028
1029 while (res) {
1030 tres = res;
1031 res = res->next;
1032 kfree(tres);
1033 }
1034
1035 res = func->bus_head;
1036 func->bus_head = NULL;
1037
1038 while (res) {
1039 tres = res;
1040 res = res->next;
1041 kfree(tres);
1042 }
1043 }
1044
1045