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