This source file includes following definitions.
- ctrl_dev
- pciehp_request_irq
- pciehp_free_irq
- pcie_poll_cmd
- pcie_wait_cmd
- pcie_do_write_cmd
- pcie_write_cmd
- pcie_write_cmd_nowait
- pciehp_check_link_active
- pci_bus_check_dev
- pciehp_check_link_status
- __pciehp_link_set
- pciehp_link_enable
- pciehp_get_raw_indicator_status
- pciehp_get_attention_status
- pciehp_get_power_status
- pciehp_get_latch_status
- pciehp_card_present
- pciehp_card_present_or_link_active
- pciehp_query_power_fault
- pciehp_set_raw_indicator_status
- pciehp_set_indicators
- pciehp_power_on_slot
- pciehp_power_off_slot
- pciehp_isr
- pciehp_ist
- pciehp_poll
- pcie_enable_notification
- pcie_disable_notification
- pcie_clear_hotplug_events
- pcie_enable_interrupt
- pcie_disable_interrupt
- pciehp_reset_slot
- pcie_init_notification
- pcie_shutdown_notification
- dbg_ctrl
- pcie_init
- pciehp_release_ctrl
- quirk_cmd_compl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 #define dev_fmt(fmt) "pciehp: " fmt
16
17 #include <linux/kernel.h>
18 #include <linux/types.h>
19 #include <linux/jiffies.h>
20 #include <linux/kthread.h>
21 #include <linux/pci.h>
22 #include <linux/pm_runtime.h>
23 #include <linux/interrupt.h>
24 #include <linux/slab.h>
25
26 #include "../pci.h"
27 #include "pciehp.h"
28
29 static inline struct pci_dev *ctrl_dev(struct controller *ctrl)
30 {
31 return ctrl->pcie->port;
32 }
33
34 static irqreturn_t pciehp_isr(int irq, void *dev_id);
35 static irqreturn_t pciehp_ist(int irq, void *dev_id);
36 static int pciehp_poll(void *data);
37
38 static inline int pciehp_request_irq(struct controller *ctrl)
39 {
40 int retval, irq = ctrl->pcie->irq;
41
42 if (pciehp_poll_mode) {
43 ctrl->poll_thread = kthread_run(&pciehp_poll, ctrl,
44 "pciehp_poll-%s",
45 slot_name(ctrl));
46 return PTR_ERR_OR_ZERO(ctrl->poll_thread);
47 }
48
49
50 retval = request_threaded_irq(irq, pciehp_isr, pciehp_ist,
51 IRQF_SHARED, "pciehp", ctrl);
52 if (retval)
53 ctrl_err(ctrl, "Cannot get irq %d for the hotplug controller\n",
54 irq);
55 return retval;
56 }
57
58 static inline void pciehp_free_irq(struct controller *ctrl)
59 {
60 if (pciehp_poll_mode)
61 kthread_stop(ctrl->poll_thread);
62 else
63 free_irq(ctrl->pcie->irq, ctrl);
64 }
65
66 static int pcie_poll_cmd(struct controller *ctrl, int timeout)
67 {
68 struct pci_dev *pdev = ctrl_dev(ctrl);
69 u16 slot_status;
70
71 while (true) {
72 pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
73 if (slot_status == (u16) ~0) {
74 ctrl_info(ctrl, "%s: no response from device\n",
75 __func__);
76 return 0;
77 }
78
79 if (slot_status & PCI_EXP_SLTSTA_CC) {
80 pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
81 PCI_EXP_SLTSTA_CC);
82 return 1;
83 }
84 if (timeout < 0)
85 break;
86 msleep(10);
87 timeout -= 10;
88 }
89 return 0;
90 }
91
92 static void pcie_wait_cmd(struct controller *ctrl)
93 {
94 unsigned int msecs = pciehp_poll_mode ? 2500 : 1000;
95 unsigned long duration = msecs_to_jiffies(msecs);
96 unsigned long cmd_timeout = ctrl->cmd_started + duration;
97 unsigned long now, timeout;
98 int rc;
99
100
101
102
103
104 if (NO_CMD_CMPL(ctrl))
105 return;
106
107 if (!ctrl->cmd_busy)
108 return;
109
110
111
112
113
114 now = jiffies;
115 if (time_before_eq(cmd_timeout, now))
116 timeout = 1;
117 else
118 timeout = cmd_timeout - now;
119
120 if (ctrl->slot_ctrl & PCI_EXP_SLTCTL_HPIE &&
121 ctrl->slot_ctrl & PCI_EXP_SLTCTL_CCIE)
122 rc = wait_event_timeout(ctrl->queue, !ctrl->cmd_busy, timeout);
123 else
124 rc = pcie_poll_cmd(ctrl, jiffies_to_msecs(timeout));
125
126 if (!rc)
127 ctrl_info(ctrl, "Timeout on hotplug command %#06x (issued %u msec ago)\n",
128 ctrl->slot_ctrl,
129 jiffies_to_msecs(jiffies - ctrl->cmd_started));
130 }
131
132 #define CC_ERRATUM_MASK (PCI_EXP_SLTCTL_PCC | \
133 PCI_EXP_SLTCTL_PIC | \
134 PCI_EXP_SLTCTL_AIC | \
135 PCI_EXP_SLTCTL_EIC)
136
137 static void pcie_do_write_cmd(struct controller *ctrl, u16 cmd,
138 u16 mask, bool wait)
139 {
140 struct pci_dev *pdev = ctrl_dev(ctrl);
141 u16 slot_ctrl_orig, slot_ctrl;
142
143 mutex_lock(&ctrl->ctrl_lock);
144
145
146
147
148 pcie_wait_cmd(ctrl);
149
150 pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &slot_ctrl);
151 if (slot_ctrl == (u16) ~0) {
152 ctrl_info(ctrl, "%s: no response from device\n", __func__);
153 goto out;
154 }
155
156 slot_ctrl_orig = slot_ctrl;
157 slot_ctrl &= ~mask;
158 slot_ctrl |= (cmd & mask);
159 ctrl->cmd_busy = 1;
160 smp_mb();
161 ctrl->slot_ctrl = slot_ctrl;
162 pcie_capability_write_word(pdev, PCI_EXP_SLTCTL, slot_ctrl);
163 ctrl->cmd_started = jiffies;
164
165
166
167
168
169
170
171
172 if (pdev->broken_cmd_compl &&
173 (slot_ctrl_orig & CC_ERRATUM_MASK) == (slot_ctrl & CC_ERRATUM_MASK))
174 ctrl->cmd_busy = 0;
175
176
177
178
179
180 if (wait)
181 pcie_wait_cmd(ctrl);
182
183 out:
184 mutex_unlock(&ctrl->ctrl_lock);
185 }
186
187
188
189
190
191
192
193 static void pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
194 {
195 pcie_do_write_cmd(ctrl, cmd, mask, true);
196 }
197
198
199 static void pcie_write_cmd_nowait(struct controller *ctrl, u16 cmd, u16 mask)
200 {
201 pcie_do_write_cmd(ctrl, cmd, mask, false);
202 }
203
204
205
206
207
208
209
210
211
212
213
214
215 int pciehp_check_link_active(struct controller *ctrl)
216 {
217 struct pci_dev *pdev = ctrl_dev(ctrl);
218 u16 lnk_status;
219 int ret;
220
221 ret = pcie_capability_read_word(pdev, PCI_EXP_LNKSTA, &lnk_status);
222 if (ret == PCIBIOS_DEVICE_NOT_FOUND || lnk_status == (u16)~0)
223 return -ENODEV;
224
225 ret = !!(lnk_status & PCI_EXP_LNKSTA_DLLLA);
226 ctrl_dbg(ctrl, "%s: lnk_status = %x\n", __func__, lnk_status);
227
228 return ret;
229 }
230
231 static bool pci_bus_check_dev(struct pci_bus *bus, int devfn)
232 {
233 u32 l;
234 int count = 0;
235 int delay = 1000, step = 20;
236 bool found = false;
237
238 do {
239 found = pci_bus_read_dev_vendor_id(bus, devfn, &l, 0);
240 count++;
241
242 if (found)
243 break;
244
245 msleep(step);
246 delay -= step;
247 } while (delay > 0);
248
249 if (count > 1)
250 pr_debug("pci %04x:%02x:%02x.%d id reading try %d times with interval %d ms to get %08x\n",
251 pci_domain_nr(bus), bus->number, PCI_SLOT(devfn),
252 PCI_FUNC(devfn), count, step, l);
253
254 return found;
255 }
256
257 int pciehp_check_link_status(struct controller *ctrl)
258 {
259 struct pci_dev *pdev = ctrl_dev(ctrl);
260 bool found;
261 u16 lnk_status;
262
263 if (!pcie_wait_for_link(pdev, true))
264 return -1;
265
266 found = pci_bus_check_dev(ctrl->pcie->port->subordinate,
267 PCI_DEVFN(0, 0));
268
269
270 if (found)
271 atomic_and(~(PCI_EXP_SLTSTA_DLLSC | PCI_EXP_SLTSTA_PDC),
272 &ctrl->pending_events);
273
274 pcie_capability_read_word(pdev, PCI_EXP_LNKSTA, &lnk_status);
275 ctrl_dbg(ctrl, "%s: lnk_status = %x\n", __func__, lnk_status);
276 if ((lnk_status & PCI_EXP_LNKSTA_LT) ||
277 !(lnk_status & PCI_EXP_LNKSTA_NLW)) {
278 ctrl_err(ctrl, "link training error: status %#06x\n",
279 lnk_status);
280 return -1;
281 }
282
283 pcie_update_link_speed(ctrl->pcie->port->subordinate, lnk_status);
284
285 if (!found)
286 return -1;
287
288 return 0;
289 }
290
291 static int __pciehp_link_set(struct controller *ctrl, bool enable)
292 {
293 struct pci_dev *pdev = ctrl_dev(ctrl);
294 u16 lnk_ctrl;
295
296 pcie_capability_read_word(pdev, PCI_EXP_LNKCTL, &lnk_ctrl);
297
298 if (enable)
299 lnk_ctrl &= ~PCI_EXP_LNKCTL_LD;
300 else
301 lnk_ctrl |= PCI_EXP_LNKCTL_LD;
302
303 pcie_capability_write_word(pdev, PCI_EXP_LNKCTL, lnk_ctrl);
304 ctrl_dbg(ctrl, "%s: lnk_ctrl = %x\n", __func__, lnk_ctrl);
305 return 0;
306 }
307
308 static int pciehp_link_enable(struct controller *ctrl)
309 {
310 return __pciehp_link_set(ctrl, true);
311 }
312
313 int pciehp_get_raw_indicator_status(struct hotplug_slot *hotplug_slot,
314 u8 *status)
315 {
316 struct controller *ctrl = to_ctrl(hotplug_slot);
317 struct pci_dev *pdev = ctrl_dev(ctrl);
318 u16 slot_ctrl;
319
320 pci_config_pm_runtime_get(pdev);
321 pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &slot_ctrl);
322 pci_config_pm_runtime_put(pdev);
323 *status = (slot_ctrl & (PCI_EXP_SLTCTL_AIC | PCI_EXP_SLTCTL_PIC)) >> 6;
324 return 0;
325 }
326
327 int pciehp_get_attention_status(struct hotplug_slot *hotplug_slot, u8 *status)
328 {
329 struct controller *ctrl = to_ctrl(hotplug_slot);
330 struct pci_dev *pdev = ctrl_dev(ctrl);
331 u16 slot_ctrl;
332
333 pci_config_pm_runtime_get(pdev);
334 pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &slot_ctrl);
335 pci_config_pm_runtime_put(pdev);
336 ctrl_dbg(ctrl, "%s: SLOTCTRL %x, value read %x\n", __func__,
337 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_ctrl);
338
339 switch (slot_ctrl & PCI_EXP_SLTCTL_AIC) {
340 case PCI_EXP_SLTCTL_ATTN_IND_ON:
341 *status = 1;
342 break;
343 case PCI_EXP_SLTCTL_ATTN_IND_BLINK:
344 *status = 2;
345 break;
346 case PCI_EXP_SLTCTL_ATTN_IND_OFF:
347 *status = 0;
348 break;
349 default:
350 *status = 0xFF;
351 break;
352 }
353
354 return 0;
355 }
356
357 void pciehp_get_power_status(struct controller *ctrl, u8 *status)
358 {
359 struct pci_dev *pdev = ctrl_dev(ctrl);
360 u16 slot_ctrl;
361
362 pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &slot_ctrl);
363 ctrl_dbg(ctrl, "%s: SLOTCTRL %x value read %x\n", __func__,
364 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_ctrl);
365
366 switch (slot_ctrl & PCI_EXP_SLTCTL_PCC) {
367 case PCI_EXP_SLTCTL_PWR_ON:
368 *status = 1;
369 break;
370 case PCI_EXP_SLTCTL_PWR_OFF:
371 *status = 0;
372 break;
373 default:
374 *status = 0xFF;
375 break;
376 }
377 }
378
379 void pciehp_get_latch_status(struct controller *ctrl, u8 *status)
380 {
381 struct pci_dev *pdev = ctrl_dev(ctrl);
382 u16 slot_status;
383
384 pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
385 *status = !!(slot_status & PCI_EXP_SLTSTA_MRLSS);
386 }
387
388
389
390
391
392
393
394
395
396
397
398
399
400 int pciehp_card_present(struct controller *ctrl)
401 {
402 struct pci_dev *pdev = ctrl_dev(ctrl);
403 u16 slot_status;
404 int ret;
405
406 ret = pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
407 if (ret == PCIBIOS_DEVICE_NOT_FOUND || slot_status == (u16)~0)
408 return -ENODEV;
409
410 return !!(slot_status & PCI_EXP_SLTSTA_PDS);
411 }
412
413
414
415
416
417
418
419
420
421
422
423
424
425 int pciehp_card_present_or_link_active(struct controller *ctrl)
426 {
427 int ret;
428
429 ret = pciehp_card_present(ctrl);
430 if (ret)
431 return ret;
432
433 return pciehp_check_link_active(ctrl);
434 }
435
436 int pciehp_query_power_fault(struct controller *ctrl)
437 {
438 struct pci_dev *pdev = ctrl_dev(ctrl);
439 u16 slot_status;
440
441 pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
442 return !!(slot_status & PCI_EXP_SLTSTA_PFD);
443 }
444
445 int pciehp_set_raw_indicator_status(struct hotplug_slot *hotplug_slot,
446 u8 status)
447 {
448 struct controller *ctrl = to_ctrl(hotplug_slot);
449 struct pci_dev *pdev = ctrl_dev(ctrl);
450
451 pci_config_pm_runtime_get(pdev);
452 pcie_write_cmd_nowait(ctrl, status << 6,
453 PCI_EXP_SLTCTL_AIC | PCI_EXP_SLTCTL_PIC);
454 pci_config_pm_runtime_put(pdev);
455 return 0;
456 }
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473 void pciehp_set_indicators(struct controller *ctrl, int pwr, int attn)
474 {
475 u16 cmd = 0, mask = 0;
476
477 if (PWR_LED(ctrl) && pwr != INDICATOR_NOOP) {
478 cmd |= (pwr & PCI_EXP_SLTCTL_PIC);
479 mask |= PCI_EXP_SLTCTL_PIC;
480 }
481
482 if (ATTN_LED(ctrl) && attn != INDICATOR_NOOP) {
483 cmd |= (attn & PCI_EXP_SLTCTL_AIC);
484 mask |= PCI_EXP_SLTCTL_AIC;
485 }
486
487 if (cmd) {
488 pcie_write_cmd_nowait(ctrl, cmd, mask);
489 ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
490 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, cmd);
491 }
492 }
493
494 int pciehp_power_on_slot(struct controller *ctrl)
495 {
496 struct pci_dev *pdev = ctrl_dev(ctrl);
497 u16 slot_status;
498 int retval;
499
500
501 pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
502 if (slot_status & PCI_EXP_SLTSTA_PFD)
503 pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
504 PCI_EXP_SLTSTA_PFD);
505 ctrl->power_fault_detected = 0;
506
507 pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PWR_ON, PCI_EXP_SLTCTL_PCC);
508 ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
509 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL,
510 PCI_EXP_SLTCTL_PWR_ON);
511
512 retval = pciehp_link_enable(ctrl);
513 if (retval)
514 ctrl_err(ctrl, "%s: Can not enable the link!\n", __func__);
515
516 return retval;
517 }
518
519 void pciehp_power_off_slot(struct controller *ctrl)
520 {
521 pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PWR_OFF, PCI_EXP_SLTCTL_PCC);
522 ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
523 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL,
524 PCI_EXP_SLTCTL_PWR_OFF);
525 }
526
527 static irqreturn_t pciehp_isr(int irq, void *dev_id)
528 {
529 struct controller *ctrl = (struct controller *)dev_id;
530 struct pci_dev *pdev = ctrl_dev(ctrl);
531 struct device *parent = pdev->dev.parent;
532 u16 status, events;
533
534
535
536
537
538 if (pdev->current_state == PCI_D3cold ||
539 (!(ctrl->slot_ctrl & PCI_EXP_SLTCTL_HPIE) && !pciehp_poll_mode))
540 return IRQ_NONE;
541
542
543
544
545
546
547 if (parent) {
548 pm_runtime_get_noresume(parent);
549 if (!pm_runtime_active(parent)) {
550 pm_runtime_put(parent);
551 disable_irq_nosync(irq);
552 atomic_or(RERUN_ISR, &ctrl->pending_events);
553 return IRQ_WAKE_THREAD;
554 }
555 }
556
557 pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &status);
558 if (status == (u16) ~0) {
559 ctrl_info(ctrl, "%s: no response from device\n", __func__);
560 if (parent)
561 pm_runtime_put(parent);
562 return IRQ_NONE;
563 }
564
565
566
567
568
569 events = status & (PCI_EXP_SLTSTA_ABP | PCI_EXP_SLTSTA_PFD |
570 PCI_EXP_SLTSTA_PDC | PCI_EXP_SLTSTA_CC |
571 PCI_EXP_SLTSTA_DLLSC);
572
573
574
575
576
577 if (ctrl->power_fault_detected)
578 events &= ~PCI_EXP_SLTSTA_PFD;
579
580 if (!events) {
581 if (parent)
582 pm_runtime_put(parent);
583 return IRQ_NONE;
584 }
585
586 pcie_capability_write_word(pdev, PCI_EXP_SLTSTA, events);
587 ctrl_dbg(ctrl, "pending interrupts %#06x from Slot Status\n", events);
588 if (parent)
589 pm_runtime_put(parent);
590
591
592
593
594
595 if (events & PCI_EXP_SLTSTA_CC) {
596 ctrl->cmd_busy = 0;
597 smp_mb();
598 wake_up(&ctrl->queue);
599
600 if (events == PCI_EXP_SLTSTA_CC)
601 return IRQ_HANDLED;
602
603 events &= ~PCI_EXP_SLTSTA_CC;
604 }
605
606 if (pdev->ignore_hotplug) {
607 ctrl_dbg(ctrl, "ignoring hotplug event %#06x\n", events);
608 return IRQ_HANDLED;
609 }
610
611
612 atomic_or(events, &ctrl->pending_events);
613 return IRQ_WAKE_THREAD;
614 }
615
616 static irqreturn_t pciehp_ist(int irq, void *dev_id)
617 {
618 struct controller *ctrl = (struct controller *)dev_id;
619 struct pci_dev *pdev = ctrl_dev(ctrl);
620 irqreturn_t ret;
621 u32 events;
622
623 ctrl->ist_running = true;
624 pci_config_pm_runtime_get(pdev);
625
626
627 if (atomic_fetch_and(~RERUN_ISR, &ctrl->pending_events) & RERUN_ISR) {
628 ret = pciehp_isr(irq, dev_id);
629 enable_irq(irq);
630 if (ret != IRQ_WAKE_THREAD)
631 goto out;
632 }
633
634 synchronize_hardirq(irq);
635 events = atomic_xchg(&ctrl->pending_events, 0);
636 if (!events) {
637 ret = IRQ_NONE;
638 goto out;
639 }
640
641
642 if (events & PCI_EXP_SLTSTA_ABP) {
643 ctrl_info(ctrl, "Slot(%s): Attention button pressed\n",
644 slot_name(ctrl));
645 pciehp_handle_button_press(ctrl);
646 }
647
648
649 if ((events & PCI_EXP_SLTSTA_PFD) && !ctrl->power_fault_detected) {
650 ctrl->power_fault_detected = 1;
651 ctrl_err(ctrl, "Slot(%s): Power fault\n", slot_name(ctrl));
652 pciehp_set_indicators(ctrl, PCI_EXP_SLTCTL_PWR_IND_OFF,
653 PCI_EXP_SLTCTL_ATTN_IND_ON);
654 }
655
656
657
658
659
660 down_read(&ctrl->reset_lock);
661 if (events & DISABLE_SLOT)
662 pciehp_handle_disable_request(ctrl);
663 else if (events & (PCI_EXP_SLTSTA_PDC | PCI_EXP_SLTSTA_DLLSC))
664 pciehp_handle_presence_or_link_change(ctrl, events);
665 up_read(&ctrl->reset_lock);
666
667 ret = IRQ_HANDLED;
668 out:
669 pci_config_pm_runtime_put(pdev);
670 ctrl->ist_running = false;
671 wake_up(&ctrl->requester);
672 return ret;
673 }
674
675 static int pciehp_poll(void *data)
676 {
677 struct controller *ctrl = data;
678
679 schedule_timeout_idle(10 * HZ);
680
681 while (!kthread_should_stop()) {
682
683 while (pciehp_isr(IRQ_NOTCONNECTED, ctrl) == IRQ_WAKE_THREAD ||
684 atomic_read(&ctrl->pending_events))
685 pciehp_ist(IRQ_NOTCONNECTED, ctrl);
686
687 if (pciehp_poll_time <= 0 || pciehp_poll_time > 60)
688 pciehp_poll_time = 2;
689
690 schedule_timeout_idle(pciehp_poll_time * HZ);
691 }
692
693 return 0;
694 }
695
696 static void pcie_enable_notification(struct controller *ctrl)
697 {
698 u16 cmd, mask;
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716 cmd = PCI_EXP_SLTCTL_DLLSCE;
717 if (ATTN_BUTTN(ctrl))
718 cmd |= PCI_EXP_SLTCTL_ABPE;
719 else
720 cmd |= PCI_EXP_SLTCTL_PDCE;
721 if (!pciehp_poll_mode)
722 cmd |= PCI_EXP_SLTCTL_HPIE | PCI_EXP_SLTCTL_CCIE;
723
724 mask = (PCI_EXP_SLTCTL_PDCE | PCI_EXP_SLTCTL_ABPE |
725 PCI_EXP_SLTCTL_PFDE |
726 PCI_EXP_SLTCTL_HPIE | PCI_EXP_SLTCTL_CCIE |
727 PCI_EXP_SLTCTL_DLLSCE);
728
729 pcie_write_cmd_nowait(ctrl, cmd, mask);
730 ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
731 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, cmd);
732 }
733
734 static void pcie_disable_notification(struct controller *ctrl)
735 {
736 u16 mask;
737
738 mask = (PCI_EXP_SLTCTL_PDCE | PCI_EXP_SLTCTL_ABPE |
739 PCI_EXP_SLTCTL_MRLSCE | PCI_EXP_SLTCTL_PFDE |
740 PCI_EXP_SLTCTL_HPIE | PCI_EXP_SLTCTL_CCIE |
741 PCI_EXP_SLTCTL_DLLSCE);
742 pcie_write_cmd(ctrl, 0, mask);
743 ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
744 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, 0);
745 }
746
747 void pcie_clear_hotplug_events(struct controller *ctrl)
748 {
749 pcie_capability_write_word(ctrl_dev(ctrl), PCI_EXP_SLTSTA,
750 PCI_EXP_SLTSTA_PDC | PCI_EXP_SLTSTA_DLLSC);
751 }
752
753 void pcie_enable_interrupt(struct controller *ctrl)
754 {
755 u16 mask;
756
757 mask = PCI_EXP_SLTCTL_HPIE | PCI_EXP_SLTCTL_DLLSCE;
758 pcie_write_cmd(ctrl, mask, mask);
759 }
760
761 void pcie_disable_interrupt(struct controller *ctrl)
762 {
763 u16 mask;
764
765
766
767
768
769
770
771
772 mask = PCI_EXP_SLTCTL_HPIE | PCI_EXP_SLTCTL_DLLSCE;
773 pcie_write_cmd(ctrl, 0, mask);
774 }
775
776
777
778
779
780
781
782
783
784 int pciehp_reset_slot(struct hotplug_slot *hotplug_slot, int probe)
785 {
786 struct controller *ctrl = to_ctrl(hotplug_slot);
787 struct pci_dev *pdev = ctrl_dev(ctrl);
788 u16 stat_mask = 0, ctrl_mask = 0;
789 int rc;
790
791 if (probe)
792 return 0;
793
794 down_write(&ctrl->reset_lock);
795
796 if (!ATTN_BUTTN(ctrl)) {
797 ctrl_mask |= PCI_EXP_SLTCTL_PDCE;
798 stat_mask |= PCI_EXP_SLTSTA_PDC;
799 }
800 ctrl_mask |= PCI_EXP_SLTCTL_DLLSCE;
801 stat_mask |= PCI_EXP_SLTSTA_DLLSC;
802
803 pcie_write_cmd(ctrl, 0, ctrl_mask);
804 ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
805 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, 0);
806
807 rc = pci_bridge_secondary_bus_reset(ctrl->pcie->port);
808
809 pcie_capability_write_word(pdev, PCI_EXP_SLTSTA, stat_mask);
810 pcie_write_cmd_nowait(ctrl, ctrl_mask, ctrl_mask);
811 ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
812 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, ctrl_mask);
813
814 up_write(&ctrl->reset_lock);
815 return rc;
816 }
817
818 int pcie_init_notification(struct controller *ctrl)
819 {
820 if (pciehp_request_irq(ctrl))
821 return -1;
822 pcie_enable_notification(ctrl);
823 ctrl->notification_enabled = 1;
824 return 0;
825 }
826
827 void pcie_shutdown_notification(struct controller *ctrl)
828 {
829 if (ctrl->notification_enabled) {
830 pcie_disable_notification(ctrl);
831 pciehp_free_irq(ctrl);
832 ctrl->notification_enabled = 0;
833 }
834 }
835
836 static inline void dbg_ctrl(struct controller *ctrl)
837 {
838 struct pci_dev *pdev = ctrl->pcie->port;
839 u16 reg16;
840
841 ctrl_dbg(ctrl, "Slot Capabilities : 0x%08x\n", ctrl->slot_cap);
842 pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, ®16);
843 ctrl_dbg(ctrl, "Slot Status : 0x%04x\n", reg16);
844 pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, ®16);
845 ctrl_dbg(ctrl, "Slot Control : 0x%04x\n", reg16);
846 }
847
848 #define FLAG(x, y) (((x) & (y)) ? '+' : '-')
849
850 struct controller *pcie_init(struct pcie_device *dev)
851 {
852 struct controller *ctrl;
853 u32 slot_cap, link_cap;
854 u8 poweron;
855 struct pci_dev *pdev = dev->port;
856 struct pci_bus *subordinate = pdev->subordinate;
857
858 ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL);
859 if (!ctrl)
860 return NULL;
861
862 ctrl->pcie = dev;
863 pcie_capability_read_dword(pdev, PCI_EXP_SLTCAP, &slot_cap);
864
865 if (pdev->hotplug_user_indicators)
866 slot_cap &= ~(PCI_EXP_SLTCAP_AIP | PCI_EXP_SLTCAP_PIP);
867
868
869
870
871
872 if (pdev->is_thunderbolt)
873 slot_cap |= PCI_EXP_SLTCAP_NCCS;
874
875 ctrl->slot_cap = slot_cap;
876 mutex_init(&ctrl->ctrl_lock);
877 mutex_init(&ctrl->state_lock);
878 init_rwsem(&ctrl->reset_lock);
879 init_waitqueue_head(&ctrl->requester);
880 init_waitqueue_head(&ctrl->queue);
881 INIT_DELAYED_WORK(&ctrl->button_work, pciehp_queue_pushbutton_work);
882 dbg_ctrl(ctrl);
883
884 down_read(&pci_bus_sem);
885 ctrl->state = list_empty(&subordinate->devices) ? OFF_STATE : ON_STATE;
886 up_read(&pci_bus_sem);
887
888
889 pcie_capability_read_dword(pdev, PCI_EXP_LNKCAP, &link_cap);
890
891
892 pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
893 PCI_EXP_SLTSTA_ABP | PCI_EXP_SLTSTA_PFD |
894 PCI_EXP_SLTSTA_MRLSC | PCI_EXP_SLTSTA_CC |
895 PCI_EXP_SLTSTA_DLLSC | PCI_EXP_SLTSTA_PDC);
896
897 ctrl_info(ctrl, "Slot #%d AttnBtn%c PwrCtrl%c MRL%c AttnInd%c PwrInd%c HotPlug%c Surprise%c Interlock%c NoCompl%c LLActRep%c%s\n",
898 (slot_cap & PCI_EXP_SLTCAP_PSN) >> 19,
899 FLAG(slot_cap, PCI_EXP_SLTCAP_ABP),
900 FLAG(slot_cap, PCI_EXP_SLTCAP_PCP),
901 FLAG(slot_cap, PCI_EXP_SLTCAP_MRLSP),
902 FLAG(slot_cap, PCI_EXP_SLTCAP_AIP),
903 FLAG(slot_cap, PCI_EXP_SLTCAP_PIP),
904 FLAG(slot_cap, PCI_EXP_SLTCAP_HPC),
905 FLAG(slot_cap, PCI_EXP_SLTCAP_HPS),
906 FLAG(slot_cap, PCI_EXP_SLTCAP_EIP),
907 FLAG(slot_cap, PCI_EXP_SLTCAP_NCCS),
908 FLAG(link_cap, PCI_EXP_LNKCAP_DLLLARC),
909 pdev->broken_cmd_compl ? " (with Cmd Compl erratum)" : "");
910
911
912
913
914
915 if (POWER_CTRL(ctrl)) {
916 pciehp_get_power_status(ctrl, &poweron);
917 if (!pciehp_card_present_or_link_active(ctrl) && poweron) {
918 pcie_disable_notification(ctrl);
919 pciehp_power_off_slot(ctrl);
920 }
921 }
922
923 return ctrl;
924 }
925
926 void pciehp_release_ctrl(struct controller *ctrl)
927 {
928 cancel_delayed_work_sync(&ctrl->button_work);
929 kfree(ctrl);
930 }
931
932 static void quirk_cmd_compl(struct pci_dev *pdev)
933 {
934 u32 slot_cap;
935
936 if (pci_is_pcie(pdev)) {
937 pcie_capability_read_dword(pdev, PCI_EXP_SLTCAP, &slot_cap);
938 if (slot_cap & PCI_EXP_SLTCAP_HPC &&
939 !(slot_cap & PCI_EXP_SLTCAP_NCCS))
940 pdev->broken_cmd_compl = 1;
941 }
942 }
943 DECLARE_PCI_FIXUP_CLASS_EARLY(PCI_VENDOR_ID_INTEL, PCI_ANY_ID,
944 PCI_CLASS_BRIDGE_PCI, 8, quirk_cmd_compl);
945 DECLARE_PCI_FIXUP_CLASS_EARLY(PCI_VENDOR_ID_QCOM, 0x0400,
946 PCI_CLASS_BRIDGE_PCI, 8, quirk_cmd_compl);
947 DECLARE_PCI_FIXUP_CLASS_EARLY(PCI_VENDOR_ID_QCOM, 0x0401,
948 PCI_CLASS_BRIDGE_PCI, 8, quirk_cmd_compl);
949 DECLARE_PCI_FIXUP_CLASS_EARLY(PCI_VENDOR_ID_HXT, 0x0401,
950 PCI_CLASS_BRIDGE_PCI, 8, quirk_cmd_compl);