PCI hotplug: create symlink to hotplug driver module
[linux-2.6.git] / drivers / pci / hotplug / pciehp_ctrl.c
1 /*
2  * PCI Express 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>, <kristen.c.accardi@intel.com>
27  *
28  */
29
30 #include <linux/module.h>
31 #include <linux/kernel.h>
32 #include <linux/types.h>
33 #include <linux/smp_lock.h>
34 #include <linux/pci.h>
35 #include <linux/workqueue.h>
36 #include "../pci.h"
37 #include "pciehp.h"
38
39 static void interrupt_event_handler(struct work_struct *work);
40
41 static int queue_interrupt_event(struct slot *p_slot, u32 event_type)
42 {
43         struct event_info *info;
44
45         info = kmalloc(sizeof(*info), GFP_ATOMIC);
46         if (!info)
47                 return -ENOMEM;
48
49         info->event_type = event_type;
50         info->p_slot = p_slot;
51         INIT_WORK(&info->work, interrupt_event_handler);
52
53         schedule_work(&info->work);
54
55         return 0;
56 }
57
58 u8 pciehp_handle_attention_button(struct slot *p_slot)
59 {
60         u32 event_type;
61         struct controller *ctrl = p_slot->ctrl;
62
63         /* Attention Button Change */
64         ctrl_dbg(ctrl, "Attention button interrupt received\n");
65
66         /*
67          *  Button pressed - See if need to TAKE ACTION!!!
68          */
69         ctrl_info(ctrl, "Button pressed on Slot(%s)\n", slot_name(p_slot));
70         event_type = INT_BUTTON_PRESS;
71
72         queue_interrupt_event(p_slot, event_type);
73
74         return 0;
75 }
76
77 u8 pciehp_handle_switch_change(struct slot *p_slot)
78 {
79         u8 getstatus;
80         u32 event_type;
81         struct controller *ctrl = p_slot->ctrl;
82
83         /* Switch Change */
84         ctrl_dbg(ctrl, "Switch interrupt received\n");
85
86         p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
87         if (getstatus) {
88                 /*
89                  * Switch opened
90                  */
91                 ctrl_info(ctrl, "Latch open on Slot(%s)\n", slot_name(p_slot));
92                 event_type = INT_SWITCH_OPEN;
93         } else {
94                 /*
95                  *  Switch closed
96                  */
97                 ctrl_info(ctrl, "Latch close on Slot(%s)\n", slot_name(p_slot));
98                 event_type = INT_SWITCH_CLOSE;
99         }
100
101         queue_interrupt_event(p_slot, event_type);
102
103         return 1;
104 }
105
106 u8 pciehp_handle_presence_change(struct slot *p_slot)
107 {
108         u32 event_type;
109         u8 presence_save;
110         struct controller *ctrl = p_slot->ctrl;
111
112         /* Presence Change */
113         ctrl_dbg(ctrl, "Presence/Notify input change\n");
114
115         /* Switch is open, assume a presence change
116          * Save the presence state
117          */
118         p_slot->hpc_ops->get_adapter_status(p_slot, &presence_save);
119         if (presence_save) {
120                 /*
121                  * Card Present
122                  */
123                 ctrl_info(ctrl, "Card present on Slot(%s)\n", slot_name(p_slot));
124                 event_type = INT_PRESENCE_ON;
125         } else {
126                 /*
127                  * Not Present
128                  */
129                 ctrl_info(ctrl, "Card not present on Slot(%s)\n",
130                           slot_name(p_slot));
131                 event_type = INT_PRESENCE_OFF;
132         }
133
134         queue_interrupt_event(p_slot, event_type);
135
136         return 1;
137 }
138
139 u8 pciehp_handle_power_fault(struct slot *p_slot)
140 {
141         u32 event_type;
142         struct controller *ctrl = p_slot->ctrl;
143
144         /* power fault */
145         ctrl_dbg(ctrl, "Power fault interrupt received\n");
146
147         if ( !(p_slot->hpc_ops->query_power_fault(p_slot))) {
148                 /*
149                  * power fault Cleared
150                  */
151                 ctrl_info(ctrl, "Power fault cleared on Slot(%s)\n",
152                           slot_name(p_slot));
153                 event_type = INT_POWER_FAULT_CLEAR;
154         } else {
155                 /*
156                  *   power fault
157                  */
158                 ctrl_info(ctrl, "Power fault on Slot(%s)\n", slot_name(p_slot));
159                 event_type = INT_POWER_FAULT;
160                 ctrl_info(ctrl, "Power fault bit %x set\n", 0);
161         }
162
163         queue_interrupt_event(p_slot, event_type);
164
165         return 1;
166 }
167
168 /* The following routines constitute the bulk of the
169    hotplug controller logic
170  */
171
172 static void set_slot_off(struct controller *ctrl, struct slot * pslot)
173 {
174         /* turn off slot, turn on Amber LED, turn off Green LED if supported*/
175         if (POWER_CTRL(ctrl)) {
176                 if (pslot->hpc_ops->power_off_slot(pslot)) {
177                         ctrl_err(ctrl,
178                                  "Issue of Slot Power Off command failed\n");
179                         return;
180                 }
181                 /*
182                  * After turning power off, we must wait for at least 1 second
183                  * before taking any action that relies on power having been
184                  * removed from the slot/adapter.
185                  */
186                 msleep(1000);
187         }
188
189         if (PWR_LED(ctrl))
190                 pslot->hpc_ops->green_led_off(pslot);
191
192         if (ATTN_LED(ctrl)) {
193                 if (pslot->hpc_ops->set_attention_status(pslot, 1)) {
194                         ctrl_err(ctrl,
195                                  "Issue of Set Attention Led command failed\n");
196                         return;
197                 }
198         }
199 }
200
201 /**
202  * board_added - Called after a board has been added to the system.
203  * @p_slot: &slot where board is added
204  *
205  * Turns power on for the board.
206  * Configures board.
207  */
208 static int board_added(struct slot *p_slot)
209 {
210         int retval = 0;
211         struct controller *ctrl = p_slot->ctrl;
212         struct pci_bus *parent = ctrl->pci_dev->subordinate;
213
214         ctrl_dbg(ctrl, "%s: slot device, slot offset, hp slot = %d, %d, %d\n",
215                  __func__, p_slot->device, ctrl->slot_device_offset,
216                  p_slot->hp_slot);
217
218         if (POWER_CTRL(ctrl)) {
219                 /* Power on slot */
220                 retval = p_slot->hpc_ops->power_on_slot(p_slot);
221                 if (retval)
222                         return retval;
223         }
224
225         if (PWR_LED(ctrl))
226                 p_slot->hpc_ops->green_led_blink(p_slot);
227
228         /* Check link training status */
229         retval = p_slot->hpc_ops->check_lnk_status(ctrl);
230         if (retval) {
231                 ctrl_err(ctrl, "Failed to check link status\n");
232                 set_slot_off(ctrl, p_slot);
233                 return retval;
234         }
235
236         /* Check for a power fault */
237         if (p_slot->hpc_ops->query_power_fault(p_slot)) {
238                 ctrl_dbg(ctrl, "Power fault detected\n");
239                 retval = POWER_FAILURE;
240                 goto err_exit;
241         }
242
243         retval = pciehp_configure_device(p_slot);
244         if (retval) {
245                 ctrl_err(ctrl, "Cannot add device at %04x:%02x:%02x\n",
246                          pci_domain_nr(parent), p_slot->bus, p_slot->device);
247                 goto err_exit;
248         }
249
250         /*
251          * Some PCI Express root ports require fixup after hot-plug operation.
252          */
253         if (pcie_mch_quirk)
254                 pci_fixup_device(pci_fixup_final, ctrl->pci_dev);
255         if (PWR_LED(ctrl))
256                 p_slot->hpc_ops->green_led_on(p_slot);
257
258         return 0;
259
260 err_exit:
261         set_slot_off(ctrl, p_slot);
262         return retval;
263 }
264
265 /**
266  * remove_board - Turns off slot and LEDs
267  * @p_slot: slot where board is being removed
268  */
269 static int remove_board(struct slot *p_slot)
270 {
271         int retval = 0;
272         struct controller *ctrl = p_slot->ctrl;
273
274         retval = pciehp_unconfigure_device(p_slot);
275         if (retval)
276                 return retval;
277
278         ctrl_dbg(ctrl, "%s: hp_slot = %d\n", __func__, p_slot->hp_slot);
279
280         if (POWER_CTRL(ctrl)) {
281                 /* power off slot */
282                 retval = p_slot->hpc_ops->power_off_slot(p_slot);
283                 if (retval) {
284                         ctrl_err(ctrl,
285                                  "Issue of Slot Disable command failed\n");
286                         return retval;
287                 }
288                 /*
289                  * After turning power off, we must wait for at least 1 second
290                  * before taking any action that relies on power having been
291                  * removed from the slot/adapter.
292                  */
293                 msleep(1000);
294         }
295
296         if (PWR_LED(ctrl))
297                 /* turn off Green LED */
298                 p_slot->hpc_ops->green_led_off(p_slot);
299
300         return 0;
301 }
302
303 struct power_work_info {
304         struct slot *p_slot;
305         struct work_struct work;
306 };
307
308 /**
309  * pciehp_power_thread - handle pushbutton events
310  * @work: &struct work_struct describing work to be done
311  *
312  * Scheduled procedure to handle blocking stuff for the pushbuttons.
313  * Handles all pending events and exits.
314  */
315 static void pciehp_power_thread(struct work_struct *work)
316 {
317         struct power_work_info *info =
318                 container_of(work, struct power_work_info, work);
319         struct slot *p_slot = info->p_slot;
320
321         mutex_lock(&p_slot->lock);
322         switch (p_slot->state) {
323         case POWEROFF_STATE:
324                 mutex_unlock(&p_slot->lock);
325                 ctrl_dbg(p_slot->ctrl,
326                          "Disabling domain:bus:device=%04x:%02x:%02x\n",
327                          pci_domain_nr(p_slot->ctrl->pci_dev->subordinate),
328                          p_slot->bus, p_slot->device);
329                 pciehp_disable_slot(p_slot);
330                 mutex_lock(&p_slot->lock);
331                 p_slot->state = STATIC_STATE;
332                 break;
333         case POWERON_STATE:
334                 mutex_unlock(&p_slot->lock);
335                 if (pciehp_enable_slot(p_slot) &&
336                     PWR_LED(p_slot->ctrl))
337                         p_slot->hpc_ops->green_led_off(p_slot);
338                 mutex_lock(&p_slot->lock);
339                 p_slot->state = STATIC_STATE;
340                 break;
341         default:
342                 break;
343         }
344         mutex_unlock(&p_slot->lock);
345
346         kfree(info);
347 }
348
349 void pciehp_queue_pushbutton_work(struct work_struct *work)
350 {
351         struct slot *p_slot = container_of(work, struct slot, work.work);
352         struct power_work_info *info;
353
354         info = kmalloc(sizeof(*info), GFP_KERNEL);
355         if (!info) {
356                 ctrl_err(p_slot->ctrl, "%s: Cannot allocate memory\n",
357                          __func__);
358                 return;
359         }
360         info->p_slot = p_slot;
361         INIT_WORK(&info->work, pciehp_power_thread);
362
363         mutex_lock(&p_slot->lock);
364         switch (p_slot->state) {
365         case BLINKINGOFF_STATE:
366                 p_slot->state = POWEROFF_STATE;
367                 break;
368         case BLINKINGON_STATE:
369                 p_slot->state = POWERON_STATE;
370                 break;
371         default:
372                 goto out;
373         }
374         queue_work(pciehp_wq, &info->work);
375  out:
376         mutex_unlock(&p_slot->lock);
377 }
378
379 static int update_slot_info(struct slot *slot)
380 {
381         struct hotplug_slot_info *info;
382         int result;
383
384         info = kmalloc(sizeof(*info), GFP_KERNEL);
385         if (!info)
386                 return -ENOMEM;
387
388         slot->hpc_ops->get_power_status(slot, &(info->power_status));
389         slot->hpc_ops->get_attention_status(slot, &(info->attention_status));
390         slot->hpc_ops->get_latch_status(slot, &(info->latch_status));
391         slot->hpc_ops->get_adapter_status(slot, &(info->adapter_status));
392
393         result = pci_hp_change_slot_info(slot->hotplug_slot, info);
394         kfree (info);
395         return result;
396 }
397
398 /*
399  * Note: This function must be called with slot->lock held
400  */
401 static void handle_button_press_event(struct slot *p_slot)
402 {
403         struct controller *ctrl = p_slot->ctrl;
404         u8 getstatus;
405
406         switch (p_slot->state) {
407         case STATIC_STATE:
408                 p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
409                 if (getstatus) {
410                         p_slot->state = BLINKINGOFF_STATE;
411                         ctrl_info(ctrl,
412                                   "PCI slot #%s - powering off due to button "
413                                   "press.\n", slot_name(p_slot));
414                 } else {
415                         p_slot->state = BLINKINGON_STATE;
416                         ctrl_info(ctrl,
417                                   "PCI slot #%s - powering on due to button "
418                                   "press.\n", slot_name(p_slot));
419                 }
420                 /* blink green LED and turn off amber */
421                 if (PWR_LED(ctrl))
422                         p_slot->hpc_ops->green_led_blink(p_slot);
423                 if (ATTN_LED(ctrl))
424                         p_slot->hpc_ops->set_attention_status(p_slot, 0);
425
426                 schedule_delayed_work(&p_slot->work, 5*HZ);
427                 break;
428         case BLINKINGOFF_STATE:
429         case BLINKINGON_STATE:
430                 /*
431                  * Cancel if we are still blinking; this means that we
432                  * press the attention again before the 5 sec. limit
433                  * expires to cancel hot-add or hot-remove
434                  */
435                 ctrl_info(ctrl, "Button cancel on Slot(%s)\n", slot_name(p_slot));
436                 cancel_delayed_work(&p_slot->work);
437                 if (p_slot->state == BLINKINGOFF_STATE) {
438                         if (PWR_LED(ctrl))
439                                 p_slot->hpc_ops->green_led_on(p_slot);
440                 } else {
441                         if (PWR_LED(ctrl))
442                                 p_slot->hpc_ops->green_led_off(p_slot);
443                 }
444                 if (ATTN_LED(ctrl))
445                         p_slot->hpc_ops->set_attention_status(p_slot, 0);
446                 ctrl_info(ctrl, "PCI slot #%s - action canceled "
447                           "due to button press\n", slot_name(p_slot));
448                 p_slot->state = STATIC_STATE;
449                 break;
450         case POWEROFF_STATE:
451         case POWERON_STATE:
452                 /*
453                  * Ignore if the slot is on power-on or power-off state;
454                  * this means that the previous attention button action
455                  * to hot-add or hot-remove is undergoing
456                  */
457                 ctrl_info(ctrl, "Button ignore on Slot(%s)\n", slot_name(p_slot));
458                 update_slot_info(p_slot);
459                 break;
460         default:
461                 ctrl_warn(ctrl, "Not a valid state\n");
462                 break;
463         }
464 }
465
466 /*
467  * Note: This function must be called with slot->lock held
468  */
469 static void handle_surprise_event(struct slot *p_slot)
470 {
471         u8 getstatus;
472         struct power_work_info *info;
473
474         info = kmalloc(sizeof(*info), GFP_KERNEL);
475         if (!info) {
476                 ctrl_err(p_slot->ctrl, "%s: Cannot allocate memory\n",
477                          __func__);
478                 return;
479         }
480         info->p_slot = p_slot;
481         INIT_WORK(&info->work, pciehp_power_thread);
482
483         p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
484         if (!getstatus)
485                 p_slot->state = POWEROFF_STATE;
486         else
487                 p_slot->state = POWERON_STATE;
488
489         queue_work(pciehp_wq, &info->work);
490 }
491
492 static void interrupt_event_handler(struct work_struct *work)
493 {
494         struct event_info *info = container_of(work, struct event_info, work);
495         struct slot *p_slot = info->p_slot;
496         struct controller *ctrl = p_slot->ctrl;
497
498         mutex_lock(&p_slot->lock);
499         switch (info->event_type) {
500         case INT_BUTTON_PRESS:
501                 handle_button_press_event(p_slot);
502                 break;
503         case INT_POWER_FAULT:
504                 if (!POWER_CTRL(ctrl))
505                         break;
506                 if (ATTN_LED(ctrl))
507                         p_slot->hpc_ops->set_attention_status(p_slot, 1);
508                 if (PWR_LED(ctrl))
509                         p_slot->hpc_ops->green_led_off(p_slot);
510                 break;
511         case INT_PRESENCE_ON:
512         case INT_PRESENCE_OFF:
513                 if (!HP_SUPR_RM(ctrl))
514                         break;
515                 ctrl_dbg(ctrl, "Surprise Removal\n");
516                 update_slot_info(p_slot);
517                 handle_surprise_event(p_slot);
518                 break;
519         default:
520                 update_slot_info(p_slot);
521                 break;
522         }
523         mutex_unlock(&p_slot->lock);
524
525         kfree(info);
526 }
527
528 int pciehp_enable_slot(struct slot *p_slot)
529 {
530         u8 getstatus = 0;
531         int rc;
532         struct controller *ctrl = p_slot->ctrl;
533
534         /* Check to see if (latch closed, card present, power off) */
535         mutex_lock(&p_slot->ctrl->crit_sect);
536
537         rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
538         if (rc || !getstatus) {
539                 ctrl_info(ctrl, "No adapter on slot(%s)\n", slot_name(p_slot));
540                 mutex_unlock(&p_slot->ctrl->crit_sect);
541                 return -ENODEV;
542         }
543         if (MRL_SENS(p_slot->ctrl)) {
544                 rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
545                 if (rc || getstatus) {
546                         ctrl_info(ctrl, "Latch open on slot(%s)\n",
547                                   slot_name(p_slot));
548                         mutex_unlock(&p_slot->ctrl->crit_sect);
549                         return -ENODEV;
550                 }
551         }
552
553         if (POWER_CTRL(p_slot->ctrl)) {
554                 rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
555                 if (rc || getstatus) {
556                         ctrl_info(ctrl, "Already enabled on slot(%s)\n",
557                                   slot_name(p_slot));
558                         mutex_unlock(&p_slot->ctrl->crit_sect);
559                         return -EINVAL;
560                 }
561         }
562
563         p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
564
565         rc = board_added(p_slot);
566         if (rc) {
567                 p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
568         }
569
570         update_slot_info(p_slot);
571
572         mutex_unlock(&p_slot->ctrl->crit_sect);
573         return rc;
574 }
575
576
577 int pciehp_disable_slot(struct slot *p_slot)
578 {
579         u8 getstatus = 0;
580         int ret = 0;
581         struct controller *ctrl = p_slot->ctrl;
582
583         if (!p_slot->ctrl)
584                 return 1;
585
586         /* Check to see if (latch closed, card present, power on) */
587         mutex_lock(&p_slot->ctrl->crit_sect);
588
589         if (!HP_SUPR_RM(p_slot->ctrl)) {
590                 ret = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
591                 if (ret || !getstatus) {
592                         ctrl_info(ctrl, "No adapter on slot(%s)\n",
593                                   slot_name(p_slot));
594                         mutex_unlock(&p_slot->ctrl->crit_sect);
595                         return -ENODEV;
596                 }
597         }
598
599         if (MRL_SENS(p_slot->ctrl)) {
600                 ret = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
601                 if (ret || getstatus) {
602                         ctrl_info(ctrl, "Latch open on slot(%s)\n",
603                                   slot_name(p_slot));
604                         mutex_unlock(&p_slot->ctrl->crit_sect);
605                         return -ENODEV;
606                 }
607         }
608
609         if (POWER_CTRL(p_slot->ctrl)) {
610                 ret = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
611                 if (ret || !getstatus) {
612                         ctrl_info(ctrl, "Already disabled on slot(%s)\n",
613                                   slot_name(p_slot));
614                         mutex_unlock(&p_slot->ctrl->crit_sect);
615                         return -EINVAL;
616                 }
617         }
618
619         ret = remove_board(p_slot);
620         update_slot_info(p_slot);
621
622         mutex_unlock(&p_slot->ctrl->crit_sect);
623         return ret;
624 }
625
626 int pciehp_sysfs_enable_slot(struct slot *p_slot)
627 {
628         int retval = -ENODEV;
629         struct controller *ctrl = p_slot->ctrl;
630
631         mutex_lock(&p_slot->lock);
632         switch (p_slot->state) {
633         case BLINKINGON_STATE:
634                 cancel_delayed_work(&p_slot->work);
635         case STATIC_STATE:
636                 p_slot->state = POWERON_STATE;
637                 mutex_unlock(&p_slot->lock);
638                 retval = pciehp_enable_slot(p_slot);
639                 mutex_lock(&p_slot->lock);
640                 p_slot->state = STATIC_STATE;
641                 break;
642         case POWERON_STATE:
643                 ctrl_info(ctrl, "Slot %s is already in powering on state\n",
644                           slot_name(p_slot));
645                 break;
646         case BLINKINGOFF_STATE:
647         case POWEROFF_STATE:
648                 ctrl_info(ctrl, "Already enabled on slot %s\n",
649                           slot_name(p_slot));
650                 break;
651         default:
652                 ctrl_err(ctrl, "Not a valid state on slot %s\n",
653                          slot_name(p_slot));
654                 break;
655         }
656         mutex_unlock(&p_slot->lock);
657
658         return retval;
659 }
660
661 int pciehp_sysfs_disable_slot(struct slot *p_slot)
662 {
663         int retval = -ENODEV;
664         struct controller *ctrl = p_slot->ctrl;
665
666         mutex_lock(&p_slot->lock);
667         switch (p_slot->state) {
668         case BLINKINGOFF_STATE:
669                 cancel_delayed_work(&p_slot->work);
670         case STATIC_STATE:
671                 p_slot->state = POWEROFF_STATE;
672                 mutex_unlock(&p_slot->lock);
673                 retval = pciehp_disable_slot(p_slot);
674                 mutex_lock(&p_slot->lock);
675                 p_slot->state = STATIC_STATE;
676                 break;
677         case POWEROFF_STATE:
678                 ctrl_info(ctrl, "Slot %s is already in powering off state\n",
679                           slot_name(p_slot));
680                 break;
681         case BLINKINGON_STATE:
682         case POWERON_STATE:
683                 ctrl_info(ctrl, "Already disabled on slot %s\n",
684                           slot_name(p_slot));
685                 break;
686         default:
687                 ctrl_err(ctrl, "Not a valid state on slot %s\n",
688                          slot_name(p_slot));
689                 break;
690         }
691         mutex_unlock(&p_slot->lock);
692
693         return retval;
694 }