2 * Standard Hot Plug Controller Driver
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
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.
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
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.
26 * Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
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>
39 static void interrupt_event_handler(struct work_struct
*work
);
40 static int shpchp_enable_slot(struct slot
*p_slot
);
41 static int shpchp_disable_slot(struct slot
*p_slot
);
43 static int queue_interrupt_event(struct slot
*p_slot
, u32 event_type
)
45 struct event_info
*info
;
47 info
= kmalloc(sizeof(*info
), GFP_ATOMIC
);
51 info
->event_type
= event_type
;
52 info
->p_slot
= p_slot
;
53 INIT_WORK(&info
->work
, interrupt_event_handler
);
55 schedule_work(&info
->work
);
60 u8
shpchp_handle_attention_button(u8 hp_slot
, struct controller
*ctrl
)
65 /* Attention Button Change */
66 dbg("shpchp: Attention button interrupt received.\n");
68 p_slot
= shpchp_find_slot(ctrl
, hp_slot
+ ctrl
->slot_device_offset
);
69 p_slot
->hpc_ops
->get_adapter_status(p_slot
, &(p_slot
->presence_save
));
72 * Button pressed - See if need to TAKE ACTION!!!
74 info("Button pressed on Slot(%s)\n", p_slot
->name
);
75 event_type
= INT_BUTTON_PRESS
;
77 queue_interrupt_event(p_slot
, event_type
);
83 u8
shpchp_handle_switch_change(u8 hp_slot
, struct controller
*ctrl
)
90 dbg("shpchp: Switch interrupt received.\n");
92 p_slot
= shpchp_find_slot(ctrl
, hp_slot
+ ctrl
->slot_device_offset
);
93 p_slot
->hpc_ops
->get_adapter_status(p_slot
, &(p_slot
->presence_save
));
94 p_slot
->hpc_ops
->get_latch_status(p_slot
, &getstatus
);
95 dbg("%s: Card present %x Power status %x\n", __FUNCTION__
,
96 p_slot
->presence_save
, p_slot
->pwr_save
);
102 info("Latch open on Slot(%s)\n", p_slot
->name
);
103 event_type
= INT_SWITCH_OPEN
;
104 if (p_slot
->pwr_save
&& p_slot
->presence_save
) {
105 event_type
= INT_POWER_FAULT
;
106 err("Surprise Removal of card\n");
112 info("Latch close on Slot(%s)\n", p_slot
->name
);
113 event_type
= INT_SWITCH_CLOSE
;
116 queue_interrupt_event(p_slot
, event_type
);
121 u8
shpchp_handle_presence_change(u8 hp_slot
, struct controller
*ctrl
)
126 /* Presence Change */
127 dbg("shpchp: Presence/Notify input change.\n");
129 p_slot
= shpchp_find_slot(ctrl
, hp_slot
+ ctrl
->slot_device_offset
);
132 * Save the presence state
134 p_slot
->hpc_ops
->get_adapter_status(p_slot
, &(p_slot
->presence_save
));
135 if (p_slot
->presence_save
) {
139 info("Card present on Slot(%s)\n", p_slot
->name
);
140 event_type
= INT_PRESENCE_ON
;
145 info("Card not present on Slot(%s)\n", p_slot
->name
);
146 event_type
= INT_PRESENCE_OFF
;
149 queue_interrupt_event(p_slot
, event_type
);
154 u8
shpchp_handle_power_fault(u8 hp_slot
, struct controller
*ctrl
)
160 dbg("shpchp: Power fault interrupt received.\n");
162 p_slot
= shpchp_find_slot(ctrl
, hp_slot
+ ctrl
->slot_device_offset
);
164 if ( !(p_slot
->hpc_ops
->query_power_fault(p_slot
))) {
166 * Power fault Cleared
168 info("Power fault cleared on Slot(%s)\n", p_slot
->name
);
169 p_slot
->status
= 0x00;
170 event_type
= INT_POWER_FAULT_CLEAR
;
175 info("Power fault on Slot(%s)\n", p_slot
->name
);
176 event_type
= INT_POWER_FAULT
;
177 /* set power fault status for this board */
178 p_slot
->status
= 0xFF;
179 info("power fault bit %x set\n", hp_slot
);
182 queue_interrupt_event(p_slot
, event_type
);
187 /* The following routines constitute the bulk of the
188 hotplug controller logic
190 static int change_bus_speed(struct controller
*ctrl
, struct slot
*p_slot
,
191 enum pci_bus_speed speed
)
195 dbg("%s: change to speed %d\n", __FUNCTION__
, speed
);
196 if ((rc
= p_slot
->hpc_ops
->set_bus_speed_mode(p_slot
, speed
))) {
197 err("%s: Issue of set bus speed mode command failed\n",
199 return WRONG_BUS_FREQUENCY
;
204 static int fix_bus_speed(struct controller
*ctrl
, struct slot
*pslot
,
205 u8 flag
, enum pci_bus_speed asp
, enum pci_bus_speed bsp
,
206 enum pci_bus_speed msp
)
211 * If other slots on the same bus are occupied, we cannot
212 * change the bus speed.
216 err("%s: speed of bus %x and adapter %x mismatch\n",
217 __FUNCTION__
, bsp
, asp
);
218 rc
= WRONG_BUS_FREQUENCY
;
225 rc
= change_bus_speed(ctrl
, pslot
, asp
);
228 rc
= change_bus_speed(ctrl
, pslot
, msp
);
234 * board_added - Called after a board has been added to the system.
236 * Turns power on for the board
240 static int board_added(struct slot
*p_slot
)
243 u8 slots_not_empty
= 0;
245 enum pci_bus_speed asp
, bsp
, msp
;
246 struct controller
*ctrl
= p_slot
->ctrl
;
248 hp_slot
= p_slot
->device
- ctrl
->slot_device_offset
;
250 dbg("%s: p_slot->device, slot_offset, hp_slot = %d, %d ,%d\n",
251 __FUNCTION__
, p_slot
->device
,
252 ctrl
->slot_device_offset
, hp_slot
);
254 /* Power on slot without connecting to bus */
255 rc
= p_slot
->hpc_ops
->power_on_slot(p_slot
);
257 err("%s: Failed to power on slot\n", __FUNCTION__
);
261 if ((ctrl
->pci_dev
->vendor
== 0x8086) && (ctrl
->pci_dev
->device
== 0x0332)) {
263 return WRONG_BUS_FREQUENCY
;
265 if ((rc
= p_slot
->hpc_ops
->set_bus_speed_mode(p_slot
, PCI_SPEED_33MHz
))) {
266 err("%s: Issue of set bus speed mode command failed\n", __FUNCTION__
);
267 return WRONG_BUS_FREQUENCY
;
270 /* turn on board, blink green LED, turn off Amber LED */
271 if ((rc
= p_slot
->hpc_ops
->slot_enable(p_slot
))) {
272 err("%s: Issue of Slot Enable command failed\n", __FUNCTION__
);
277 rc
= p_slot
->hpc_ops
->get_adapter_speed(p_slot
, &asp
);
279 err("%s: Can't get adapter speed or bus mode mismatch\n",
281 return WRONG_BUS_FREQUENCY
;
284 rc
= p_slot
->hpc_ops
->get_cur_bus_speed(p_slot
, &bsp
);
286 err("%s: Can't get bus operation speed\n", __FUNCTION__
);
287 return WRONG_BUS_FREQUENCY
;
290 rc
= p_slot
->hpc_ops
->get_max_bus_speed(p_slot
, &msp
);
292 err("%s: Can't get max bus operation speed\n", __FUNCTION__
);
296 /* Check if there are other slots or devices on the same bus */
297 if (!list_empty(&ctrl
->pci_dev
->subordinate
->devices
))
300 dbg("%s: slots_not_empty %d, adapter_speed %d, bus_speed %d, "
301 "max_bus_speed %d\n", __FUNCTION__
, slots_not_empty
, asp
,
304 rc
= fix_bus_speed(ctrl
, p_slot
, slots_not_empty
, asp
, bsp
, msp
);
308 /* turn on board, blink green LED, turn off Amber LED */
309 if ((rc
= p_slot
->hpc_ops
->slot_enable(p_slot
))) {
310 err("%s: Issue of Slot Enable command failed\n", __FUNCTION__
);
314 /* Wait for ~1 second */
317 dbg("%s: slot status = %x\n", __FUNCTION__
, p_slot
->status
);
318 /* Check for a power fault */
319 if (p_slot
->status
== 0xFF) {
320 /* power fault occurred, but it was benign */
321 dbg("%s: power fault\n", __FUNCTION__
);
327 if (shpchp_configure_device(p_slot
)) {
328 err("Cannot add device at 0x%x:0x%x\n", p_slot
->bus
,
334 p_slot
->is_a_board
= 0x01;
335 p_slot
->pwr_save
= 1;
337 p_slot
->hpc_ops
->green_led_on(p_slot
);
342 /* turn off slot, turn on Amber LED, turn off Green LED */
343 rc
= p_slot
->hpc_ops
->slot_disable(p_slot
);
345 err("%s: Issue of Slot Disable command failed\n", __FUNCTION__
);
354 * remove_board - Turns off slot and LED's
357 static int remove_board(struct slot
*p_slot
)
359 struct controller
*ctrl
= p_slot
->ctrl
;
363 if (shpchp_unconfigure_device(p_slot
))
366 hp_slot
= p_slot
->device
- ctrl
->slot_device_offset
;
367 p_slot
= shpchp_find_slot(ctrl
, hp_slot
+ ctrl
->slot_device_offset
);
369 dbg("In %s, hp_slot = %d\n", __FUNCTION__
, hp_slot
);
371 /* Change status to shutdown */
372 if (p_slot
->is_a_board
)
373 p_slot
->status
= 0x01;
375 /* turn off slot, turn on Amber LED, turn off Green LED */
376 rc
= p_slot
->hpc_ops
->slot_disable(p_slot
);
378 err("%s: Issue of Slot Disable command failed\n", __FUNCTION__
);
382 rc
= p_slot
->hpc_ops
->set_attention_status(p_slot
, 0);
384 err("%s: Issue of Set Attention command failed\n", __FUNCTION__
);
388 p_slot
->pwr_save
= 0;
389 p_slot
->is_a_board
= 0;
395 struct pushbutton_work_info
{
397 struct work_struct work
;
401 * shpchp_pushbutton_thread
403 * Scheduled procedure to handle blocking stuff for the pushbuttons
404 * Handles all pending events and exits.
407 static void shpchp_pushbutton_thread(struct work_struct
*work
)
409 struct pushbutton_work_info
*info
=
410 container_of(work
, struct pushbutton_work_info
, work
);
411 struct slot
*p_slot
= info
->p_slot
;
413 mutex_lock(&p_slot
->lock
);
414 switch (p_slot
->state
) {
416 mutex_unlock(&p_slot
->lock
);
417 shpchp_disable_slot(p_slot
);
418 mutex_lock(&p_slot
->lock
);
419 p_slot
->state
= STATIC_STATE
;
422 mutex_unlock(&p_slot
->lock
);
423 if (shpchp_enable_slot(p_slot
))
424 p_slot
->hpc_ops
->green_led_off(p_slot
);
425 mutex_lock(&p_slot
->lock
);
426 p_slot
->state
= STATIC_STATE
;
431 mutex_unlock(&p_slot
->lock
);
436 void queue_pushbutton_work(struct work_struct
*work
)
438 struct slot
*p_slot
= container_of(work
, struct slot
, work
.work
);
439 struct pushbutton_work_info
*info
;
441 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
443 err("%s: Cannot allocate memory\n", __FUNCTION__
);
446 info
->p_slot
= p_slot
;
447 INIT_WORK(&info
->work
, shpchp_pushbutton_thread
);
449 mutex_lock(&p_slot
->lock
);
450 switch (p_slot
->state
) {
451 case BLINKINGOFF_STATE
:
452 p_slot
->state
= POWEROFF_STATE
;
454 case BLINKINGON_STATE
:
455 p_slot
->state
= POWERON_STATE
;
460 queue_work(shpchp_wq
, &info
->work
);
462 mutex_unlock(&p_slot
->lock
);
465 static int update_slot_info (struct slot
*slot
)
467 struct hotplug_slot_info
*info
;
470 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
474 slot
->hpc_ops
->get_power_status(slot
, &(info
->power_status
));
475 slot
->hpc_ops
->get_attention_status(slot
, &(info
->attention_status
));
476 slot
->hpc_ops
->get_latch_status(slot
, &(info
->latch_status
));
477 slot
->hpc_ops
->get_adapter_status(slot
, &(info
->adapter_status
));
479 result
= pci_hp_change_slot_info(slot
->hotplug_slot
, info
);
485 * Note: This function must be called with slot->lock held
487 static void handle_button_press_event(struct slot
*p_slot
)
491 switch (p_slot
->state
) {
493 p_slot
->hpc_ops
->get_power_status(p_slot
, &getstatus
);
495 p_slot
->state
= BLINKINGOFF_STATE
;
496 info("PCI slot #%s - powering off due to button "
497 "press.\n", p_slot
->name
);
499 p_slot
->state
= BLINKINGON_STATE
;
500 info("PCI slot #%s - powering on due to button "
501 "press.\n", p_slot
->name
);
503 /* blink green LED and turn off amber */
504 p_slot
->hpc_ops
->green_led_blink(p_slot
);
505 p_slot
->hpc_ops
->set_attention_status(p_slot
, 0);
507 schedule_delayed_work(&p_slot
->work
, 5*HZ
);
509 case BLINKINGOFF_STATE
:
510 case BLINKINGON_STATE
:
512 * Cancel if we are still blinking; this means that we
513 * press the attention again before the 5 sec. limit
514 * expires to cancel hot-add or hot-remove
516 info("Button cancel on Slot(%s)\n", p_slot
->name
);
517 dbg("%s: button cancel\n", __FUNCTION__
);
518 cancel_delayed_work(&p_slot
->work
);
519 if (p_slot
->state
== BLINKINGOFF_STATE
)
520 p_slot
->hpc_ops
->green_led_on(p_slot
);
522 p_slot
->hpc_ops
->green_led_off(p_slot
);
523 p_slot
->hpc_ops
->set_attention_status(p_slot
, 0);
524 info("PCI slot #%s - action canceled due to button press\n",
526 p_slot
->state
= STATIC_STATE
;
531 * Ignore if the slot is on power-on or power-off state;
532 * this means that the previous attention button action
533 * to hot-add or hot-remove is undergoing
535 info("Button ignore on Slot(%s)\n", p_slot
->name
);
536 update_slot_info(p_slot
);
539 warn("Not a valid state\n");
544 static void interrupt_event_handler(struct work_struct
*work
)
546 struct event_info
*info
= container_of(work
, struct event_info
, work
);
547 struct slot
*p_slot
= info
->p_slot
;
549 mutex_lock(&p_slot
->lock
);
550 switch (info
->event_type
) {
551 case INT_BUTTON_PRESS
:
552 handle_button_press_event(p_slot
);
554 case INT_POWER_FAULT
:
555 dbg("%s: power fault\n", __FUNCTION__
);
556 p_slot
->hpc_ops
->set_attention_status(p_slot
, 1);
557 p_slot
->hpc_ops
->green_led_off(p_slot
);
560 update_slot_info(p_slot
);
563 mutex_unlock(&p_slot
->lock
);
569 static int shpchp_enable_slot (struct slot
*p_slot
)
572 int rc
, retval
= -ENODEV
;
574 /* Check to see if (latch closed, card present, power off) */
575 mutex_lock(&p_slot
->ctrl
->crit_sect
);
576 rc
= p_slot
->hpc_ops
->get_adapter_status(p_slot
, &getstatus
);
577 if (rc
|| !getstatus
) {
578 info("No adapter on slot(%s)\n", p_slot
->name
);
581 rc
= p_slot
->hpc_ops
->get_latch_status(p_slot
, &getstatus
);
582 if (rc
|| getstatus
) {
583 info("Latch open on slot(%s)\n", p_slot
->name
);
586 rc
= p_slot
->hpc_ops
->get_power_status(p_slot
, &getstatus
);
587 if (rc
|| getstatus
) {
588 info("Already enabled on slot(%s)\n", p_slot
->name
);
592 p_slot
->is_a_board
= 1;
594 /* We have to save the presence info for these slots */
595 p_slot
->hpc_ops
->get_adapter_status(p_slot
, &(p_slot
->presence_save
));
596 p_slot
->hpc_ops
->get_power_status(p_slot
, &(p_slot
->pwr_save
));
597 dbg("%s: p_slot->pwr_save %x\n", __FUNCTION__
, p_slot
->pwr_save
);
598 p_slot
->hpc_ops
->get_latch_status(p_slot
, &getstatus
);
600 if(((p_slot
->ctrl
->pci_dev
->vendor
== PCI_VENDOR_ID_AMD
) ||
601 (p_slot
->ctrl
->pci_dev
->device
== PCI_DEVICE_ID_AMD_POGO_7458
))
602 && p_slot
->ctrl
->num_slots
== 1) {
603 /* handle amd pogo errata; this must be done before enable */
604 amd_pogo_errata_save_misc_reg(p_slot
);
605 retval
= board_added(p_slot
);
606 /* handle amd pogo errata; this must be done after enable */
607 amd_pogo_errata_restore_misc_reg(p_slot
);
609 retval
= board_added(p_slot
);
612 p_slot
->hpc_ops
->get_adapter_status(p_slot
,
613 &(p_slot
->presence_save
));
614 p_slot
->hpc_ops
->get_latch_status(p_slot
, &getstatus
);
617 update_slot_info(p_slot
);
619 mutex_unlock(&p_slot
->ctrl
->crit_sect
);
624 static int shpchp_disable_slot (struct slot
*p_slot
)
627 int rc
, retval
= -ENODEV
;
632 /* Check to see if (latch closed, card present, power on) */
633 mutex_lock(&p_slot
->ctrl
->crit_sect
);
635 rc
= p_slot
->hpc_ops
->get_adapter_status(p_slot
, &getstatus
);
636 if (rc
|| !getstatus
) {
637 info("No adapter on slot(%s)\n", p_slot
->name
);
640 rc
= p_slot
->hpc_ops
->get_latch_status(p_slot
, &getstatus
);
641 if (rc
|| getstatus
) {
642 info("Latch open on slot(%s)\n", p_slot
->name
);
645 rc
= p_slot
->hpc_ops
->get_power_status(p_slot
, &getstatus
);
646 if (rc
|| !getstatus
) {
647 info("Already disabled slot(%s)\n", p_slot
->name
);
651 retval
= remove_board(p_slot
);
652 update_slot_info(p_slot
);
654 mutex_unlock(&p_slot
->ctrl
->crit_sect
);
658 int shpchp_sysfs_enable_slot(struct slot
*p_slot
)
660 int retval
= -ENODEV
;
662 mutex_lock(&p_slot
->lock
);
663 switch (p_slot
->state
) {
664 case BLINKINGON_STATE
:
665 cancel_delayed_work(&p_slot
->work
);
667 p_slot
->state
= POWERON_STATE
;
668 mutex_unlock(&p_slot
->lock
);
669 retval
= shpchp_enable_slot(p_slot
);
670 mutex_lock(&p_slot
->lock
);
671 p_slot
->state
= STATIC_STATE
;
674 info("Slot %s is already in powering on state\n",
677 case BLINKINGOFF_STATE
:
679 info("Already enabled on slot %s\n", p_slot
->name
);
682 err("Not a valid state on slot %s\n", p_slot
->name
);
685 mutex_unlock(&p_slot
->lock
);
690 int shpchp_sysfs_disable_slot(struct slot
*p_slot
)
692 int retval
= -ENODEV
;
694 mutex_lock(&p_slot
->lock
);
695 switch (p_slot
->state
) {
696 case BLINKINGOFF_STATE
:
697 cancel_delayed_work(&p_slot
->work
);
699 p_slot
->state
= POWEROFF_STATE
;
700 mutex_unlock(&p_slot
->lock
);
701 retval
= shpchp_disable_slot(p_slot
);
702 mutex_lock(&p_slot
->lock
);
703 p_slot
->state
= STATIC_STATE
;
706 info("Slot %s is already in powering off state\n",
709 case BLINKINGON_STATE
:
711 info("Already disabled on slot %s\n", p_slot
->name
);
714 err("Not a valid state on slot %s\n", p_slot
->name
);
717 mutex_unlock(&p_slot
->lock
);