2 * PCI Express PCI Hot Plug 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/kernel.h>
31 #include <linux/module.h>
32 #include <linux/types.h>
33 #include <linux/signal.h>
34 #include <linux/jiffies.h>
35 #include <linux/timer.h>
36 #include <linux/pci.h>
37 #include <linux/interrupt.h>
38 #include <linux/time.h>
39 #include <linux/slab.h>
44 static inline struct pci_dev *ctrl_dev(struct controller *ctrl)
46 return ctrl->pcie->port;
49 /* Power Control Command */
51 #define POWER_OFF PCI_EXP_SLTCTL_PCC
53 static irqreturn_t pcie_isr(int irq, void *dev_id);
54 static void start_int_poll_timer(struct controller *ctrl, int sec);
56 /* This is the interrupt polling timeout function. */
57 static void int_poll_timeout(unsigned long data)
59 struct controller *ctrl = (struct controller *)data;
61 /* Poll for interrupt events. regs == NULL => polling */
64 init_timer(&ctrl->poll_timer);
65 if (!pciehp_poll_time)
66 pciehp_poll_time = 2; /* default polling interval is 2 sec */
68 start_int_poll_timer(ctrl, pciehp_poll_time);
71 /* This function starts the interrupt polling timer. */
72 static void start_int_poll_timer(struct controller *ctrl, int sec)
74 /* Clamp to sane value */
75 if ((sec <= 0) || (sec > 60))
78 ctrl->poll_timer.function = &int_poll_timeout;
79 ctrl->poll_timer.data = (unsigned long)ctrl;
80 ctrl->poll_timer.expires = jiffies + sec * HZ;
81 add_timer(&ctrl->poll_timer);
84 static inline int pciehp_request_irq(struct controller *ctrl)
86 int retval, irq = ctrl->pcie->irq;
88 /* Install interrupt polling timer. Start with 10 sec delay */
89 if (pciehp_poll_mode) {
90 init_timer(&ctrl->poll_timer);
91 start_int_poll_timer(ctrl, 10);
95 /* Installs the interrupt handler */
96 retval = request_irq(irq, pcie_isr, IRQF_SHARED, MY_NAME, ctrl);
98 ctrl_err(ctrl, "Cannot get irq %d for the hotplug controller\n",
103 static inline void pciehp_free_irq(struct controller *ctrl)
105 if (pciehp_poll_mode)
106 del_timer_sync(&ctrl->poll_timer);
108 free_irq(ctrl->pcie->irq, ctrl);
111 static int pcie_poll_cmd(struct controller *ctrl)
113 struct pci_dev *pdev = ctrl_dev(ctrl);
115 int err, timeout = 1000;
117 err = pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
118 if (!err && (slot_status & PCI_EXP_SLTSTA_CC)) {
119 pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
123 while (timeout > 0) {
126 err = pcie_capability_read_word(pdev, PCI_EXP_SLTSTA,
128 if (!err && (slot_status & PCI_EXP_SLTSTA_CC)) {
129 pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
134 return 0; /* timeout */
137 static void pcie_wait_cmd(struct controller *ctrl, int poll)
139 unsigned int msecs = pciehp_poll_mode ? 2500 : 1000;
140 unsigned long timeout = msecs_to_jiffies(msecs);
144 rc = pcie_poll_cmd(ctrl);
146 rc = wait_event_timeout(ctrl->queue, !ctrl->cmd_busy, timeout);
148 ctrl_dbg(ctrl, "Command not completed in 1000 msec\n");
152 * pcie_write_cmd - Issue controller command
153 * @ctrl: controller to which the command is issued
154 * @cmd: command value written to slot control register
155 * @mask: bitmask of slot control register to be modified
157 static int pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
159 struct pci_dev *pdev = ctrl_dev(ctrl);
164 mutex_lock(&ctrl->ctrl_lock);
166 retval = pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
168 ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
173 if (slot_status & PCI_EXP_SLTSTA_CC) {
174 if (!ctrl->no_cmd_complete) {
176 * After 1 sec and CMD_COMPLETED still not set, just
177 * proceed forward to issue the next command according
178 * to spec. Just print out the error message.
180 ctrl_dbg(ctrl, "CMD_COMPLETED not clear after 1 sec\n");
181 } else if (!NO_CMD_CMPL(ctrl)) {
183 * This controller seems to notify of command completed
184 * event even though it supports none of power
185 * controller, attention led, power led and EMI.
187 ctrl_dbg(ctrl, "Unexpected CMD_COMPLETED. Need to "
188 "wait for command completed event.\n");
189 ctrl->no_cmd_complete = 0;
191 ctrl_dbg(ctrl, "Unexpected CMD_COMPLETED. Maybe "
192 "the controller is broken.\n");
196 retval = pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &slot_ctrl);
198 ctrl_err(ctrl, "%s: Cannot read SLOTCTRL register\n", __func__);
203 slot_ctrl |= (cmd & mask);
206 retval = pcie_capability_write_word(pdev, PCI_EXP_SLTCTL, slot_ctrl);
208 ctrl_err(ctrl, "Cannot write to SLOTCTRL register\n");
211 * Wait for command completion.
213 if (!retval && !ctrl->no_cmd_complete) {
216 * if hotplug interrupt is not enabled or command
217 * completed interrupt is not enabled, we need to poll
218 * command completed event.
220 if (!(slot_ctrl & PCI_EXP_SLTCTL_HPIE) ||
221 !(slot_ctrl & PCI_EXP_SLTCTL_CCIE))
223 pcie_wait_cmd(ctrl, poll);
226 mutex_unlock(&ctrl->ctrl_lock);
230 static bool check_link_active(struct controller *ctrl)
232 struct pci_dev *pdev = ctrl_dev(ctrl);
236 if (pcie_capability_read_word(pdev, PCI_EXP_LNKSTA, &lnk_status))
239 ret = !!(lnk_status & PCI_EXP_LNKSTA_DLLLA);
242 ctrl_dbg(ctrl, "%s: lnk_status = %x\n", __func__, lnk_status);
247 static void __pcie_wait_link_active(struct controller *ctrl, bool active)
251 if (check_link_active(ctrl) == active)
253 while (timeout > 0) {
256 if (check_link_active(ctrl) == active)
259 ctrl_dbg(ctrl, "Data Link Layer Link Active not %s in 1000 msec\n",
260 active ? "set" : "cleared");
263 static void pcie_wait_link_active(struct controller *ctrl)
265 __pcie_wait_link_active(ctrl, true);
268 static void pcie_wait_link_not_active(struct controller *ctrl)
270 __pcie_wait_link_active(ctrl, false);
273 static bool pci_bus_check_dev(struct pci_bus *bus, int devfn)
277 int delay = 1000, step = 20;
281 found = pci_bus_read_dev_vendor_id(bus, devfn, &l, 0);
291 if (count > 1 && pciehp_debug)
292 printk(KERN_DEBUG "pci %04x:%02x:%02x.%d id reading try %d times with interval %d ms to get %08x\n",
293 pci_domain_nr(bus), bus->number, PCI_SLOT(devfn),
294 PCI_FUNC(devfn), count, step, l);
299 int pciehp_check_link_status(struct controller *ctrl)
301 struct pci_dev *pdev = ctrl_dev(ctrl);
307 * Data Link Layer Link Active Reporting must be capable for
308 * hot-plug capable downstream port. But old controller might
309 * not implement it. In this case, we wait for 1000 ms.
311 if (ctrl->link_active_reporting)
312 pcie_wait_link_active(ctrl);
316 /* wait 100ms before read pci conf, and try in 1s */
318 found = pci_bus_check_dev(ctrl->pcie->port->subordinate,
321 retval = pcie_capability_read_word(pdev, PCI_EXP_LNKSTA, &lnk_status);
323 ctrl_err(ctrl, "Cannot read LNKSTATUS register\n");
327 ctrl_dbg(ctrl, "%s: lnk_status = %x\n", __func__, lnk_status);
328 if ((lnk_status & PCI_EXP_LNKSTA_LT) ||
329 !(lnk_status & PCI_EXP_LNKSTA_NLW)) {
330 ctrl_err(ctrl, "Link Training Error occurs \n");
335 pcie_update_link_speed(ctrl->pcie->port->subordinate, lnk_status);
337 if (!found && !retval)
343 static int __pciehp_link_set(struct controller *ctrl, bool enable)
345 struct pci_dev *pdev = ctrl_dev(ctrl);
349 retval = pcie_capability_read_word(pdev, PCI_EXP_LNKCTL, &lnk_ctrl);
351 ctrl_err(ctrl, "Cannot read LNKCTRL register\n");
356 lnk_ctrl &= ~PCI_EXP_LNKCTL_LD;
358 lnk_ctrl |= PCI_EXP_LNKCTL_LD;
360 retval = pcie_capability_write_word(pdev, PCI_EXP_LNKCTL, lnk_ctrl);
362 ctrl_err(ctrl, "Cannot write LNKCTRL register\n");
365 ctrl_dbg(ctrl, "%s: lnk_ctrl = %x\n", __func__, lnk_ctrl);
370 static int pciehp_link_enable(struct controller *ctrl)
372 return __pciehp_link_set(ctrl, true);
375 static int pciehp_link_disable(struct controller *ctrl)
377 return __pciehp_link_set(ctrl, false);
380 int pciehp_get_attention_status(struct slot *slot, u8 *status)
382 struct controller *ctrl = slot->ctrl;
383 struct pci_dev *pdev = ctrl_dev(ctrl);
388 retval = pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &slot_ctrl);
390 ctrl_err(ctrl, "%s: Cannot read SLOTCTRL register\n", __func__);
394 ctrl_dbg(ctrl, "%s: SLOTCTRL %x, value read %x\n", __func__,
395 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_ctrl);
397 atten_led_state = (slot_ctrl & PCI_EXP_SLTCTL_AIC) >> 6;
399 switch (atten_led_state) {
401 *status = 0xFF; /* Reserved */
404 *status = 1; /* On */
407 *status = 2; /* Blink */
410 *status = 0; /* Off */
420 int pciehp_get_power_status(struct slot *slot, u8 *status)
422 struct controller *ctrl = slot->ctrl;
423 struct pci_dev *pdev = ctrl_dev(ctrl);
428 retval = pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &slot_ctrl);
430 ctrl_err(ctrl, "%s: Cannot read SLOTCTRL register\n", __func__);
433 ctrl_dbg(ctrl, "%s: SLOTCTRL %x value read %x\n", __func__,
434 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_ctrl);
436 pwr_state = (slot_ctrl & PCI_EXP_SLTCTL_PCC) >> 10;
453 int pciehp_get_latch_status(struct slot *slot, u8 *status)
455 struct controller *ctrl = slot->ctrl;
456 struct pci_dev *pdev = ctrl_dev(ctrl);
460 retval = pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
462 ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
466 *status = !!(slot_status & PCI_EXP_SLTSTA_MRLSS);
470 int pciehp_get_adapter_status(struct slot *slot, u8 *status)
472 struct controller *ctrl = slot->ctrl;
473 struct pci_dev *pdev = ctrl_dev(ctrl);
477 retval = pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
479 ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
483 *status = !!(slot_status & PCI_EXP_SLTSTA_PDS);
487 int pciehp_query_power_fault(struct slot *slot)
489 struct controller *ctrl = slot->ctrl;
490 struct pci_dev *pdev = ctrl_dev(ctrl);
494 retval = pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
496 ctrl_err(ctrl, "Cannot check for power fault\n");
499 return !!(slot_status & PCI_EXP_SLTSTA_PFD);
502 int pciehp_set_attention_status(struct slot *slot, u8 value)
504 struct controller *ctrl = slot->ctrl;
508 cmd_mask = PCI_EXP_SLTCTL_AIC;
510 case 0 : /* turn off */
513 case 1: /* turn on */
516 case 2: /* turn blink */
522 ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
523 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
524 return pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
527 void pciehp_green_led_on(struct slot *slot)
529 struct controller *ctrl = slot->ctrl;
534 cmd_mask = PCI_EXP_SLTCTL_PIC;
535 pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
536 ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
537 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
540 void pciehp_green_led_off(struct slot *slot)
542 struct controller *ctrl = slot->ctrl;
547 cmd_mask = PCI_EXP_SLTCTL_PIC;
548 pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
549 ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
550 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
553 void pciehp_green_led_blink(struct slot *slot)
555 struct controller *ctrl = slot->ctrl;
560 cmd_mask = PCI_EXP_SLTCTL_PIC;
561 pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
562 ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
563 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
566 int pciehp_power_on_slot(struct slot * slot)
568 struct controller *ctrl = slot->ctrl;
569 struct pci_dev *pdev = ctrl_dev(ctrl);
575 /* Clear sticky power-fault bit from previous power failures */
576 retval = pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
578 ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
582 slot_status &= PCI_EXP_SLTSTA_PFD;
584 retval = pcie_capability_write_word(pdev, PCI_EXP_SLTSTA, slot_status);
587 "%s: Cannot write to SLOTSTATUS register\n",
592 ctrl->power_fault_detected = 0;
595 cmd_mask = PCI_EXP_SLTCTL_PCC;
596 retval = pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
598 ctrl_err(ctrl, "Write %x command failed!\n", slot_cmd);
601 ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
602 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
604 retval = pciehp_link_enable(ctrl);
606 ctrl_err(ctrl, "%s: Can not enable the link!\n", __func__);
611 int pciehp_power_off_slot(struct slot * slot)
613 struct controller *ctrl = slot->ctrl;
618 /* Disable the link at first */
619 pciehp_link_disable(ctrl);
620 /* wait the link is down */
621 if (ctrl->link_active_reporting)
622 pcie_wait_link_not_active(ctrl);
626 slot_cmd = POWER_OFF;
627 cmd_mask = PCI_EXP_SLTCTL_PCC;
628 retval = pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
630 ctrl_err(ctrl, "Write command failed!\n");
633 ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
634 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
638 static irqreturn_t pcie_isr(int irq, void *dev_id)
640 struct controller *ctrl = (struct controller *)dev_id;
641 struct pci_dev *pdev = ctrl_dev(ctrl);
642 struct slot *slot = ctrl->slot;
643 u16 detected, intr_loc;
646 * In order to guarantee that all interrupt events are
647 * serviced, we need to re-inspect Slot Status register after
648 * clearing what is presumed to be the last pending interrupt.
652 if (pcie_capability_read_word(pdev, PCI_EXP_SLTSTA,
654 ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS\n",
659 detected &= (PCI_EXP_SLTSTA_ABP | PCI_EXP_SLTSTA_PFD |
660 PCI_EXP_SLTSTA_MRLSC | PCI_EXP_SLTSTA_PDC |
662 detected &= ~intr_loc;
663 intr_loc |= detected;
667 pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
669 ctrl_err(ctrl, "%s: Cannot write to SLOTSTATUS\n",
675 ctrl_dbg(ctrl, "%s: intr_loc %x\n", __func__, intr_loc);
677 /* Check Command Complete Interrupt Pending */
678 if (intr_loc & PCI_EXP_SLTSTA_CC) {
681 wake_up(&ctrl->queue);
684 if (!(intr_loc & ~PCI_EXP_SLTSTA_CC))
687 /* Check MRL Sensor Changed */
688 if (intr_loc & PCI_EXP_SLTSTA_MRLSC)
689 pciehp_handle_switch_change(slot);
691 /* Check Attention Button Pressed */
692 if (intr_loc & PCI_EXP_SLTSTA_ABP)
693 pciehp_handle_attention_button(slot);
695 /* Check Presence Detect Changed */
696 if (intr_loc & PCI_EXP_SLTSTA_PDC)
697 pciehp_handle_presence_change(slot);
699 /* Check Power Fault Detected */
700 if ((intr_loc & PCI_EXP_SLTSTA_PFD) && !ctrl->power_fault_detected) {
701 ctrl->power_fault_detected = 1;
702 pciehp_handle_power_fault(slot);
707 int pcie_enable_notification(struct controller *ctrl)
712 * TBD: Power fault detected software notification support.
714 * Power fault detected software notification is not enabled
715 * now, because it caused power fault detected interrupt storm
716 * on some machines. On those machines, power fault detected
717 * bit in the slot status register was set again immediately
718 * when it is cleared in the interrupt service routine, and
719 * next power fault detected interrupt was notified again.
721 cmd = PCI_EXP_SLTCTL_PDCE;
722 if (ATTN_BUTTN(ctrl))
723 cmd |= PCI_EXP_SLTCTL_ABPE;
725 cmd |= PCI_EXP_SLTCTL_MRLSCE;
726 if (!pciehp_poll_mode)
727 cmd |= PCI_EXP_SLTCTL_HPIE | PCI_EXP_SLTCTL_CCIE;
729 mask = (PCI_EXP_SLTCTL_PDCE | PCI_EXP_SLTCTL_ABPE |
730 PCI_EXP_SLTCTL_MRLSCE | PCI_EXP_SLTCTL_PFDE |
731 PCI_EXP_SLTCTL_HPIE | PCI_EXP_SLTCTL_CCIE);
733 if (pcie_write_cmd(ctrl, cmd, mask)) {
734 ctrl_err(ctrl, "Cannot enable software notification\n");
740 static void pcie_disable_notification(struct controller *ctrl)
743 mask = (PCI_EXP_SLTCTL_PDCE | PCI_EXP_SLTCTL_ABPE |
744 PCI_EXP_SLTCTL_MRLSCE | PCI_EXP_SLTCTL_PFDE |
745 PCI_EXP_SLTCTL_HPIE | PCI_EXP_SLTCTL_CCIE |
746 PCI_EXP_SLTCTL_DLLSCE);
747 if (pcie_write_cmd(ctrl, 0, mask))
748 ctrl_warn(ctrl, "Cannot disable software notification\n");
752 * pciehp has a 1:1 bus:slot relationship so we ultimately want a secondary
753 * bus reset of the bridge, but if the slot supports surprise removal we need
754 * to disable presence detection around the bus reset and clear any spurious
757 int pciehp_reset_slot(struct slot *slot, int probe)
759 struct controller *ctrl = slot->ctrl;
760 struct pci_dev *pdev = ctrl_dev(ctrl);
765 if (HP_SUPR_RM(ctrl)) {
766 pcie_write_cmd(ctrl, 0, PCI_EXP_SLTCTL_PDCE);
767 if (pciehp_poll_mode)
768 del_timer_sync(&ctrl->poll_timer);
771 pci_reset_bridge_secondary_bus(ctrl->pcie->port);
773 if (HP_SUPR_RM(ctrl)) {
774 pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
776 pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PDCE, PCI_EXP_SLTCTL_PDCE);
777 if (pciehp_poll_mode)
778 int_poll_timeout(ctrl->poll_timer.data);
784 int pcie_init_notification(struct controller *ctrl)
786 if (pciehp_request_irq(ctrl))
788 if (pcie_enable_notification(ctrl)) {
789 pciehp_free_irq(ctrl);
792 ctrl->notification_enabled = 1;
796 static void pcie_shutdown_notification(struct controller *ctrl)
798 if (ctrl->notification_enabled) {
799 pcie_disable_notification(ctrl);
800 pciehp_free_irq(ctrl);
801 ctrl->notification_enabled = 0;
805 static int pcie_init_slot(struct controller *ctrl)
809 slot = kzalloc(sizeof(*slot), GFP_KERNEL);
813 slot->wq = alloc_workqueue("pciehp-%u", 0, 0, PSN(ctrl));
818 mutex_init(&slot->lock);
819 INIT_DELAYED_WORK(&slot->work, pciehp_queue_pushbutton_work);
827 static void pcie_cleanup_slot(struct controller *ctrl)
829 struct slot *slot = ctrl->slot;
830 cancel_delayed_work(&slot->work);
831 destroy_workqueue(slot->wq);
835 static inline void dbg_ctrl(struct controller *ctrl)
839 struct pci_dev *pdev = ctrl->pcie->port;
844 ctrl_info(ctrl, "Hotplug Controller:\n");
845 ctrl_info(ctrl, " Seg/Bus/Dev/Func/IRQ : %s IRQ %d\n",
846 pci_name(pdev), pdev->irq);
847 ctrl_info(ctrl, " Vendor ID : 0x%04x\n", pdev->vendor);
848 ctrl_info(ctrl, " Device ID : 0x%04x\n", pdev->device);
849 ctrl_info(ctrl, " Subsystem ID : 0x%04x\n",
850 pdev->subsystem_device);
851 ctrl_info(ctrl, " Subsystem Vendor ID : 0x%04x\n",
852 pdev->subsystem_vendor);
853 ctrl_info(ctrl, " PCIe Cap offset : 0x%02x\n",
855 for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
856 if (!pci_resource_len(pdev, i))
858 ctrl_info(ctrl, " PCI resource [%d] : %pR\n",
859 i, &pdev->resource[i]);
861 ctrl_info(ctrl, "Slot Capabilities : 0x%08x\n", ctrl->slot_cap);
862 ctrl_info(ctrl, " Physical Slot Number : %d\n", PSN(ctrl));
863 ctrl_info(ctrl, " Attention Button : %3s\n",
864 ATTN_BUTTN(ctrl) ? "yes" : "no");
865 ctrl_info(ctrl, " Power Controller : %3s\n",
866 POWER_CTRL(ctrl) ? "yes" : "no");
867 ctrl_info(ctrl, " MRL Sensor : %3s\n",
868 MRL_SENS(ctrl) ? "yes" : "no");
869 ctrl_info(ctrl, " Attention Indicator : %3s\n",
870 ATTN_LED(ctrl) ? "yes" : "no");
871 ctrl_info(ctrl, " Power Indicator : %3s\n",
872 PWR_LED(ctrl) ? "yes" : "no");
873 ctrl_info(ctrl, " Hot-Plug Surprise : %3s\n",
874 HP_SUPR_RM(ctrl) ? "yes" : "no");
875 ctrl_info(ctrl, " EMI Present : %3s\n",
876 EMI(ctrl) ? "yes" : "no");
877 ctrl_info(ctrl, " Command Completed : %3s\n",
878 NO_CMD_CMPL(ctrl) ? "no" : "yes");
879 pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, ®16);
880 ctrl_info(ctrl, "Slot Status : 0x%04x\n", reg16);
881 pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, ®16);
882 ctrl_info(ctrl, "Slot Control : 0x%04x\n", reg16);
885 struct controller *pcie_init(struct pcie_device *dev)
887 struct controller *ctrl;
888 u32 slot_cap, link_cap;
889 struct pci_dev *pdev = dev->port;
891 ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL);
893 dev_err(&dev->device, "%s: Out of memory\n", __func__);
897 if (pcie_capability_read_dword(pdev, PCI_EXP_SLTCAP, &slot_cap)) {
898 ctrl_err(ctrl, "Cannot read SLOTCAP register\n");
902 ctrl->slot_cap = slot_cap;
903 mutex_init(&ctrl->ctrl_lock);
904 init_waitqueue_head(&ctrl->queue);
907 * Controller doesn't notify of command completion if the "No
908 * Command Completed Support" bit is set in Slot Capability
909 * register or the controller supports none of power
910 * controller, attention led, power led and EMI.
912 if (NO_CMD_CMPL(ctrl) ||
913 !(POWER_CTRL(ctrl) | ATTN_LED(ctrl) | PWR_LED(ctrl) | EMI(ctrl)))
914 ctrl->no_cmd_complete = 1;
916 /* Check if Data Link Layer Link Active Reporting is implemented */
917 if (pcie_capability_read_dword(pdev, PCI_EXP_LNKCAP, &link_cap)) {
918 ctrl_err(ctrl, "%s: Cannot read LNKCAP register\n", __func__);
921 if (link_cap & PCI_EXP_LNKCAP_DLLLARC) {
922 ctrl_dbg(ctrl, "Link Active Reporting supported\n");
923 ctrl->link_active_reporting = 1;
926 /* Clear all remaining event bits in Slot Status register */
927 if (pcie_capability_write_word(pdev, PCI_EXP_SLTSTA, 0x1f))
930 /* Disable software notification */
931 pcie_disable_notification(ctrl);
933 ctrl_info(ctrl, "HPC vendor_id %x device_id %x ss_vid %x ss_did %x\n",
934 pdev->vendor, pdev->device, pdev->subsystem_vendor,
935 pdev->subsystem_device);
937 if (pcie_init_slot(ctrl))
948 void pciehp_release_ctrl(struct controller *ctrl)
950 pcie_shutdown_notification(ctrl);
951 pcie_cleanup_slot(ctrl);