?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[CONNECTOR]: Initialize subsystem earlier.
[linux-2.6/verdex.git] / drivers / pci / hotplug / sgi_hotplug.c
blob8cb9abde736b43e40e6a72d6008838e60697c02d
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/proc_fs.h>
17 #include <linux/types.h>
18 #include <linux/mutex.h>
19
20 #include <asm/sn/addrs.h>
21 #include <asm/sn/l1.h>
22 #include <asm/sn/module.h>
23 #include <asm/sn/pcibr_provider.h>
24 #include <asm/sn/pcibus_provider_defs.h>
25 #include <asm/sn/pcidev.h>
26 #include <asm/sn/sn_sal.h>
27 #include <asm/sn/types.h>
28
29 #include "../pci.h"
30 #include "pci_hotplug.h"
31
32 MODULE_LICENSE("GPL");
33 MODULE_AUTHOR("SGI (prarit@sgi.com, dickie@sgi.com, habeck@sgi.com)");
34 MODULE_DESCRIPTION("SGI Altix Hot Plug PCI Controller Driver");
35
36 #define PCIIO_ASIC_TYPE_TIOCA 4
37 #define PCI_SLOT_ALREADY_UP 2 /* slot already up */
38 #define PCI_SLOT_ALREADY_DOWN 3 /* slot already down */
39 #define PCI_L1_ERR 7 /* L1 console command error */
40 #define PCI_EMPTY_33MHZ 15 /* empty 33 MHz bus */
41 #define PCI_L1_QSIZE 128 /* our L1 message buffer size */
42 #define SN_MAX_HP_SLOTS 32 /* max hotplug slots */
43 #define SGI_HOTPLUG_PROM_REV 0x0430 /* Min. required PROM version */
44 #define SN_SLOT_NAME_SIZE 33 /* size of name string */
45
46 /* internal list head */
47 static struct list_head sn_hp_list;
48
49 /* hotplug_slot struct's private pointer */
50 struct slot {
51 int device_num;
52 struct pci_bus *pci_bus;
53 /* this struct for glue internal only */
54 struct hotplug_slot *hotplug_slot;
55 struct list_head hp_list;
56 char physical_path[SN_SLOT_NAME_SIZE];
57 };
58
59 struct pcibr_slot_enable_resp {
60 int resp_sub_errno;
61 char resp_l1_msg[PCI_L1_QSIZE + 1];
62 };
63
64 struct pcibr_slot_disable_resp {
65 int resp_sub_errno;
66 char resp_l1_msg[PCI_L1_QSIZE + 1];
67 };
68
69 enum sn_pci_req_e {
70 PCI_REQ_SLOT_ELIGIBLE,
71 PCI_REQ_SLOT_DISABLE
72 };
73
74 static int enable_slot(struct hotplug_slot *slot);
75 static int disable_slot(struct hotplug_slot *slot);
76 static inline int get_power_status(struct hotplug_slot *slot, u8 *value);
77
78 static struct hotplug_slot_ops sn_hotplug_slot_ops = {
79 .owner = THIS_MODULE,
80 .enable_slot = enable_slot,
81 .disable_slot = disable_slot,
82 .get_power_status = get_power_status,
83 };
84
85 static DEFINE_MUTEX(sn_hotplug_mutex);
86
87 static ssize_t path_show (struct hotplug_slot *bss_hotplug_slot,
88 char *buf)
89 {
90 int retval = -ENOENT;
91 struct slot *slot = bss_hotplug_slot->private;
92
93 if (!slot)
94 return retval;
95
96 retval = sprintf (buf, "%s\n", slot->physical_path);
97 return retval;
98 }
99
100 static struct hotplug_slot_attribute sn_slot_path_attr = __ATTR_RO(path);
101
102 static int sn_pci_slot_valid(struct pci_bus *pci_bus, int device)
103 {
104 struct pcibus_info *pcibus_info;
105 int bricktype;
106 int bus_num;
107
108 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
109
110 /* Check to see if this is a valid slot on 'pci_bus' */
111 if (!(pcibus_info->pbi_valid_devices & (1 << device)))
112 return -EPERM;
113
114 bricktype = MODULE_GET_BTYPE(pcibus_info->pbi_moduleid);
115 bus_num = pcibus_info->pbi_buscommon.bs_persist_busnum & 0xf;
116
117 /* Do not allow hotplug operations on base I/O cards */
118 if ((bricktype == L1_BRICKTYPE_IX || bricktype == L1_BRICKTYPE_IA) &&
119 (bus_num == 1 && device != 1))
120 return -EPERM;
121
122 return 1;
123 }
124
125 static int sn_pci_bus_valid(struct pci_bus *pci_bus)
126 {
127 struct pcibus_info *pcibus_info;
128 int asic_type;
129 int bricktype;
130
131 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
132
133 /* Don't register slots hanging off the TIOCA bus */
134 asic_type = pcibus_info->pbi_buscommon.bs_asic_type;
135 if (asic_type == PCIIO_ASIC_TYPE_TIOCA)
136 return -EPERM;
137
138 /* Only register slots in I/O Bricks that support hotplug */
139 bricktype = MODULE_GET_BTYPE(pcibus_info->pbi_moduleid);
140 switch (bricktype) {
141 case L1_BRICKTYPE_IX:
142 case L1_BRICKTYPE_PX:
143 case L1_BRICKTYPE_IA:
144 case L1_BRICKTYPE_PA:
145 return 1;
146 break;
147 default:
148 return -EPERM;
149 break;
150 }
151
152 return -EIO;
153 }
154
155 static int sn_hp_slot_private_alloc(struct hotplug_slot *bss_hotplug_slot,
156 struct pci_bus *pci_bus, int device)
157 {
158 struct pcibus_info *pcibus_info;
159 struct slot *slot;
160
161 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
162
163 slot = kzalloc(sizeof(*slot), GFP_KERNEL);
164 if (!slot)
165 return -ENOMEM;
166 bss_hotplug_slot->private = slot;
167
168 bss_hotplug_slot->name = kmalloc(SN_SLOT_NAME_SIZE, GFP_KERNEL);
169 if (!bss_hotplug_slot->name) {
170 kfree(bss_hotplug_slot->private);
171 return -ENOMEM;
172 }
173
174 slot->device_num = device;
175 slot->pci_bus = pci_bus;
176 sprintf(bss_hotplug_slot->name, "%04x:%02x:%02x",
177 pci_domain_nr(pci_bus),
178 ((int)pcibus_info->pbi_buscommon.bs_persist_busnum) & 0xf,
179 device + 1);
180 sprintf(slot->physical_path, "module_%c%c%c%c%.2d",
181 '0'+RACK_GET_CLASS(MODULE_GET_RACK(pcibus_info->pbi_moduleid)),
182 '0'+RACK_GET_GROUP(MODULE_GET_RACK(pcibus_info->pbi_moduleid)),
183 '0'+RACK_GET_NUM(MODULE_GET_RACK(pcibus_info->pbi_moduleid)),
184 MODULE_GET_BTCHAR(pcibus_info->pbi_moduleid),
185 MODULE_GET_BPOS(pcibus_info->pbi_moduleid));
186 slot->hotplug_slot = bss_hotplug_slot;
187 list_add(&slot->hp_list, &sn_hp_list);
188
189 return 0;
190 }
191
192 static struct hotplug_slot * sn_hp_destroy(void)
193 {
194 struct slot *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 list_del(&((struct slot *)bss_hotplug_slot->private)->
200 hp_list);
201 sysfs_remove_file(&bss_hotplug_slot->kobj,
202 &sn_slot_path_attr.attr);
203 break;
204 }
205 return bss_hotplug_slot;
206 }
207
208 static void sn_bus_alloc_data(struct pci_dev *dev)
209 {
210 struct pci_bus *subordinate_bus;
211 struct pci_dev *child;
212
213 sn_pci_fixup_slot(dev);
214
215 /* Recursively sets up the sn_irq_info structs */
216 if (dev->subordinate) {
217 subordinate_bus = dev->subordinate;
218 list_for_each_entry(child, &subordinate_bus->devices, bus_list)
219 sn_bus_alloc_data(child);
220 }
221 }
222
223 static void sn_bus_free_data(struct pci_dev *dev)
224 {
225 struct pci_bus *subordinate_bus;
226 struct pci_dev *child;
227
228 /* Recursively clean up sn_irq_info structs */
229 if (dev->subordinate) {
230 subordinate_bus = dev->subordinate;
231 list_for_each_entry(child, &subordinate_bus->devices, bus_list)
232 sn_bus_free_data(child);
233 }
234 /*
235 * Some drivers may use dma accesses during the
236 * driver remove function. We release the sysdata
237 * areas after the driver remove functions have
238 * been called.
239 */
240 sn_bus_store_sysdata(dev);
241 sn_pci_unfixup_slot(dev);
242 }
243
244 static int sn_slot_enable(struct hotplug_slot *bss_hotplug_slot,
245 int device_num)
246 {
247 struct slot *slot = bss_hotplug_slot->private;
248 struct pcibus_info *pcibus_info;
249 struct pcibr_slot_enable_resp resp;
250 int rc;
251
252 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
253
254 /*
255 * Power-on and initialize the slot in the SN
256 * PCI infrastructure.
257 */
258 rc = sal_pcibr_slot_enable(pcibus_info, device_num, &resp);
259
260 if (rc == PCI_SLOT_ALREADY_UP) {
261 dev_dbg(slot->pci_bus->self, "is already active\n");
262 return 1; /* return 1 to user */
263 }
264
265 if (rc == PCI_L1_ERR) {
266 dev_dbg(slot->pci_bus->self,
267 "L1 failure %d with message: %s",
268 resp.resp_sub_errno, resp.resp_l1_msg);
269 return -EPERM;
270 }
271
272 if (rc) {
273 dev_dbg(slot->pci_bus->self,
274 "insert failed with error %d sub-error %d\n",
275 rc, resp.resp_sub_errno);
276 return -EIO;
277 }
278
279 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
280 pcibus_info->pbi_enabled_devices |= (1 << device_num);
281
282 return 0;
283 }
284
285 static int sn_slot_disable(struct hotplug_slot *bss_hotplug_slot,
286 int device_num, int action)
287 {
288 struct slot *slot = bss_hotplug_slot->private;
289 struct pcibus_info *pcibus_info;
290 struct pcibr_slot_disable_resp resp;
291 int rc;
292
293 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
294
295 rc = sal_pcibr_slot_disable(pcibus_info, device_num, action, &resp);
296
297 if ((action == PCI_REQ_SLOT_ELIGIBLE) &&
298 (rc == PCI_SLOT_ALREADY_DOWN)) {
299 dev_dbg(slot->pci_bus->self, "Slot %s already inactive\n");
300 return 1; /* return 1 to user */
301 }
302
303 if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_EMPTY_33MHZ)) {
304 dev_dbg(slot->pci_bus->self,
305 "Cannot remove last 33MHz card\n");
306 return -EPERM;
307 }
308
309 if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_L1_ERR)) {
310 dev_dbg(slot->pci_bus->self,
311 "L1 failure %d with message \n%s\n",
312 resp.resp_sub_errno, resp.resp_l1_msg);
313 return -EPERM;
314 }
315
316 if ((action == PCI_REQ_SLOT_ELIGIBLE) && rc) {
317 dev_dbg(slot->pci_bus->self,
318 "remove failed with error %d sub-error %d\n",
319 rc, resp.resp_sub_errno);
320 return -EIO;
321 }
322
323 if ((action == PCI_REQ_SLOT_ELIGIBLE) && !rc)
324 return 0;
325
326 if ((action == PCI_REQ_SLOT_DISABLE) && !rc) {
327 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
328 pcibus_info->pbi_enabled_devices &= ~(1 << device_num);
329 dev_dbg(slot->pci_bus->self, "remove successful\n");
330 return 0;
331 }
332
333 if ((action == PCI_REQ_SLOT_DISABLE) && rc) {
334 dev_dbg(slot->pci_bus->self,"remove failed rc = %d\n", rc);
335 }
336
337 return rc;
338 }
339
340 static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
341 {
342 struct slot *slot = bss_hotplug_slot->private;
343 struct pci_bus *new_bus = NULL;
344 struct pci_dev *dev;
345 int func, num_funcs;
346 int new_ppb = 0;
347 int rc;
348
349 /* Serialize the Linux PCI infrastructure */
350 mutex_lock(&sn_hotplug_mutex);
351
352 /*
353 * Power-on and initialize the slot in the SN
354 * PCI infrastructure.
355 */
356 rc = sn_slot_enable(bss_hotplug_slot, slot->device_num);
357 if (rc) {
358 mutex_unlock(&sn_hotplug_mutex);
359 return rc;
360 }
361
362 num_funcs = pci_scan_slot(slot->pci_bus,
363 PCI_DEVFN(slot->device_num + 1, 0));
364 if (!num_funcs) {
365 dev_dbg(slot->pci_bus->self, "no device in slot\n");
366 mutex_unlock(&sn_hotplug_mutex);
367 return -ENODEV;
368 }
369
370 sn_pci_controller_fixup(pci_domain_nr(slot->pci_bus),
371 slot->pci_bus->number,
372 slot->pci_bus);
373 /*
374 * Map SN resources for all functions on the card
375 * to the Linux PCI interface and tell the drivers
376 * about them.
377 */
378 for (func = 0; func < num_funcs; func++) {
379 dev = pci_get_slot(slot->pci_bus,
380 PCI_DEVFN(slot->device_num + 1,
381 PCI_FUNC(func)));
382 if (dev) {
383 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
384 unsigned char sec_bus;
385 pci_read_config_byte(dev, PCI_SECONDARY_BUS,
386 &sec_bus);
387 new_bus = pci_add_new_bus(dev->bus, dev,
388 sec_bus);
389 pci_scan_child_bus(new_bus);
390 sn_pci_controller_fixup(pci_domain_nr(new_bus),
391 new_bus->number,
392 new_bus);
393 new_ppb = 1;
394 }
395 sn_bus_alloc_data(dev);
396 pci_dev_put(dev);
397 }
398 }
399
400 /* Call the driver for the new device */
401 pci_bus_add_devices(slot->pci_bus);
402 /* Call the drivers for the new devices subordinate to PPB */
403 if (new_ppb)
404 pci_bus_add_devices(new_bus);
405
406 mutex_unlock(&sn_hotplug_mutex);
407
408 if (rc == 0)
409 dev_dbg(slot->pci_bus->self,
410 "insert operation successful\n");
411 else
412 dev_dbg(slot->pci_bus->self,
413 "insert operation failed rc = %d\n", rc);
414
415 return rc;
416 }
417
418 static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
419 {
420 struct slot *slot = bss_hotplug_slot->private;
421 struct pci_dev *dev;
422 int func;
423 int rc;
424
425 /* Acquire update access to the bus */
426 mutex_lock(&sn_hotplug_mutex);
427
428 /* is it okay to bring this slot down? */
429 rc = sn_slot_disable(bss_hotplug_slot, slot->device_num,
430 PCI_REQ_SLOT_ELIGIBLE);
431 if (rc)
432 goto leaving;
433
434 /* Free the SN resources assigned to the Linux device.*/
435 for (func = 0; func < 8; func++) {
436 dev = pci_get_slot(slot->pci_bus,
437 PCI_DEVFN(slot->device_num + 1,
438 PCI_FUNC(func)));
439 if (dev) {
440 sn_bus_free_data(dev);
441 pci_remove_bus_device(dev);
442 pci_dev_put(dev);
443 }
444 }
445
446 /* free the collected sysdata pointers */
447 sn_bus_free_sysdata();
448
449 /* Deactivate slot */
450 rc = sn_slot_disable(bss_hotplug_slot, slot->device_num,
451 PCI_REQ_SLOT_DISABLE);
452 leaving:
453 /* Release the bus lock */
454 mutex_unlock(&sn_hotplug_mutex);
455
456 return rc;
457 }
458
459 static inline int get_power_status(struct hotplug_slot *bss_hotplug_slot,
460 u8 *value)
461 {
462 struct slot *slot = bss_hotplug_slot->private;
463 struct pcibus_info *pcibus_info;
464
465 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
466 mutex_lock(&sn_hotplug_mutex);
467 *value = pcibus_info->pbi_enabled_devices & (1 << slot->device_num);
468 mutex_unlock(&sn_hotplug_mutex);
469 return 0;
470 }
471
472 static void sn_release_slot(struct hotplug_slot *bss_hotplug_slot)
473 {
474 kfree(bss_hotplug_slot->info);
475 kfree(bss_hotplug_slot->name);
476 kfree(bss_hotplug_slot->private);
477 kfree(bss_hotplug_slot);
478 }
479
480 static int sn_hotplug_slot_register(struct pci_bus *pci_bus)
481 {
482 int device;
483 struct hotplug_slot *bss_hotplug_slot;
484 int rc = 0;
485
486 /*
487 * Currently only four devices are supported,
488 * in the future there maybe more -- up to 32.
489 */
490
491 for (device = 0; device < SN_MAX_HP_SLOTS ; device++) {
492 if (sn_pci_slot_valid(pci_bus, device) != 1)
493 continue;
494
495 bss_hotplug_slot = kzalloc(sizeof(*bss_hotplug_slot),
496 GFP_KERNEL);
497 if (!bss_hotplug_slot) {
498 rc = -ENOMEM;
499 goto alloc_err;
500 }
501
502 bss_hotplug_slot->info =
503 kzalloc(sizeof(struct hotplug_slot_info),
504 GFP_KERNEL);
505 if (!bss_hotplug_slot->info) {
506 rc = -ENOMEM;
507 goto alloc_err;
508 }
509
510 if (sn_hp_slot_private_alloc(bss_hotplug_slot,
511 pci_bus, device)) {
512 rc = -ENOMEM;
513 goto alloc_err;
514 }
515
516 bss_hotplug_slot->ops = &sn_hotplug_slot_ops;
517 bss_hotplug_slot->release = &sn_release_slot;
518
519 rc = pci_hp_register(bss_hotplug_slot);
520 if (rc)
521 goto register_err;
522
523 rc = sysfs_create_file(&bss_hotplug_slot->kobj,
524 &sn_slot_path_attr.attr);
525 if (rc)
526 goto register_err;
527 }
528 dev_dbg(pci_bus->self, "Registered bus with hotplug\n");
529 return rc;
530
531 register_err:
532 dev_dbg(pci_bus->self, "bus failed to register with err = %d\n",
533 rc);
534
535 alloc_err:
536 if (rc == -ENOMEM)
537 dev_dbg(pci_bus->self, "Memory allocation error\n");
538
539 /* destroy THIS element */
540 if (bss_hotplug_slot)
541 sn_release_slot(bss_hotplug_slot);
542
543 /* destroy anything else on the list */
544 while ((bss_hotplug_slot = sn_hp_destroy()))
545 pci_hp_deregister(bss_hotplug_slot);
546
547 return rc;
548 }
549
550 static int sn_pci_hotplug_init(void)
551 {
552 struct pci_bus *pci_bus = NULL;
553 int rc;
554 int registered = 0;
555
556 if (sn_sal_rev() < SGI_HOTPLUG_PROM_REV) {
557 printk(KERN_ERR "%s: PROM version must be greater than 4.30\n",
558 __FUNCTION__);
559 return -EPERM;
560 }
561
562 INIT_LIST_HEAD(&sn_hp_list);
563
564 while ((pci_bus = pci_find_next_bus(pci_bus))) {
565 if (!pci_bus->sysdata)
566 continue;
567
568 rc = sn_pci_bus_valid(pci_bus);
569 if (rc != 1) {
570 dev_dbg(pci_bus->self, "not a valid hotplug bus\n");
571 continue;
572 }
573 dev_dbg(pci_bus->self, "valid hotplug bus\n");
574
575 rc = sn_hotplug_slot_register(pci_bus);
576 if (!rc) {
577 registered = 1;
578 } else {
579 registered = 0;
580 break;
581 }
582 }
583
584 return registered == 1 ? 0 : -ENODEV;
585 }
586
587 static void sn_pci_hotplug_exit(void)
588 {
589 struct hotplug_slot *bss_hotplug_slot;
590
591 while ((bss_hotplug_slot = sn_hp_destroy()))
592 pci_hp_deregister(bss_hotplug_slot);
593
594 if (!list_empty(&sn_hp_list))
595 printk(KERN_ERR "%s: internal list is not empty\n", __FILE__);
596 }
597
598 module_init(sn_pci_hotplug_init);
599 module_exit(sn_pci_hotplug_exit);
Verdex Pro support