1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25 #include <sys/sysmacros.h>
26 #include <sys/types.h>
27 #include <sys/kmem.h>
28 #include <sys/modctl.h>
29 #include <sys/ddi.h>
30 #include <sys/sunddi.h>
31 #include <sys/sunndi.h>
32 #include <sys/fm/protocol.h>
33 #include <sys/fm/util.h>
34 #include <sys/fm/io/ddi.h>
35 #include <sys/fm/io/pci.h>
36 #include <sys/promif.h>
37 #include <sys/disp.h>
38 #include <sys/atomic.h>
39 #include <sys/pcie.h>
40 #include <sys/pci_cap.h>
41 #include <sys/pcie_impl.h>
42
43 #define PF_PCIE_BDG_ERR (PCIE_DEVSTS_FE_DETECTED | PCIE_DEVSTS_NFE_DETECTED | \
44 PCIE_DEVSTS_CE_DETECTED)
45
46 #define PF_PCI_BDG_ERR (PCI_STAT_S_SYSERR | PCI_STAT_S_TARG_AB | \
47 PCI_STAT_R_MAST_AB | PCI_STAT_R_TARG_AB | PCI_STAT_S_PERROR)
48
49 #define PF_AER_FATAL_ERR (PCIE_AER_UCE_DLP | PCIE_AER_UCE_SD |\
50 PCIE_AER_UCE_FCP | PCIE_AER_UCE_RO | PCIE_AER_UCE_MTLP)
51 #define PF_AER_NON_FATAL_ERR (PCIE_AER_UCE_PTLP | PCIE_AER_UCE_TO | \
52 PCIE_AER_UCE_CA | PCIE_AER_UCE_ECRC | PCIE_AER_UCE_UR)
53
54 #define PF_SAER_FATAL_ERR (PCIE_AER_SUCE_USC_MSG_DATA_ERR | \
55 PCIE_AER_SUCE_UC_ATTR_ERR | PCIE_AER_SUCE_UC_ADDR_ERR | \
56 PCIE_AER_SUCE_SERR_ASSERT)
57 #define PF_SAER_NON_FATAL_ERR (PCIE_AER_SUCE_TA_ON_SC | \
58 PCIE_AER_SUCE_MA_ON_SC | PCIE_AER_SUCE_RCVD_TA | \
59 PCIE_AER_SUCE_RCVD_MA | PCIE_AER_SUCE_USC_ERR | \
60 PCIE_AER_SUCE_UC_DATA_ERR | PCIE_AER_SUCE_TIMER_EXPIRED | \
61 PCIE_AER_SUCE_PERR_ASSERT | PCIE_AER_SUCE_INTERNAL_ERR)
62
63 #define PF_PCI_PARITY_ERR (PCI_STAT_S_PERROR | PCI_STAT_PERROR)
64
65 #define PF_FIRST_AER_ERR(bit, adv) \
66 (bit & (1 << (adv->pcie_adv_ctl & PCIE_AER_CTL_FST_ERR_PTR_MASK)))
67
68 #define HAS_AER_LOGS(pfd_p, bit) \
69 (PCIE_HAS_AER(pfd_p->pe_bus_p) && \
70 PF_FIRST_AER_ERR(bit, PCIE_ADV_REG(pfd_p)))
71
72 #define PF_FIRST_SAER_ERR(bit, adv) \
73 (bit & (1 << (adv->pcie_sue_ctl & PCIE_AER_SCTL_FST_ERR_PTR_MASK)))
74
75 #define HAS_SAER_LOGS(pfd_p, bit) \
76 (PCIE_HAS_AER(pfd_p->pe_bus_p) && \
77 PF_FIRST_SAER_ERR(bit, PCIE_ADV_BDG_REG(pfd_p)))
78
79 #define GET_SAER_CMD(pfd_p) \
80 ((PCIE_ADV_BDG_HDR(pfd_p, 1) >> \
81 PCIE_AER_SUCE_HDR_CMD_LWR_SHIFT) & PCIE_AER_SUCE_HDR_CMD_LWR_MASK)
82
83 #define CE_ADVISORY(pfd_p) \
84 (PCIE_ADV_REG(pfd_p)->pcie_ce_status & PCIE_AER_CE_AD_NFE)
85
86 /* PCIe Fault Fabric Error analysis table */
87 typedef struct pf_fab_err_tbl {
88 uint32_t bit; /* Error bit */
89 int (*handler)(); /* Error handling fuction */
90 uint16_t affected_flags; /* Primary affected flag */
91 /*
92 * Secondary affected flag, effective when the information
93 * indicated by the primary flag is not available, eg.
94 * PF_AFFECTED_AER/SAER/ADDR
95 */
96 uint16_t sec_affected_flags;
97 } pf_fab_err_tbl_t;
98
99 static pcie_bus_t *pf_is_ready(dev_info_t *);
100 /* Functions for scanning errors */
101 static int pf_default_hdl(dev_info_t *, pf_impl_t *);
102 static int pf_dispatch(dev_info_t *, pf_impl_t *, boolean_t);
103 static boolean_t pf_in_addr_range(pcie_bus_t *, uint64_t);
104
105 /* Functions for gathering errors */
106 static void pf_pcix_ecc_regs_gather(pf_pcix_ecc_regs_t *pcix_ecc_regs,
107 pcie_bus_t *bus_p, boolean_t bdg);
108 static void pf_pcix_regs_gather(pf_data_t *pfd_p, pcie_bus_t *bus_p);
109 static void pf_pcie_regs_gather(pf_data_t *pfd_p, pcie_bus_t *bus_p);
110 static void pf_pci_regs_gather(pf_data_t *pfd_p, pcie_bus_t *bus_p);
111 static int pf_dummy_cb(dev_info_t *, ddi_fm_error_t *, const void *);
112 static void pf_en_dq(pf_data_t *pfd_p, pf_impl_t *impl_p);
113
114 /* Functions for analysing errors */
115 static int pf_analyse_error(ddi_fm_error_t *, pf_impl_t *);
116 static void pf_adjust_for_no_aer(pf_data_t *);
117 static void pf_adjust_for_no_saer(pf_data_t *);
118 static pf_data_t *pf_get_pcie_bridge(pf_data_t *, pcie_req_id_t);
119 static pf_data_t *pf_get_parent_pcie_bridge(pf_data_t *);
120 static boolean_t pf_matched_in_rc(pf_data_t *, pf_data_t *,
121 uint32_t);
122 static int pf_analyse_error_tbl(ddi_fm_error_t *, pf_impl_t *,
123 pf_data_t *, const pf_fab_err_tbl_t *, uint32_t);
124 static int pf_analyse_ca_ur(ddi_fm_error_t *, uint32_t,
125 pf_data_t *, pf_data_t *);
126 static int pf_analyse_ma_ta(ddi_fm_error_t *, uint32_t,
127 pf_data_t *, pf_data_t *);
128 static int pf_analyse_pci(ddi_fm_error_t *, uint32_t,
129 pf_data_t *, pf_data_t *);
130 static int pf_analyse_perr_assert(ddi_fm_error_t *, uint32_t,
131 pf_data_t *, pf_data_t *);
132 static int pf_analyse_ptlp(ddi_fm_error_t *, uint32_t,
133 pf_data_t *, pf_data_t *);
134 static int pf_analyse_sc(ddi_fm_error_t *, uint32_t,
135 pf_data_t *, pf_data_t *);
136 static int pf_analyse_to(ddi_fm_error_t *, uint32_t,
137 pf_data_t *, pf_data_t *);
138 static int pf_analyse_uc(ddi_fm_error_t *, uint32_t,
139 pf_data_t *, pf_data_t *);
140 static int pf_analyse_uc_data(ddi_fm_error_t *, uint32_t,
141 pf_data_t *, pf_data_t *);
142 static int pf_no_panic(ddi_fm_error_t *, uint32_t,
143 pf_data_t *, pf_data_t *);
144 static int pf_panic(ddi_fm_error_t *, uint32_t,
145 pf_data_t *, pf_data_t *);
146 static void pf_send_ereport(ddi_fm_error_t *, pf_impl_t *);
147 static int pf_fm_callback(dev_info_t *dip, ddi_fm_error_t *derr);
148
149 /* PCIe Fabric Handle Lookup Support Functions. */
150 static int pf_hdl_child_lookup(dev_info_t *, ddi_fm_error_t *, uint32_t,
151 uint64_t, pcie_req_id_t);
152 static int pf_hdl_compare(dev_info_t *, ddi_fm_error_t *, uint32_t, uint64_t,
153 pcie_req_id_t, ndi_fmc_t *);
154 static int pf_log_hdl_lookup(dev_info_t *, ddi_fm_error_t *, pf_data_t *,
155 boolean_t);
156
157 static int pf_handler_enter(dev_info_t *, pf_impl_t *);
158 static void pf_handler_exit(dev_info_t *);
159 static void pf_reset_pfd(pf_data_t *);
160
161 boolean_t pcie_full_scan = B_FALSE; /* Force to always do a full scan */
162 int pcie_disable_scan = 0; /* Disable fabric scan */
163
164 /* Inform interested parties that error handling is about to begin. */
165 /* ARGSUSED */
166 void
pf_eh_enter(pcie_bus_t * bus_p)167 pf_eh_enter(pcie_bus_t *bus_p) {
168 }
169
170 /* Inform interested parties that error handling has ended. */
171 void
pf_eh_exit(pcie_bus_t * bus_p)172 pf_eh_exit(pcie_bus_t *bus_p)
173 {
174 pcie_bus_t *rbus_p = PCIE_DIP2BUS(bus_p->bus_rp_dip);
175 pf_data_t *root_pfd_p = PCIE_BUS2PFD(rbus_p);
176 pf_data_t *pfd_p;
177 uint_t intr_type = PCIE_ROOT_EH_SRC(root_pfd_p)->intr_type;
178
179 pciev_eh_exit(root_pfd_p, intr_type);
180
181 /* Clear affected device info and INTR SRC */
182 for (pfd_p = root_pfd_p; pfd_p; pfd_p = pfd_p->pe_next) {
183 PFD_AFFECTED_DEV(pfd_p)->pe_affected_flags = 0;
184 PFD_AFFECTED_DEV(pfd_p)->pe_affected_bdf = PCIE_INVALID_BDF;
185 if (PCIE_IS_ROOT(PCIE_PFD2BUS(pfd_p))) {
186 PCIE_ROOT_EH_SRC(pfd_p)->intr_type = PF_INTR_TYPE_NONE;
187 PCIE_ROOT_EH_SRC(pfd_p)->intr_data = NULL;
188 }
189 }
190 }
191
192 /*
193 * Scan Fabric is the entry point for PCI/PCIe IO fabric errors. The
194 * caller may create a local pf_data_t with the "root fault"
195 * information populated to either do a precise or full scan. More
196 * than one pf_data_t maybe linked together if there are multiple
197 * errors. Only a PCIe compliant Root Port device may pass in NULL
198 * for the root_pfd_p.
199 *
200 * "Root Complexes" such as NPE and PX should call scan_fabric using itself as
201 * the rdip. PCIe Root ports should call pf_scan_fabric using it's parent as
202 * the rdip.
203 *
204 * Scan fabric initiated from RCs are likely due to a fabric message, traps or
205 * any RC detected errors that propagated to/from the fabric.
206 *
207 * This code assumes that by the time pf_scan_fabric is
208 * called, pf_handler_enter has NOT been called on the rdip.
209 */
210 int
pf_scan_fabric(dev_info_t * rdip,ddi_fm_error_t * derr,pf_data_t * root_pfd_p)211 pf_scan_fabric(dev_info_t *rdip, ddi_fm_error_t *derr, pf_data_t *root_pfd_p)
212 {
213 pf_impl_t impl;
214 pf_data_t *pfd_p, *pfd_head_p, *pfd_tail_p;
215 int scan_flag = PF_SCAN_SUCCESS;
216 int analyse_flag = PF_ERR_NO_ERROR;
217 boolean_t full_scan = pcie_full_scan;
218
219 if (pcie_disable_scan)
220 return (analyse_flag);
221
222 /* Find the head and tail of this link list */
223 pfd_head_p = root_pfd_p;
224 for (pfd_tail_p = root_pfd_p; pfd_tail_p && pfd_tail_p->pe_next;
225 pfd_tail_p = pfd_tail_p->pe_next)
226 ;
227
228 /* Save head/tail */
229 impl.pf_total = 0;
230 impl.pf_derr = derr;
231 impl.pf_dq_head_p = pfd_head_p;
232 impl.pf_dq_tail_p = pfd_tail_p;
233
234 /* If scan is initiated from RP then RP itself must be scanned. */
235 if (PCIE_IS_RP(PCIE_DIP2BUS(rdip)) && pf_is_ready(rdip) &&
236 !root_pfd_p) {
237 scan_flag = pf_handler_enter(rdip, &impl);
238 if (scan_flag & PF_SCAN_DEADLOCK)
239 goto done;
240
241 scan_flag = pf_default_hdl(rdip, &impl);
242 if (scan_flag & PF_SCAN_NO_ERR_IN_CHILD)
243 goto done;
244 }
245
246 /*
247 * Scan the fabric using the scan_bdf and scan_addr in error q.
248 * scan_bdf will be valid in the following cases:
249 * - Fabric message
250 * - Poisoned TLP
251 * - Signaled UR/CA
252 * - Received UR/CA
253 * - PIO load failures
254 */
255 for (pfd_p = impl.pf_dq_head_p; pfd_p && PFD_IS_ROOT(pfd_p);
256 pfd_p = pfd_p->pe_next) {
257 impl.pf_fault = PCIE_ROOT_FAULT(pfd_p);
258
259 if (PFD_IS_RC(pfd_p))
260 impl.pf_total++;
261
262 if (impl.pf_fault->full_scan)
263 full_scan = B_TRUE;
264
265 if (full_scan ||
266 PCIE_CHECK_VALID_BDF(impl.pf_fault->scan_bdf) ||
267 impl.pf_fault->scan_addr)
268 scan_flag |= pf_dispatch(rdip, &impl, full_scan);
269
270 if (full_scan)
271 break;
272 }
273
274 done:
275 /*
276 * If this is due to safe access, don't analyze the errors and return
277 * success regardless of how scan fabric went.
278 */
279 if (derr->fme_flag != DDI_FM_ERR_UNEXPECTED) {
280 analyse_flag = PF_ERR_NO_PANIC;
281 } else {
282 analyse_flag = pf_analyse_error(derr, &impl);
283 }
284
285 pf_send_ereport(derr, &impl);
286
287 /*
288 * Check if any hardened driver's callback reported a panic.
289 * If so panic.
290 */
291 if (scan_flag & PF_SCAN_CB_FAILURE)
292 analyse_flag |= PF_ERR_PANIC;
293
294 /*
295 * If a deadlock was detected, panic the system as error analysis has
296 * been compromised.
297 */
298 if (scan_flag & PF_SCAN_DEADLOCK)
299 analyse_flag |= PF_ERR_PANIC_DEADLOCK;
300
301 derr->fme_status = PF_ERR2DDIFM_ERR(scan_flag);
302
303 return (analyse_flag);
304 }
305
306 void
pcie_force_fullscan()307 pcie_force_fullscan() {
308 pcie_full_scan = B_TRUE;
309 }
310
311 /*
312 * pf_dispatch walks the device tree and calls the pf_default_hdl if the device
313 * falls in the error path.
314 *
315 * Returns PF_SCAN_* flags
316 */
317 static int
pf_dispatch(dev_info_t * pdip,pf_impl_t * impl,boolean_t full_scan)318 pf_dispatch(dev_info_t *pdip, pf_impl_t *impl, boolean_t full_scan)
319 {
320 dev_info_t *dip;
321 pcie_req_id_t rid = impl->pf_fault->scan_bdf;
322 pcie_bus_t *bus_p;
323 int scan_flag = PF_SCAN_SUCCESS;
324
325 for (dip = ddi_get_child(pdip); dip; dip = ddi_get_next_sibling(dip)) {
326 /* Make sure dip is attached and ready */
327 if (!(bus_p = pf_is_ready(dip)))
328 continue;
329
330 scan_flag |= pf_handler_enter(dip, impl);
331 if (scan_flag & PF_SCAN_DEADLOCK)
332 break;
333
334 /*
335 * Handle this device if it is a:
336 * o Full Scan
337 * o PCI/PCI-X Device
338 * o Fault BDF = Device BDF
339 * o BDF/ADDR is in range of the Bridge/Switch
340 */
341 if (full_scan ||
342 (bus_p->bus_bdf == rid) ||
343 pf_in_bus_range(bus_p, rid) ||
344 pf_in_addr_range(bus_p, impl->pf_fault->scan_addr)) {
345 int hdl_flag = pf_default_hdl(dip, impl);
346 scan_flag |= hdl_flag;
347
348 /*
349 * A bridge may have detected no errors in which case
350 * there is no need to scan further down.
351 */
352 if (hdl_flag & PF_SCAN_NO_ERR_IN_CHILD)
353 continue;
354 } else {
355 pf_handler_exit(dip);
356 continue;
357 }
358
359 /* match or in bridge bus-range */
360 switch (bus_p->bus_dev_type) {
361 case PCIE_PCIECAP_DEV_TYPE_PCIE2PCI:
362 case PCIE_PCIECAP_DEV_TYPE_PCI2PCIE:
363 scan_flag |= pf_dispatch(dip, impl, B_TRUE);
364 break;
365 case PCIE_PCIECAP_DEV_TYPE_UP:
366 case PCIE_PCIECAP_DEV_TYPE_DOWN:
367 case PCIE_PCIECAP_DEV_TYPE_ROOT:
368 {
369 pf_data_t *pfd_p = PCIE_BUS2PFD(bus_p);
370 pf_pci_err_regs_t *err_p = PCI_ERR_REG(pfd_p);
371 pf_pci_bdg_err_regs_t *serr_p = PCI_BDG_ERR_REG(pfd_p);
372 /*
373 * Continue if the fault BDF != the switch or there is a
374 * parity error
375 */
376 if ((bus_p->bus_bdf != rid) ||
377 (err_p->pci_err_status & PF_PCI_PARITY_ERR) ||
378 (serr_p->pci_bdg_sec_stat & PF_PCI_PARITY_ERR))
379 scan_flag |= pf_dispatch(dip, impl, full_scan);
380 break;
381 }
382 case PCIE_PCIECAP_DEV_TYPE_PCIE_DEV:
383 case PCIE_PCIECAP_DEV_TYPE_PCI_DEV:
384 /*
385 * Reached a PCIe end point so stop. Note dev_type
386 * PCI_DEV is just a PCIe device that requires IO Space
387 */
388 break;
389 case PCIE_PCIECAP_DEV_TYPE_PCI_PSEUDO:
390 if (PCIE_IS_BDG(bus_p))
391 scan_flag |= pf_dispatch(dip, impl, B_TRUE);
392 break;
393 default:
394 ASSERT(B_FALSE);
395 }
396 }
397 return (scan_flag);
398 }
399
400 /* Returns whether the "bdf" is in the bus range of a switch/bridge */
401 boolean_t
pf_in_bus_range(pcie_bus_t * bus_p,pcie_req_id_t bdf)402 pf_in_bus_range(pcie_bus_t *bus_p, pcie_req_id_t bdf)
403 {
404 pci_bus_range_t *br_p = &bus_p->bus_bus_range;
405 uint8_t bus_no = (bdf & PCIE_REQ_ID_BUS_MASK) >>
406 PCIE_REQ_ID_BUS_SHIFT;
407
408 /* check if given bdf falls within bridge's bus range */
409 if (PCIE_IS_BDG(bus_p) &&
410 ((bus_no >= br_p->lo) && (bus_no <= br_p->hi)))
411 return (B_TRUE);
412 else
413 return (B_FALSE);
414 }
415
416 /*
417 * Return whether the "addr" is in the assigned addr of a device.
418 */
419 boolean_t
pf_in_assigned_addr(pcie_bus_t * bus_p,uint64_t addr)420 pf_in_assigned_addr(pcie_bus_t *bus_p, uint64_t addr)
421 {
422 uint_t i;
423 uint64_t low, hi;
424 pci_regspec_t *assign_p = bus_p->bus_assigned_addr;
425
426 for (i = 0; i < bus_p->bus_assigned_entries; i++, assign_p++) {
427 low = assign_p->pci_phys_low;
428 hi = low + assign_p->pci_size_low;
429 if ((addr < hi) && (addr >= low))
430 return (B_TRUE);
431 }
432 return (B_FALSE);
433 }
434
435 /*
436 * Returns whether the "addr" is in the addr range of a switch/bridge, or if the
437 * "addr" is in the assigned addr of a device.
438 */
439 static boolean_t
pf_in_addr_range(pcie_bus_t * bus_p,uint64_t addr)440 pf_in_addr_range(pcie_bus_t *bus_p, uint64_t addr)
441 {
442 uint_t i;
443 uint64_t low, hi;
444 ppb_ranges_t *ranges_p = bus_p->bus_addr_ranges;
445
446 if (!addr)
447 return (B_FALSE);
448
449 /* check if given address belongs to this device */
450 if (pf_in_assigned_addr(bus_p, addr))
451 return (B_TRUE);
452
453 /* check if given address belongs to a child below this device */
454 if (!PCIE_IS_BDG(bus_p))
455 return (B_FALSE);
456
457 for (i = 0; i < bus_p->bus_addr_entries; i++, ranges_p++) {
458 switch (ranges_p->child_high & PCI_ADDR_MASK) {
459 case PCI_ADDR_IO:
460 case PCI_ADDR_MEM32:
461 low = ranges_p->child_low;
462 hi = ranges_p->size_low + low;
463 if ((addr < hi) && (addr >= low))
464 return (B_TRUE);
465 break;
466 case PCI_ADDR_MEM64:
467 low = ((uint64_t)ranges_p->child_mid << 32) |
468 (uint64_t)ranges_p->child_low;
469 hi = (((uint64_t)ranges_p->size_high << 32) |
470 (uint64_t)ranges_p->size_low) + low;
471 if ((addr < hi) && (addr >= low))
472 return (B_TRUE);
473 break;
474 }
475 }
476 return (B_FALSE);
477 }
478
479 static pcie_bus_t *
pf_is_ready(dev_info_t * dip)480 pf_is_ready(dev_info_t *dip)
481 {
482 pcie_bus_t *bus_p = PCIE_DIP2BUS(dip);
483 if (!bus_p)
484 return (NULL);
485
486 if (!(bus_p->bus_fm_flags & PF_FM_READY))
487 return (NULL);
488 return (bus_p);
489 }
490
491 static void
pf_pcix_ecc_regs_gather(pf_pcix_ecc_regs_t * pcix_ecc_regs,pcie_bus_t * bus_p,boolean_t bdg)492 pf_pcix_ecc_regs_gather(pf_pcix_ecc_regs_t *pcix_ecc_regs,
493 pcie_bus_t *bus_p, boolean_t bdg)
494 {
495 if (bdg) {
496 pcix_ecc_regs->pcix_ecc_ctlstat = PCIX_CAP_GET(32, bus_p,
497 PCI_PCIX_BDG_ECC_STATUS);
498 pcix_ecc_regs->pcix_ecc_fstaddr = PCIX_CAP_GET(32, bus_p,
499 PCI_PCIX_BDG_ECC_FST_AD);
500 pcix_ecc_regs->pcix_ecc_secaddr = PCIX_CAP_GET(32, bus_p,
501 PCI_PCIX_BDG_ECC_SEC_AD);
502 pcix_ecc_regs->pcix_ecc_attr = PCIX_CAP_GET(32, bus_p,
503 PCI_PCIX_BDG_ECC_ATTR);
504 } else {
505 pcix_ecc_regs->pcix_ecc_ctlstat = PCIX_CAP_GET(32, bus_p,
506 PCI_PCIX_ECC_STATUS);
507 pcix_ecc_regs->pcix_ecc_fstaddr = PCIX_CAP_GET(32, bus_p,
508 PCI_PCIX_ECC_FST_AD);
509 pcix_ecc_regs->pcix_ecc_secaddr = PCIX_CAP_GET(32, bus_p,
510 PCI_PCIX_ECC_SEC_AD);
511 pcix_ecc_regs->pcix_ecc_attr = PCIX_CAP_GET(32, bus_p,
512 PCI_PCIX_ECC_ATTR);
513 }
514 }
515
516
517 static void
pf_pcix_regs_gather(pf_data_t * pfd_p,pcie_bus_t * bus_p)518 pf_pcix_regs_gather(pf_data_t *pfd_p, pcie_bus_t *bus_p)
519 {
520 /*
521 * For PCI-X device PCI-X Capability only exists for Type 0 Headers.
522 * PCI-X Bridge Capability only exists for Type 1 Headers.
523 * Both capabilities do not exist at the same time.
524 */
525 if (PCIE_IS_BDG(bus_p)) {
526 pf_pcix_bdg_err_regs_t *pcix_bdg_regs;
527
528 pcix_bdg_regs = PCIX_BDG_ERR_REG(pfd_p);
529
530 pcix_bdg_regs->pcix_bdg_sec_stat = PCIX_CAP_GET(16, bus_p,
531 PCI_PCIX_SEC_STATUS);
532 pcix_bdg_regs->pcix_bdg_stat = PCIX_CAP_GET(32, bus_p,
533 PCI_PCIX_BDG_STATUS);
534
535 if (PCIX_ECC_VERSION_CHECK(bus_p)) {
536 /*
537 * PCI Express to PCI-X bridges only implement the
538 * secondary side of the PCI-X ECC registers, bit one is
539 * read-only so we make sure we do not write to it.
540 */
541 if (!PCIE_IS_PCIE_BDG(bus_p)) {
542 PCIX_CAP_PUT(32, bus_p, PCI_PCIX_BDG_ECC_STATUS,
543 0);
544 pf_pcix_ecc_regs_gather(
545 PCIX_BDG_ECC_REG(pfd_p, 0), bus_p, B_TRUE);
546 PCIX_CAP_PUT(32, bus_p, PCI_PCIX_BDG_ECC_STATUS,
547 1);
548 }
549 pf_pcix_ecc_regs_gather(PCIX_BDG_ECC_REG(pfd_p, 0),
550 bus_p, B_TRUE);
551 }
552 } else {
553 pf_pcix_err_regs_t *pcix_regs = PCIX_ERR_REG(pfd_p);
554
555 pcix_regs->pcix_command = PCIX_CAP_GET(16, bus_p,
556 PCI_PCIX_COMMAND);
557 pcix_regs->pcix_status = PCIX_CAP_GET(32, bus_p,
558 PCI_PCIX_STATUS);
559 if (PCIX_ECC_VERSION_CHECK(bus_p))
560 pf_pcix_ecc_regs_gather(PCIX_ECC_REG(pfd_p), bus_p,
561 B_TRUE);
562 }
563 }
564
565 static void
pf_pcie_regs_gather(pf_data_t * pfd_p,pcie_bus_t * bus_p)566 pf_pcie_regs_gather(pf_data_t *pfd_p, pcie_bus_t *bus_p)
567 {
568 pf_pcie_err_regs_t *pcie_regs = PCIE_ERR_REG(pfd_p);
569 pf_pcie_adv_err_regs_t *pcie_adv_regs = PCIE_ADV_REG(pfd_p);
570
571 pcie_regs->pcie_err_status = PCIE_CAP_GET(16, bus_p, PCIE_DEVSTS);
572 pcie_regs->pcie_err_ctl = PCIE_CAP_GET(16, bus_p, PCIE_DEVCTL);
573 pcie_regs->pcie_dev_cap = PCIE_CAP_GET(32, bus_p, PCIE_DEVCAP);
574
575 if (PCIE_IS_BDG(bus_p) && PCIE_IS_PCIX(bus_p))
576 pf_pcix_regs_gather(pfd_p, bus_p);
577
578 if (PCIE_IS_ROOT(bus_p)) {
579 pf_pcie_rp_err_regs_t *pcie_rp_regs = PCIE_RP_REG(pfd_p);
580
581 pcie_rp_regs->pcie_rp_status = PCIE_CAP_GET(32, bus_p,
582 PCIE_ROOTSTS);
583 pcie_rp_regs->pcie_rp_ctl = PCIE_CAP_GET(16, bus_p,
584 PCIE_ROOTCTL);
585 }
586
587 if (!PCIE_HAS_AER(bus_p))
588 return;
589
590 /* Gather UE AERs */
591 pcie_adv_regs->pcie_adv_ctl = PCIE_AER_GET(32, bus_p,
592 PCIE_AER_CTL);
593 pcie_adv_regs->pcie_ue_status = PCIE_AER_GET(32, bus_p,
594 PCIE_AER_UCE_STS);
595 pcie_adv_regs->pcie_ue_mask = PCIE_AER_GET(32, bus_p,
596 PCIE_AER_UCE_MASK);
597 pcie_adv_regs->pcie_ue_sev = PCIE_AER_GET(32, bus_p,
598 PCIE_AER_UCE_SERV);
599 PCIE_ADV_HDR(pfd_p, 0) = PCIE_AER_GET(32, bus_p,
600 PCIE_AER_HDR_LOG);
601 PCIE_ADV_HDR(pfd_p, 1) = PCIE_AER_GET(32, bus_p,
602 PCIE_AER_HDR_LOG + 0x4);
603 PCIE_ADV_HDR(pfd_p, 2) = PCIE_AER_GET(32, bus_p,
604 PCIE_AER_HDR_LOG + 0x8);
605 PCIE_ADV_HDR(pfd_p, 3) = PCIE_AER_GET(32, bus_p,
606 PCIE_AER_HDR_LOG + 0xc);
607
608 /* Gather CE AERs */
609 pcie_adv_regs->pcie_ce_status = PCIE_AER_GET(32, bus_p,
610 PCIE_AER_CE_STS);
611 pcie_adv_regs->pcie_ce_mask = PCIE_AER_GET(32, bus_p,
612 PCIE_AER_CE_MASK);
613
614 /*
615 * If pci express to pci bridge then grab the bridge
616 * error registers.
617 */
618 if (PCIE_IS_PCIE_BDG(bus_p)) {
619 pf_pcie_adv_bdg_err_regs_t *pcie_bdg_regs =
620 PCIE_ADV_BDG_REG(pfd_p);
621
622 pcie_bdg_regs->pcie_sue_ctl = PCIE_AER_GET(32, bus_p,
623 PCIE_AER_SCTL);
624 pcie_bdg_regs->pcie_sue_status = PCIE_AER_GET(32, bus_p,
625 PCIE_AER_SUCE_STS);
626 pcie_bdg_regs->pcie_sue_mask = PCIE_AER_GET(32, bus_p,
627 PCIE_AER_SUCE_MASK);
628 pcie_bdg_regs->pcie_sue_sev = PCIE_AER_GET(32, bus_p,
629 PCIE_AER_SUCE_SERV);
630 PCIE_ADV_BDG_HDR(pfd_p, 0) = PCIE_AER_GET(32, bus_p,
631 PCIE_AER_SHDR_LOG);
632 PCIE_ADV_BDG_HDR(pfd_p, 1) = PCIE_AER_GET(32, bus_p,
633 PCIE_AER_SHDR_LOG + 0x4);
634 PCIE_ADV_BDG_HDR(pfd_p, 2) = PCIE_AER_GET(32, bus_p,
635 PCIE_AER_SHDR_LOG + 0x8);
636 PCIE_ADV_BDG_HDR(pfd_p, 3) = PCIE_AER_GET(32, bus_p,
637 PCIE_AER_SHDR_LOG + 0xc);
638 }
639
640 /*
641 * If PCI Express root port then grab the root port
642 * error registers.
643 */
644 if (PCIE_IS_ROOT(bus_p)) {
645 pf_pcie_adv_rp_err_regs_t *pcie_rp_regs =
646 PCIE_ADV_RP_REG(pfd_p);
647
648 pcie_rp_regs->pcie_rp_err_cmd = PCIE_AER_GET(32, bus_p,
649 PCIE_AER_RE_CMD);
650 pcie_rp_regs->pcie_rp_err_status = PCIE_AER_GET(32, bus_p,
651 PCIE_AER_RE_STS);
652 pcie_rp_regs->pcie_rp_ce_src_id = PCIE_AER_GET(16, bus_p,
653 PCIE_AER_CE_SRC_ID);
654 pcie_rp_regs->pcie_rp_ue_src_id = PCIE_AER_GET(16, bus_p,
655 PCIE_AER_ERR_SRC_ID);
656 }
657 }
658
659 static void
pf_pci_regs_gather(pf_data_t * pfd_p,pcie_bus_t * bus_p)660 pf_pci_regs_gather(pf_data_t *pfd_p, pcie_bus_t *bus_p)
661 {
662 pf_pci_err_regs_t *pci_regs = PCI_ERR_REG(pfd_p);
663
664 /*
665 * Start by reading all the error registers that are available for
666 * pci and pci express and for leaf devices and bridges/switches
667 */
668 pci_regs->pci_err_status = PCIE_GET(16, bus_p, PCI_CONF_STAT);
669 pci_regs->pci_cfg_comm = PCIE_GET(16, bus_p, PCI_CONF_COMM);
670
671 /*
672 * If pci-pci bridge grab PCI bridge specific error registers.
673 */
674 if (PCIE_IS_BDG(bus_p)) {
675 pf_pci_bdg_err_regs_t *pci_bdg_regs = PCI_BDG_ERR_REG(pfd_p);
676 pci_bdg_regs->pci_bdg_sec_stat =
677 PCIE_GET(16, bus_p, PCI_BCNF_SEC_STATUS);
678 pci_bdg_regs->pci_bdg_ctrl =
679 PCIE_GET(16, bus_p, PCI_BCNF_BCNTRL);
680 }
681
682 /*
683 * If pci express device grab pci express error registers and
684 * check for advanced error reporting features and grab them if
685 * available.
686 */
687 if (PCIE_IS_PCIE(bus_p))
688 pf_pcie_regs_gather(pfd_p, bus_p);
689 else if (PCIE_IS_PCIX(bus_p))
690 pf_pcix_regs_gather(pfd_p, bus_p);
691
692 }
693
694 static void
pf_pcix_regs_clear(pf_data_t * pfd_p,pcie_bus_t * bus_p)695 pf_pcix_regs_clear(pf_data_t *pfd_p, pcie_bus_t *bus_p)
696 {
697 if (PCIE_IS_BDG(bus_p)) {
698 pf_pcix_bdg_err_regs_t *pcix_bdg_regs;
699
700 pcix_bdg_regs = PCIX_BDG_ERR_REG(pfd_p);
701
702 PCIX_CAP_PUT(16, bus_p, PCI_PCIX_SEC_STATUS,
703 pcix_bdg_regs->pcix_bdg_sec_stat);
704
705 PCIX_CAP_PUT(32, bus_p, PCI_PCIX_BDG_STATUS,
706 pcix_bdg_regs->pcix_bdg_stat);
707
708 if (PCIX_ECC_VERSION_CHECK(bus_p)) {
709 pf_pcix_ecc_regs_t *pcix_bdg_ecc_regs;
710 /*
711 * PCI Express to PCI-X bridges only implement the
712 * secondary side of the PCI-X ECC registers. For
713 * clearing, there is no need to "select" the ECC
714 * register, just write what was originally read.
715 */
716 if (!PCIE_IS_PCIE_BDG(bus_p)) {
717 pcix_bdg_ecc_regs = PCIX_BDG_ECC_REG(pfd_p, 0);
718 PCIX_CAP_PUT(32, bus_p, PCI_PCIX_BDG_ECC_STATUS,
719 pcix_bdg_ecc_regs->pcix_ecc_ctlstat);
720
721 }
722 pcix_bdg_ecc_regs = PCIX_BDG_ECC_REG(pfd_p, 1);
723 PCIX_CAP_PUT(32, bus_p, PCI_PCIX_BDG_ECC_STATUS,
724 pcix_bdg_ecc_regs->pcix_ecc_ctlstat);
725 }
726 } else {
727 pf_pcix_err_regs_t *pcix_regs = PCIX_ERR_REG(pfd_p);
728
729 PCIX_CAP_PUT(32, bus_p, PCI_PCIX_STATUS,
730 pcix_regs->pcix_status);
731
732 if (PCIX_ECC_VERSION_CHECK(bus_p)) {
733 pf_pcix_ecc_regs_t *pcix_ecc_regs = PCIX_ECC_REG(pfd_p);
734
735 PCIX_CAP_PUT(32, bus_p, PCI_PCIX_ECC_STATUS,
736 pcix_ecc_regs->pcix_ecc_ctlstat);
737 }
738 }
739 }
740
741 static void
pf_pcie_regs_clear(pf_data_t * pfd_p,pcie_bus_t * bus_p)742 pf_pcie_regs_clear(pf_data_t *pfd_p, pcie_bus_t *bus_p)
743 {
744 pf_pcie_err_regs_t *pcie_regs = PCIE_ERR_REG(pfd_p);
745 pf_pcie_adv_err_regs_t *pcie_adv_regs = PCIE_ADV_REG(pfd_p);
746
747 PCIE_CAP_PUT(16, bus_p, PCIE_DEVSTS, pcie_regs->pcie_err_status);
748
749 if (PCIE_IS_BDG(bus_p) && PCIE_IS_PCIX(bus_p))
750 pf_pcix_regs_clear(pfd_p, bus_p);
751
752 if (!PCIE_HAS_AER(bus_p))
753 return;
754
755 PCIE_AER_PUT(32, bus_p, PCIE_AER_UCE_STS,
756 pcie_adv_regs->pcie_ue_status);
757
758 PCIE_AER_PUT(32, bus_p, PCIE_AER_CE_STS,
759 pcie_adv_regs->pcie_ce_status);
760
761 if (PCIE_IS_PCIE_BDG(bus_p)) {
762 pf_pcie_adv_bdg_err_regs_t *pcie_bdg_regs =
763 PCIE_ADV_BDG_REG(pfd_p);
764
765 PCIE_AER_PUT(32, bus_p, PCIE_AER_SUCE_STS,
766 pcie_bdg_regs->pcie_sue_status);
767 }
768
769 /*
770 * If PCI Express root complex then clear the root complex
771 * error registers.
772 */
773 if (PCIE_IS_ROOT(bus_p)) {
774 pf_pcie_adv_rp_err_regs_t *pcie_rp_regs;
775
776 pcie_rp_regs = PCIE_ADV_RP_REG(pfd_p);
777
778 PCIE_AER_PUT(32, bus_p, PCIE_AER_RE_STS,
779 pcie_rp_regs->pcie_rp_err_status);
780 }
781 }
782
783 static void
pf_pci_regs_clear(pf_data_t * pfd_p,pcie_bus_t * bus_p)784 pf_pci_regs_clear(pf_data_t *pfd_p, pcie_bus_t *bus_p)
785 {
786 if (PCIE_IS_PCIE(bus_p))
787 pf_pcie_regs_clear(pfd_p, bus_p);
788 else if (PCIE_IS_PCIX(bus_p))
789 pf_pcix_regs_clear(pfd_p, bus_p);
790
791 PCIE_PUT(16, bus_p, PCI_CONF_STAT, pfd_p->pe_pci_regs->pci_err_status);
792
793 if (PCIE_IS_BDG(bus_p)) {
794 pf_pci_bdg_err_regs_t *pci_bdg_regs = PCI_BDG_ERR_REG(pfd_p);
795 PCIE_PUT(16, bus_p, PCI_BCNF_SEC_STATUS,
796 pci_bdg_regs->pci_bdg_sec_stat);
797 }
798 }
799
800 /* ARGSUSED */
801 void
pcie_clear_errors(dev_info_t * dip)802 pcie_clear_errors(dev_info_t *dip)
803 {
804 pcie_bus_t *bus_p = PCIE_DIP2BUS(dip);
805 pf_data_t *pfd_p = PCIE_DIP2PFD(dip);
806
807 ASSERT(bus_p);
808
809 pf_pci_regs_gather(pfd_p, bus_p);
810 pf_pci_regs_clear(pfd_p, bus_p);
811 }
812
813 /* Find the fault BDF, fault Addr or full scan on a PCIe Root Port. */
814 static void
pf_pci_find_rp_fault(pf_data_t * pfd_p,pcie_bus_t * bus_p)815 pf_pci_find_rp_fault(pf_data_t *pfd_p, pcie_bus_t *bus_p)
816 {
817 pf_root_fault_t *root_fault = PCIE_ROOT_FAULT(pfd_p);
818 pf_pcie_adv_rp_err_regs_t *rp_regs = PCIE_ADV_RP_REG(pfd_p);
819 uint32_t root_err = rp_regs->pcie_rp_err_status;
820 uint32_t ue_err = PCIE_ADV_REG(pfd_p)->pcie_ue_status;
821 int num_faults = 0;
822
823 /* Since this data structure is reused, make sure to reset it */
824 root_fault->full_scan = B_FALSE;
825 root_fault->scan_bdf = PCIE_INVALID_BDF;
826 root_fault->scan_addr = 0;
827
828 if (!PCIE_HAS_AER(bus_p) &&
829 (PCI_BDG_ERR_REG(pfd_p)->pci_bdg_sec_stat & PF_PCI_BDG_ERR)) {
830 PCIE_ROOT_FAULT(pfd_p)->full_scan = B_TRUE;
831 return;
832 }
833
834 /*
835 * Check to see if an error has been received that
836 * requires a scan of the fabric. Count the number of
837 * faults seen. If MUL CE/FE_NFE that counts for
838 * atleast 2 faults, so just return with full_scan.
839 */
840 if ((root_err & PCIE_AER_RE_STS_MUL_CE_RCVD) ||
841 (root_err & PCIE_AER_RE_STS_MUL_FE_NFE_RCVD)) {
842 PCIE_ROOT_FAULT(pfd_p)->full_scan = B_TRUE;
843 return;
844 }
845
846 if (root_err & PCIE_AER_RE_STS_CE_RCVD)
847 num_faults++;
848
849 if (root_err & PCIE_AER_RE_STS_FE_NFE_RCVD)
850 num_faults++;
851
852 if (ue_err & PCIE_AER_UCE_CA)
853 num_faults++;
854
855 if (ue_err & PCIE_AER_UCE_UR)
856 num_faults++;
857
858 /* If no faults just return */
859 if (num_faults == 0)
860 return;
861
862 /* If faults > 1 do full scan */
863 if (num_faults > 1) {
864 PCIE_ROOT_FAULT(pfd_p)->full_scan = B_TRUE;
865 return;
866 }
867
868 /* By this point, there is only 1 fault detected */
869 if (root_err & PCIE_AER_RE_STS_CE_RCVD) {
870 PCIE_ROOT_FAULT(pfd_p)->scan_bdf = rp_regs->pcie_rp_ce_src_id;
871 num_faults--;
872 } else if (root_err & PCIE_AER_RE_STS_FE_NFE_RCVD) {
873 PCIE_ROOT_FAULT(pfd_p)->scan_bdf = rp_regs->pcie_rp_ue_src_id;
874 num_faults--;
875 } else if ((HAS_AER_LOGS(pfd_p, PCIE_AER_UCE_CA) ||
876 HAS_AER_LOGS(pfd_p, PCIE_AER_UCE_UR)) &&
877 (pf_tlp_decode(PCIE_PFD2BUS(pfd_p), PCIE_ADV_REG(pfd_p)) ==
878 DDI_SUCCESS)) {
879 PCIE_ROOT_FAULT(pfd_p)->scan_addr =
880 PCIE_ADV_REG(pfd_p)->pcie_ue_tgt_addr;
881 num_faults--;
882 }
883
884 /*
885 * This means an error did occur, but we couldn't extract the fault BDF
886 */
887 if (num_faults > 0)
888 PCIE_ROOT_FAULT(pfd_p)->full_scan = B_TRUE;
889
890 }
891
892
893 /*
894 * Load PCIe Fault Data for PCI/PCIe devices into PCIe Fault Data Queue
895 *
896 * Returns a scan flag.
897 * o PF_SCAN_SUCCESS - Error gathered and cleared sucessfuly, data added to
898 * Fault Q
899 * o PF_SCAN_BAD_RESPONSE - Unable to talk to device, item added to fault Q
900 * o PF_SCAN_CB_FAILURE - A hardened device deemed that the error was fatal.
901 * o PF_SCAN_NO_ERR_IN_CHILD - Only applies to bridge to prevent further
902 * unnecessary scanning
903 * o PF_SCAN_IN_DQ - This device has already been scanned; it was skipped this
904 * time.
905 */
906 static int
pf_default_hdl(dev_info_t * dip,pf_impl_t * impl)907 pf_default_hdl(dev_info_t *dip, pf_impl_t *impl)
908 {
909 pcie_bus_t *bus_p = PCIE_DIP2BUS(dip);
910 pf_data_t *pfd_p = PCIE_DIP2PFD(dip);
911 int cb_sts, scan_flag = PF_SCAN_SUCCESS;
912
913 /* Make sure this device hasn't already been snapshotted and cleared */
914 if (pfd_p->pe_valid == B_TRUE) {
915 scan_flag |= PF_SCAN_IN_DQ;
916 goto done;
917 }
918
919 /*
920 * Read vendor/device ID and check with cached data, if it doesn't match
921 * could very well be a device that isn't responding anymore. Just
922 * stop. Save the basic info in the error q for post mortem debugging
923 * purposes.
924 */
925 if (PCIE_GET(32, bus_p, PCI_CONF_VENID) != bus_p->bus_dev_ven_id) {
926 char buf[FM_MAX_CLASS];
927
928 (void) snprintf(buf, FM_MAX_CLASS, "%s.%s",
929 PCI_ERROR_SUBCLASS, PCI_NR);
930 ddi_fm_ereport_post(dip, buf, fm_ena_generate(0, FM_ENA_FMT1),
931 DDI_NOSLEEP, FM_VERSION, DATA_TYPE_UINT8, 0, NULL);
932
933 /*
934 * For IOV/Hotplug purposes skip gathering info fo this device,
935 * but populate affected info and severity. Clear out any data
936 * that maybe been saved in the last fabric scan.
937 */
938 pf_reset_pfd(pfd_p);
939 pfd_p->pe_severity_flags = PF_ERR_PANIC_BAD_RESPONSE;
940 PFD_AFFECTED_DEV(pfd_p)->pe_affected_flags = PF_AFFECTED_SELF;
941
942 /* Add the snapshot to the error q */
943 pf_en_dq(pfd_p, impl);
944 pfd_p->pe_valid = B_TRUE;
945
946 return (PF_SCAN_BAD_RESPONSE);
947 }
948
949 pf_pci_regs_gather(pfd_p, bus_p);
950 pf_pci_regs_clear(pfd_p, bus_p);
951 if (PCIE_IS_RP(bus_p))
952 pf_pci_find_rp_fault(pfd_p, bus_p);
953
954 cb_sts = pf_fm_callback(dip, impl->pf_derr);
955
956 if (cb_sts == DDI_FM_FATAL || cb_sts == DDI_FM_UNKNOWN)
957 scan_flag |= PF_SCAN_CB_FAILURE;
958
959 /* Add the snapshot to the error q */
960 pf_en_dq(pfd_p, impl);
961
962 done:
963 /*
964 * If a bridge does not have any error no need to scan any further down.
965 * For PCIe devices, check the PCIe device status and PCI secondary
966 * status.
967 * - Some non-compliant PCIe devices do not utilize PCIe
968 * error registers. If so rely on legacy PCI error registers.
969 * For PCI devices, check the PCI secondary status.
970 */
971 if (PCIE_IS_PCIE_BDG(bus_p) &&
972 !(PCIE_ERR_REG(pfd_p)->pcie_err_status & PF_PCIE_BDG_ERR) &&
973 !(PCI_BDG_ERR_REG(pfd_p)->pci_bdg_sec_stat & PF_PCI_BDG_ERR))
974 scan_flag |= PF_SCAN_NO_ERR_IN_CHILD;
975
976 if (PCIE_IS_PCI_BDG(bus_p) &&
977 !(PCI_BDG_ERR_REG(pfd_p)->pci_bdg_sec_stat & PF_PCI_BDG_ERR))
978 scan_flag |= PF_SCAN_NO_ERR_IN_CHILD;
979
980 pfd_p->pe_valid = B_TRUE;
981 return (scan_flag);
982 }
983
984 /*
985 * Called during postattach to initialize a device's error handling
986 * capabilities. If the devices has already been hardened, then there isn't
987 * much needed. Otherwise initialize the device's default FMA capabilities.
988 *
989 * In a future project where PCIe support is removed from pcifm, several
990 * "properties" that are setup in ddi_fm_init and pci_ereport_setup need to be
991 * created here so that the PCI/PCIe eversholt rules will work properly.
992 */
993 void
pf_init(dev_info_t * dip,ddi_iblock_cookie_t ibc,ddi_attach_cmd_t cmd)994 pf_init(dev_info_t *dip, ddi_iblock_cookie_t ibc, ddi_attach_cmd_t cmd)
995 {
996 pcie_bus_t *bus_p = PCIE_DIP2BUS(dip);
997 struct i_ddi_fmhdl *fmhdl = DEVI(dip)->devi_fmhdl;
998 boolean_t need_cb_register = B_FALSE;
999
1000 if (!bus_p) {
1001 cmn_err(CE_WARN, "devi_bus information is not set for %s%d.\n",
1002 ddi_driver_name(dip), ddi_get_instance(dip));
1003 return;
1004 }
1005
1006 if (fmhdl) {
1007 /*
1008 * If device is only ereport capable and not callback capable
1009 * make it callback capable. The only downside is that the
1010 * "fm-errcb-capable" property is not created for this device
1011 * which should be ok since it's not used anywhere.
1012 */
1013 if (!(fmhdl->fh_cap & DDI_FM_ERRCB_CAPABLE))
1014 need_cb_register = B_TRUE;
1015 } else {
1016 int cap;
1017 /*
1018 * fm-capable in driver.conf can be used to set fm_capabilities.
1019 * If fm-capable is not defined, set the default
1020 * DDI_FM_EREPORT_CAPABLE and DDI_FM_ERRCB_CAPABLE.
1021 */
1022 cap = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
1023 DDI_PROP_DONTPASS, "fm-capable",
1024 DDI_FM_EREPORT_CAPABLE | DDI_FM_ERRCB_CAPABLE);
1025 cap &= (DDI_FM_EREPORT_CAPABLE | DDI_FM_ERRCB_CAPABLE);
1026
1027 bus_p->bus_fm_flags |= PF_FM_IS_NH;
1028
1029 if (cmd == DDI_ATTACH) {
1030 ddi_fm_init(dip, &cap, &ibc);
1031 pci_ereport_setup(dip);
1032 }
1033
1034 if (cap & DDI_FM_ERRCB_CAPABLE)
1035 need_cb_register = B_TRUE;
1036
1037 fmhdl = DEVI(dip)->devi_fmhdl;
1038 }
1039
1040 /* If ddi_fm_init fails for any reason RETURN */
1041 if (!fmhdl) {
1042 bus_p->bus_fm_flags = 0;
1043 return;
1044 }
1045
1046 fmhdl->fh_cap |= DDI_FM_ERRCB_CAPABLE;
1047 if (cmd == DDI_ATTACH) {
1048 if (need_cb_register)
1049 ddi_fm_handler_register(dip, pf_dummy_cb, NULL);
1050 }
1051
1052 bus_p->bus_fm_flags |= PF_FM_READY;
1053 }
1054
1055 /* undo FMA lock, called at predetach */
1056 void
pf_fini(dev_info_t * dip,ddi_detach_cmd_t cmd)1057 pf_fini(dev_info_t *dip, ddi_detach_cmd_t cmd)
1058 {
1059 pcie_bus_t *bus_p = PCIE_DIP2BUS(dip);
1060
1061 if (!bus_p)
1062 return;
1063
1064 /* Don't fini anything if device isn't FM Ready */
1065 if (!(bus_p->bus_fm_flags & PF_FM_READY))
1066 return;
1067
1068 /* no other code should set the flag to false */
1069 bus_p->bus_fm_flags &= ~PF_FM_READY;
1070
1071 /*
1072 * Grab the mutex to make sure device isn't in the middle of
1073 * error handling. Setting the bus_fm_flag to ~PF_FM_READY
1074 * should prevent this device from being error handled after
1075 * the mutex has been released.
1076 */
1077 (void) pf_handler_enter(dip, NULL);
1078 pf_handler_exit(dip);
1079
1080 /* undo non-hardened drivers */
1081 if (bus_p->bus_fm_flags & PF_FM_IS_NH) {
1082 if (cmd == DDI_DETACH) {
1083 bus_p->bus_fm_flags &= ~PF_FM_IS_NH;
1084 pci_ereport_teardown(dip);
1085 /*
1086 * ddi_fini itself calls ddi_handler_unregister,
1087 * so no need to explicitly call unregister.
1088 */
1089 ddi_fm_fini(dip);
1090 }
1091 }
1092 }
1093
1094 /*ARGSUSED*/
1095 static int
pf_dummy_cb(dev_info_t * dip,ddi_fm_error_t * derr,const void * not_used)1096 pf_dummy_cb(dev_info_t *dip, ddi_fm_error_t *derr, const void *not_used)
1097 {
1098 return (DDI_FM_OK);
1099 }
1100
1101 /*
1102 * Add PFD to queue. If it is an RC add it to the beginning,
1103 * otherwise add it to the end.
1104 */
1105 static void
pf_en_dq(pf_data_t * pfd_p,pf_impl_t * impl)1106 pf_en_dq(pf_data_t *pfd_p, pf_impl_t *impl)
1107 {
1108 pf_data_t *head_p = impl->pf_dq_head_p;
1109 pf_data_t *tail_p = impl->pf_dq_tail_p;
1110
1111 impl->pf_total++;
1112
1113 if (!head_p) {
1114 ASSERT(PFD_IS_ROOT(pfd_p));
1115 impl->pf_dq_head_p = pfd_p;
1116 impl->pf_dq_tail_p = pfd_p;
1117 pfd_p->pe_prev = NULL;
1118 pfd_p->pe_next = NULL;
1119 return;
1120 }
1121
1122 /* Check if this is a Root Port eprt */
1123 if (PFD_IS_ROOT(pfd_p)) {
1124 pf_data_t *root_p, *last_p = NULL;
1125
1126 /* The first item must be a RP */
1127 root_p = head_p;
1128 for (last_p = head_p; last_p && PFD_IS_ROOT(last_p);
1129 last_p = last_p->pe_next)
1130 root_p = last_p;
1131
1132 /* root_p is the last RP pfd. last_p is the first non-RP pfd. */
1133 root_p->pe_next = pfd_p;
1134 pfd_p->pe_prev = root_p;
1135 pfd_p->pe_next = last_p;
1136
1137 if (last_p)
1138 last_p->pe_prev = pfd_p;
1139 else
1140 tail_p = pfd_p;
1141 } else {
1142 tail_p->pe_next = pfd_p;
1143 pfd_p->pe_prev = tail_p;
1144 pfd_p->pe_next = NULL;
1145 tail_p = pfd_p;
1146 }
1147
1148 impl->pf_dq_head_p = head_p;
1149 impl->pf_dq_tail_p = tail_p;
1150 }
1151
1152 /*
1153 * Ignore:
1154 * - TRAINING: as leaves do not have children
1155 * - SD: as leaves do not have children
1156 */
1157 const pf_fab_err_tbl_t pcie_pcie_tbl[] = {
1158 {PCIE_AER_UCE_DLP, pf_panic,
1159 PF_AFFECTED_PARENT, 0},
1160
1161 {PCIE_AER_UCE_PTLP, pf_analyse_ptlp,
1162 PF_AFFECTED_SELF, 0},
1163
1164 {PCIE_AER_UCE_FCP, pf_panic,
1165 PF_AFFECTED_PARENT, 0},
1166
1167 {PCIE_AER_UCE_TO, pf_analyse_to,
1168 PF_AFFECTED_SELF, 0},
1169
1170 {PCIE_AER_UCE_CA, pf_analyse_ca_ur,
1171 PF_AFFECTED_SELF, 0},
1172
1173 {PCIE_AER_UCE_UC, pf_analyse_uc,
1174 0, 0},
1175
1176 {PCIE_AER_UCE_RO, pf_panic,
1177 PF_AFFECTED_PARENT, 0},
1178
1179 {PCIE_AER_UCE_MTLP, pf_panic,
1180 PF_AFFECTED_PARENT, 0},
1181
1182 {PCIE_AER_UCE_ECRC, pf_panic,
1183 PF_AFFECTED_SELF, 0},
1184
1185 {PCIE_AER_UCE_UR, pf_analyse_ca_ur,
1186 PF_AFFECTED_SELF, 0},
1187
1188 {NULL, NULL, NULL, NULL}
1189 };
1190
1191 const pf_fab_err_tbl_t pcie_rp_tbl[] = {
1192 {PCIE_AER_UCE_TRAINING, pf_no_panic,
1193 PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN, 0},
1194
1195 {PCIE_AER_UCE_DLP, pf_panic,
1196 PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN, 0},
1197
1198 {PCIE_AER_UCE_SD, pf_no_panic,
1199 PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN, 0},
1200
1201 {PCIE_AER_UCE_PTLP, pf_analyse_ptlp,
1202 PF_AFFECTED_AER, PF_AFFECTED_CHILDREN},
1203
1204 {PCIE_AER_UCE_FCP, pf_panic,
1205 PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN, 0},
1206
1207 {PCIE_AER_UCE_TO, pf_panic,
1208 PF_AFFECTED_ADDR, PF_AFFECTED_CHILDREN},
1209
1210 {PCIE_AER_UCE_CA, pf_no_panic,
1211 PF_AFFECTED_AER, PF_AFFECTED_CHILDREN},
1212
1213 {PCIE_AER_UCE_UC, pf_analyse_uc,
1214 0, 0},
1215
1216 {PCIE_AER_UCE_RO, pf_panic,
1217 PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN, 0},
1218
1219 {PCIE_AER_UCE_MTLP, pf_panic,
1220 PF_AFFECTED_SELF | PF_AFFECTED_AER,
1221 PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN},
1222
1223 {PCIE_AER_UCE_ECRC, pf_panic,
1224 PF_AFFECTED_AER, PF_AFFECTED_CHILDREN},
1225
1226 {PCIE_AER_UCE_UR, pf_no_panic,
1227 PF_AFFECTED_AER, PF_AFFECTED_CHILDREN},
1228
1229 {NULL, NULL, NULL, NULL}
1230 };
1231
1232 const pf_fab_err_tbl_t pcie_sw_tbl[] = {
1233 {PCIE_AER_UCE_TRAINING, pf_no_panic,
1234 PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN, 0},
1235
1236 {PCIE_AER_UCE_DLP, pf_panic,
1237 PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN, 0},
1238
1239 {PCIE_AER_UCE_SD, pf_no_panic,
1240 PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN, 0},
1241
1242 {PCIE_AER_UCE_PTLP, pf_analyse_ptlp,
1243 PF_AFFECTED_AER, PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN},
1244
1245 {PCIE_AER_UCE_FCP, pf_panic,
1246 PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN, 0},
1247
1248 {PCIE_AER_UCE_TO, pf_analyse_to,
1249 PF_AFFECTED_CHILDREN, 0},
1250
1251 {PCIE_AER_UCE_CA, pf_analyse_ca_ur,
1252 PF_AFFECTED_AER, PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN},
1253
1254 {PCIE_AER_UCE_UC, pf_analyse_uc,
1255 0, 0},
1256
1257 {PCIE_AER_UCE_RO, pf_panic,
1258 PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN, 0},
1259
1260 {PCIE_AER_UCE_MTLP, pf_panic,
1261 PF_AFFECTED_SELF | PF_AFFECTED_AER,
1262 PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN},
1263
1264 {PCIE_AER_UCE_ECRC, pf_panic,
1265 PF_AFFECTED_AER, PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN},
1266
1267 {PCIE_AER_UCE_UR, pf_analyse_ca_ur,
1268 PF_AFFECTED_AER, PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN},
1269
1270 {NULL, NULL, NULL, NULL}
1271 };
1272
1273 const pf_fab_err_tbl_t pcie_pcie_bdg_tbl[] = {
1274 {PCIE_AER_SUCE_TA_ON_SC, pf_analyse_sc,
1275 0, 0},
1276
1277 {PCIE_AER_SUCE_MA_ON_SC, pf_analyse_sc,
1278 0, 0},
1279
1280 {PCIE_AER_SUCE_RCVD_TA, pf_analyse_ma_ta,
1281 0, 0},
1282
1283 {PCIE_AER_SUCE_RCVD_MA, pf_analyse_ma_ta,
1284 0, 0},
1285
1286 {PCIE_AER_SUCE_USC_ERR, pf_panic,
1287 PF_AFFECTED_SAER, PF_AFFECTED_CHILDREN},
1288
1289 {PCIE_AER_SUCE_USC_MSG_DATA_ERR, pf_analyse_ma_ta,
1290 PF_AFFECTED_SAER, PF_AFFECTED_CHILDREN},
1291
1292 {PCIE_AER_SUCE_UC_DATA_ERR, pf_analyse_uc_data,
1293 PF_AFFECTED_SAER, PF_AFFECTED_CHILDREN},
1294
1295 {PCIE_AER_SUCE_UC_ATTR_ERR, pf_panic,
1296 PF_AFFECTED_CHILDREN, 0},
1297
1298 {PCIE_AER_SUCE_UC_ADDR_ERR, pf_panic,
1299 PF_AFFECTED_CHILDREN, 0},
1300
1301 {PCIE_AER_SUCE_TIMER_EXPIRED, pf_panic,
1302 PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN, 0},
1303
1304 {PCIE_AER_SUCE_PERR_ASSERT, pf_analyse_perr_assert,
1305 0, 0},
1306
1307 {PCIE_AER_SUCE_SERR_ASSERT, pf_no_panic,
1308 0, 0},
1309
1310 {PCIE_AER_SUCE_INTERNAL_ERR, pf_panic,
1311 PF_AFFECTED_SELF | PF_AFFECTED_CHILDREN, 0},
1312
1313 {NULL, NULL, NULL, NULL}
1314 };
1315
1316 const pf_fab_err_tbl_t pcie_pci_bdg_tbl[] = {
1317 {PCI_STAT_PERROR, pf_analyse_pci,
1318 PF_AFFECTED_SELF, 0},
1319
1320 {PCI_STAT_S_PERROR, pf_analyse_pci,
1321 PF_AFFECTED_SELF, 0},
1322
1323 {PCI_STAT_S_SYSERR, pf_panic,
1324 PF_AFFECTED_SELF, 0},
1325
1326 {PCI_STAT_R_MAST_AB, pf_analyse_pci,
1327 PF_AFFECTED_SELF, 0},
1328
1329 {PCI_STAT_R_TARG_AB, pf_analyse_pci,
1330 PF_AFFECTED_SELF, 0},
1331
1332 {PCI_STAT_S_TARG_AB, pf_analyse_pci,
1333 PF_AFFECTED_SELF, 0},
1334
1335 {NULL, NULL, NULL, NULL}
1336 };
1337
1338 const pf_fab_err_tbl_t pcie_pci_tbl[] = {
1339 {PCI_STAT_PERROR, pf_analyse_pci,
1340 PF_AFFECTED_SELF, 0},
1341
1342 {PCI_STAT_S_PERROR, pf_analyse_pci,
1343 PF_AFFECTED_SELF, 0},
1344
1345 {PCI_STAT_S_SYSERR, pf_panic,
1346 PF_AFFECTED_SELF, 0},
1347
1348 {PCI_STAT_R_MAST_AB, pf_analyse_pci,
1349 PF_AFFECTED_SELF, 0},
1350
1351 {PCI_STAT_R_TARG_AB, pf_analyse_pci,
1352 PF_AFFECTED_SELF, 0},
1353
1354 {PCI_STAT_S_TARG_AB, pf_analyse_pci,
1355 PF_AFFECTED_SELF, 0},
1356
1357 {NULL, NULL, NULL, NULL}
1358 };
1359
1360 #define PF_MASKED_AER_ERR(pfd_p) \
1361 (PCIE_ADV_REG(pfd_p)->pcie_ue_status & \
1362 ((PCIE_ADV_REG(pfd_p)->pcie_ue_mask) ^ 0xFFFFFFFF))
1363 #define PF_MASKED_SAER_ERR(pfd_p) \
1364 (PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_status & \
1365 ((PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_mask) ^ 0xFFFFFFFF))
1366 /*
1367 * Analyse all the PCIe Fault Data (erpt) gathered during dispatch in the erpt
1368 * Queue.
1369 */
1370 static int
pf_analyse_error(ddi_fm_error_t * derr,pf_impl_t * impl)1371 pf_analyse_error(ddi_fm_error_t *derr, pf_impl_t *impl)
1372 {
1373 int sts_flags, error_flags = 0;
1374 pf_data_t *pfd_p;
1375
1376 for (pfd_p = impl->pf_dq_head_p; pfd_p; pfd_p = pfd_p->pe_next) {
1377 sts_flags = 0;
1378
1379 /* skip analysing error when no error info is gathered */
1380 if (pfd_p->pe_severity_flags == PF_ERR_PANIC_BAD_RESPONSE)
1381 goto done;
1382
1383 switch (PCIE_PFD2BUS(pfd_p)->bus_dev_type) {
1384 case PCIE_PCIECAP_DEV_TYPE_PCIE_DEV:
1385 case PCIE_PCIECAP_DEV_TYPE_PCI_DEV:
1386 if (PCIE_DEVSTS_CE_DETECTED &
1387 PCIE_ERR_REG(pfd_p)->pcie_err_status)
1388 sts_flags |= PF_ERR_CE;
1389
1390 pf_adjust_for_no_aer(pfd_p);
1391 sts_flags |= pf_analyse_error_tbl(derr, impl,
1392 pfd_p, pcie_pcie_tbl, PF_MASKED_AER_ERR(pfd_p));
1393 break;
1394 case PCIE_PCIECAP_DEV_TYPE_ROOT:
1395 pf_adjust_for_no_aer(pfd_p);
1396 sts_flags |= pf_analyse_error_tbl(derr, impl,
1397 pfd_p, pcie_rp_tbl, PF_MASKED_AER_ERR(pfd_p));
1398 break;
1399 case PCIE_PCIECAP_DEV_TYPE_RC_PSEUDO:
1400 /* no adjust_for_aer for pseudo RC */
1401 /* keep the severity passed on from RC if any */
1402 sts_flags |= pfd_p->pe_severity_flags;
1403 sts_flags |= pf_analyse_error_tbl(derr, impl, pfd_p,
1404 pcie_rp_tbl, PF_MASKED_AER_ERR(pfd_p));
1405 break;
1406 case PCIE_PCIECAP_DEV_TYPE_UP:
1407 case PCIE_PCIECAP_DEV_TYPE_DOWN:
1408 if (PCIE_DEVSTS_CE_DETECTED &
1409 PCIE_ERR_REG(pfd_p)->pcie_err_status)
1410 sts_flags |= PF_ERR_CE;
1411
1412 pf_adjust_for_no_aer(pfd_p);
1413 sts_flags |= pf_analyse_error_tbl(derr, impl,
1414 pfd_p, pcie_sw_tbl, PF_MASKED_AER_ERR(pfd_p));
1415 break;
1416 case PCIE_PCIECAP_DEV_TYPE_PCIE2PCI:
1417 if (PCIE_DEVSTS_CE_DETECTED &
1418 PCIE_ERR_REG(pfd_p)->pcie_err_status)
1419 sts_flags |= PF_ERR_CE;
1420
1421 pf_adjust_for_no_aer(pfd_p);
1422 pf_adjust_for_no_saer(pfd_p);
1423 sts_flags |= pf_analyse_error_tbl(derr,
1424 impl, pfd_p, pcie_pcie_tbl,
1425 PF_MASKED_AER_ERR(pfd_p));
1426 sts_flags |= pf_analyse_error_tbl(derr,
1427 impl, pfd_p, pcie_pcie_bdg_tbl,
1428 PF_MASKED_SAER_ERR(pfd_p));
1429 /*
1430 * Some non-compliant PCIe devices do not utilize PCIe
1431 * error registers. So fallthrough and rely on legacy
1432 * PCI error registers.
1433 */
1434 if ((PCIE_DEVSTS_NFE_DETECTED | PCIE_DEVSTS_FE_DETECTED)
1435 & PCIE_ERR_REG(pfd_p)->pcie_err_status)
1436 break;
1437 /* FALLTHROUGH */
1438 case PCIE_PCIECAP_DEV_TYPE_PCI_PSEUDO:
1439 sts_flags |= pf_analyse_error_tbl(derr, impl,
1440 pfd_p, pcie_pci_tbl,
1441 PCI_ERR_REG(pfd_p)->pci_err_status);
1442
1443 if (!PCIE_IS_BDG(PCIE_PFD2BUS(pfd_p)))
1444 break;
1445
1446 sts_flags |= pf_analyse_error_tbl(derr,
1447 impl, pfd_p, pcie_pci_bdg_tbl,
1448 PCI_BDG_ERR_REG(pfd_p)->pci_bdg_sec_stat);
1449 }
1450
1451 pfd_p->pe_severity_flags = sts_flags;
1452
1453 done:
1454 pfd_p->pe_orig_severity_flags = pfd_p->pe_severity_flags;
1455 /* Have pciev_eh adjust the severity */
1456 pfd_p->pe_severity_flags = pciev_eh(pfd_p, impl);
1457
1458 error_flags |= pfd_p->pe_severity_flags;
1459 }
1460
1461 return (error_flags);
1462 }
1463
1464 static int
pf_analyse_error_tbl(ddi_fm_error_t * derr,pf_impl_t * impl,pf_data_t * pfd_p,const pf_fab_err_tbl_t * tbl,uint32_t err_reg)1465 pf_analyse_error_tbl(ddi_fm_error_t *derr, pf_impl_t *impl,
1466 pf_data_t *pfd_p, const pf_fab_err_tbl_t *tbl, uint32_t err_reg)
1467 {
1468 const pf_fab_err_tbl_t *row;
1469 int err = 0;
1470 uint16_t flags;
1471 uint32_t bit;
1472
1473 for (row = tbl; err_reg && (row->bit != NULL); row++) {
1474 bit = row->bit;
1475 if (!(err_reg & bit))
1476 continue;
1477 err |= row->handler(derr, bit, impl->pf_dq_head_p, pfd_p);
1478
1479 flags = row->affected_flags;
1480 /*
1481 * check if the primary flag is valid;
1482 * if not, use the secondary flag
1483 */
1484 if (flags & PF_AFFECTED_AER) {
1485 if (!HAS_AER_LOGS(pfd_p, bit)) {
1486 flags = row->sec_affected_flags;
1487 }
1488 } else if (flags & PF_AFFECTED_SAER) {
1489 if (!HAS_SAER_LOGS(pfd_p, bit)) {
1490 flags = row->sec_affected_flags;
1491 }
1492 } else if (flags & PF_AFFECTED_ADDR) {
1493 /* only Root has this flag */
1494 if (PCIE_ROOT_FAULT(pfd_p)->scan_addr == 0) {
1495 flags = row->sec_affected_flags;
1496 }
1497 }
1498
1499 PFD_AFFECTED_DEV(pfd_p)->pe_affected_flags |= flags;
1500 }
1501
1502 if (!err)
1503 err = PF_ERR_NO_ERROR;
1504
1505 return (err);
1506 }
1507
1508 /*
1509 * PCIe Completer Abort and Unsupport Request error analyser. If a PCIe device
1510 * issues a CA/UR a corresponding Received CA/UR should have been seen in the
1511 * PCIe root complex. Check to see if RC did indeed receive a CA/UR, if so then
1512 * this error may be safely ignored. If not check the logs and see if an
1513 * associated handler for this transaction can be found.
1514 */
1515 /* ARGSUSED */
1516 static int
pf_analyse_ca_ur(ddi_fm_error_t * derr,uint32_t bit,pf_data_t * dq_head_p,pf_data_t * pfd_p)1517 pf_analyse_ca_ur(ddi_fm_error_t *derr, uint32_t bit, pf_data_t *dq_head_p,
1518 pf_data_t *pfd_p)
1519 {
1520 uint32_t abort_type;
1521 dev_info_t *rpdip = PCIE_PFD2BUS(pfd_p)->bus_rp_dip;
1522
1523 /* If UR's are masked forgive this error */
1524 if ((pcie_get_aer_uce_mask() & PCIE_AER_UCE_UR) &&
1525 (bit == PCIE_AER_UCE_UR))
1526 return (PF_ERR_NO_PANIC);
1527
1528 /*
1529 * If a RP has an CA/UR it means a leaf sent a bad request to the RP
1530 * such as a config read or a bad DMA address.
1531 */
1532 if (PCIE_IS_RP(PCIE_PFD2BUS(pfd_p)))
1533 goto handle_lookup;
1534
1535 if (bit == PCIE_AER_UCE_UR)
1536 abort_type = PCI_STAT_R_MAST_AB;
1537 else
1538 abort_type = PCI_STAT_R_TARG_AB;
1539
1540 if (pf_matched_in_rc(dq_head_p, pfd_p, abort_type))
1541 return (PF_ERR_MATCHED_RC);
1542
1543 handle_lookup:
1544 if (HAS_AER_LOGS(pfd_p, bit) &&
1545 pf_log_hdl_lookup(rpdip, derr, pfd_p, B_TRUE) == PF_HDL_FOUND)
1546 return (PF_ERR_MATCHED_DEVICE);
1547
1548 return (PF_ERR_PANIC);
1549 }
1550
1551 /*
1552 * PCIe-PCI Bridge Received Master Abort and Target error analyser. If a PCIe
1553 * Bridge receives a MA/TA a corresponding sent CA/UR should have been seen in
1554 * the PCIe root complex. Check to see if RC did indeed receive a CA/UR, if so
1555 * then this error may be safely ignored. If not check the logs and see if an
1556 * associated handler for this transaction can be found.
1557 */
1558 /* ARGSUSED */
1559 static int
pf_analyse_ma_ta(ddi_fm_error_t * derr,uint32_t bit,pf_data_t * dq_head_p,pf_data_t * pfd_p)1560 pf_analyse_ma_ta(ddi_fm_error_t *derr, uint32_t bit, pf_data_t *dq_head_p,
1561 pf_data_t *pfd_p)
1562 {
1563 dev_info_t *rpdip = PCIE_PFD2BUS(pfd_p)->bus_rp_dip;
1564 uint32_t abort_type;
1565
1566 /* If UR's are masked forgive this error */
1567 if ((pcie_get_aer_uce_mask() & PCIE_AER_UCE_UR) &&
1568 (bit == PCIE_AER_SUCE_RCVD_MA))
1569 return (PF_ERR_NO_PANIC);
1570
1571 if (bit == PCIE_AER_SUCE_RCVD_MA)
1572 abort_type = PCI_STAT_R_MAST_AB;
1573 else
1574 abort_type = PCI_STAT_R_TARG_AB;
1575
1576 if (pf_matched_in_rc(dq_head_p, pfd_p, abort_type))
1577 return (PF_ERR_MATCHED_RC);
1578
1579 if (!HAS_SAER_LOGS(pfd_p, bit))
1580 return (PF_ERR_PANIC);
1581
1582 if (pf_log_hdl_lookup(rpdip, derr, pfd_p, B_FALSE) == PF_HDL_FOUND)
1583 return (PF_ERR_MATCHED_DEVICE);
1584
1585 return (PF_ERR_PANIC);
1586 }
1587
1588 /*
1589 * Generic PCI error analyser. This function is used for Parity Errors,
1590 * Received Master Aborts, Received Target Aborts, and Signaled Target Aborts.
1591 * In general PCI devices do not have error logs, it is very difficult to figure
1592 * out what transaction caused the error. Instead find the nearest PCIe-PCI
1593 * Bridge and check to see if it has logs and if it has an error associated with
1594 * this PCI Device.
1595 */
1596 /* ARGSUSED */
1597 static int
pf_analyse_pci(ddi_fm_error_t * derr,uint32_t bit,pf_data_t * dq_head_p,pf_data_t * pfd_p)1598 pf_analyse_pci(ddi_fm_error_t *derr, uint32_t bit, pf_data_t *dq_head_p,
1599 pf_data_t *pfd_p)
1600 {
1601 pf_data_t *parent_pfd_p;
1602 uint16_t cmd;
1603 uint32_t aer_ue_status;
1604 pcie_bus_t *bus_p = PCIE_PFD2BUS(pfd_p);
1605 pf_pcie_adv_bdg_err_regs_t *parent_saer_p;
1606
1607 if (PCI_ERR_REG(pfd_p)->pci_err_status & PCI_STAT_S_SYSERR)
1608 return (PF_ERR_PANIC);
1609
1610 /* If UR's are masked forgive this error */
1611 if ((pcie_get_aer_uce_mask() & PCIE_AER_UCE_UR) &&
1612 (bit == PCI_STAT_R_MAST_AB))
1613 return (PF_ERR_NO_PANIC);
1614
1615
1616 if (bit & (PCI_STAT_PERROR | PCI_STAT_S_PERROR)) {
1617 aer_ue_status = PCIE_AER_SUCE_PERR_ASSERT;
1618 } else {
1619 aer_ue_status = (PCIE_AER_SUCE_TA_ON_SC |
1620 PCIE_AER_SUCE_MA_ON_SC | PCIE_AER_SUCE_RCVD_TA |
1621 PCIE_AER_SUCE_RCVD_MA);
1622 }
1623
1624 parent_pfd_p = pf_get_parent_pcie_bridge(pfd_p);
1625 if (parent_pfd_p == NULL)
1626 return (PF_ERR_PANIC);
1627
1628 /* Check if parent bridge has seen this error */
1629 parent_saer_p = PCIE_ADV_BDG_REG(parent_pfd_p);
1630 if (!(parent_saer_p->pcie_sue_status & aer_ue_status) ||
1631 !HAS_SAER_LOGS(parent_pfd_p, aer_ue_status))
1632 return (PF_ERR_PANIC);
1633
1634 /*
1635 * If the addr or bdf from the parent PCIe bridge logs belong to this
1636 * PCI device, assume the PCIe bridge's error handling has already taken
1637 * care of this PCI device's error.
1638 */
1639 if (pf_pci_decode(parent_pfd_p, &cmd) != DDI_SUCCESS)
1640 return (PF_ERR_PANIC);
1641
1642 if ((parent_saer_p->pcie_sue_tgt_bdf == bus_p->bus_bdf) ||
1643 pf_in_addr_range(bus_p, parent_saer_p->pcie_sue_tgt_addr))
1644 return (PF_ERR_MATCHED_PARENT);
1645
1646 /*
1647 * If this device is a PCI-PCI bridge, check if the bdf in the parent
1648 * PCIe bridge logs is in the range of this PCI-PCI Bridge's bus ranges.
1649 * If they are, then assume the PCIe bridge's error handling has already
1650 * taken care of this PCI-PCI bridge device's error.
1651 */
1652 if (PCIE_IS_BDG(bus_p) &&
1653 pf_in_bus_range(bus_p, parent_saer_p->pcie_sue_tgt_bdf))
1654 return (PF_ERR_MATCHED_PARENT);
1655
1656 return (PF_ERR_PANIC);
1657 }
1658
1659 /*
1660 * PCIe Bridge transactions associated with PERR.
1661 * o Bridge received a poisoned Non-Posted Write (CFG Writes) from PCIe
1662 * o Bridge received a poisoned Posted Write from (MEM Writes) from PCIe
1663 * o Bridge received a poisoned Completion on a Split Transction from PCIe
1664 * o Bridge received a poisoned Completion on a Delayed Transction from PCIe
1665 *
1666 * Check for non-poisoned PCIe transactions that got forwarded to the secondary
1667 * side and detects a PERR#. Except for delayed read completions, a poisoned
1668 * TLP will be forwarded to the secondary bus and PERR# will be asserted.
1669 */
1670 /* ARGSUSED */
1671 static int
pf_analyse_perr_assert(ddi_fm_error_t * derr,uint32_t bit,pf_data_t * dq_head_p,pf_data_t * pfd_p)1672 pf_analyse_perr_assert(ddi_fm_error_t *derr, uint32_t bit, pf_data_t *dq_head_p,
1673 pf_data_t *pfd_p)
1674 {
1675 dev_info_t *rpdip = PCIE_PFD2BUS(pfd_p)->bus_rp_dip;
1676 uint16_t cmd;
1677 int hdl_sts = PF_HDL_NOTFOUND;
1678 int err = PF_ERR_NO_ERROR;
1679 pf_pcie_adv_bdg_err_regs_t *saer_p;
1680
1681
1682 if (HAS_SAER_LOGS(pfd_p, bit)) {
1683 saer_p = PCIE_ADV_BDG_REG(pfd_p);
1684 if (pf_pci_decode(pfd_p, &cmd) != DDI_SUCCESS)
1685 return (PF_ERR_PANIC);
1686
1687 cmd_switch:
1688 switch (cmd) {
1689 case PCI_PCIX_CMD_IOWR:
1690 case PCI_PCIX_CMD_MEMWR:
1691 case PCI_PCIX_CMD_MEMWR_BL:
1692 case PCI_PCIX_CMD_MEMWRBL:
1693 /* Posted Writes Transactions */
1694 if (saer_p->pcie_sue_tgt_trans == PF_ADDR_PIO)
1695 hdl_sts = pf_log_hdl_lookup(rpdip, derr, pfd_p,
1696 B_FALSE);
1697 break;
1698 case PCI_PCIX_CMD_CFWR:
1699 /*
1700 * Check to see if it is a non-posted write. If so, a
1701 * UR Completion would have been sent.
1702 */
1703 if (pf_matched_in_rc(dq_head_p, pfd_p,
1704 PCI_STAT_R_MAST_AB)) {
1705 hdl_sts = PF_HDL_FOUND;
1706 err = PF_ERR_MATCHED_RC;
1707 goto done;
1708 }
1709 hdl_sts = pf_log_hdl_lookup(rpdip, derr, pfd_p,
1710 B_FALSE);
1711 break;
1712 case PCI_PCIX_CMD_SPL:
1713 hdl_sts = pf_log_hdl_lookup(rpdip, derr, pfd_p,
1714 B_FALSE);
1715 break;
1716 case PCI_PCIX_CMD_DADR:
1717 cmd = (PCIE_ADV_BDG_HDR(pfd_p, 1) >>
1718 PCIE_AER_SUCE_HDR_CMD_UP_SHIFT) &
1719 PCIE_AER_SUCE_HDR_CMD_UP_MASK;
1720 if (cmd != PCI_PCIX_CMD_DADR)
1721 goto cmd_switch;
1722 /* FALLTHROUGH */
1723 default:
1724 /* Unexpected situation, panic */
1725 hdl_sts = PF_HDL_NOTFOUND;
1726 }
1727
1728 if (hdl_sts == PF_HDL_FOUND)
1729 err = PF_ERR_MATCHED_DEVICE;
1730 else
1731 err = PF_ERR_PANIC;
1732 } else {
1733 /*
1734 * Check to see if it is a non-posted write. If so, a UR
1735 * Completion would have been sent.
1736 */
1737 if ((PCIE_ERR_REG(pfd_p)->pcie_err_status &
1738 PCIE_DEVSTS_UR_DETECTED) &&
1739 pf_matched_in_rc(dq_head_p, pfd_p, PCI_STAT_R_MAST_AB))
1740 err = PF_ERR_MATCHED_RC;
1741
1742 /* Check for posted writes. Transaction is lost. */
1743 if (PCI_BDG_ERR_REG(pfd_p)->pci_bdg_sec_stat &
1744 PCI_STAT_S_PERROR)
1745 err = PF_ERR_PANIC;
1746
1747 /*
1748 * All other scenarios are due to read completions. Check for
1749 * PERR on the primary side. If found the primary side error
1750 * handling will take care of this error.
1751 */
1752 if (err == PF_ERR_NO_ERROR) {
1753 if (PCI_ERR_REG(pfd_p)->pci_err_status &
1754 PCI_STAT_PERROR)
1755 err = PF_ERR_MATCHED_PARENT;
1756 else
1757 err = PF_ERR_PANIC;
1758 }
1759 }
1760
1761 done:
1762 return (err);
1763 }
1764
1765 /*
1766 * PCIe Poisoned TLP error analyser. If a PCIe device receives a Poisoned TLP,
1767 * check the logs and see if an associated handler for this transaction can be
1768 * found.
1769 */
1770 /* ARGSUSED */
1771 static int
pf_analyse_ptlp(ddi_fm_error_t * derr,uint32_t bit,pf_data_t * dq_head_p,pf_data_t * pfd_p)1772 pf_analyse_ptlp(ddi_fm_error_t *derr, uint32_t bit, pf_data_t *dq_head_p,
1773 pf_data_t *pfd_p)
1774 {
1775 dev_info_t *rpdip = PCIE_PFD2BUS(pfd_p)->bus_rp_dip;
1776
1777 /*
1778 * If AERs are supported find the logs in this device, otherwise look in
1779 * it's parent's logs.
1780 */
1781 if (HAS_AER_LOGS(pfd_p, bit)) {
1782 pcie_tlp_hdr_t *hdr = (pcie_tlp_hdr_t *)&PCIE_ADV_HDR(pfd_p, 0);
1783
1784 /*
1785 * Double check that the log contains a poisoned TLP.
1786 * Some devices like PLX switch do not log poison TLP headers.
1787 */
1788 if (hdr->ep) {
1789 if (pf_log_hdl_lookup(rpdip, derr, pfd_p, B_TRUE) ==
1790 PF_HDL_FOUND)
1791 return (PF_ERR_MATCHED_DEVICE);
1792 }
1793
1794 /*
1795 * If an address is found and hdl lookup failed panic.
1796 * Otherwise check parents to see if there was enough
1797 * information recover.
1798 */
1799 if (PCIE_ADV_REG(pfd_p)->pcie_ue_tgt_addr)
1800 return (PF_ERR_PANIC);
1801 }
1802
1803 /*
1804 * Check to see if the rc has already handled this error or a parent has
1805 * already handled this error.
1806 *
1807 * If the error info in the RC wasn't enough to find the fault device,
1808 * such as if the faulting device lies behind a PCIe-PCI bridge from a
1809 * poisoned completion, check to see if the PCIe-PCI bridge has enough
1810 * info to recover. For completion TLP's, the AER header logs only
1811 * contain the faulting BDF in the Root Port. For PCIe device the fault
1812 * BDF is the fault device. But if the fault device is behind a
1813 * PCIe-PCI bridge the fault BDF could turn out just to be a PCIe-PCI
1814 * bridge's secondary bus number.
1815 */
1816 if (!PFD_IS_ROOT(pfd_p)) {
1817 dev_info_t *pdip = ddi_get_parent(PCIE_PFD2DIP(pfd_p));
1818 pf_data_t *parent_pfd_p;
1819
1820 if (PCIE_PFD2BUS(pfd_p)->bus_rp_dip == pdip) {
1821 if (pf_matched_in_rc(dq_head_p, pfd_p, PCI_STAT_PERROR))
1822 return (PF_ERR_MATCHED_RC);
1823 }
1824
1825 parent_pfd_p = PCIE_DIP2PFD(pdip);
1826
1827 if (HAS_AER_LOGS(parent_pfd_p, bit))
1828 return (PF_ERR_MATCHED_PARENT);
1829 } else {
1830 pf_data_t *bdg_pfd_p;
1831 pcie_req_id_t secbus;
1832
1833 /*
1834 * Looking for a pcie bridge only makes sense if the BDF
1835 * Dev/Func = 0/0
1836 */
1837 if (!PCIE_HAS_AER(PCIE_PFD2BUS(pfd_p)))
1838 goto done;
1839
1840 secbus = PCIE_ADV_REG(pfd_p)->pcie_ue_tgt_bdf;
1841
1842 if (!PCIE_CHECK_VALID_BDF(secbus) || (secbus & 0xFF))
1843 goto done;
1844
1845 bdg_pfd_p = pf_get_pcie_bridge(pfd_p, secbus);
1846
1847 if (bdg_pfd_p && HAS_SAER_LOGS(bdg_pfd_p,
1848 PCIE_AER_SUCE_PERR_ASSERT)) {
1849 return pf_analyse_perr_assert(derr,
1850 PCIE_AER_SUCE_PERR_ASSERT, dq_head_p, pfd_p);
1851 }
1852 }
1853 done:
1854 return (PF_ERR_PANIC);
1855 }
1856
1857 /*
1858 * PCIe-PCI Bridge Received Master and Target abort error analyser on Split
1859 * Completions. If a PCIe Bridge receives a MA/TA check logs and see if an
1860 * associated handler for this transaction can be found.
1861 */
1862 /* ARGSUSED */
1863 static int
pf_analyse_sc(ddi_fm_error_t * derr,uint32_t bit,pf_data_t * dq_head_p,pf_data_t * pfd_p)1864 pf_analyse_sc(ddi_fm_error_t *derr, uint32_t bit, pf_data_t *dq_head_p,
1865 pf_data_t *pfd_p)
1866 {
1867 dev_info_t *rpdip = PCIE_PFD2BUS(pfd_p)->bus_rp_dip;
1868 uint16_t cmd;
1869 int sts = PF_HDL_NOTFOUND;
1870
1871 if (!HAS_SAER_LOGS(pfd_p, bit))
1872 return (PF_ERR_PANIC);
1873
1874 if (pf_pci_decode(pfd_p, &cmd) != DDI_SUCCESS)
1875 return (PF_ERR_PANIC);
1876
1877 if (cmd == PCI_PCIX_CMD_SPL)
1878 sts = pf_log_hdl_lookup(rpdip, derr, pfd_p, B_FALSE);
1879
1880 if (sts == PF_HDL_FOUND)
1881 return (PF_ERR_MATCHED_DEVICE);
1882
1883 return (PF_ERR_PANIC);
1884 }
1885
1886 /*
1887 * PCIe Timeout error analyser. This error can be forgiven if it is marked as
1888 * CE Advisory. If it is marked as advisory, this means the HW can recover
1889 * and/or retry the transaction automatically.
1890 */
1891 /* ARGSUSED */
1892 static int
pf_analyse_to(ddi_fm_error_t * derr,uint32_t bit,pf_data_t * dq_head_p,pf_data_t * pfd_p)1893 pf_analyse_to(ddi_fm_error_t *derr, uint32_t bit, pf_data_t *dq_head_p,
1894 pf_data_t *pfd_p)
1895 {
1896 if (HAS_AER_LOGS(pfd_p, bit) && CE_ADVISORY(pfd_p))
1897 return (PF_ERR_NO_PANIC);
1898
1899 return (PF_ERR_PANIC);
1900 }
1901
1902 /*
1903 * PCIe Unexpected Completion. Check to see if this TLP was misrouted by
1904 * matching the device BDF with the TLP Log. If misrouting panic, otherwise
1905 * don't panic.
1906 */
1907 /* ARGSUSED */
1908 static int
pf_analyse_uc(ddi_fm_error_t * derr,uint32_t bit,pf_data_t * dq_head_p,pf_data_t * pfd_p)1909 pf_analyse_uc(ddi_fm_error_t *derr, uint32_t bit, pf_data_t *dq_head_p,
1910 pf_data_t *pfd_p)
1911 {
1912 if (HAS_AER_LOGS(pfd_p, bit) &&
1913 (PCIE_PFD2BUS(pfd_p)->bus_bdf == (PCIE_ADV_HDR(pfd_p, 2) >> 16)))
1914 return (PF_ERR_NO_PANIC);
1915
1916 /*
1917 * This is a case of mis-routing. Any of the switches above this
1918 * device could be at fault.
1919 */
1920 PFD_AFFECTED_DEV(pfd_p)->pe_affected_flags = PF_AFFECTED_ROOT;
1921
1922 return (PF_ERR_PANIC);
1923 }
1924
1925 /*
1926 * PCIe-PCI Bridge Uncorrectable Data error analyser. All Uncorrectable Data
1927 * errors should have resulted in a PCIe Poisoned TLP to the RC, except for
1928 * Posted Writes. Check the logs for Posted Writes and if the RC did not see a
1929 * Poisoned TLP.
1930 *
1931 * Non-Posted Writes will also generate a UR in the completion status, which the
1932 * RC should also see.
1933 */
1934 /* ARGSUSED */
1935 static int
pf_analyse_uc_data(ddi_fm_error_t * derr,uint32_t bit,pf_data_t * dq_head_p,pf_data_t * pfd_p)1936 pf_analyse_uc_data(ddi_fm_error_t *derr, uint32_t bit, pf_data_t *dq_head_p,
1937 pf_data_t *pfd_p)
1938 {
1939 dev_info_t *rpdip = PCIE_PFD2BUS(pfd_p)->bus_rp_dip;
1940
1941 if (!HAS_SAER_LOGS(pfd_p, bit))
1942 return (PF_ERR_PANIC);
1943
1944 if (pf_matched_in_rc(dq_head_p, pfd_p, PCI_STAT_PERROR))
1945 return (PF_ERR_MATCHED_RC);
1946
1947 if (pf_log_hdl_lookup(rpdip, derr, pfd_p, B_FALSE) == PF_HDL_FOUND)
1948 return (PF_ERR_MATCHED_DEVICE);
1949
1950 return (PF_ERR_PANIC);
1951 }
1952
1953 /* ARGSUSED */
1954 static int
pf_no_panic(ddi_fm_error_t * derr,uint32_t bit,pf_data_t * dq_head_p,pf_data_t * pfd_p)1955 pf_no_panic(ddi_fm_error_t *derr, uint32_t bit, pf_data_t *dq_head_p,
1956 pf_data_t *pfd_p)
1957 {
1958 return (PF_ERR_NO_PANIC);
1959 }
1960
1961 /* ARGSUSED */
1962 static int
pf_panic(ddi_fm_error_t * derr,uint32_t bit,pf_data_t * dq_head_p,pf_data_t * pfd_p)1963 pf_panic(ddi_fm_error_t *derr, uint32_t bit, pf_data_t *dq_head_p,
1964 pf_data_t *pfd_p)
1965 {
1966 return (PF_ERR_PANIC);
1967 }
1968
1969 /*
1970 * If a PCIe device does not support AER, assume all AER statuses have been set,
1971 * unless other registers do not indicate a certain error occuring.
1972 */
1973 static void
pf_adjust_for_no_aer(pf_data_t * pfd_p)1974 pf_adjust_for_no_aer(pf_data_t *pfd_p)
1975 {
1976 uint32_t aer_ue = 0;
1977 uint16_t status;
1978
1979 if (PCIE_HAS_AER(PCIE_PFD2BUS(pfd_p)))
1980 return;
1981
1982 if (PCIE_ERR_REG(pfd_p)->pcie_err_status & PCIE_DEVSTS_FE_DETECTED)
1983 aer_ue = PF_AER_FATAL_ERR;
1984
1985 if (PCIE_ERR_REG(pfd_p)->pcie_err_status & PCIE_DEVSTS_NFE_DETECTED) {
1986 aer_ue = PF_AER_NON_FATAL_ERR;
1987 status = PCI_ERR_REG(pfd_p)->pci_err_status;
1988
1989 /* Check if the device received a PTLP */
1990 if (!(status & PCI_STAT_PERROR))
1991 aer_ue &= ~PCIE_AER_UCE_PTLP;
1992
1993 /* Check if the device signaled a CA */
1994 if (!(status & PCI_STAT_S_TARG_AB))
1995 aer_ue &= ~PCIE_AER_UCE_CA;
1996
1997 /* Check if the device sent a UR */
1998 if (!(PCIE_ERR_REG(pfd_p)->pcie_err_status &
1999 PCIE_DEVSTS_UR_DETECTED))
2000 aer_ue &= ~PCIE_AER_UCE_UR;
2001
2002 /*
2003 * Ignore ECRCs as it is optional and will manefest itself as
2004 * another error like PTLP and MFP
2005 */
2006 aer_ue &= ~PCIE_AER_UCE_ECRC;
2007
2008 /*
2009 * Generally if NFE is set, SERR should also be set. Exception:
2010 * When certain non-fatal errors are masked, and some of them
2011 * happened to be the cause of the NFE, SERR will not be set and
2012 * they can not be the source of this interrupt.
2013 *
2014 * On x86, URs are masked (NFE + UR can be set), if any other
2015 * non-fatal errors (i.e, PTLP, CTO, CA, UC, ECRC, ACS) did
2016 * occur, SERR should be set since they are not masked. So if
2017 * SERR is not set, none of them occurred.
2018 */
2019 if (!(status & PCI_STAT_S_SYSERR))
2020 aer_ue &= ~PCIE_AER_UCE_TO;
2021 }
2022
2023 if (!PCIE_IS_BDG(PCIE_PFD2BUS(pfd_p))) {
2024 aer_ue &= ~PCIE_AER_UCE_TRAINING;
2025 aer_ue &= ~PCIE_AER_UCE_SD;
2026 }
2027
2028 PCIE_ADV_REG(pfd_p)->pcie_ue_status = aer_ue;
2029 }
2030
2031 static void
pf_adjust_for_no_saer(pf_data_t * pfd_p)2032 pf_adjust_for_no_saer(pf_data_t *pfd_p)
2033 {
2034 uint32_t s_aer_ue = 0;
2035 uint16_t status;
2036
2037 if (PCIE_HAS_AER(PCIE_PFD2BUS(pfd_p)))
2038 return;
2039
2040 if (PCIE_ERR_REG(pfd_p)->pcie_err_status & PCIE_DEVSTS_FE_DETECTED)
2041 s_aer_ue = PF_SAER_FATAL_ERR;
2042
2043 if (PCIE_ERR_REG(pfd_p)->pcie_err_status & PCIE_DEVSTS_NFE_DETECTED) {
2044 s_aer_ue = PF_SAER_NON_FATAL_ERR;
2045 status = PCI_BDG_ERR_REG(pfd_p)->pci_bdg_sec_stat;
2046
2047 /* Check if the device received a UC_DATA */
2048 if (!(status & PCI_STAT_PERROR))
2049 s_aer_ue &= ~PCIE_AER_SUCE_UC_DATA_ERR;
2050
2051 /* Check if the device received a RCVD_MA/MA_ON_SC */
2052 if (!(status & (PCI_STAT_R_MAST_AB))) {
2053 s_aer_ue &= ~PCIE_AER_SUCE_RCVD_MA;
2054 s_aer_ue &= ~PCIE_AER_SUCE_MA_ON_SC;
2055 }
2056
2057 /* Check if the device received a RCVD_TA/TA_ON_SC */
2058 if (!(status & (PCI_STAT_R_TARG_AB))) {
2059 s_aer_ue &= ~PCIE_AER_SUCE_RCVD_TA;
2060 s_aer_ue &= ~PCIE_AER_SUCE_TA_ON_SC;
2061 }
2062 }
2063
2064 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_status = s_aer_ue;
2065 }
2066
2067 /* Find the PCIe-PCI bridge based on secondary bus number */
2068 static pf_data_t *
pf_get_pcie_bridge(pf_data_t * pfd_p,pcie_req_id_t secbus)2069 pf_get_pcie_bridge(pf_data_t *pfd_p, pcie_req_id_t secbus)
2070 {
2071 pf_data_t *bdg_pfd_p;
2072
2073 /* Search down for the PCIe-PCI device. */
2074 for (bdg_pfd_p = pfd_p->pe_next; bdg_pfd_p;
2075 bdg_pfd_p = bdg_pfd_p->pe_next) {
2076 if (PCIE_IS_PCIE_BDG(PCIE_PFD2BUS(bdg_pfd_p)) &&
2077 PCIE_PFD2BUS(bdg_pfd_p)->bus_bdg_secbus == secbus)
2078 return (bdg_pfd_p);
2079 }
2080
2081 return (NULL);
2082 }
2083
2084 /* Find the PCIe-PCI bridge of a PCI device */
2085 static pf_data_t *
pf_get_parent_pcie_bridge(pf_data_t * pfd_p)2086 pf_get_parent_pcie_bridge(pf_data_t *pfd_p)
2087 {
2088 dev_info_t *dip, *rp_dip = PCIE_PFD2BUS(pfd_p)->bus_rp_dip;
2089
2090 /* This only makes sense if the device is a PCI device */
2091 if (!PCIE_IS_PCI(PCIE_PFD2BUS(pfd_p)))
2092 return (NULL);
2093
2094 /*
2095 * Search up for the PCIe-PCI device. Watchout for x86 where pci
2096 * devices hang directly off of NPE.
2097 */
2098 for (dip = PCIE_PFD2DIP(pfd_p); dip; dip = ddi_get_parent(dip)) {
2099 if (dip == rp_dip)
2100 dip = NULL;
2101
2102 if (PCIE_IS_PCIE_BDG(PCIE_DIP2BUS(dip)))
2103 return (PCIE_DIP2PFD(dip));
2104 }
2105
2106 return (NULL);
2107 }
2108
2109 /*
2110 * See if a leaf error was bubbled up to the Root Complex (RC) and handled.
2111 * As of right now only RC's have enough information to have errors found in the
2112 * fabric to be matched to the RC. Note that Root Port's (RP) do not carry
2113 * enough information. Currently known RC's are SPARC Fire architecture and
2114 * it's equivalents, and x86's NPE.
2115 * SPARC Fire architectures have a plethora of error registers, while currently
2116 * NPE only have the address of a failed load.
2117 *
2118 * Check if the RC logged an error with the appropriate status type/abort type.
2119 * Ex: Parity Error, Received Master/Target Abort
2120 * Check if either the fault address found in the rc matches the device's
2121 * assigned address range (PIO's only) or the fault BDF in the rc matches the
2122 * device's BDF or Secondary Bus/Bus Range.
2123 */
2124 static boolean_t
pf_matched_in_rc(pf_data_t * dq_head_p,pf_data_t * pfd_p,uint32_t abort_type)2125 pf_matched_in_rc(pf_data_t *dq_head_p, pf_data_t *pfd_p,
2126 uint32_t abort_type)
2127 {
2128 pcie_bus_t *bus_p = PCIE_PFD2BUS(pfd_p);
2129 pf_data_t *rc_pfd_p;
2130 pcie_req_id_t fault_bdf;
2131
2132 for (rc_pfd_p = dq_head_p; PFD_IS_ROOT(rc_pfd_p);
2133 rc_pfd_p = rc_pfd_p->pe_next) {
2134 /* Only root complex's have enough information to match */
2135 if (!PCIE_IS_RC(PCIE_PFD2BUS(rc_pfd_p)))
2136 continue;
2137
2138 /* If device and rc abort type does not match continue */
2139 if (!(PCI_BDG_ERR_REG(rc_pfd_p)->pci_bdg_sec_stat & abort_type))
2140 continue;
2141
2142 fault_bdf = PCIE_ROOT_FAULT(rc_pfd_p)->scan_bdf;
2143
2144 /* The Fault BDF = Device's BDF */
2145 if (fault_bdf == bus_p->bus_bdf)
2146 return (B_TRUE);
2147
2148 /* The Fault Addr is in device's address range */
2149 if (pf_in_addr_range(bus_p,
2150 PCIE_ROOT_FAULT(rc_pfd_p)->scan_addr))
2151 return (B_TRUE);
2152
2153 /* The Fault BDF is from PCIe-PCI Bridge's secondary bus */
2154 if (PCIE_IS_PCIE_BDG(bus_p) &&
2155 pf_in_bus_range(bus_p, fault_bdf))
2156 return (B_TRUE);
2157 }
2158
2159 return (B_FALSE);
2160 }
2161
2162 /*
2163 * Check the RP and see if the error is PIO/DMA. If the RP also has a PERR then
2164 * it is a DMA, otherwise it's a PIO
2165 */
2166 static void
pf_pci_find_trans_type(pf_data_t * pfd_p,uint64_t * addr,uint32_t * trans_type,pcie_req_id_t * bdf)2167 pf_pci_find_trans_type(pf_data_t *pfd_p, uint64_t *addr, uint32_t *trans_type,
2168 pcie_req_id_t *bdf) {
2169 pf_data_t *rc_pfd_p;
2170
2171 /* Could be DMA or PIO. Find out by look at error type. */
2172 switch (PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_status) {
2173 case PCIE_AER_SUCE_TA_ON_SC:
2174 case PCIE_AER_SUCE_MA_ON_SC:
2175 *trans_type = PF_ADDR_DMA;
2176 return;
2177 case PCIE_AER_SUCE_RCVD_TA:
2178 case PCIE_AER_SUCE_RCVD_MA:
2179 *bdf = PCIE_INVALID_BDF;
2180 *trans_type = PF_ADDR_PIO;
2181 return;
2182 case PCIE_AER_SUCE_USC_ERR:
2183 case PCIE_AER_SUCE_UC_DATA_ERR:
2184 case PCIE_AER_SUCE_PERR_ASSERT:
2185 break;
2186 default:
2187 *addr = 0;
2188 *bdf = PCIE_INVALID_BDF;
2189 *trans_type = 0;
2190 return;
2191 }
2192
2193 *bdf = PCIE_INVALID_BDF;
2194 *trans_type = PF_ADDR_PIO;
2195 for (rc_pfd_p = pfd_p->pe_prev; rc_pfd_p;
2196 rc_pfd_p = rc_pfd_p->pe_prev) {
2197 if (PFD_IS_ROOT(rc_pfd_p) &&
2198 (PCI_BDG_ERR_REG(rc_pfd_p)->pci_bdg_sec_stat &
2199 PCI_STAT_PERROR)) {
2200 *trans_type = PF_ADDR_DMA;
2201 return;
2202 }
2203 }
2204 }
2205
2206 /*
2207 * pf_pci_decode function decodes the secondary aer transaction logs in
2208 * PCIe-PCI bridges.
2209 *
2210 * The log is 128 bits long and arranged in this manner.
2211 * [0:35] Transaction Attribute (s_aer_h0-saer_h1)
2212 * [36:39] Transaction lower command (saer_h1)
2213 * [40:43] Transaction upper command (saer_h1)
2214 * [44:63] Reserved
2215 * [64:127] Address (saer_h2-saer_h3)
2216 */
2217 /* ARGSUSED */
2218 int
pf_pci_decode(pf_data_t * pfd_p,uint16_t * cmd)2219 pf_pci_decode(pf_data_t *pfd_p, uint16_t *cmd) {
2220 pcix_attr_t *attr;
2221 uint64_t addr;
2222 uint32_t trans_type;
2223 pcie_req_id_t bdf = PCIE_INVALID_BDF;
2224
2225 attr = (pcix_attr_t *)&PCIE_ADV_BDG_HDR(pfd_p, 0);
2226 *cmd = GET_SAER_CMD(pfd_p);
2227
2228 cmd_switch:
2229 switch (*cmd) {
2230 case PCI_PCIX_CMD_IORD:
2231 case PCI_PCIX_CMD_IOWR:
2232 /* IO Access should always be down stream */
2233 addr = PCIE_ADV_BDG_HDR(pfd_p, 2);
2234 bdf = attr->rid;
2235 trans_type = PF_ADDR_PIO;
2236 break;
2237 case PCI_PCIX_CMD_MEMRD_DW:
2238 case PCI_PCIX_CMD_MEMRD_BL:
2239 case PCI_PCIX_CMD_MEMRDBL:
2240 case PCI_PCIX_CMD_MEMWR:
2241 case PCI_PCIX_CMD_MEMWR_BL:
2242 case PCI_PCIX_CMD_MEMWRBL:
2243 addr = ((uint64_t)PCIE_ADV_BDG_HDR(pfd_p, 3) <<
2244 PCIE_AER_SUCE_HDR_ADDR_SHIFT) | PCIE_ADV_BDG_HDR(pfd_p, 2);
2245 bdf = attr->rid;
2246
2247 pf_pci_find_trans_type(pfd_p, &addr, &trans_type, &bdf);
2248 break;
2249 case PCI_PCIX_CMD_CFRD:
2250 case PCI_PCIX_CMD_CFWR:
2251 /*
2252 * CFG Access should always be down stream. Match the BDF in
2253 * the address phase.
2254 */
2255 addr = 0;
2256 bdf = attr->rid;
2257 trans_type = PF_ADDR_CFG;
2258 break;
2259 case PCI_PCIX_CMD_SPL:
2260 /*
2261 * Check for DMA read completions. The requesting BDF is in the
2262 * Address phase.
2263 */
2264 addr = 0;
2265 bdf = attr->rid;
2266 trans_type = PF_ADDR_DMA;
2267 break;
2268 case PCI_PCIX_CMD_DADR:
2269 /*
2270 * For Dual Address Cycles the transaction command is in the 2nd
2271 * address phase.
2272 */
2273 *cmd = (PCIE_ADV_BDG_HDR(pfd_p, 1) >>
2274 PCIE_AER_SUCE_HDR_CMD_UP_SHIFT) &
2275 PCIE_AER_SUCE_HDR_CMD_UP_MASK;
2276 if (*cmd != PCI_PCIX_CMD_DADR)
2277 goto cmd_switch;
2278 /* FALLTHROUGH */
2279 default:
2280 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_tgt_trans = 0;
2281 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_tgt_bdf = PCIE_INVALID_BDF;
2282 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_tgt_addr = 0;
2283 return (DDI_FAILURE);
2284 }
2285 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_tgt_trans = trans_type;
2286 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_tgt_bdf = bdf;
2287 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_tgt_addr = addr;
2288 return (DDI_SUCCESS);
2289 }
2290
2291 /*
2292 * Based on either the BDF/ADDR find and mark the faulting DMA/ACC handler.
2293 * Returns either PF_HDL_NOTFOUND or PF_HDL_FOUND.
2294 */
2295 int
pf_hdl_lookup(dev_info_t * dip,uint64_t ena,uint32_t flag,uint64_t addr,pcie_req_id_t bdf)2296 pf_hdl_lookup(dev_info_t *dip, uint64_t ena, uint32_t flag, uint64_t addr,
2297 pcie_req_id_t bdf)
2298 {
2299 ddi_fm_error_t derr;
2300
2301 /* If we don't know the addr or rid just return with NOTFOUND */
2302 if ((addr == NULL) && !PCIE_CHECK_VALID_BDF(bdf))
2303 return (PF_HDL_NOTFOUND);
2304
2305 /*
2306 * Disable DMA handle lookup until DMA errors can be handled and
2307 * reported synchronously. When enabled again, check for the
2308 * PF_ADDR_DMA flag
2309 */
2310 if (!(flag & (PF_ADDR_PIO | PF_ADDR_CFG))) {
2311 return (PF_HDL_NOTFOUND);
2312 }
2313
2314 bzero(&derr, sizeof (ddi_fm_error_t));
2315 derr.fme_version = DDI_FME_VERSION;
2316 derr.fme_flag = DDI_FM_ERR_UNEXPECTED;
2317 derr.fme_ena = ena;
2318
2319 return (pf_hdl_child_lookup(dip, &derr, flag, addr, bdf));
2320 }
2321
2322 static int
pf_hdl_child_lookup(dev_info_t * dip,ddi_fm_error_t * derr,uint32_t flag,uint64_t addr,pcie_req_id_t bdf)2323 pf_hdl_child_lookup(dev_info_t *dip, ddi_fm_error_t *derr, uint32_t flag,
2324 uint64_t addr, pcie_req_id_t bdf)
2325 {
2326 int status = PF_HDL_NOTFOUND;
2327 ndi_fmc_t *fcp = NULL;
2328 struct i_ddi_fmhdl *fmhdl = DEVI(dip)->devi_fmhdl;
2329 pcie_req_id_t dip_bdf;
2330 boolean_t have_lock = B_FALSE;
2331 pcie_bus_t *bus_p;
2332 dev_info_t *cdip;
2333
2334 if (!(bus_p = pf_is_ready(dip))) {
2335 return (status);
2336 }
2337
2338 ASSERT(fmhdl);
2339 if (!i_ddi_fm_handler_owned(dip)) {
2340 /*
2341 * pf_handler_enter always returns SUCCESS if the 'impl' arg is
2342 * NULL.
2343 */
2344 (void) pf_handler_enter(dip, NULL);
2345 have_lock = B_TRUE;
2346 }
2347
2348 dip_bdf = PCI_GET_BDF(dip);
2349
2350 /* Check if dip and BDF match, if not recurse to it's children. */
2351 if (!PCIE_IS_RC(bus_p) && (!PCIE_CHECK_VALID_BDF(bdf) ||
2352 dip_bdf == bdf)) {
2353 if ((flag & PF_ADDR_DMA) && DDI_FM_DMA_ERR_CAP(fmhdl->fh_cap))
2354 fcp = fmhdl->fh_dma_cache;
2355 else
2356 fcp = NULL;
2357
2358 if (fcp)
2359 status = pf_hdl_compare(dip, derr, DMA_HANDLE, addr,
2360 bdf, fcp);
2361
2362
2363 if (((flag & PF_ADDR_PIO) || (flag & PF_ADDR_CFG)) &&
2364 DDI_FM_ACC_ERR_CAP(fmhdl->fh_cap))
2365 fcp = fmhdl->fh_acc_cache;
2366 else
2367 fcp = NULL;
2368
2369 if (fcp)
2370 status = pf_hdl_compare(dip, derr, ACC_HANDLE, addr,
2371 bdf, fcp);
2372 }
2373
2374 /* If we found the handler or know it's this device, we're done */
2375 if (!PCIE_IS_RC(bus_p) && ((dip_bdf == bdf) ||
2376 (status == PF_HDL_FOUND)))
2377 goto done;
2378
2379 /*
2380 * If the current devuce us a PCIe-PCI bridge need to check for special
2381 * cases:
2382 *
2383 * If it is a PIO and we don't have an address or this is a DMA, check
2384 * to see if the BDF = secondary bus. If so stop. The BDF isn't a real
2385 * BDF and the fault device could have come from any device in the PCI
2386 * bus.
2387 */
2388 if (PCIE_IS_PCIE_BDG(bus_p) &&
2389 ((flag & PF_ADDR_DMA || flag & PF_ADDR_PIO)) &&
2390 ((bus_p->bus_bdg_secbus << PCIE_REQ_ID_BUS_SHIFT) == bdf))
2391 goto done;
2392
2393
2394 /* If we can't find the handler check it's children */
2395 for (cdip = ddi_get_child(dip); cdip;
2396 cdip = ddi_get_next_sibling(cdip)) {
2397 if ((bus_p = PCIE_DIP2BUS(cdip)) == NULL)
2398 continue;
2399
2400 if (pf_in_bus_range(bus_p, bdf) ||
2401 pf_in_addr_range(bus_p, addr))
2402 status = pf_hdl_child_lookup(cdip, derr, flag, addr,
2403 bdf);
2404
2405 if (status == PF_HDL_FOUND)
2406 goto done;
2407 }
2408
2409 done:
2410 if (have_lock == B_TRUE)
2411 pf_handler_exit(dip);
2412
2413 return (status);
2414 }
2415
2416 static int
pf_hdl_compare(dev_info_t * dip,ddi_fm_error_t * derr,uint32_t flag,uint64_t addr,pcie_req_id_t bdf,ndi_fmc_t * fcp)2417 pf_hdl_compare(dev_info_t *dip, ddi_fm_error_t *derr, uint32_t flag,
2418 uint64_t addr, pcie_req_id_t bdf, ndi_fmc_t *fcp) {
2419 ndi_fmcentry_t *fep;
2420 int found = 0;
2421 int status;
2422
2423 mutex_enter(&fcp->fc_lock);
2424 for (fep = fcp->fc_head; fep != NULL; fep = fep->fce_next) {
2425 ddi_fmcompare_t compare_func;
2426
2427 /*
2428 * Compare captured error state with handle
2429 * resources. During the comparison and
2430 * subsequent error handling, we block
2431 * attempts to free the cache entry.
2432 */
2433 compare_func = (flag == ACC_HANDLE) ?
2434 i_ddi_fm_acc_err_cf_get((ddi_acc_handle_t)
2435 fep->fce_resource) :
2436 i_ddi_fm_dma_err_cf_get((ddi_dma_handle_t)
2437 fep->fce_resource);
2438
2439 if (compare_func == NULL) /* unbound or not FLAGERR */
2440 continue;
2441
2442 status = compare_func(dip, fep->fce_resource,
2443 (void *)&addr, (void *)&bdf);
2444
2445 if (status == DDI_FM_NONFATAL) {
2446 found++;
2447
2448 /* Set the error for this resource handle */
2449 if (flag == ACC_HANDLE) {
2450 ddi_acc_handle_t ap = fep->fce_resource;
2451
2452 i_ddi_fm_acc_err_set(ap, derr->fme_ena, status,
2453 DDI_FM_ERR_UNEXPECTED);
2454 ddi_fm_acc_err_get(ap, derr, DDI_FME_VERSION);
2455 derr->fme_acc_handle = ap;
2456 } else {
2457 ddi_dma_handle_t dp = fep->fce_resource;
2458
2459 i_ddi_fm_dma_err_set(dp, derr->fme_ena, status,
2460 DDI_FM_ERR_UNEXPECTED);
2461 ddi_fm_dma_err_get(dp, derr, DDI_FME_VERSION);
2462 derr->fme_dma_handle = dp;
2463 }
2464 }
2465 }
2466 mutex_exit(&fcp->fc_lock);
2467
2468 /*
2469 * If a handler isn't found and we know this is the right device mark
2470 * them all failed.
2471 */
2472 if ((addr != NULL) && PCIE_CHECK_VALID_BDF(bdf) && (found == 0)) {
2473 status = pf_hdl_compare(dip, derr, flag, addr, bdf, fcp);
2474 if (status == PF_HDL_FOUND)
2475 found++;
2476 }
2477
2478 return ((found) ? PF_HDL_FOUND : PF_HDL_NOTFOUND);
2479 }
2480
2481 /*
2482 * Automatically decode AER header logs and does a handling look up based on the
2483 * AER header decoding.
2484 *
2485 * For this function only the Primary/Secondary AER Header Logs need to be valid
2486 * in the pfd (PCIe Fault Data) arg.
2487 *
2488 * Returns either PF_HDL_NOTFOUND or PF_HDL_FOUND.
2489 */
2490 /* ARGSUSED */
2491 static int
pf_log_hdl_lookup(dev_info_t * rpdip,ddi_fm_error_t * derr,pf_data_t * pfd_p,boolean_t is_primary)2492 pf_log_hdl_lookup(dev_info_t *rpdip, ddi_fm_error_t *derr, pf_data_t *pfd_p,
2493 boolean_t is_primary)
2494 {
2495 /*
2496 * Disabling this function temporarily until errors can be handled
2497 * synchronously.
2498 *
2499 * This function is currently only called during the middle of a fabric
2500 * scan. If the fabric scan is called synchronously with an error seen
2501 * in the RP/RC, then the related errors in the fabric will have a
2502 * PF_ERR_MATCHED_RC error severity. pf_log_hdl_lookup code will be by
2503 * passed when the severity is PF_ERR_MATCHED_RC. Handle lookup would
2504 * have already happened in RP/RC error handling in a synchronous
2505 * manner. Errors unrelated should panic, because they are being
2506 * handled asynchronously.
2507 *
2508 * If fabric scan is called asynchronously from any RP/RC error, then
2509 * DMA/PIO UE errors seen in the fabric should panic. pf_lop_hdl_lookup
2510 * will return PF_HDL_NOTFOUND to ensure that the system panics.
2511 */
2512 return (PF_HDL_NOTFOUND);
2513 }
2514
2515 /*
2516 * Decodes the TLP and returns the BDF of the handler, address and transaction
2517 * type if known.
2518 *
2519 * Types of TLP logs seen in RC, and what to extract:
2520 *
2521 * Memory(DMA) - Requester BDF, address, PF_DMA_ADDR
2522 * Memory(PIO) - address, PF_PIO_ADDR
2523 * CFG - Should not occur and result in UR
2524 * Completion(DMA) - Requester BDF, PF_DMA_ADDR
2525 * Completion(PIO) - Requester BDF, PF_PIO_ADDR
2526 *
2527 * Types of TLP logs seen in SW/Leaf, and what to extract:
2528 *
2529 * Memory(DMA) - Requester BDF, address, PF_DMA_ADDR
2530 * Memory(PIO) - address, PF_PIO_ADDR
2531 * CFG - Destined BDF, address, PF_CFG_ADDR
2532 * Completion(DMA) - Requester BDF, PF_DMA_ADDR
2533 * Completion(PIO) - Requester BDF, PF_PIO_ADDR
2534 *
2535 * The adv_reg_p must be passed in separately for use with SPARC RPs. A
2536 * SPARC RP could have multiple AER header logs which cannot be directly
2537 * accessed via the bus_p.
2538 */
2539 int
pf_tlp_decode(pcie_bus_t * bus_p,pf_pcie_adv_err_regs_t * adv_reg_p)2540 pf_tlp_decode(pcie_bus_t *bus_p, pf_pcie_adv_err_regs_t *adv_reg_p) {
2541 pcie_tlp_hdr_t *tlp_hdr = (pcie_tlp_hdr_t *)adv_reg_p->pcie_ue_hdr;
2542 pcie_req_id_t my_bdf, tlp_bdf, flt_bdf = PCIE_INVALID_BDF;
2543 uint64_t flt_addr = 0;
2544 uint32_t flt_trans_type = 0;
2545
2546 adv_reg_p->pcie_ue_tgt_addr = 0;
2547 adv_reg_p->pcie_ue_tgt_bdf = PCIE_INVALID_BDF;
2548 adv_reg_p->pcie_ue_tgt_trans = 0;
2549
2550 my_bdf = bus_p->bus_bdf;
2551 switch (tlp_hdr->type) {
2552 case PCIE_TLP_TYPE_IO:
2553 case PCIE_TLP_TYPE_MEM:
2554 case PCIE_TLP_TYPE_MEMLK:
2555 /* Grab the 32/64bit fault address */
2556 if (tlp_hdr->fmt & 0x1) {
2557 flt_addr = ((uint64_t)adv_reg_p->pcie_ue_hdr[2] << 32);
2558 flt_addr |= adv_reg_p->pcie_ue_hdr[3];
2559 } else {
2560 flt_addr = adv_reg_p->pcie_ue_hdr[2];
2561 }
2562
2563 tlp_bdf = (pcie_req_id_t)(adv_reg_p->pcie_ue_hdr[1] >> 16);
2564
2565 /*
2566 * If the req bdf >= this.bdf, then it means the request is this
2567 * device or came from a device below it. Unless this device is
2568 * a PCIe root port then it means is a DMA, otherwise PIO.
2569 */
2570 if ((tlp_bdf >= my_bdf) && !PCIE_IS_ROOT(bus_p)) {
2571 flt_trans_type = PF_ADDR_DMA;
2572 flt_bdf = tlp_bdf;
2573 } else if (PCIE_IS_ROOT(bus_p) &&
2574 (PF_FIRST_AER_ERR(PCIE_AER_UCE_PTLP, adv_reg_p) ||
2575 (PF_FIRST_AER_ERR(PCIE_AER_UCE_CA, adv_reg_p)))) {
2576 flt_trans_type = PF_ADDR_DMA;
2577 flt_bdf = tlp_bdf;
2578 } else {
2579 flt_trans_type = PF_ADDR_PIO;
2580 flt_bdf = PCIE_INVALID_BDF;
2581 }
2582 break;
2583 case PCIE_TLP_TYPE_CFG0:
2584 case PCIE_TLP_TYPE_CFG1:
2585 flt_addr = 0;
2586 flt_bdf = (pcie_req_id_t)(adv_reg_p->pcie_ue_hdr[2] >> 16);
2587 flt_trans_type = PF_ADDR_CFG;
2588 break;
2589 case PCIE_TLP_TYPE_CPL:
2590 case PCIE_TLP_TYPE_CPLLK:
2591 {
2592 pcie_cpl_t *cpl_tlp = (pcie_cpl_t *)&adv_reg_p->pcie_ue_hdr[1];
2593
2594 flt_addr = NULL;
2595 flt_bdf = (cpl_tlp->rid > cpl_tlp->cid) ? cpl_tlp->rid :
2596 cpl_tlp->cid;
2597
2598 /*
2599 * If the cpl bdf < this.bdf, then it means the request is this
2600 * device or came from a device below it. Unless this device is
2601 * a PCIe root port then it means is a DMA, otherwise PIO.
2602 */
2603 if (cpl_tlp->rid > cpl_tlp->cid) {
2604 flt_trans_type = PF_ADDR_DMA;
2605 } else {
2606 flt_trans_type = PF_ADDR_PIO | PF_ADDR_CFG;
2607 }
2608 break;
2609 }
2610 default:
2611 return (DDI_FAILURE);
2612 }
2613
2614 adv_reg_p->pcie_ue_tgt_addr = flt_addr;
2615 adv_reg_p->pcie_ue_tgt_bdf = flt_bdf;
2616 adv_reg_p->pcie_ue_tgt_trans = flt_trans_type;
2617
2618 return (DDI_SUCCESS);
2619 }
2620
2621 #define PCIE_EREPORT DDI_IO_CLASS "." PCI_ERROR_SUBCLASS "." PCIEX_FABRIC
2622 static int
pf_ereport_setup(dev_info_t * dip,uint64_t ena,nvlist_t ** ereport,nvlist_t ** detector,errorq_elem_t ** eqep)2623 pf_ereport_setup(dev_info_t *dip, uint64_t ena, nvlist_t **ereport,
2624 nvlist_t **detector, errorq_elem_t **eqep)
2625 {
2626 struct i_ddi_fmhdl *fmhdl = DEVI(dip)->devi_fmhdl;
2627 char device_path[MAXPATHLEN];
2628 nv_alloc_t *nva;
2629
2630 *eqep = errorq_reserve(fmhdl->fh_errorq);
2631 if (*eqep == NULL) {
2632 atomic_inc_64(&fmhdl->fh_kstat.fek_erpt_dropped.value.ui64);
2633 return (DDI_FAILURE);
2634 }
2635
2636 *ereport = errorq_elem_nvl(fmhdl->fh_errorq, *eqep);
2637 nva = errorq_elem_nva(fmhdl->fh_errorq, *eqep);
2638
2639 ASSERT(*ereport);
2640 ASSERT(nva);
2641
2642 /*
2643 * Use the dev_path/devid for this device instance.
2644 */
2645 *detector = fm_nvlist_create(nva);
2646 if (dip == ddi_root_node()) {
2647 device_path[0] = '/';
2648 device_path[1] = '\0';
2649 } else {
2650 (void) ddi_pathname(dip, device_path);
2651 }
2652
2653 fm_fmri_dev_set(*detector, FM_DEV_SCHEME_VERSION, NULL,
2654 device_path, NULL, NULL);
2655
2656 if (ena == 0)
2657 ena = fm_ena_generate(0, FM_ENA_FMT1);
2658
2659 fm_ereport_set(*ereport, 0, PCIE_EREPORT, ena, *detector, NULL);
2660
2661 return (DDI_SUCCESS);
2662 }
2663
2664 /* ARGSUSED */
2665 static void
pf_ereport_post(dev_info_t * dip,nvlist_t ** ereport,nvlist_t ** detector,errorq_elem_t ** eqep)2666 pf_ereport_post(dev_info_t *dip, nvlist_t **ereport, nvlist_t **detector,
2667 errorq_elem_t **eqep)
2668 {
2669 struct i_ddi_fmhdl *fmhdl = DEVI(dip)->devi_fmhdl;
2670
2671 errorq_commit(fmhdl->fh_errorq, *eqep, ERRORQ_ASYNC);
2672 }
2673
2674 static void
pf_send_ereport(ddi_fm_error_t * derr,pf_impl_t * impl)2675 pf_send_ereport(ddi_fm_error_t *derr, pf_impl_t *impl)
2676 {
2677 nvlist_t *ereport;
2678 nvlist_t *detector;
2679 errorq_elem_t *eqep;
2680 pcie_bus_t *bus_p;
2681 pf_data_t *pfd_p;
2682 uint32_t total = impl->pf_total;
2683
2684 /*
2685 * Ereports need to be sent in a top down fashion. The fabric translator
2686 * expects the ereports from the Root first. This is needed to tell if
2687 * the system contains a PCIe complaint RC/RP.
2688 */
2689 for (pfd_p = impl->pf_dq_head_p; pfd_p; pfd_p = pfd_p->pe_next) {
2690 bus_p = PCIE_PFD2BUS(pfd_p);
2691 pfd_p->pe_valid = B_FALSE;
2692
2693 if (derr->fme_flag != DDI_FM_ERR_UNEXPECTED ||
2694 !DDI_FM_EREPORT_CAP(ddi_fm_capable(PCIE_PFD2DIP(pfd_p))))
2695 continue;
2696
2697 if (pf_ereport_setup(PCIE_BUS2DIP(bus_p), derr->fme_ena,
2698 &ereport, &detector, &eqep) != DDI_SUCCESS)
2699 continue;
2700
2701 if (PFD_IS_RC(pfd_p)) {
2702 fm_payload_set(ereport,
2703 "scan_bdf", DATA_TYPE_UINT16,
2704 PCIE_ROOT_FAULT(pfd_p)->scan_bdf,
2705 "scan_addr", DATA_TYPE_UINT64,
2706 PCIE_ROOT_FAULT(pfd_p)->scan_addr,
2707 "intr_src", DATA_TYPE_UINT16,
2708 PCIE_ROOT_EH_SRC(pfd_p)->intr_type,
2709 NULL);
2710 goto generic;
2711 }
2712
2713 /* Generic PCI device information */
2714 fm_payload_set(ereport,
2715 "bdf", DATA_TYPE_UINT16, bus_p->bus_bdf,
2716 "device_id", DATA_TYPE_UINT16,
2717 (bus_p->bus_dev_ven_id >> 16),
2718 "vendor_id", DATA_TYPE_UINT16,
2719 (bus_p->bus_dev_ven_id & 0xFFFF),
2720 "rev_id", DATA_TYPE_UINT8, bus_p->bus_rev_id,
2721 "dev_type", DATA_TYPE_UINT16, bus_p->bus_dev_type,
2722 "pcie_off", DATA_TYPE_UINT16, bus_p->bus_pcie_off,
2723 "pcix_off", DATA_TYPE_UINT16, bus_p->bus_pcix_off,
2724 "aer_off", DATA_TYPE_UINT16, bus_p->bus_aer_off,
2725 "ecc_ver", DATA_TYPE_UINT16, bus_p->bus_ecc_ver,
2726 NULL);
2727
2728 /* PCI registers */
2729 fm_payload_set(ereport,
2730 "pci_status", DATA_TYPE_UINT16,
2731 PCI_ERR_REG(pfd_p)->pci_err_status,
2732 "pci_command", DATA_TYPE_UINT16,
2733 PCI_ERR_REG(pfd_p)->pci_cfg_comm,
2734 NULL);
2735
2736 /* PCI bridge registers */
2737 if (PCIE_IS_BDG(bus_p)) {
2738 fm_payload_set(ereport,
2739 "pci_bdg_sec_status", DATA_TYPE_UINT16,
2740 PCI_BDG_ERR_REG(pfd_p)->pci_bdg_sec_stat,
2741 "pci_bdg_ctrl", DATA_TYPE_UINT16,
2742 PCI_BDG_ERR_REG(pfd_p)->pci_bdg_ctrl,
2743 NULL);
2744 }
2745
2746 /* PCIx registers */
2747 if (PCIE_IS_PCIX(bus_p) && !PCIE_IS_BDG(bus_p)) {
2748 fm_payload_set(ereport,
2749 "pcix_status", DATA_TYPE_UINT32,
2750 PCIX_ERR_REG(pfd_p)->pcix_status,
2751 "pcix_command", DATA_TYPE_UINT16,
2752 PCIX_ERR_REG(pfd_p)->pcix_command,
2753 NULL);
2754 }
2755
2756 /* PCIx ECC Registers */
2757 if (PCIX_ECC_VERSION_CHECK(bus_p)) {
2758 pf_pcix_ecc_regs_t *ecc_bdg_reg;
2759 pf_pcix_ecc_regs_t *ecc_reg;
2760
2761 if (PCIE_IS_BDG(bus_p))
2762 ecc_bdg_reg = PCIX_BDG_ECC_REG(pfd_p, 0);
2763 ecc_reg = PCIX_ECC_REG(pfd_p);
2764 fm_payload_set(ereport,
2765 "pcix_ecc_control_0", DATA_TYPE_UINT16,
2766 PCIE_IS_BDG(bus_p) ?
2767 (ecc_bdg_reg->pcix_ecc_ctlstat >> 16) :
2768 (ecc_reg->pcix_ecc_ctlstat >> 16),
2769 "pcix_ecc_status_0", DATA_TYPE_UINT16,
2770 PCIE_IS_BDG(bus_p) ?
2771 (ecc_bdg_reg->pcix_ecc_ctlstat & 0xFFFF) :
2772 (ecc_reg->pcix_ecc_ctlstat & 0xFFFF),
2773 "pcix_ecc_fst_addr_0", DATA_TYPE_UINT32,
2774 PCIE_IS_BDG(bus_p) ?
2775 ecc_bdg_reg->pcix_ecc_fstaddr :
2776 ecc_reg->pcix_ecc_fstaddr,
2777 "pcix_ecc_sec_addr_0", DATA_TYPE_UINT32,
2778 PCIE_IS_BDG(bus_p) ?
2779 ecc_bdg_reg->pcix_ecc_secaddr :
2780 ecc_reg->pcix_ecc_secaddr,
2781 "pcix_ecc_attr_0", DATA_TYPE_UINT32,
2782 PCIE_IS_BDG(bus_p) ?
2783 ecc_bdg_reg->pcix_ecc_attr :
2784 ecc_reg->pcix_ecc_attr,
2785 NULL);
2786 }
2787
2788 /* PCIx ECC Bridge Registers */
2789 if (PCIX_ECC_VERSION_CHECK(bus_p) && PCIE_IS_BDG(bus_p)) {
2790 pf_pcix_ecc_regs_t *ecc_bdg_reg;
2791
2792 ecc_bdg_reg = PCIX_BDG_ECC_REG(pfd_p, 1);
2793 fm_payload_set(ereport,
2794 "pcix_ecc_control_1", DATA_TYPE_UINT16,
2795 (ecc_bdg_reg->pcix_ecc_ctlstat >> 16),
2796 "pcix_ecc_status_1", DATA_TYPE_UINT16,
2797 (ecc_bdg_reg->pcix_ecc_ctlstat & 0xFFFF),
2798 "pcix_ecc_fst_addr_1", DATA_TYPE_UINT32,
2799 ecc_bdg_reg->pcix_ecc_fstaddr,
2800 "pcix_ecc_sec_addr_1", DATA_TYPE_UINT32,
2801 ecc_bdg_reg->pcix_ecc_secaddr,
2802 "pcix_ecc_attr_1", DATA_TYPE_UINT32,
2803 ecc_bdg_reg->pcix_ecc_attr,
2804 NULL);
2805 }
2806
2807 /* PCIx Bridge */
2808 if (PCIE_IS_PCIX(bus_p) && PCIE_IS_BDG(bus_p)) {
2809 fm_payload_set(ereport,
2810 "pcix_bdg_status", DATA_TYPE_UINT32,
2811 PCIX_BDG_ERR_REG(pfd_p)->pcix_bdg_stat,
2812 "pcix_bdg_sec_status", DATA_TYPE_UINT16,
2813 PCIX_BDG_ERR_REG(pfd_p)->pcix_bdg_sec_stat,
2814 NULL);
2815 }
2816
2817 /* PCIe registers */
2818 if (PCIE_IS_PCIE(bus_p)) {
2819 fm_payload_set(ereport,
2820 "pcie_status", DATA_TYPE_UINT16,
2821 PCIE_ERR_REG(pfd_p)->pcie_err_status,
2822 "pcie_command", DATA_TYPE_UINT16,
2823 PCIE_ERR_REG(pfd_p)->pcie_err_ctl,
2824 "pcie_dev_cap", DATA_TYPE_UINT32,
2825 PCIE_ERR_REG(pfd_p)->pcie_dev_cap,
2826 NULL);
2827 }
2828
2829 /* PCIe AER registers */
2830 if (PCIE_HAS_AER(bus_p)) {
2831 fm_payload_set(ereport,
2832 "pcie_adv_ctl", DATA_TYPE_UINT32,
2833 PCIE_ADV_REG(pfd_p)->pcie_adv_ctl,
2834 "pcie_ue_status", DATA_TYPE_UINT32,
2835 PCIE_ADV_REG(pfd_p)->pcie_ue_status,
2836 "pcie_ue_mask", DATA_TYPE_UINT32,
2837 PCIE_ADV_REG(pfd_p)->pcie_ue_mask,
2838 "pcie_ue_sev", DATA_TYPE_UINT32,
2839 PCIE_ADV_REG(pfd_p)->pcie_ue_sev,
2840 "pcie_ue_hdr0", DATA_TYPE_UINT32,
2841 PCIE_ADV_REG(pfd_p)->pcie_ue_hdr[0],
2842 "pcie_ue_hdr1", DATA_TYPE_UINT32,
2843 PCIE_ADV_REG(pfd_p)->pcie_ue_hdr[1],
2844 "pcie_ue_hdr2", DATA_TYPE_UINT32,
2845 PCIE_ADV_REG(pfd_p)->pcie_ue_hdr[2],
2846 "pcie_ue_hdr3", DATA_TYPE_UINT32,
2847 PCIE_ADV_REG(pfd_p)->pcie_ue_hdr[3],
2848 "pcie_ce_status", DATA_TYPE_UINT32,
2849 PCIE_ADV_REG(pfd_p)->pcie_ce_status,
2850 "pcie_ce_mask", DATA_TYPE_UINT32,
2851 PCIE_ADV_REG(pfd_p)->pcie_ce_mask,
2852 NULL);
2853 }
2854
2855 /* PCIe AER decoded header */
2856 if (HAS_AER_LOGS(pfd_p, PCIE_ADV_REG(pfd_p)->pcie_ue_status)) {
2857 fm_payload_set(ereport,
2858 "pcie_ue_tgt_trans", DATA_TYPE_UINT32,
2859 PCIE_ADV_REG(pfd_p)->pcie_ue_tgt_trans,
2860 "pcie_ue_tgt_addr", DATA_TYPE_UINT64,
2861 PCIE_ADV_REG(pfd_p)->pcie_ue_tgt_addr,
2862 "pcie_ue_tgt_bdf", DATA_TYPE_UINT16,
2863 PCIE_ADV_REG(pfd_p)->pcie_ue_tgt_bdf,
2864 NULL);
2865 /* Clear these values as they no longer valid */
2866 PCIE_ADV_REG(pfd_p)->pcie_ue_tgt_trans = 0;
2867 PCIE_ADV_REG(pfd_p)->pcie_ue_tgt_addr = 0;
2868 PCIE_ADV_REG(pfd_p)->pcie_ue_tgt_bdf = PCIE_INVALID_BDF;
2869 }
2870
2871 /* PCIe BDG AER registers */
2872 if (PCIE_IS_PCIE_BDG(bus_p) && PCIE_HAS_AER(bus_p)) {
2873 fm_payload_set(ereport,
2874 "pcie_sue_adv_ctl", DATA_TYPE_UINT32,
2875 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_ctl,
2876 "pcie_sue_status", DATA_TYPE_UINT32,
2877 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_status,
2878 "pcie_sue_mask", DATA_TYPE_UINT32,
2879 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_mask,
2880 "pcie_sue_sev", DATA_TYPE_UINT32,
2881 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_sev,
2882 "pcie_sue_hdr0", DATA_TYPE_UINT32,
2883 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_hdr[0],
2884 "pcie_sue_hdr1", DATA_TYPE_UINT32,
2885 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_hdr[1],
2886 "pcie_sue_hdr2", DATA_TYPE_UINT32,
2887 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_hdr[2],
2888 "pcie_sue_hdr3", DATA_TYPE_UINT32,
2889 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_hdr[3],
2890 NULL);
2891 }
2892
2893 /* PCIe BDG AER decoded header */
2894 if (PCIE_IS_PCIE_BDG(bus_p) && HAS_SAER_LOGS(pfd_p,
2895 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_status)) {
2896 fm_payload_set(ereport,
2897 "pcie_sue_tgt_trans", DATA_TYPE_UINT32,
2898 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_tgt_trans,
2899 "pcie_sue_tgt_addr", DATA_TYPE_UINT64,
2900 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_tgt_addr,
2901 "pcie_sue_tgt_bdf", DATA_TYPE_UINT16,
2902 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_tgt_bdf,
2903 NULL);
2904 /* Clear these values as they no longer valid */
2905 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_tgt_trans = 0;
2906 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_tgt_addr = 0;
2907 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_tgt_bdf =
2908 PCIE_INVALID_BDF;
2909 }
2910
2911 /* PCIe RP registers */
2912 if (PCIE_IS_RP(bus_p)) {
2913 fm_payload_set(ereport,
2914 "pcie_rp_status", DATA_TYPE_UINT32,
2915 PCIE_RP_REG(pfd_p)->pcie_rp_status,
2916 "pcie_rp_control", DATA_TYPE_UINT16,
2917 PCIE_RP_REG(pfd_p)->pcie_rp_ctl,
2918 NULL);
2919 }
2920
2921 /* PCIe RP AER registers */
2922 if (PCIE_IS_RP(bus_p) && PCIE_HAS_AER(bus_p)) {
2923 fm_payload_set(ereport,
2924 "pcie_adv_rp_status", DATA_TYPE_UINT32,
2925 PCIE_ADV_RP_REG(pfd_p)->pcie_rp_err_status,
2926 "pcie_adv_rp_command", DATA_TYPE_UINT32,
2927 PCIE_ADV_RP_REG(pfd_p)->pcie_rp_err_cmd,
2928 "pcie_adv_rp_ce_src_id", DATA_TYPE_UINT16,
2929 PCIE_ADV_RP_REG(pfd_p)->pcie_rp_ce_src_id,
2930 "pcie_adv_rp_ue_src_id", DATA_TYPE_UINT16,
2931 PCIE_ADV_RP_REG(pfd_p)->pcie_rp_ue_src_id,
2932 NULL);
2933 }
2934
2935 generic:
2936 /* IOV related information */
2937 if (!PCIE_BDG_IS_UNASSIGNED(PCIE_PFD2BUS(impl->pf_dq_head_p))) {
2938 fm_payload_set(ereport,
2939 "pcie_aff_flags", DATA_TYPE_UINT16,
2940 PFD_AFFECTED_DEV(pfd_p)->pe_affected_flags,
2941 "pcie_aff_bdf", DATA_TYPE_UINT16,
2942 PFD_AFFECTED_DEV(pfd_p)->pe_affected_bdf,
2943 "orig_sev", DATA_TYPE_UINT32,
2944 pfd_p->pe_orig_severity_flags,
2945 NULL);
2946 }
2947
2948 /* Misc ereport information */
2949 fm_payload_set(ereport,
2950 "remainder", DATA_TYPE_UINT32, --total,
2951 "severity", DATA_TYPE_UINT32, pfd_p->pe_severity_flags,
2952 NULL);
2953
2954 pf_ereport_post(PCIE_BUS2DIP(bus_p), &ereport, &detector,
2955 &eqep);
2956 }
2957
2958 /* Unlock all the devices in the queue */
2959 for (pfd_p = impl->pf_dq_tail_p; pfd_p; pfd_p = pfd_p->pe_prev) {
2960 if (pfd_p->pe_lock) {
2961 pf_handler_exit(PCIE_PFD2DIP(pfd_p));
2962 }
2963 }
2964 }
2965
2966 /*
2967 * pf_handler_enter must be called to serial access to each device's pf_data_t.
2968 * Once error handling is finished with the device call pf_handler_exit to allow
2969 * other threads to access it. The same thread may call pf_handler_enter
2970 * several times without any consequences.
2971 *
2972 * The "impl" variable is passed in during scan fabric to double check that
2973 * there is not a recursive algorithm and to ensure only one thread is doing a
2974 * fabric scan at all times.
2975 *
2976 * In some cases "impl" is not available, such as "child lookup" being called
2977 * from outside of scan fabric, just pass in NULL for this variable and this
2978 * extra check will be skipped.
2979 */
2980 static int
pf_handler_enter(dev_info_t * dip,pf_impl_t * impl)2981 pf_handler_enter(dev_info_t *dip, pf_impl_t *impl)
2982 {
2983 pf_data_t *pfd_p = PCIE_DIP2PFD(dip);
2984
2985 ASSERT(pfd_p);
2986
2987 /*
2988 * Check to see if the lock has already been taken by this
2989 * thread. If so just return and don't take lock again.
2990 */
2991 if (!pfd_p->pe_lock || !impl) {
2992 i_ddi_fm_handler_enter(dip);
2993 pfd_p->pe_lock = B_TRUE;
2994 return (PF_SCAN_SUCCESS);
2995 }
2996
2997 /* Check to see that this dip is already in the "impl" error queue */
2998 for (pfd_p = impl->pf_dq_head_p; pfd_p; pfd_p = pfd_p->pe_next) {
2999 if (PCIE_PFD2DIP(pfd_p) == dip) {
3000 return (PF_SCAN_SUCCESS);
3001 }
3002 }
3003
3004 return (PF_SCAN_DEADLOCK);
3005 }
3006
3007 static void
pf_handler_exit(dev_info_t * dip)3008 pf_handler_exit(dev_info_t *dip)
3009 {
3010 pf_data_t *pfd_p = PCIE_DIP2PFD(dip);
3011
3012 ASSERT(pfd_p);
3013
3014 ASSERT(pfd_p->pe_lock == B_TRUE);
3015 i_ddi_fm_handler_exit(dip);
3016 pfd_p->pe_lock = B_FALSE;
3017 }
3018
3019 /*
3020 * This function calls the driver's callback function (if it's FMA hardened
3021 * and callback capable). This function relies on the current thread already
3022 * owning the driver's fmhdl lock.
3023 */
3024 static int
pf_fm_callback(dev_info_t * dip,ddi_fm_error_t * derr)3025 pf_fm_callback(dev_info_t *dip, ddi_fm_error_t *derr)
3026 {
3027 int cb_sts = DDI_FM_OK;
3028
3029 if (DDI_FM_ERRCB_CAP(ddi_fm_capable(dip))) {
3030 dev_info_t *pdip = ddi_get_parent(dip);
3031 struct i_ddi_fmhdl *hdl = DEVI(pdip)->devi_fmhdl;
3032 struct i_ddi_fmtgt *tgt = hdl->fh_tgts;
3033 struct i_ddi_errhdl *errhdl;
3034 while (tgt != NULL) {
3035 if (dip == tgt->ft_dip) {
3036 errhdl = tgt->ft_errhdl;
3037 cb_sts = errhdl->eh_func(dip, derr,
3038 errhdl->eh_impl);
3039 break;
3040 }
3041 tgt = tgt->ft_next;
3042 }
3043 }
3044 return (cb_sts);
3045 }
3046
3047 static void
pf_reset_pfd(pf_data_t * pfd_p)3048 pf_reset_pfd(pf_data_t *pfd_p)
3049 {
3050 pcie_bus_t *bus_p = PCIE_PFD2BUS(pfd_p);
3051
3052 pfd_p->pe_severity_flags = 0;
3053 pfd_p->pe_orig_severity_flags = 0;
3054 /* pe_lock and pe_valid were reset in pf_send_ereport */
3055
3056 PFD_AFFECTED_DEV(pfd_p)->pe_affected_flags = 0;
3057 PFD_AFFECTED_DEV(pfd_p)->pe_affected_bdf = PCIE_INVALID_BDF;
3058
3059 if (PCIE_IS_ROOT(bus_p)) {
3060 PCIE_ROOT_FAULT(pfd_p)->scan_bdf = PCIE_INVALID_BDF;
3061 PCIE_ROOT_FAULT(pfd_p)->scan_addr = 0;
3062 PCIE_ROOT_FAULT(pfd_p)->full_scan = B_FALSE;
3063 PCIE_ROOT_EH_SRC(pfd_p)->intr_type = PF_INTR_TYPE_NONE;
3064 PCIE_ROOT_EH_SRC(pfd_p)->intr_data = NULL;
3065 }
3066
3067 if (PCIE_IS_BDG(bus_p)) {
3068 bzero(PCI_BDG_ERR_REG(pfd_p), sizeof (pf_pci_bdg_err_regs_t));
3069 }
3070
3071 PCI_ERR_REG(pfd_p)->pci_err_status = 0;
3072 PCI_ERR_REG(pfd_p)->pci_cfg_comm = 0;
3073
3074 if (PCIE_IS_PCIE(bus_p)) {
3075 if (PCIE_IS_ROOT(bus_p)) {
3076 bzero(PCIE_RP_REG(pfd_p),
3077 sizeof (pf_pcie_rp_err_regs_t));
3078 bzero(PCIE_ADV_RP_REG(pfd_p),
3079 sizeof (pf_pcie_adv_rp_err_regs_t));
3080 PCIE_ADV_RP_REG(pfd_p)->pcie_rp_ce_src_id =
3081 PCIE_INVALID_BDF;
3082 PCIE_ADV_RP_REG(pfd_p)->pcie_rp_ue_src_id =
3083 PCIE_INVALID_BDF;
3084 } else if (PCIE_IS_PCIE_BDG(bus_p)) {
3085 bzero(PCIE_ADV_BDG_REG(pfd_p),
3086 sizeof (pf_pcie_adv_bdg_err_regs_t));
3087 PCIE_ADV_BDG_REG(pfd_p)->pcie_sue_tgt_bdf =
3088 PCIE_INVALID_BDF;
3089 }
3090
3091 if (PCIE_IS_PCIE_BDG(bus_p) && PCIE_IS_PCIX(bus_p)) {
3092 if (PCIX_ECC_VERSION_CHECK(bus_p)) {
3093 bzero(PCIX_BDG_ECC_REG(pfd_p, 0),
3094 sizeof (pf_pcix_ecc_regs_t));
3095 bzero(PCIX_BDG_ECC_REG(pfd_p, 1),
3096 sizeof (pf_pcix_ecc_regs_t));
3097 }
3098 PCIX_BDG_ERR_REG(pfd_p)->pcix_bdg_sec_stat = 0;
3099 PCIX_BDG_ERR_REG(pfd_p)->pcix_bdg_stat = 0;
3100 }
3101
3102 PCIE_ADV_REG(pfd_p)->pcie_adv_ctl = 0;
3103 PCIE_ADV_REG(pfd_p)->pcie_ue_status = 0;
3104 PCIE_ADV_REG(pfd_p)->pcie_ue_mask = 0;
3105 PCIE_ADV_REG(pfd_p)->pcie_ue_sev = 0;
3106 PCIE_ADV_HDR(pfd_p, 0) = 0;
3107 PCIE_ADV_HDR(pfd_p, 1) = 0;
3108 PCIE_ADV_HDR(pfd_p, 2) = 0;
3109 PCIE_ADV_HDR(pfd_p, 3) = 0;
3110 PCIE_ADV_REG(pfd_p)->pcie_ce_status = 0;
3111 PCIE_ADV_REG(pfd_p)->pcie_ce_mask = 0;
3112 PCIE_ADV_REG(pfd_p)->pcie_ue_tgt_trans = 0;
3113 PCIE_ADV_REG(pfd_p)->pcie_ue_tgt_addr = 0;
3114 PCIE_ADV_REG(pfd_p)->pcie_ue_tgt_bdf = PCIE_INVALID_BDF;
3115
3116 PCIE_ERR_REG(pfd_p)->pcie_err_status = 0;
3117 PCIE_ERR_REG(pfd_p)->pcie_err_ctl = 0;
3118 PCIE_ERR_REG(pfd_p)->pcie_dev_cap = 0;
3119
3120 } else if (PCIE_IS_PCIX(bus_p)) {
3121 if (PCIE_IS_BDG(bus_p)) {
3122 if (PCIX_ECC_VERSION_CHECK(bus_p)) {
3123 bzero(PCIX_BDG_ECC_REG(pfd_p, 0),
3124 sizeof (pf_pcix_ecc_regs_t));
3125 bzero(PCIX_BDG_ECC_REG(pfd_p, 1),
3126 sizeof (pf_pcix_ecc_regs_t));
3127 }
3128 PCIX_BDG_ERR_REG(pfd_p)->pcix_bdg_sec_stat = 0;
3129 PCIX_BDG_ERR_REG(pfd_p)->pcix_bdg_stat = 0;
3130 } else {
3131 if (PCIX_ECC_VERSION_CHECK(bus_p)) {
3132 bzero(PCIX_ECC_REG(pfd_p),
3133 sizeof (pf_pcix_ecc_regs_t));
3134 }
3135 PCIX_ERR_REG(pfd_p)->pcix_command = 0;
3136 PCIX_ERR_REG(pfd_p)->pcix_status = 0;
3137 }
3138 }
3139
3140 pfd_p->pe_prev = NULL;
3141 pfd_p->pe_next = NULL;
3142 pfd_p->pe_rber_fatal = B_FALSE;
3143 }
3144
3145 pcie_bus_t *
pf_find_busp_by_bdf(pf_impl_t * impl,pcie_req_id_t bdf)3146 pf_find_busp_by_bdf(pf_impl_t *impl, pcie_req_id_t bdf)
3147 {
3148 pcie_bus_t *temp_bus_p;
3149 pf_data_t *temp_pfd_p;
3150
3151 for (temp_pfd_p = impl->pf_dq_head_p;
3152 temp_pfd_p;
3153 temp_pfd_p = temp_pfd_p->pe_next) {
3154 temp_bus_p = PCIE_PFD2BUS(temp_pfd_p);
3155
3156 if (bdf == temp_bus_p->bus_bdf) {
3157 return (temp_bus_p);
3158 }
3159 }
3160
3161 return (NULL);
3162 }
3163
3164 pcie_bus_t *
pf_find_busp_by_addr(pf_impl_t * impl,uint64_t addr)3165 pf_find_busp_by_addr(pf_impl_t *impl, uint64_t addr)
3166 {
3167 pcie_bus_t *temp_bus_p;
3168 pf_data_t *temp_pfd_p;
3169
3170 for (temp_pfd_p = impl->pf_dq_head_p;
3171 temp_pfd_p;
3172 temp_pfd_p = temp_pfd_p->pe_next) {
3173 temp_bus_p = PCIE_PFD2BUS(temp_pfd_p);
3174
3175 if (pf_in_assigned_addr(temp_bus_p, addr)) {
3176 return (temp_bus_p);
3177 }
3178 }
3179
3180 return (NULL);
3181 }
3182
3183 pcie_bus_t *
pf_find_busp_by_aer(pf_impl_t * impl,pf_data_t * pfd_p)3184 pf_find_busp_by_aer(pf_impl_t *impl, pf_data_t *pfd_p)
3185 {
3186 pf_pcie_adv_err_regs_t *reg_p = PCIE_ADV_REG(pfd_p);
3187 pcie_bus_t *temp_bus_p = NULL;
3188 pcie_req_id_t bdf;
3189 uint64_t addr;
3190 pcie_tlp_hdr_t *tlp_hdr = (pcie_tlp_hdr_t *)reg_p->pcie_ue_hdr;
3191 uint32_t trans_type = reg_p->pcie_ue_tgt_trans;
3192
3193 if ((tlp_hdr->type == PCIE_TLP_TYPE_CPL) ||
3194 (tlp_hdr->type == PCIE_TLP_TYPE_CPLLK)) {
3195 pcie_cpl_t *cpl_tlp = (pcie_cpl_t *)®_p->pcie_ue_hdr[1];
3196
3197 bdf = (cpl_tlp->rid > cpl_tlp->cid) ? cpl_tlp->rid :
3198 cpl_tlp->cid;
3199 temp_bus_p = pf_find_busp_by_bdf(impl, bdf);
3200 } else if (trans_type == PF_ADDR_PIO) {
3201 addr = reg_p->pcie_ue_tgt_addr;
3202 temp_bus_p = pf_find_busp_by_addr(impl, addr);
3203 } else {
3204 /* PF_ADDR_DMA type */
3205 bdf = reg_p->pcie_ue_tgt_bdf;
3206 temp_bus_p = pf_find_busp_by_bdf(impl, bdf);
3207 }
3208
3209 return (temp_bus_p);
3210 }
3211
3212 pcie_bus_t *
pf_find_busp_by_saer(pf_impl_t * impl,pf_data_t * pfd_p)3213 pf_find_busp_by_saer(pf_impl_t *impl, pf_data_t *pfd_p)
3214 {
3215 pf_pcie_adv_bdg_err_regs_t *reg_p = PCIE_ADV_BDG_REG(pfd_p);
3216 pcie_bus_t *temp_bus_p = NULL;
3217 pcie_req_id_t bdf;
3218 uint64_t addr;
3219
3220 addr = reg_p->pcie_sue_tgt_addr;
3221 bdf = reg_p->pcie_sue_tgt_bdf;
3222
3223 if (addr != NULL) {
3224 temp_bus_p = pf_find_busp_by_addr(impl, addr);
3225 } else if (PCIE_CHECK_VALID_BDF(bdf)) {
3226 temp_bus_p = pf_find_busp_by_bdf(impl, bdf);
3227 }
3228
3229 return (temp_bus_p);
3230 }
3231