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/pci.h>
34 #include <linux/workqueue.h>
38 static void interrupt_event_handler(struct work_struct
*work
);
39 static int shpchp_enable_slot(struct slot
*p_slot
);
40 static int shpchp_disable_slot(struct slot
*p_slot
);
42 static int queue_interrupt_event(struct slot
*p_slot
, u32 event_type
)
44 struct event_info
*info
;
46 info
= kmalloc(sizeof(*info
), GFP_ATOMIC
);
50 info
->event_type
= event_type
;
51 info
->p_slot
= p_slot
;
52 INIT_WORK(&info
->work
, interrupt_event_handler
);
54 schedule_work(&info
->work
);
59 u8
shpchp_handle_attention_button(u8 hp_slot
, struct controller
*ctrl
)
64 /* Attention Button Change */
65 ctrl_dbg(ctrl
, "Attention button interrupt received.\n");
67 p_slot
= shpchp_find_slot(ctrl
, hp_slot
+ ctrl
->slot_device_offset
);
68 p_slot
->hpc_ops
->get_adapter_status(p_slot
, &(p_slot
->presence_save
));
71 * Button pressed - See if need to TAKE ACTION!!!
73 ctrl_info(ctrl
, "Button pressed on Slot(%s)\n", slot_name(p_slot
));
74 event_type
= INT_BUTTON_PRESS
;
76 queue_interrupt_event(p_slot
, event_type
);
82 u8
shpchp_handle_switch_change(u8 hp_slot
, struct controller
*ctrl
)
89 ctrl_dbg(ctrl
, "Switch interrupt received.\n");
91 p_slot
= shpchp_find_slot(ctrl
, hp_slot
+ ctrl
->slot_device_offset
);
92 p_slot
->hpc_ops
->get_adapter_status(p_slot
, &(p_slot
->presence_save
));
93 p_slot
->hpc_ops
->get_latch_status(p_slot
, &getstatus
);
94 ctrl_dbg(ctrl
, "%s: Card present %x Power status %x\n",
95 __func__
, p_slot
->presence_save
, p_slot
->pwr_save
);
101 ctrl_info(ctrl
, "Latch open on Slot(%s)\n", slot_name(p_slot
));
102 event_type
= INT_SWITCH_OPEN
;
103 if (p_slot
->pwr_save
&& p_slot
->presence_save
) {
104 event_type
= INT_POWER_FAULT
;
105 ctrl_err(ctrl
, "Surprise Removal of card\n");
111 ctrl_info(ctrl
, "Latch close on Slot(%s)\n", slot_name(p_slot
));
112 event_type
= INT_SWITCH_CLOSE
;
115 queue_interrupt_event(p_slot
, event_type
);
120 u8
shpchp_handle_presence_change(u8 hp_slot
, struct controller
*ctrl
)
125 /* Presence Change */
126 ctrl_dbg(ctrl
, "Presence/Notify input change.\n");
128 p_slot
= shpchp_find_slot(ctrl
, hp_slot
+ ctrl
->slot_device_offset
);
131 * Save the presence state
133 p_slot
->hpc_ops
->get_adapter_status(p_slot
, &(p_slot
->presence_save
));
134 if (p_slot
->presence_save
) {
138 ctrl_info(ctrl
, "Card present on Slot(%s)\n",
140 event_type
= INT_PRESENCE_ON
;
145 ctrl_info(ctrl
, "Card not present on Slot(%s)\n",
147 event_type
= INT_PRESENCE_OFF
;
150 queue_interrupt_event(p_slot
, event_type
);
155 u8
shpchp_handle_power_fault(u8 hp_slot
, struct controller
*ctrl
)
161 ctrl_dbg(ctrl
, "Power fault interrupt received.\n");
163 p_slot
= shpchp_find_slot(ctrl
, hp_slot
+ ctrl
->slot_device_offset
);
165 if ( !(p_slot
->hpc_ops
->query_power_fault(p_slot
))) {
167 * Power fault Cleared
169 ctrl_info(ctrl
, "Power fault cleared on Slot(%s)\n",
171 p_slot
->status
= 0x00;
172 event_type
= INT_POWER_FAULT_CLEAR
;
177 ctrl_info(ctrl
, "Power fault on Slot(%s)\n", slot_name(p_slot
));
178 event_type
= INT_POWER_FAULT
;
179 /* set power fault status for this board */
180 p_slot
->status
= 0xFF;
181 ctrl_info(ctrl
, "power fault bit %x set\n", hp_slot
);
184 queue_interrupt_event(p_slot
, event_type
);
189 /* The following routines constitute the bulk of the
190 hotplug controller logic
192 static int change_bus_speed(struct controller
*ctrl
, struct slot
*p_slot
,
193 enum pci_bus_speed speed
)
197 ctrl_dbg(ctrl
, "%s: change to speed %d\n", __func__
, speed
);
198 if ((rc
= p_slot
->hpc_ops
->set_bus_speed_mode(p_slot
, speed
))) {
199 ctrl_err(ctrl
, "%s: Issue of set bus speed mode command "
200 "failed\n", __func__
);
201 return WRONG_BUS_FREQUENCY
;
206 static int fix_bus_speed(struct controller
*ctrl
, struct slot
*pslot
,
207 u8 flag
, enum pci_bus_speed asp
, enum pci_bus_speed bsp
,
208 enum pci_bus_speed msp
)
213 * If other slots on the same bus are occupied, we cannot
214 * change the bus speed.
218 ctrl_err(ctrl
, "%s: speed of bus %x and adapter %x "
219 "mismatch\n", __func__
, bsp
, asp
);
220 rc
= WRONG_BUS_FREQUENCY
;
227 rc
= change_bus_speed(ctrl
, pslot
, asp
);
230 rc
= change_bus_speed(ctrl
, pslot
, msp
);
236 * board_added - Called after a board has been added to the system.
237 * @p_slot: target &slot
239 * Turns power on for the board.
242 static int board_added(struct slot
*p_slot
)
245 u8 slots_not_empty
= 0;
247 enum pci_bus_speed asp
, bsp
, msp
;
248 struct controller
*ctrl
= p_slot
->ctrl
;
250 hp_slot
= p_slot
->device
- ctrl
->slot_device_offset
;
253 "%s: p_slot->device, slot_offset, hp_slot = %d, %d ,%d\n",
254 __func__
, p_slot
->device
, ctrl
->slot_device_offset
, hp_slot
);
256 /* Power on slot without connecting to bus */
257 rc
= p_slot
->hpc_ops
->power_on_slot(p_slot
);
259 ctrl_err(ctrl
, "%s: Failed to power on slot\n", __func__
);
263 if ((ctrl
->pci_dev
->vendor
== 0x8086) && (ctrl
->pci_dev
->device
== 0x0332)) {
265 return WRONG_BUS_FREQUENCY
;
267 if ((rc
= p_slot
->hpc_ops
->set_bus_speed_mode(p_slot
, PCI_SPEED_33MHz
))) {
268 ctrl_err(ctrl
, "%s: Issue of set bus speed mode command"
269 " failed\n", __func__
);
270 return WRONG_BUS_FREQUENCY
;
273 /* turn on board, blink green LED, turn off Amber LED */
274 if ((rc
= p_slot
->hpc_ops
->slot_enable(p_slot
))) {
275 ctrl_err(ctrl
, "%s: Issue of Slot Enable command"
276 " failed\n", __func__
);
281 rc
= p_slot
->hpc_ops
->get_adapter_speed(p_slot
, &asp
);
283 ctrl_err(ctrl
, "%s: Can't get adapter speed or bus mode "
284 "mismatch\n", __func__
);
285 return WRONG_BUS_FREQUENCY
;
288 rc
= p_slot
->hpc_ops
->get_cur_bus_speed(p_slot
, &bsp
);
290 ctrl_err(ctrl
, "%s: Can't get bus operation speed\n", __func__
);
291 return WRONG_BUS_FREQUENCY
;
294 rc
= p_slot
->hpc_ops
->get_max_bus_speed(p_slot
, &msp
);
296 ctrl_err(ctrl
, "%s: Can't get max bus operation speed\n",
301 /* Check if there are other slots or devices on the same bus */
302 if (!list_empty(&ctrl
->pci_dev
->subordinate
->devices
))
305 ctrl_dbg(ctrl
, "%s: slots_not_empty %d, adapter_speed %d, bus_speed %d,"
306 " max_bus_speed %d\n", __func__
, slots_not_empty
, asp
,
309 rc
= fix_bus_speed(ctrl
, p_slot
, slots_not_empty
, asp
, bsp
, msp
);
313 /* turn on board, blink green LED, turn off Amber LED */
314 if ((rc
= p_slot
->hpc_ops
->slot_enable(p_slot
))) {
315 ctrl_err(ctrl
, "%s: Issue of Slot Enable command failed\n",
320 /* Wait for ~1 second */
323 ctrl_dbg(ctrl
, "%s: slot status = %x\n", __func__
, p_slot
->status
);
324 /* Check for a power fault */
325 if (p_slot
->status
== 0xFF) {
326 /* power fault occurred, but it was benign */
327 ctrl_dbg(ctrl
, "%s: power fault\n", __func__
);
333 if (shpchp_configure_device(p_slot
)) {
334 ctrl_err(ctrl
, "Cannot add device at 0x%x:0x%x\n",
335 p_slot
->bus
, p_slot
->device
);
340 p_slot
->is_a_board
= 0x01;
341 p_slot
->pwr_save
= 1;
343 p_slot
->hpc_ops
->green_led_on(p_slot
);
348 /* turn off slot, turn on Amber LED, turn off Green LED */
349 rc
= p_slot
->hpc_ops
->slot_disable(p_slot
);
351 ctrl_err(ctrl
, "%s: Issue of Slot Disable command failed\n",
361 * remove_board - Turns off slot and LEDs
362 * @p_slot: target &slot
364 static int remove_board(struct slot
*p_slot
)
366 struct controller
*ctrl
= p_slot
->ctrl
;
370 if (shpchp_unconfigure_device(p_slot
))
373 hp_slot
= p_slot
->device
- ctrl
->slot_device_offset
;
374 p_slot
= shpchp_find_slot(ctrl
, hp_slot
+ ctrl
->slot_device_offset
);
376 ctrl_dbg(ctrl
, "In %s, hp_slot = %d\n", __func__
, hp_slot
);
378 /* Change status to shutdown */
379 if (p_slot
->is_a_board
)
380 p_slot
->status
= 0x01;
382 /* turn off slot, turn on Amber LED, turn off Green LED */
383 rc
= p_slot
->hpc_ops
->slot_disable(p_slot
);
385 ctrl_err(ctrl
, "%s: Issue of Slot Disable command failed\n",
390 rc
= p_slot
->hpc_ops
->set_attention_status(p_slot
, 0);
392 ctrl_err(ctrl
, "%s: Issue of Set Attention command failed\n",
397 p_slot
->pwr_save
= 0;
398 p_slot
->is_a_board
= 0;
404 struct pushbutton_work_info
{
406 struct work_struct work
;
410 * shpchp_pushbutton_thread - handle pushbutton events
411 * @work: &struct work_struct to be handled
413 * Scheduled procedure to handle blocking stuff for the pushbuttons.
414 * Handles all pending events and exits.
416 static void shpchp_pushbutton_thread(struct work_struct
*work
)
418 struct pushbutton_work_info
*info
=
419 container_of(work
, struct pushbutton_work_info
, work
);
420 struct slot
*p_slot
= info
->p_slot
;
422 mutex_lock(&p_slot
->lock
);
423 switch (p_slot
->state
) {
425 mutex_unlock(&p_slot
->lock
);
426 shpchp_disable_slot(p_slot
);
427 mutex_lock(&p_slot
->lock
);
428 p_slot
->state
= STATIC_STATE
;
431 mutex_unlock(&p_slot
->lock
);
432 if (shpchp_enable_slot(p_slot
))
433 p_slot
->hpc_ops
->green_led_off(p_slot
);
434 mutex_lock(&p_slot
->lock
);
435 p_slot
->state
= STATIC_STATE
;
440 mutex_unlock(&p_slot
->lock
);
445 void shpchp_queue_pushbutton_work(struct work_struct
*work
)
447 struct slot
*p_slot
= container_of(work
, struct slot
, work
.work
);
448 struct pushbutton_work_info
*info
;
450 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
452 ctrl_err(p_slot
->ctrl
, "%s: Cannot allocate memory\n",
456 info
->p_slot
= p_slot
;
457 INIT_WORK(&info
->work
, shpchp_pushbutton_thread
);
459 mutex_lock(&p_slot
->lock
);
460 switch (p_slot
->state
) {
461 case BLINKINGOFF_STATE
:
462 p_slot
->state
= POWEROFF_STATE
;
464 case BLINKINGON_STATE
:
465 p_slot
->state
= POWERON_STATE
;
470 queue_work(shpchp_wq
, &info
->work
);
472 mutex_unlock(&p_slot
->lock
);
475 static int update_slot_info (struct slot
*slot
)
477 struct hotplug_slot_info
*info
;
480 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
484 slot
->hpc_ops
->get_power_status(slot
, &(info
->power_status
));
485 slot
->hpc_ops
->get_attention_status(slot
, &(info
->attention_status
));
486 slot
->hpc_ops
->get_latch_status(slot
, &(info
->latch_status
));
487 slot
->hpc_ops
->get_adapter_status(slot
, &(info
->adapter_status
));
489 result
= pci_hp_change_slot_info(slot
->hotplug_slot
, info
);
495 * Note: This function must be called with slot->lock held
497 static void handle_button_press_event(struct slot
*p_slot
)
500 struct controller
*ctrl
= p_slot
->ctrl
;
502 switch (p_slot
->state
) {
504 p_slot
->hpc_ops
->get_power_status(p_slot
, &getstatus
);
506 p_slot
->state
= BLINKINGOFF_STATE
;
507 ctrl_info(ctrl
, "PCI slot #%s - powering off due to "
508 "button press.\n", slot_name(p_slot
));
510 p_slot
->state
= BLINKINGON_STATE
;
511 ctrl_info(ctrl
, "PCI slot #%s - powering on due to "
512 "button press.\n", slot_name(p_slot
));
514 /* blink green LED and turn off amber */
515 p_slot
->hpc_ops
->green_led_blink(p_slot
);
516 p_slot
->hpc_ops
->set_attention_status(p_slot
, 0);
518 schedule_delayed_work(&p_slot
->work
, 5*HZ
);
520 case BLINKINGOFF_STATE
:
521 case BLINKINGON_STATE
:
523 * Cancel if we are still blinking; this means that we
524 * press the attention again before the 5 sec. limit
525 * expires to cancel hot-add or hot-remove
527 ctrl_info(ctrl
, "Button cancel on Slot(%s)\n",
529 ctrl_dbg(ctrl
, "%s: button cancel\n", __func__
);
530 cancel_delayed_work(&p_slot
->work
);
531 if (p_slot
->state
== BLINKINGOFF_STATE
)
532 p_slot
->hpc_ops
->green_led_on(p_slot
);
534 p_slot
->hpc_ops
->green_led_off(p_slot
);
535 p_slot
->hpc_ops
->set_attention_status(p_slot
, 0);
536 ctrl_info(ctrl
, "PCI slot #%s - action canceled due to "
537 "button press\n", slot_name(p_slot
));
538 p_slot
->state
= STATIC_STATE
;
543 * Ignore if the slot is on power-on or power-off state;
544 * this means that the previous attention button action
545 * to hot-add or hot-remove is undergoing
547 ctrl_info(ctrl
, "Button ignore on Slot(%s)\n",
549 update_slot_info(p_slot
);
552 ctrl_warn(ctrl
, "Not a valid state\n");
557 static void interrupt_event_handler(struct work_struct
*work
)
559 struct event_info
*info
= container_of(work
, struct event_info
, work
);
560 struct slot
*p_slot
= info
->p_slot
;
562 mutex_lock(&p_slot
->lock
);
563 switch (info
->event_type
) {
564 case INT_BUTTON_PRESS
:
565 handle_button_press_event(p_slot
);
567 case INT_POWER_FAULT
:
568 ctrl_dbg(p_slot
->ctrl
, "%s: power fault\n", __func__
);
569 p_slot
->hpc_ops
->set_attention_status(p_slot
, 1);
570 p_slot
->hpc_ops
->green_led_off(p_slot
);
573 update_slot_info(p_slot
);
576 mutex_unlock(&p_slot
->lock
);
582 static int shpchp_enable_slot (struct slot
*p_slot
)
585 int rc
, retval
= -ENODEV
;
586 struct controller
*ctrl
= p_slot
->ctrl
;
588 /* Check to see if (latch closed, card present, power off) */
589 mutex_lock(&p_slot
->ctrl
->crit_sect
);
590 rc
= p_slot
->hpc_ops
->get_adapter_status(p_slot
, &getstatus
);
591 if (rc
|| !getstatus
) {
592 ctrl_info(ctrl
, "No adapter on slot(%s)\n", slot_name(p_slot
));
595 rc
= p_slot
->hpc_ops
->get_latch_status(p_slot
, &getstatus
);
596 if (rc
|| getstatus
) {
597 ctrl_info(ctrl
, "Latch open on slot(%s)\n", slot_name(p_slot
));
600 rc
= p_slot
->hpc_ops
->get_power_status(p_slot
, &getstatus
);
601 if (rc
|| getstatus
) {
602 ctrl_info(ctrl
, "Already enabled on slot(%s)\n",
607 p_slot
->is_a_board
= 1;
609 /* We have to save the presence info for these slots */
610 p_slot
->hpc_ops
->get_adapter_status(p_slot
, &(p_slot
->presence_save
));
611 p_slot
->hpc_ops
->get_power_status(p_slot
, &(p_slot
->pwr_save
));
612 ctrl_dbg(ctrl
, "%s: p_slot->pwr_save %x\n", __func__
, p_slot
->pwr_save
);
613 p_slot
->hpc_ops
->get_latch_status(p_slot
, &getstatus
);
615 if(((p_slot
->ctrl
->pci_dev
->vendor
== PCI_VENDOR_ID_AMD
) ||
616 (p_slot
->ctrl
->pci_dev
->device
== PCI_DEVICE_ID_AMD_POGO_7458
))
617 && p_slot
->ctrl
->num_slots
== 1) {
618 /* handle amd pogo errata; this must be done before enable */
619 amd_pogo_errata_save_misc_reg(p_slot
);
620 retval
= board_added(p_slot
);
621 /* handle amd pogo errata; this must be done after enable */
622 amd_pogo_errata_restore_misc_reg(p_slot
);
624 retval
= board_added(p_slot
);
627 p_slot
->hpc_ops
->get_adapter_status(p_slot
,
628 &(p_slot
->presence_save
));
629 p_slot
->hpc_ops
->get_latch_status(p_slot
, &getstatus
);
632 update_slot_info(p_slot
);
634 mutex_unlock(&p_slot
->ctrl
->crit_sect
);
639 static int shpchp_disable_slot (struct slot
*p_slot
)
642 int rc
, retval
= -ENODEV
;
643 struct controller
*ctrl
= p_slot
->ctrl
;
648 /* Check to see if (latch closed, card present, power on) */
649 mutex_lock(&p_slot
->ctrl
->crit_sect
);
651 rc
= p_slot
->hpc_ops
->get_adapter_status(p_slot
, &getstatus
);
652 if (rc
|| !getstatus
) {
653 ctrl_info(ctrl
, "No adapter on slot(%s)\n", slot_name(p_slot
));
656 rc
= p_slot
->hpc_ops
->get_latch_status(p_slot
, &getstatus
);
657 if (rc
|| getstatus
) {
658 ctrl_info(ctrl
, "Latch open on slot(%s)\n", slot_name(p_slot
));
661 rc
= p_slot
->hpc_ops
->get_power_status(p_slot
, &getstatus
);
662 if (rc
|| !getstatus
) {
663 ctrl_info(ctrl
, "Already disabled slot(%s)\n",
668 retval
= remove_board(p_slot
);
669 update_slot_info(p_slot
);
671 mutex_unlock(&p_slot
->ctrl
->crit_sect
);
675 int shpchp_sysfs_enable_slot(struct slot
*p_slot
)
677 int retval
= -ENODEV
;
678 struct controller
*ctrl
= p_slot
->ctrl
;
680 mutex_lock(&p_slot
->lock
);
681 switch (p_slot
->state
) {
682 case BLINKINGON_STATE
:
683 cancel_delayed_work(&p_slot
->work
);
685 p_slot
->state
= POWERON_STATE
;
686 mutex_unlock(&p_slot
->lock
);
687 retval
= shpchp_enable_slot(p_slot
);
688 mutex_lock(&p_slot
->lock
);
689 p_slot
->state
= STATIC_STATE
;
692 ctrl_info(ctrl
, "Slot %s is already in powering on state\n",
695 case BLINKINGOFF_STATE
:
697 ctrl_info(ctrl
, "Already enabled on slot %s\n",
701 ctrl_err(ctrl
, "Not a valid state on slot %s\n",
705 mutex_unlock(&p_slot
->lock
);
710 int shpchp_sysfs_disable_slot(struct slot
*p_slot
)
712 int retval
= -ENODEV
;
713 struct controller
*ctrl
= p_slot
->ctrl
;
715 mutex_lock(&p_slot
->lock
);
716 switch (p_slot
->state
) {
717 case BLINKINGOFF_STATE
:
718 cancel_delayed_work(&p_slot
->work
);
720 p_slot
->state
= POWEROFF_STATE
;
721 mutex_unlock(&p_slot
->lock
);
722 retval
= shpchp_disable_slot(p_slot
);
723 mutex_lock(&p_slot
->lock
);
724 p_slot
->state
= STATIC_STATE
;
727 ctrl_info(ctrl
, "Slot %s is already in powering off state\n",
730 case BLINKINGON_STATE
:
732 ctrl_info(ctrl
, "Already disabled on slot %s\n",
736 ctrl_err(ctrl
, "Not a valid state on slot %s\n",
740 mutex_unlock(&p_slot
->lock
);