Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2005-2006 Silicon Graphics, Inc. All rights reserved.
4 *
5 * This work was based on the 2.4/2.6 kernel development by Dick Reigner.
6 * Work to add BIOS PROM support was completed by Mike Habeck.
7 */
8
9#include <linux/acpi.h>
10#include <linux/init.h>
11#include <linux/kernel.h>
12#include <linux/module.h>
13#include <linux/pci.h>
14#include <linux/pci_hotplug.h>
15#include <linux/proc_fs.h>
16#include <linux/slab.h>
17#include <linux/types.h>
18#include <linux/mutex.h>
19
20#include <asm/sn/addrs.h>
21#include <asm/sn/geo.h>
22#include <asm/sn/l1.h>
23#include <asm/sn/module.h>
24#include <asm/sn/pcibr_provider.h>
25#include <asm/sn/pcibus_provider_defs.h>
26#include <asm/sn/pcidev.h>
27#include <asm/sn/sn_feature_sets.h>
28#include <asm/sn/sn_sal.h>
29#include <asm/sn/types.h>
30#include <asm/sn/acpi.h>
31
32#include "../pci.h"
33
34MODULE_LICENSE("GPL");
35MODULE_AUTHOR("SGI (prarit@sgi.com, dickie@sgi.com, habeck@sgi.com)");
36MODULE_DESCRIPTION("SGI Altix Hot Plug PCI Controller Driver");
37
38
39/* SAL call error codes. Keep in sync with prom header io/include/pcibr.h */
40#define PCI_SLOT_ALREADY_UP 2 /* slot already up */
41#define PCI_SLOT_ALREADY_DOWN 3 /* slot already down */
42#define PCI_L1_ERR 7 /* L1 console command error */
43#define PCI_EMPTY_33MHZ 15 /* empty 33 MHz bus */
44
45
46#define PCIIO_ASIC_TYPE_TIOCA 4
47#define PCI_L1_QSIZE 128 /* our L1 message buffer size */
48#define SN_MAX_HP_SLOTS 32 /* max hotplug slots */
49#define SN_SLOT_NAME_SIZE 33 /* size of name string */
50
51/* internal list head */
52static struct list_head sn_hp_list;
53
54/* hotplug_slot struct's private pointer */
55struct slot {
56 int device_num;
57 struct pci_bus *pci_bus;
58 /* this struct for glue internal only */
59 struct hotplug_slot *hotplug_slot;
60 struct list_head hp_list;
61 char physical_path[SN_SLOT_NAME_SIZE];
62};
63
64struct pcibr_slot_enable_resp {
65 int resp_sub_errno;
66 char resp_l1_msg[PCI_L1_QSIZE + 1];
67};
68
69struct pcibr_slot_disable_resp {
70 int resp_sub_errno;
71 char resp_l1_msg[PCI_L1_QSIZE + 1];
72};
73
74enum sn_pci_req_e {
75 PCI_REQ_SLOT_ELIGIBLE,
76 PCI_REQ_SLOT_DISABLE
77};
78
79static int enable_slot(struct hotplug_slot *slot);
80static int disable_slot(struct hotplug_slot *slot);
81static inline int get_power_status(struct hotplug_slot *slot, u8 *value);
82
83static struct hotplug_slot_ops sn_hotplug_slot_ops = {
84 .enable_slot = enable_slot,
85 .disable_slot = disable_slot,
86 .get_power_status = get_power_status,
87};
88
89static DEFINE_MUTEX(sn_hotplug_mutex);
90
91static ssize_t path_show(struct pci_slot *pci_slot, char *buf)
92{
93 int retval = -ENOENT;
94 struct slot *slot = pci_slot->hotplug->private;
95
96 if (!slot)
97 return retval;
98
99 retval = sprintf(buf, "%s\n", slot->physical_path);
100 return retval;
101}
102
103static struct pci_slot_attribute sn_slot_path_attr = __ATTR_RO(path);
104
105static int sn_pci_slot_valid(struct pci_bus *pci_bus, int device)
106{
107 struct pcibus_info *pcibus_info;
108 u16 busnum, segment, ioboard_type;
109
110 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
111
112 /* Check to see if this is a valid slot on 'pci_bus' */
113 if (!(pcibus_info->pbi_valid_devices & (1 << device)))
114 return -EPERM;
115
116 ioboard_type = sn_ioboard_to_pci_bus(pci_bus);
117 busnum = pcibus_info->pbi_buscommon.bs_persist_busnum;
118 segment = pci_domain_nr(pci_bus) & 0xf;
119
120 /* Do not allow hotplug operations on base I/O cards */
121 if ((ioboard_type == L1_BRICKTYPE_IX ||
122 ioboard_type == L1_BRICKTYPE_IA) &&
123 (segment == 1 && busnum == 0 && device != 1))
124 return -EPERM;
125
126 return 1;
127}
128
129static int sn_pci_bus_valid(struct pci_bus *pci_bus)
130{
131 struct pcibus_info *pcibus_info;
132 u32 asic_type;
133 u16 ioboard_type;
134
135 /* Don't register slots hanging off the TIOCA bus */
136 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
137 asic_type = pcibus_info->pbi_buscommon.bs_asic_type;
138 if (asic_type == PCIIO_ASIC_TYPE_TIOCA)
139 return -EPERM;
140
141 /* Only register slots in I/O Bricks that support hotplug */
142 ioboard_type = sn_ioboard_to_pci_bus(pci_bus);
143 switch (ioboard_type) {
144 case L1_BRICKTYPE_IX:
145 case L1_BRICKTYPE_PX:
146 case L1_BRICKTYPE_IA:
147 case L1_BRICKTYPE_PA:
148 case L1_BOARDTYPE_PCIX3SLOT:
149 return 1;
150 break;
151 default:
152 return -EPERM;
153 break;
154 }
155
156 return -EIO;
157}
158
159static int sn_hp_slot_private_alloc(struct hotplug_slot *bss_hotplug_slot,
160 struct pci_bus *pci_bus, int device,
161 char *name)
162{
163 struct pcibus_info *pcibus_info;
164 struct slot *slot;
165
166 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
167
168 slot = kzalloc(sizeof(*slot), GFP_KERNEL);
169 if (!slot)
170 return -ENOMEM;
171 bss_hotplug_slot->private = slot;
172
173 slot->device_num = device;
174 slot->pci_bus = pci_bus;
175 sprintf(name, "%04x:%02x:%02x",
176 pci_domain_nr(pci_bus),
177 ((u16)pcibus_info->pbi_buscommon.bs_persist_busnum),
178 device + 1);
179
180 sn_generate_path(pci_bus, slot->physical_path);
181
182 slot->hotplug_slot = bss_hotplug_slot;
183 list_add(&slot->hp_list, &sn_hp_list);
184
185 return 0;
186}
187
188static struct hotplug_slot *sn_hp_destroy(void)
189{
190 struct slot *slot;
191 struct pci_slot *pci_slot;
192 struct hotplug_slot *bss_hotplug_slot = NULL;
193
194 list_for_each_entry(slot, &sn_hp_list, hp_list) {
195 bss_hotplug_slot = slot->hotplug_slot;
196 pci_slot = bss_hotplug_slot->pci_slot;
197 list_del(&((struct slot *)bss_hotplug_slot->private)->
198 hp_list);
199 sysfs_remove_file(&pci_slot->kobj,
200 &sn_slot_path_attr.attr);
201 break;
202 }
203 return bss_hotplug_slot;
204}
205
206static void sn_bus_free_data(struct pci_dev *dev)
207{
208 struct pci_bus *subordinate_bus;
209 struct pci_dev *child;
210
211 /* Recursively clean up sn_irq_info structs */
212 if (dev->subordinate) {
213 subordinate_bus = dev->subordinate;
214 list_for_each_entry(child, &subordinate_bus->devices, bus_list)
215 sn_bus_free_data(child);
216 }
217 /*
218 * Some drivers may use dma accesses during the
219 * driver remove function. We release the sysdata
220 * areas after the driver remove functions have
221 * been called.
222 */
223 sn_bus_store_sysdata(dev);
224 sn_pci_unfixup_slot(dev);
225}
226
227static int sn_slot_enable(struct hotplug_slot *bss_hotplug_slot,
228 int device_num, char **ssdt)
229{
230 struct slot *slot = bss_hotplug_slot->private;
231 struct pcibus_info *pcibus_info;
232 struct pcibr_slot_enable_resp resp;
233 int rc;
234
235 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
236
237 /*
238 * Power-on and initialize the slot in the SN
239 * PCI infrastructure.
240 */
241 rc = sal_pcibr_slot_enable(pcibus_info, device_num, &resp, ssdt);
242
243
244 if (rc == PCI_SLOT_ALREADY_UP) {
245 pci_dbg(slot->pci_bus->self, "is already active\n");
246 return 1; /* return 1 to user */
247 }
248
249 if (rc == PCI_L1_ERR) {
250 pci_dbg(slot->pci_bus->self, "L1 failure %d with message: %s",
251 resp.resp_sub_errno, resp.resp_l1_msg);
252 return -EPERM;
253 }
254
255 if (rc) {
256 pci_dbg(slot->pci_bus->self, "insert failed with error %d sub-error %d\n",
257 rc, resp.resp_sub_errno);
258 return -EIO;
259 }
260
261 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
262 pcibus_info->pbi_enabled_devices |= (1 << device_num);
263
264 return 0;
265}
266
267static int sn_slot_disable(struct hotplug_slot *bss_hotplug_slot,
268 int device_num, int action)
269{
270 struct slot *slot = bss_hotplug_slot->private;
271 struct pcibus_info *pcibus_info;
272 struct pcibr_slot_disable_resp resp;
273 int rc;
274
275 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
276
277 rc = sal_pcibr_slot_disable(pcibus_info, device_num, action, &resp);
278
279 if ((action == PCI_REQ_SLOT_ELIGIBLE) &&
280 (rc == PCI_SLOT_ALREADY_DOWN)) {
281 pci_dbg(slot->pci_bus->self, "Slot %s already inactive\n", slot->physical_path);
282 return 1; /* return 1 to user */
283 }
284
285 if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_EMPTY_33MHZ)) {
286 pci_dbg(slot->pci_bus->self, "Cannot remove last 33MHz card\n");
287 return -EPERM;
288 }
289
290 if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_L1_ERR)) {
291 pci_dbg(slot->pci_bus->self, "L1 failure %d with message \n%s\n",
292 resp.resp_sub_errno, resp.resp_l1_msg);
293 return -EPERM;
294 }
295
296 if ((action == PCI_REQ_SLOT_ELIGIBLE) && rc) {
297 pci_dbg(slot->pci_bus->self, "remove failed with error %d sub-error %d\n",
298 rc, resp.resp_sub_errno);
299 return -EIO;
300 }
301
302 if ((action == PCI_REQ_SLOT_ELIGIBLE) && !rc)
303 return 0;
304
305 if ((action == PCI_REQ_SLOT_DISABLE) && !rc) {
306 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
307 pcibus_info->pbi_enabled_devices &= ~(1 << device_num);
308 pci_dbg(slot->pci_bus->self, "remove successful\n");
309 return 0;
310 }
311
312 if ((action == PCI_REQ_SLOT_DISABLE) && rc) {
313 pci_dbg(slot->pci_bus->self, "remove failed rc = %d\n", rc);
314 }
315
316 return rc;
317}
318
319/*
320 * Power up and configure the slot via a SAL call to PROM.
321 * Scan slot (and any children), do any platform specific fixup,
322 * and find device driver.
323 */
324static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
325{
326 struct slot *slot = bss_hotplug_slot->private;
327 struct pci_bus *new_bus = NULL;
328 struct pci_dev *dev;
329 int num_funcs;
330 int new_ppb = 0;
331 int rc;
332 char *ssdt = NULL;
333 void pcibios_fixup_device_resources(struct pci_dev *);
334
335 /* Serialize the Linux PCI infrastructure */
336 mutex_lock(&sn_hotplug_mutex);
337
338 /*
339 * Power-on and initialize the slot in the SN
340 * PCI infrastructure. Also, retrieve the ACPI SSDT
341 * table for the slot (if ACPI capable PROM).
342 */
343 rc = sn_slot_enable(bss_hotplug_slot, slot->device_num, &ssdt);
344 if (rc) {
345 mutex_unlock(&sn_hotplug_mutex);
346 return rc;
347 }
348
349 if (ssdt)
350 ssdt = __va(ssdt);
351 /* Add the new SSDT for the slot to the ACPI namespace */
352 if (SN_ACPI_BASE_SUPPORT() && ssdt) {
353 acpi_status ret;
354
355 ret = acpi_load_table((struct acpi_table_header *)ssdt);
356 if (ACPI_FAILURE(ret)) {
357 printk(KERN_ERR "%s: acpi_load_table failed (0x%x)\n",
358 __func__, ret);
359 /* try to continue on */
360 }
361 }
362
363 num_funcs = pci_scan_slot(slot->pci_bus,
364 PCI_DEVFN(slot->device_num + 1, 0));
365 if (!num_funcs) {
366 pci_dbg(slot->pci_bus->self, "no device in slot\n");
367 mutex_unlock(&sn_hotplug_mutex);
368 return -ENODEV;
369 }
370
371 /*
372 * Map SN resources for all functions on the card
373 * to the Linux PCI interface and tell the drivers
374 * about them.
375 */
376 list_for_each_entry(dev, &slot->pci_bus->devices, bus_list) {
377 if (PCI_SLOT(dev->devfn) != slot->device_num + 1)
378 continue;
379
380 /* Need to do slot fixup on PPB before fixup of children
381 * (PPB's pcidev_info needs to be in pcidev_info list
382 * before child's SN_PCIDEV_INFO() call to setup
383 * pdi_host_pcidev_info).
384 */
385 pcibios_fixup_device_resources(dev);
386 if (SN_ACPI_BASE_SUPPORT())
387 sn_acpi_slot_fixup(dev);
388 else
389 sn_io_slot_fixup(dev);
390 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
391 pci_hp_add_bridge(dev);
392 if (dev->subordinate) {
393 new_bus = dev->subordinate;
394 new_ppb = 1;
395 }
396 }
397 }
398
399 /*
400 * Add the slot's devices to the ACPI infrastructure */
401 if (SN_ACPI_BASE_SUPPORT() && ssdt) {
402 unsigned long long adr;
403 struct acpi_device *pdevice;
404 acpi_handle phandle;
405 acpi_handle chandle = NULL;
406 acpi_handle rethandle;
407 acpi_status ret;
408
409 phandle = acpi_device_handle(PCI_CONTROLLER(slot->pci_bus)->companion);
410
411 if (acpi_bus_get_device(phandle, &pdevice)) {
412 pci_dbg(slot->pci_bus->self, "no parent device, assuming NULL\n");
413 pdevice = NULL;
414 }
415
416 acpi_scan_lock_acquire();
417 /*
418 * Walk the rootbus node's immediate children looking for
419 * the slot's device node(s). There can be more than
420 * one for multifunction devices.
421 */
422 for (;;) {
423 rethandle = NULL;
424 ret = acpi_get_next_object(ACPI_TYPE_DEVICE,
425 phandle, chandle,
426 &rethandle);
427
428 if (ret == AE_NOT_FOUND || rethandle == NULL)
429 break;
430
431 chandle = rethandle;
432
433 ret = acpi_evaluate_integer(chandle, METHOD_NAME__ADR,
434 NULL, &adr);
435
436 if (ACPI_SUCCESS(ret) &&
437 (adr>>16) == (slot->device_num + 1)) {
438
439 ret = acpi_bus_scan(chandle);
440 if (ACPI_FAILURE(ret)) {
441 printk(KERN_ERR "%s: acpi_bus_scan failed (0x%x) for slot %d func %d\n",
442 __func__, ret, (int)(adr>>16),
443 (int)(adr&0xffff));
444 /* try to continue on */
445 }
446 }
447 }
448 acpi_scan_lock_release();
449 }
450
451 pci_lock_rescan_remove();
452
453 /* Call the driver for the new device */
454 pci_bus_add_devices(slot->pci_bus);
455 /* Call the drivers for the new devices subordinate to PPB */
456 if (new_ppb)
457 pci_bus_add_devices(new_bus);
458
459 pci_unlock_rescan_remove();
460 mutex_unlock(&sn_hotplug_mutex);
461
462 if (rc == 0)
463 pci_dbg(slot->pci_bus->self, "insert operation successful\n");
464 else
465 pci_dbg(slot->pci_bus->self, "insert operation failed rc = %d\n", rc);
466
467 return rc;
468}
469
470static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
471{
472 struct slot *slot = bss_hotplug_slot->private;
473 struct pci_dev *dev, *temp;
474 int rc;
475 acpi_handle ssdt_hdl = NULL;
476
477 /* Acquire update access to the bus */
478 mutex_lock(&sn_hotplug_mutex);
479
480 /* is it okay to bring this slot down? */
481 rc = sn_slot_disable(bss_hotplug_slot, slot->device_num,
482 PCI_REQ_SLOT_ELIGIBLE);
483 if (rc)
484 goto leaving;
485
486 /* free the ACPI resources for the slot */
487 if (SN_ACPI_BASE_SUPPORT() &&
488 PCI_CONTROLLER(slot->pci_bus)->companion) {
489 unsigned long long adr;
490 struct acpi_device *device;
491 acpi_handle phandle;
492 acpi_handle chandle = NULL;
493 acpi_handle rethandle;
494 acpi_status ret;
495
496 /* Get the rootbus node pointer */
497 phandle = acpi_device_handle(PCI_CONTROLLER(slot->pci_bus)->companion);
498
499 acpi_scan_lock_acquire();
500 /*
501 * Walk the rootbus node's immediate children looking for
502 * the slot's device node(s). There can be more than
503 * one for multifunction devices.
504 */
505 for (;;) {
506 rethandle = NULL;
507 ret = acpi_get_next_object(ACPI_TYPE_DEVICE,
508 phandle, chandle,
509 &rethandle);
510
511 if (ret == AE_NOT_FOUND || rethandle == NULL)
512 break;
513
514 chandle = rethandle;
515
516 ret = acpi_evaluate_integer(chandle,
517 METHOD_NAME__ADR,
518 NULL, &adr);
519 if (ACPI_SUCCESS(ret) &&
520 (adr>>16) == (slot->device_num + 1)) {
521 /* retain the owner id */
522 ssdt_hdl = chandle;
523
524 ret = acpi_bus_get_device(chandle,
525 &device);
526 if (ACPI_SUCCESS(ret))
527 acpi_bus_trim(device);
528 }
529 }
530 acpi_scan_lock_release();
531 }
532
533 pci_lock_rescan_remove();
534 /* Free the SN resources assigned to the Linux device.*/
535 list_for_each_entry_safe(dev, temp, &slot->pci_bus->devices, bus_list) {
536 if (PCI_SLOT(dev->devfn) != slot->device_num + 1)
537 continue;
538
539 pci_dev_get(dev);
540 sn_bus_free_data(dev);
541 pci_stop_and_remove_bus_device(dev);
542 pci_dev_put(dev);
543 }
544 pci_unlock_rescan_remove();
545
546 /* Remove the SSDT for the slot from the ACPI namespace */
547 if (SN_ACPI_BASE_SUPPORT() && ssdt_hdl) {
548 acpi_status ret;
549 ret = acpi_unload_parent_table(ssdt_hdl);
550 if (ACPI_FAILURE(ret)) {
551 acpi_handle_err(ssdt_hdl,
552 "%s: acpi_unload_parent_table failed (0x%x)\n",
553 __func__, ret);
554 /* try to continue on */
555 }
556 }
557
558 /* free the collected sysdata pointers */
559 sn_bus_free_sysdata();
560
561 /* Deactivate slot */
562 rc = sn_slot_disable(bss_hotplug_slot, slot->device_num,
563 PCI_REQ_SLOT_DISABLE);
564 leaving:
565 /* Release the bus lock */
566 mutex_unlock(&sn_hotplug_mutex);
567
568 return rc;
569}
570
571static inline int get_power_status(struct hotplug_slot *bss_hotplug_slot,
572 u8 *value)
573{
574 struct slot *slot = bss_hotplug_slot->private;
575 struct pcibus_info *pcibus_info;
576 u32 power;
577
578 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
579 mutex_lock(&sn_hotplug_mutex);
580 power = pcibus_info->pbi_enabled_devices & (1 << slot->device_num);
581 *value = power ? 1 : 0;
582 mutex_unlock(&sn_hotplug_mutex);
583 return 0;
584}
585
586static void sn_release_slot(struct hotplug_slot *bss_hotplug_slot)
587{
588 kfree(bss_hotplug_slot->info);
589 kfree(bss_hotplug_slot->private);
590 kfree(bss_hotplug_slot);
591}
592
593static int sn_hotplug_slot_register(struct pci_bus *pci_bus)
594{
595 int device;
596 struct pci_slot *pci_slot;
597 struct hotplug_slot *bss_hotplug_slot;
598 char name[SN_SLOT_NAME_SIZE];
599 int rc = 0;
600
601 /*
602 * Currently only four devices are supported,
603 * in the future there maybe more -- up to 32.
604 */
605
606 for (device = 0; device < SN_MAX_HP_SLOTS ; device++) {
607 if (sn_pci_slot_valid(pci_bus, device) != 1)
608 continue;
609
610 bss_hotplug_slot = kzalloc(sizeof(*bss_hotplug_slot),
611 GFP_KERNEL);
612 if (!bss_hotplug_slot) {
613 rc = -ENOMEM;
614 goto alloc_err;
615 }
616
617 bss_hotplug_slot->info =
618 kzalloc(sizeof(struct hotplug_slot_info),
619 GFP_KERNEL);
620 if (!bss_hotplug_slot->info) {
621 rc = -ENOMEM;
622 goto alloc_err;
623 }
624
625 if (sn_hp_slot_private_alloc(bss_hotplug_slot,
626 pci_bus, device, name)) {
627 rc = -ENOMEM;
628 goto alloc_err;
629 }
630 bss_hotplug_slot->ops = &sn_hotplug_slot_ops;
631 bss_hotplug_slot->release = &sn_release_slot;
632
633 rc = pci_hp_register(bss_hotplug_slot, pci_bus, device, name);
634 if (rc)
635 goto register_err;
636
637 pci_slot = bss_hotplug_slot->pci_slot;
638 rc = sysfs_create_file(&pci_slot->kobj,
639 &sn_slot_path_attr.attr);
640 if (rc)
641 goto register_err;
642 }
643 pci_dbg(pci_bus->self, "Registered bus with hotplug\n");
644 return rc;
645
646register_err:
647 pci_dbg(pci_bus->self, "bus failed to register with err = %d\n",
648 rc);
649
650alloc_err:
651 if (rc == -ENOMEM)
652 pci_dbg(pci_bus->self, "Memory allocation error\n");
653
654 /* destroy THIS element */
655 if (bss_hotplug_slot)
656 sn_release_slot(bss_hotplug_slot);
657
658 /* destroy anything else on the list */
659 while ((bss_hotplug_slot = sn_hp_destroy()))
660 pci_hp_deregister(bss_hotplug_slot);
661
662 return rc;
663}
664
665static int __init sn_pci_hotplug_init(void)
666{
667 struct pci_bus *pci_bus = NULL;
668 int rc;
669 int registered = 0;
670
671 if (!sn_prom_feature_available(PRF_HOTPLUG_SUPPORT)) {
672 printk(KERN_ERR "%s: PROM version does not support hotplug.\n",
673 __func__);
674 return -EPERM;
675 }
676
677 INIT_LIST_HEAD(&sn_hp_list);
678
679 while ((pci_bus = pci_find_next_bus(pci_bus))) {
680 if (!pci_bus->sysdata)
681 continue;
682
683 rc = sn_pci_bus_valid(pci_bus);
684 if (rc != 1) {
685 pci_dbg(pci_bus->self, "not a valid hotplug bus\n");
686 continue;
687 }
688 pci_dbg(pci_bus->self, "valid hotplug bus\n");
689
690 rc = sn_hotplug_slot_register(pci_bus);
691 if (!rc) {
692 registered = 1;
693 } else {
694 registered = 0;
695 break;
696 }
697 }
698
699 return registered == 1 ? 0 : -ENODEV;
700}
701
702static void __exit sn_pci_hotplug_exit(void)
703{
704 struct hotplug_slot *bss_hotplug_slot;
705
706 while ((bss_hotplug_slot = sn_hp_destroy()))
707 pci_hp_deregister(bss_hotplug_slot);
708
709 if (!list_empty(&sn_hp_list))
710 printk(KERN_ERR "%s: internal list is not empty\n", __FILE__);
711}
712
713module_init(sn_pci_hotplug_init);
714module_exit(sn_pci_hotplug_exit);
1/*
2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
4 * for more details.
5 *
6 * Copyright (C) 2005-2006 Silicon Graphics, Inc. All rights reserved.
7 *
8 * This work was based on the 2.4/2.6 kernel development by Dick Reigner.
9 * Work to add BIOS PROM support was completed by Mike Habeck.
10 */
11
12#include <linux/init.h>
13#include <linux/kernel.h>
14#include <linux/module.h>
15#include <linux/pci.h>
16#include <linux/pci_hotplug.h>
17#include <linux/proc_fs.h>
18#include <linux/slab.h>
19#include <linux/types.h>
20#include <linux/mutex.h>
21
22#include <asm/sn/addrs.h>
23#include <asm/sn/geo.h>
24#include <asm/sn/l1.h>
25#include <asm/sn/module.h>
26#include <asm/sn/pcibr_provider.h>
27#include <asm/sn/pcibus_provider_defs.h>
28#include <asm/sn/pcidev.h>
29#include <asm/sn/sn_feature_sets.h>
30#include <asm/sn/sn_sal.h>
31#include <asm/sn/types.h>
32#include <linux/acpi.h>
33#include <asm/sn/acpi.h>
34
35#include "../pci.h"
36
37MODULE_LICENSE("GPL");
38MODULE_AUTHOR("SGI (prarit@sgi.com, dickie@sgi.com, habeck@sgi.com)");
39MODULE_DESCRIPTION("SGI Altix Hot Plug PCI Controller Driver");
40
41
42/* SAL call error codes. Keep in sync with prom header io/include/pcibr.h */
43#define PCI_SLOT_ALREADY_UP 2 /* slot already up */
44#define PCI_SLOT_ALREADY_DOWN 3 /* slot already down */
45#define PCI_L1_ERR 7 /* L1 console command error */
46#define PCI_EMPTY_33MHZ 15 /* empty 33 MHz bus */
47
48
49#define PCIIO_ASIC_TYPE_TIOCA 4
50#define PCI_L1_QSIZE 128 /* our L1 message buffer size */
51#define SN_MAX_HP_SLOTS 32 /* max hotplug slots */
52#define SN_SLOT_NAME_SIZE 33 /* size of name string */
53
54/* internal list head */
55static struct list_head sn_hp_list;
56
57/* hotplug_slot struct's private pointer */
58struct slot {
59 int device_num;
60 struct pci_bus *pci_bus;
61 /* this struct for glue internal only */
62 struct hotplug_slot *hotplug_slot;
63 struct list_head hp_list;
64 char physical_path[SN_SLOT_NAME_SIZE];
65};
66
67struct pcibr_slot_enable_resp {
68 int resp_sub_errno;
69 char resp_l1_msg[PCI_L1_QSIZE + 1];
70};
71
72struct pcibr_slot_disable_resp {
73 int resp_sub_errno;
74 char resp_l1_msg[PCI_L1_QSIZE + 1];
75};
76
77enum sn_pci_req_e {
78 PCI_REQ_SLOT_ELIGIBLE,
79 PCI_REQ_SLOT_DISABLE
80};
81
82static int enable_slot(struct hotplug_slot *slot);
83static int disable_slot(struct hotplug_slot *slot);
84static inline int get_power_status(struct hotplug_slot *slot, u8 *value);
85
86static struct hotplug_slot_ops sn_hotplug_slot_ops = {
87 .enable_slot = enable_slot,
88 .disable_slot = disable_slot,
89 .get_power_status = get_power_status,
90};
91
92static DEFINE_MUTEX(sn_hotplug_mutex);
93
94static ssize_t path_show(struct pci_slot *pci_slot, char *buf)
95{
96 int retval = -ENOENT;
97 struct slot *slot = pci_slot->hotplug->private;
98
99 if (!slot)
100 return retval;
101
102 retval = sprintf (buf, "%s\n", slot->physical_path);
103 return retval;
104}
105
106static struct pci_slot_attribute sn_slot_path_attr = __ATTR_RO(path);
107
108static int sn_pci_slot_valid(struct pci_bus *pci_bus, int device)
109{
110 struct pcibus_info *pcibus_info;
111 u16 busnum, segment, ioboard_type;
112
113 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
114
115 /* Check to see if this is a valid slot on 'pci_bus' */
116 if (!(pcibus_info->pbi_valid_devices & (1 << device)))
117 return -EPERM;
118
119 ioboard_type = sn_ioboard_to_pci_bus(pci_bus);
120 busnum = pcibus_info->pbi_buscommon.bs_persist_busnum;
121 segment = pci_domain_nr(pci_bus) & 0xf;
122
123 /* Do not allow hotplug operations on base I/O cards */
124 if ((ioboard_type == L1_BRICKTYPE_IX ||
125 ioboard_type == L1_BRICKTYPE_IA) &&
126 (segment == 1 && busnum == 0 && device != 1))
127 return -EPERM;
128
129 return 1;
130}
131
132static int sn_pci_bus_valid(struct pci_bus *pci_bus)
133{
134 struct pcibus_info *pcibus_info;
135 u32 asic_type;
136 u16 ioboard_type;
137
138 /* Don't register slots hanging off the TIOCA bus */
139 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
140 asic_type = pcibus_info->pbi_buscommon.bs_asic_type;
141 if (asic_type == PCIIO_ASIC_TYPE_TIOCA)
142 return -EPERM;
143
144 /* Only register slots in I/O Bricks that support hotplug */
145 ioboard_type = sn_ioboard_to_pci_bus(pci_bus);
146 switch (ioboard_type) {
147 case L1_BRICKTYPE_IX:
148 case L1_BRICKTYPE_PX:
149 case L1_BRICKTYPE_IA:
150 case L1_BRICKTYPE_PA:
151 case L1_BOARDTYPE_PCIX3SLOT:
152 return 1;
153 break;
154 default:
155 return -EPERM;
156 break;
157 }
158
159 return -EIO;
160}
161
162static int sn_hp_slot_private_alloc(struct hotplug_slot *bss_hotplug_slot,
163 struct pci_bus *pci_bus, int device,
164 char *name)
165{
166 struct pcibus_info *pcibus_info;
167 struct slot *slot;
168
169 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
170
171 slot = kzalloc(sizeof(*slot), GFP_KERNEL);
172 if (!slot)
173 return -ENOMEM;
174 bss_hotplug_slot->private = slot;
175
176 slot->device_num = device;
177 slot->pci_bus = pci_bus;
178 sprintf(name, "%04x:%02x:%02x",
179 pci_domain_nr(pci_bus),
180 ((u16)pcibus_info->pbi_buscommon.bs_persist_busnum),
181 device + 1);
182
183 sn_generate_path(pci_bus, slot->physical_path);
184
185 slot->hotplug_slot = bss_hotplug_slot;
186 list_add(&slot->hp_list, &sn_hp_list);
187
188 return 0;
189}
190
191static struct hotplug_slot * sn_hp_destroy(void)
192{
193 struct slot *slot;
194 struct pci_slot *pci_slot;
195 struct hotplug_slot *bss_hotplug_slot = NULL;
196
197 list_for_each_entry(slot, &sn_hp_list, hp_list) {
198 bss_hotplug_slot = slot->hotplug_slot;
199 pci_slot = bss_hotplug_slot->pci_slot;
200 list_del(&((struct slot *)bss_hotplug_slot->private)->
201 hp_list);
202 sysfs_remove_file(&pci_slot->kobj,
203 &sn_slot_path_attr.attr);
204 break;
205 }
206 return bss_hotplug_slot;
207}
208
209static void sn_bus_free_data(struct pci_dev *dev)
210{
211 struct pci_bus *subordinate_bus;
212 struct pci_dev *child;
213
214 /* Recursively clean up sn_irq_info structs */
215 if (dev->subordinate) {
216 subordinate_bus = dev->subordinate;
217 list_for_each_entry(child, &subordinate_bus->devices, bus_list)
218 sn_bus_free_data(child);
219 }
220 /*
221 * Some drivers may use dma accesses during the
222 * driver remove function. We release the sysdata
223 * areas after the driver remove functions have
224 * been called.
225 */
226 sn_bus_store_sysdata(dev);
227 sn_pci_unfixup_slot(dev);
228}
229
230static int sn_slot_enable(struct hotplug_slot *bss_hotplug_slot,
231 int device_num, char **ssdt)
232{
233 struct slot *slot = bss_hotplug_slot->private;
234 struct pcibus_info *pcibus_info;
235 struct pcibr_slot_enable_resp resp;
236 int rc;
237
238 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
239
240 /*
241 * Power-on and initialize the slot in the SN
242 * PCI infrastructure.
243 */
244 rc = sal_pcibr_slot_enable(pcibus_info, device_num, &resp, ssdt);
245
246
247 if (rc == PCI_SLOT_ALREADY_UP) {
248 dev_dbg(&slot->pci_bus->self->dev, "is already active\n");
249 return 1; /* return 1 to user */
250 }
251
252 if (rc == PCI_L1_ERR) {
253 dev_dbg(&slot->pci_bus->self->dev,
254 "L1 failure %d with message: %s",
255 resp.resp_sub_errno, resp.resp_l1_msg);
256 return -EPERM;
257 }
258
259 if (rc) {
260 dev_dbg(&slot->pci_bus->self->dev,
261 "insert failed with error %d sub-error %d\n",
262 rc, resp.resp_sub_errno);
263 return -EIO;
264 }
265
266 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
267 pcibus_info->pbi_enabled_devices |= (1 << device_num);
268
269 return 0;
270}
271
272static int sn_slot_disable(struct hotplug_slot *bss_hotplug_slot,
273 int device_num, int action)
274{
275 struct slot *slot = bss_hotplug_slot->private;
276 struct pcibus_info *pcibus_info;
277 struct pcibr_slot_disable_resp resp;
278 int rc;
279
280 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
281
282 rc = sal_pcibr_slot_disable(pcibus_info, device_num, action, &resp);
283
284 if ((action == PCI_REQ_SLOT_ELIGIBLE) &&
285 (rc == PCI_SLOT_ALREADY_DOWN)) {
286 dev_dbg(&slot->pci_bus->self->dev, "Slot %s already inactive\n", slot->physical_path);
287 return 1; /* return 1 to user */
288 }
289
290 if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_EMPTY_33MHZ)) {
291 dev_dbg(&slot->pci_bus->self->dev,
292 "Cannot remove last 33MHz card\n");
293 return -EPERM;
294 }
295
296 if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_L1_ERR)) {
297 dev_dbg(&slot->pci_bus->self->dev,
298 "L1 failure %d with message \n%s\n",
299 resp.resp_sub_errno, resp.resp_l1_msg);
300 return -EPERM;
301 }
302
303 if ((action == PCI_REQ_SLOT_ELIGIBLE) && rc) {
304 dev_dbg(&slot->pci_bus->self->dev,
305 "remove failed with error %d sub-error %d\n",
306 rc, resp.resp_sub_errno);
307 return -EIO;
308 }
309
310 if ((action == PCI_REQ_SLOT_ELIGIBLE) && !rc)
311 return 0;
312
313 if ((action == PCI_REQ_SLOT_DISABLE) && !rc) {
314 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
315 pcibus_info->pbi_enabled_devices &= ~(1 << device_num);
316 dev_dbg(&slot->pci_bus->self->dev, "remove successful\n");
317 return 0;
318 }
319
320 if ((action == PCI_REQ_SLOT_DISABLE) && rc) {
321 dev_dbg(&slot->pci_bus->self->dev,"remove failed rc = %d\n", rc);
322 }
323
324 return rc;
325}
326
327/*
328 * Power up and configure the slot via a SAL call to PROM.
329 * Scan slot (and any children), do any platform specific fixup,
330 * and find device driver.
331 */
332static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
333{
334 struct slot *slot = bss_hotplug_slot->private;
335 struct pci_bus *new_bus = NULL;
336 struct pci_dev *dev;
337 int func, num_funcs;
338 int new_ppb = 0;
339 int rc;
340 char *ssdt = NULL;
341 void pcibios_fixup_device_resources(struct pci_dev *);
342
343 /* Serialize the Linux PCI infrastructure */
344 mutex_lock(&sn_hotplug_mutex);
345
346 /*
347 * Power-on and initialize the slot in the SN
348 * PCI infrastructure. Also, retrieve the ACPI SSDT
349 * table for the slot (if ACPI capable PROM).
350 */
351 rc = sn_slot_enable(bss_hotplug_slot, slot->device_num, &ssdt);
352 if (rc) {
353 mutex_unlock(&sn_hotplug_mutex);
354 return rc;
355 }
356
357 if (ssdt)
358 ssdt = __va(ssdt);
359 /* Add the new SSDT for the slot to the ACPI namespace */
360 if (SN_ACPI_BASE_SUPPORT() && ssdt) {
361 acpi_status ret;
362
363 ret = acpi_load_table((struct acpi_table_header *)ssdt);
364 if (ACPI_FAILURE(ret)) {
365 printk(KERN_ERR "%s: acpi_load_table failed (0x%x)\n",
366 __func__, ret);
367 /* try to continue on */
368 }
369 }
370
371 num_funcs = pci_scan_slot(slot->pci_bus,
372 PCI_DEVFN(slot->device_num + 1, 0));
373 if (!num_funcs) {
374 dev_dbg(&slot->pci_bus->self->dev, "no device in slot\n");
375 mutex_unlock(&sn_hotplug_mutex);
376 return -ENODEV;
377 }
378
379 /*
380 * Map SN resources for all functions on the card
381 * to the Linux PCI interface and tell the drivers
382 * about them.
383 */
384 for (func = 0; func < num_funcs; func++) {
385 dev = pci_get_slot(slot->pci_bus,
386 PCI_DEVFN(slot->device_num + 1,
387 PCI_FUNC(func)));
388 if (dev) {
389 /* Need to do slot fixup on PPB before fixup of children
390 * (PPB's pcidev_info needs to be in pcidev_info list
391 * before child's SN_PCIDEV_INFO() call to setup
392 * pdi_host_pcidev_info).
393 */
394 pcibios_fixup_device_resources(dev);
395 if (SN_ACPI_BASE_SUPPORT())
396 sn_acpi_slot_fixup(dev);
397 else
398 sn_io_slot_fixup(dev);
399 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
400 unsigned char sec_bus;
401 pci_read_config_byte(dev, PCI_SECONDARY_BUS,
402 &sec_bus);
403 new_bus = pci_add_new_bus(dev->bus, dev,
404 sec_bus);
405 pci_scan_child_bus(new_bus);
406 new_ppb = 1;
407 }
408 pci_dev_put(dev);
409 }
410 }
411
412 /*
413 * Add the slot's devices to the ACPI infrastructure */
414 if (SN_ACPI_BASE_SUPPORT() && ssdt) {
415 unsigned long long adr;
416 struct acpi_device *pdevice;
417 struct acpi_device *device;
418 acpi_handle phandle;
419 acpi_handle chandle = NULL;
420 acpi_handle rethandle;
421 acpi_status ret;
422
423 phandle = PCI_CONTROLLER(slot->pci_bus)->acpi_handle;
424
425 if (acpi_bus_get_device(phandle, &pdevice)) {
426 dev_dbg(&slot->pci_bus->self->dev,
427 "no parent device, assuming NULL\n");
428 pdevice = NULL;
429 }
430
431 /*
432 * Walk the rootbus node's immediate children looking for
433 * the slot's device node(s). There can be more than
434 * one for multifunction devices.
435 */
436 for (;;) {
437 rethandle = NULL;
438 ret = acpi_get_next_object(ACPI_TYPE_DEVICE,
439 phandle, chandle,
440 &rethandle);
441
442 if (ret == AE_NOT_FOUND || rethandle == NULL)
443 break;
444
445 chandle = rethandle;
446
447 ret = acpi_evaluate_integer(chandle, METHOD_NAME__ADR,
448 NULL, &adr);
449
450 if (ACPI_SUCCESS(ret) &&
451 (adr>>16) == (slot->device_num + 1)) {
452
453 ret = acpi_bus_add(&device, pdevice, chandle,
454 ACPI_BUS_TYPE_DEVICE);
455 if (ACPI_FAILURE(ret)) {
456 printk(KERN_ERR "%s: acpi_bus_add "
457 "failed (0x%x) for slot %d "
458 "func %d\n", __func__,
459 ret, (int)(adr>>16),
460 (int)(adr&0xffff));
461 /* try to continue on */
462 } else {
463 acpi_bus_start(device);
464 }
465 }
466 }
467 }
468
469 /* Call the driver for the new device */
470 pci_bus_add_devices(slot->pci_bus);
471 /* Call the drivers for the new devices subordinate to PPB */
472 if (new_ppb)
473 pci_bus_add_devices(new_bus);
474
475 mutex_unlock(&sn_hotplug_mutex);
476
477 if (rc == 0)
478 dev_dbg(&slot->pci_bus->self->dev,
479 "insert operation successful\n");
480 else
481 dev_dbg(&slot->pci_bus->self->dev,
482 "insert operation failed rc = %d\n", rc);
483
484 return rc;
485}
486
487static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
488{
489 struct slot *slot = bss_hotplug_slot->private;
490 struct pci_dev *dev;
491 int func;
492 int rc;
493 acpi_owner_id ssdt_id = 0;
494
495 /* Acquire update access to the bus */
496 mutex_lock(&sn_hotplug_mutex);
497
498 /* is it okay to bring this slot down? */
499 rc = sn_slot_disable(bss_hotplug_slot, slot->device_num,
500 PCI_REQ_SLOT_ELIGIBLE);
501 if (rc)
502 goto leaving;
503
504 /* free the ACPI resources for the slot */
505 if (SN_ACPI_BASE_SUPPORT() &&
506 PCI_CONTROLLER(slot->pci_bus)->acpi_handle) {
507 unsigned long long adr;
508 struct acpi_device *device;
509 acpi_handle phandle;
510 acpi_handle chandle = NULL;
511 acpi_handle rethandle;
512 acpi_status ret;
513
514 /* Get the rootbus node pointer */
515 phandle = PCI_CONTROLLER(slot->pci_bus)->acpi_handle;
516
517 /*
518 * Walk the rootbus node's immediate children looking for
519 * the slot's device node(s). There can be more than
520 * one for multifunction devices.
521 */
522 for (;;) {
523 rethandle = NULL;
524 ret = acpi_get_next_object(ACPI_TYPE_DEVICE,
525 phandle, chandle,
526 &rethandle);
527
528 if (ret == AE_NOT_FOUND || rethandle == NULL)
529 break;
530
531 chandle = rethandle;
532
533 ret = acpi_evaluate_integer(chandle,
534 METHOD_NAME__ADR,
535 NULL, &adr);
536 if (ACPI_SUCCESS(ret) &&
537 (adr>>16) == (slot->device_num + 1)) {
538 /* retain the owner id */
539 acpi_get_id(chandle, &ssdt_id);
540
541 ret = acpi_bus_get_device(chandle,
542 &device);
543 if (ACPI_SUCCESS(ret))
544 acpi_bus_trim(device, 1);
545 }
546 }
547
548 }
549
550 /* Free the SN resources assigned to the Linux device.*/
551 for (func = 0; func < 8; func++) {
552 dev = pci_get_slot(slot->pci_bus,
553 PCI_DEVFN(slot->device_num + 1,
554 PCI_FUNC(func)));
555 if (dev) {
556 sn_bus_free_data(dev);
557 pci_remove_bus_device(dev);
558 pci_dev_put(dev);
559 }
560 }
561
562 /* Remove the SSDT for the slot from the ACPI namespace */
563 if (SN_ACPI_BASE_SUPPORT() && ssdt_id) {
564 acpi_status ret;
565 ret = acpi_unload_table_id(ssdt_id);
566 if (ACPI_FAILURE(ret)) {
567 printk(KERN_ERR "%s: acpi_unload_table_id "
568 "failed (0x%x) for id %d\n",
569 __func__, ret, ssdt_id);
570 /* try to continue on */
571 }
572 }
573
574 /* free the collected sysdata pointers */
575 sn_bus_free_sysdata();
576
577 /* Deactivate slot */
578 rc = sn_slot_disable(bss_hotplug_slot, slot->device_num,
579 PCI_REQ_SLOT_DISABLE);
580 leaving:
581 /* Release the bus lock */
582 mutex_unlock(&sn_hotplug_mutex);
583
584 return rc;
585}
586
587static inline int get_power_status(struct hotplug_slot *bss_hotplug_slot,
588 u8 *value)
589{
590 struct slot *slot = bss_hotplug_slot->private;
591 struct pcibus_info *pcibus_info;
592 u32 power;
593
594 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
595 mutex_lock(&sn_hotplug_mutex);
596 power = pcibus_info->pbi_enabled_devices & (1 << slot->device_num);
597 *value = power ? 1 : 0;
598 mutex_unlock(&sn_hotplug_mutex);
599 return 0;
600}
601
602static void sn_release_slot(struct hotplug_slot *bss_hotplug_slot)
603{
604 kfree(bss_hotplug_slot->info);
605 kfree(bss_hotplug_slot->private);
606 kfree(bss_hotplug_slot);
607}
608
609static int sn_hotplug_slot_register(struct pci_bus *pci_bus)
610{
611 int device;
612 struct pci_slot *pci_slot;
613 struct hotplug_slot *bss_hotplug_slot;
614 char name[SN_SLOT_NAME_SIZE];
615 int rc = 0;
616
617 /*
618 * Currently only four devices are supported,
619 * in the future there maybe more -- up to 32.
620 */
621
622 for (device = 0; device < SN_MAX_HP_SLOTS ; device++) {
623 if (sn_pci_slot_valid(pci_bus, device) != 1)
624 continue;
625
626 bss_hotplug_slot = kzalloc(sizeof(*bss_hotplug_slot),
627 GFP_KERNEL);
628 if (!bss_hotplug_slot) {
629 rc = -ENOMEM;
630 goto alloc_err;
631 }
632
633 bss_hotplug_slot->info =
634 kzalloc(sizeof(struct hotplug_slot_info),
635 GFP_KERNEL);
636 if (!bss_hotplug_slot->info) {
637 rc = -ENOMEM;
638 goto alloc_err;
639 }
640
641 if (sn_hp_slot_private_alloc(bss_hotplug_slot,
642 pci_bus, device, name)) {
643 rc = -ENOMEM;
644 goto alloc_err;
645 }
646 bss_hotplug_slot->ops = &sn_hotplug_slot_ops;
647 bss_hotplug_slot->release = &sn_release_slot;
648
649 rc = pci_hp_register(bss_hotplug_slot, pci_bus, device, name);
650 if (rc)
651 goto register_err;
652
653 pci_slot = bss_hotplug_slot->pci_slot;
654 rc = sysfs_create_file(&pci_slot->kobj,
655 &sn_slot_path_attr.attr);
656 if (rc)
657 goto register_err;
658 }
659 dev_dbg(&pci_bus->self->dev, "Registered bus with hotplug\n");
660 return rc;
661
662register_err:
663 dev_dbg(&pci_bus->self->dev, "bus failed to register with err = %d\n",
664 rc);
665
666alloc_err:
667 if (rc == -ENOMEM)
668 dev_dbg(&pci_bus->self->dev, "Memory allocation error\n");
669
670 /* destroy THIS element */
671 if (bss_hotplug_slot)
672 sn_release_slot(bss_hotplug_slot);
673
674 /* destroy anything else on the list */
675 while ((bss_hotplug_slot = sn_hp_destroy()))
676 pci_hp_deregister(bss_hotplug_slot);
677
678 return rc;
679}
680
681static int __init sn_pci_hotplug_init(void)
682{
683 struct pci_bus *pci_bus = NULL;
684 int rc;
685 int registered = 0;
686
687 if (!sn_prom_feature_available(PRF_HOTPLUG_SUPPORT)) {
688 printk(KERN_ERR "%s: PROM version does not support hotplug.\n",
689 __func__);
690 return -EPERM;
691 }
692
693 INIT_LIST_HEAD(&sn_hp_list);
694
695 while ((pci_bus = pci_find_next_bus(pci_bus))) {
696 if (!pci_bus->sysdata)
697 continue;
698
699 rc = sn_pci_bus_valid(pci_bus);
700 if (rc != 1) {
701 dev_dbg(&pci_bus->self->dev, "not a valid hotplug bus\n");
702 continue;
703 }
704 dev_dbg(&pci_bus->self->dev, "valid hotplug bus\n");
705
706 rc = sn_hotplug_slot_register(pci_bus);
707 if (!rc) {
708 registered = 1;
709 } else {
710 registered = 0;
711 break;
712 }
713 }
714
715 return registered == 1 ? 0 : -ENODEV;
716}
717
718static void __exit sn_pci_hotplug_exit(void)
719{
720 struct hotplug_slot *bss_hotplug_slot;
721
722 while ((bss_hotplug_slot = sn_hp_destroy()))
723 pci_hp_deregister(bss_hotplug_slot);
724
725 if (!list_empty(&sn_hp_list))
726 printk(KERN_ERR "%s: internal list is not empty\n", __FILE__);
727}
728
729module_init(sn_pci_hotplug_init);
730module_exit(sn_pci_hotplug_exit);