diff options
Diffstat (limited to 'arch/sparc64/kernel/pci_psycho.c')
-rw-r--r-- | arch/sparc64/kernel/pci_psycho.c | 361 |
1 files changed, 0 insertions, 361 deletions
diff --git a/arch/sparc64/kernel/pci_psycho.c b/arch/sparc64/kernel/pci_psycho.c index 2de51fb34ee7..bac9c1ba40e0 100644 --- a/arch/sparc64/kernel/pci_psycho.c +++ b/arch/sparc64/kernel/pci_psycho.c | |||
@@ -98,9 +98,6 @@ static void *psycho_pci_config_mkaddr(struct pci_pbm_info *pbm, | |||
98 | } | 98 | } |
99 | 99 | ||
100 | /* PSYCHO error handling support. */ | 100 | /* PSYCHO error handling support. */ |
101 | enum psycho_error_type { | ||
102 | UE_ERR, CE_ERR, PCI_ERR | ||
103 | }; | ||
104 | 101 | ||
105 | /* Helper function of IOMMU error checking, which checks out | 102 | /* Helper function of IOMMU error checking, which checks out |
106 | * the state of the streaming buffers. The IOMMU lock is | 103 | * the state of the streaming buffers. The IOMMU lock is |
@@ -125,112 +122,10 @@ enum psycho_error_type { | |||
125 | #define PSYCHO_STC_DATA_B 0xc000UL | 122 | #define PSYCHO_STC_DATA_B 0xc000UL |
126 | #define PSYCHO_STC_ERR_A 0xb400UL | 123 | #define PSYCHO_STC_ERR_A 0xb400UL |
127 | #define PSYCHO_STC_ERR_B 0xc400UL | 124 | #define PSYCHO_STC_ERR_B 0xc400UL |
128 | #define PSYCHO_STCERR_WRITE 0x0000000000000002UL /* Write Error */ | ||
129 | #define PSYCHO_STCERR_READ 0x0000000000000001UL /* Read Error */ | ||
130 | #define PSYCHO_STC_TAG_A 0xb800UL | 125 | #define PSYCHO_STC_TAG_A 0xb800UL |
131 | #define PSYCHO_STC_TAG_B 0xc800UL | 126 | #define PSYCHO_STC_TAG_B 0xc800UL |
132 | #define PSYCHO_STCTAG_PPN 0x0fffffff00000000UL /* Physical Page Number */ | ||
133 | #define PSYCHO_STCTAG_VPN 0x00000000ffffe000UL /* Virtual Page Number */ | ||
134 | #define PSYCHO_STCTAG_VALID 0x0000000000000002UL /* Valid */ | ||
135 | #define PSYCHO_STCTAG_WRITE 0x0000000000000001UL /* Writable */ | ||
136 | #define PSYCHO_STC_LINE_A 0xb900UL | 127 | #define PSYCHO_STC_LINE_A 0xb900UL |
137 | #define PSYCHO_STC_LINE_B 0xc900UL | 128 | #define PSYCHO_STC_LINE_B 0xc900UL |
138 | #define PSYCHO_STCLINE_LINDX 0x0000000001e00000UL /* LRU Index */ | ||
139 | #define PSYCHO_STCLINE_SPTR 0x00000000001f8000UL /* Dirty Data Start Pointer */ | ||
140 | #define PSYCHO_STCLINE_LADDR 0x0000000000007f00UL /* Line Address */ | ||
141 | #define PSYCHO_STCLINE_EPTR 0x00000000000000fcUL /* Dirty Data End Pointer */ | ||
142 | #define PSYCHO_STCLINE_VALID 0x0000000000000002UL /* Valid */ | ||
143 | #define PSYCHO_STCLINE_FOFN 0x0000000000000001UL /* Fetch Outstanding / Flush Necessary */ | ||
144 | |||
145 | static DEFINE_SPINLOCK(stc_buf_lock); | ||
146 | static unsigned long stc_error_buf[128]; | ||
147 | static unsigned long stc_tag_buf[16]; | ||
148 | static unsigned long stc_line_buf[16]; | ||
149 | |||
150 | static void psycho_check_stc_error(struct pci_pbm_info *pbm) | ||
151 | { | ||
152 | struct strbuf *strbuf = &pbm->stc; | ||
153 | unsigned long err_base, tag_base, line_base; | ||
154 | u64 control; | ||
155 | int i; | ||
156 | |||
157 | err_base = strbuf->strbuf_err_stat; | ||
158 | tag_base = strbuf->strbuf_tag_diag; | ||
159 | line_base = strbuf->strbuf_line_diag; | ||
160 | |||
161 | spin_lock(&stc_buf_lock); | ||
162 | |||
163 | /* This is __REALLY__ dangerous. When we put the | ||
164 | * streaming buffer into diagnostic mode to probe | ||
165 | * it's tags and error status, we _must_ clear all | ||
166 | * of the line tag valid bits before re-enabling | ||
167 | * the streaming buffer. If any dirty data lives | ||
168 | * in the STC when we do this, we will end up | ||
169 | * invalidating it before it has a chance to reach | ||
170 | * main memory. | ||
171 | */ | ||
172 | control = psycho_read(strbuf->strbuf_control); | ||
173 | psycho_write(strbuf->strbuf_control, | ||
174 | (control | PSYCHO_STRBUF_CTRL_DENAB)); | ||
175 | for (i = 0; i < 128; i++) { | ||
176 | unsigned long val; | ||
177 | |||
178 | val = psycho_read(err_base + (i * 8UL)); | ||
179 | psycho_write(err_base + (i * 8UL), 0UL); | ||
180 | stc_error_buf[i] = val; | ||
181 | } | ||
182 | for (i = 0; i < 16; i++) { | ||
183 | stc_tag_buf[i] = psycho_read(tag_base + (i * 8UL)); | ||
184 | stc_line_buf[i] = psycho_read(line_base + (i * 8UL)); | ||
185 | psycho_write(tag_base + (i * 8UL), 0UL); | ||
186 | psycho_write(line_base + (i * 8UL), 0UL); | ||
187 | } | ||
188 | |||
189 | /* OK, state is logged, exit diagnostic mode. */ | ||
190 | psycho_write(strbuf->strbuf_control, control); | ||
191 | |||
192 | for (i = 0; i < 16; i++) { | ||
193 | int j, saw_error, first, last; | ||
194 | |||
195 | saw_error = 0; | ||
196 | first = i * 8; | ||
197 | last = first + 8; | ||
198 | for (j = first; j < last; j++) { | ||
199 | unsigned long errval = stc_error_buf[j]; | ||
200 | if (errval != 0) { | ||
201 | saw_error++; | ||
202 | printk("%s: STC_ERR(%d)[wr(%d)rd(%d)]\n", | ||
203 | pbm->name, | ||
204 | j, | ||
205 | (errval & PSYCHO_STCERR_WRITE) ? 1 : 0, | ||
206 | (errval & PSYCHO_STCERR_READ) ? 1 : 0); | ||
207 | } | ||
208 | } | ||
209 | if (saw_error != 0) { | ||
210 | unsigned long tagval = stc_tag_buf[i]; | ||
211 | unsigned long lineval = stc_line_buf[i]; | ||
212 | printk("%s: STC_TAG(%d)[PA(%016lx)VA(%08lx)V(%d)W(%d)]\n", | ||
213 | pbm->name, | ||
214 | i, | ||
215 | ((tagval & PSYCHO_STCTAG_PPN) >> 19UL), | ||
216 | (tagval & PSYCHO_STCTAG_VPN), | ||
217 | ((tagval & PSYCHO_STCTAG_VALID) ? 1 : 0), | ||
218 | ((tagval & PSYCHO_STCTAG_WRITE) ? 1 : 0)); | ||
219 | printk("%s: STC_LINE(%d)[LIDX(%lx)SP(%lx)LADDR(%lx)EP(%lx)" | ||
220 | "V(%d)FOFN(%d)]\n", | ||
221 | pbm->name, | ||
222 | i, | ||
223 | ((lineval & PSYCHO_STCLINE_LINDX) >> 21UL), | ||
224 | ((lineval & PSYCHO_STCLINE_SPTR) >> 15UL), | ||
225 | ((lineval & PSYCHO_STCLINE_LADDR) >> 8UL), | ||
226 | ((lineval & PSYCHO_STCLINE_EPTR) >> 2UL), | ||
227 | ((lineval & PSYCHO_STCLINE_VALID) ? 1 : 0), | ||
228 | ((lineval & PSYCHO_STCLINE_FOFN) ? 1 : 0)); | ||
229 | } | ||
230 | } | ||
231 | |||
232 | spin_unlock(&stc_buf_lock); | ||
233 | } | ||
234 | 129 | ||
235 | /* When an Uncorrectable Error or a PCI Error happens, we | 130 | /* When an Uncorrectable Error or a PCI Error happens, we |
236 | * interrogate the IOMMU state to see if it is the cause. | 131 | * interrogate the IOMMU state to see if it is the cause. |
@@ -257,122 +152,7 @@ static void psycho_check_stc_error(struct pci_pbm_info *pbm) | |||
257 | #define PSYCHO_IOMMU_TSBBASE 0x0208UL | 152 | #define PSYCHO_IOMMU_TSBBASE 0x0208UL |
258 | #define PSYCHO_IOMMU_FLUSH 0x0210UL | 153 | #define PSYCHO_IOMMU_FLUSH 0x0210UL |
259 | #define PSYCHO_IOMMU_TAG 0xa580UL | 154 | #define PSYCHO_IOMMU_TAG 0xa580UL |
260 | #define PSYCHO_IOMMU_TAG_ERRSTS (0x3UL << 23UL) | ||
261 | #define PSYCHO_IOMMU_TAG_ERR (0x1UL << 22UL) | ||
262 | #define PSYCHO_IOMMU_TAG_WRITE (0x1UL << 21UL) | ||
263 | #define PSYCHO_IOMMU_TAG_STREAM (0x1UL << 20UL) | ||
264 | #define PSYCHO_IOMMU_TAG_SIZE (0x1UL << 19UL) | ||
265 | #define PSYCHO_IOMMU_TAG_VPAGE 0x7ffffUL | ||
266 | #define PSYCHO_IOMMU_DATA 0xa600UL | 155 | #define PSYCHO_IOMMU_DATA 0xa600UL |
267 | #define PSYCHO_IOMMU_DATA_VALID (1UL << 30UL) | ||
268 | #define PSYCHO_IOMMU_DATA_CACHE (1UL << 28UL) | ||
269 | #define PSYCHO_IOMMU_DATA_PPAGE 0xfffffffUL | ||
270 | static void psycho_check_iommu_error(struct pci_pbm_info *pbm, | ||
271 | unsigned long afsr, | ||
272 | unsigned long afar, | ||
273 | enum psycho_error_type type) | ||
274 | { | ||
275 | struct iommu *iommu = pbm->iommu; | ||
276 | unsigned long iommu_tag[16]; | ||
277 | unsigned long iommu_data[16]; | ||
278 | unsigned long flags; | ||
279 | u64 control; | ||
280 | int i; | ||
281 | |||
282 | spin_lock_irqsave(&iommu->lock, flags); | ||
283 | control = psycho_read(iommu->iommu_control); | ||
284 | if (control & PSYCHO_IOMMU_CTRL_XLTEERR) { | ||
285 | char *type_string; | ||
286 | |||
287 | /* Clear the error encountered bit. */ | ||
288 | control &= ~PSYCHO_IOMMU_CTRL_XLTEERR; | ||
289 | psycho_write(iommu->iommu_control, control); | ||
290 | |||
291 | switch((control & PSYCHO_IOMMU_CTRL_XLTESTAT) >> 25UL) { | ||
292 | case 0: | ||
293 | type_string = "Protection Error"; | ||
294 | break; | ||
295 | case 1: | ||
296 | type_string = "Invalid Error"; | ||
297 | break; | ||
298 | case 2: | ||
299 | type_string = "TimeOut Error"; | ||
300 | break; | ||
301 | case 3: | ||
302 | default: | ||
303 | type_string = "ECC Error"; | ||
304 | break; | ||
305 | }; | ||
306 | printk("%s: IOMMU Error, type[%s]\n", | ||
307 | pbm->name, type_string); | ||
308 | |||
309 | /* Put the IOMMU into diagnostic mode and probe | ||
310 | * it's TLB for entries with error status. | ||
311 | * | ||
312 | * It is very possible for another DVMA to occur | ||
313 | * while we do this probe, and corrupt the system | ||
314 | * further. But we are so screwed at this point | ||
315 | * that we are likely to crash hard anyways, so | ||
316 | * get as much diagnostic information to the | ||
317 | * console as we can. | ||
318 | */ | ||
319 | psycho_write(iommu->iommu_control, | ||
320 | control | PSYCHO_IOMMU_CTRL_DENAB); | ||
321 | for (i = 0; i < 16; i++) { | ||
322 | unsigned long base = pbm->controller_regs; | ||
323 | |||
324 | iommu_tag[i] = | ||
325 | psycho_read(base + PSYCHO_IOMMU_TAG + (i * 8UL)); | ||
326 | iommu_data[i] = | ||
327 | psycho_read(base + PSYCHO_IOMMU_DATA + (i * 8UL)); | ||
328 | |||
329 | /* Now clear out the entry. */ | ||
330 | psycho_write(base + PSYCHO_IOMMU_TAG + (i * 8UL), 0); | ||
331 | psycho_write(base + PSYCHO_IOMMU_DATA + (i * 8UL), 0); | ||
332 | } | ||
333 | |||
334 | /* Leave diagnostic mode. */ | ||
335 | psycho_write(iommu->iommu_control, control); | ||
336 | |||
337 | for (i = 0; i < 16; i++) { | ||
338 | unsigned long tag, data; | ||
339 | |||
340 | tag = iommu_tag[i]; | ||
341 | if (!(tag & PSYCHO_IOMMU_TAG_ERR)) | ||
342 | continue; | ||
343 | |||
344 | data = iommu_data[i]; | ||
345 | switch((tag & PSYCHO_IOMMU_TAG_ERRSTS) >> 23UL) { | ||
346 | case 0: | ||
347 | type_string = "Protection Error"; | ||
348 | break; | ||
349 | case 1: | ||
350 | type_string = "Invalid Error"; | ||
351 | break; | ||
352 | case 2: | ||
353 | type_string = "TimeOut Error"; | ||
354 | break; | ||
355 | case 3: | ||
356 | default: | ||
357 | type_string = "ECC Error"; | ||
358 | break; | ||
359 | }; | ||
360 | printk("%s: IOMMU TAG(%d)[error(%s) wr(%d) str(%d) sz(%dK) vpg(%08lx)]\n", | ||
361 | pbm->name, i, type_string, | ||
362 | ((tag & PSYCHO_IOMMU_TAG_WRITE) ? 1 : 0), | ||
363 | ((tag & PSYCHO_IOMMU_TAG_STREAM) ? 1 : 0), | ||
364 | ((tag & PSYCHO_IOMMU_TAG_SIZE) ? 64 : 8), | ||
365 | (tag & PSYCHO_IOMMU_TAG_VPAGE) << IOMMU_PAGE_SHIFT); | ||
366 | printk("%s: IOMMU DATA(%d)[valid(%d) cache(%d) ppg(%016lx)]\n", | ||
367 | pbm->name, i, | ||
368 | ((data & PSYCHO_IOMMU_DATA_VALID) ? 1 : 0), | ||
369 | ((data & PSYCHO_IOMMU_DATA_CACHE) ? 1 : 0), | ||
370 | (data & PSYCHO_IOMMU_DATA_PPAGE) << IOMMU_PAGE_SHIFT); | ||
371 | } | ||
372 | } | ||
373 | psycho_check_stc_error(pbm); | ||
374 | spin_unlock_irqrestore(&iommu->lock, flags); | ||
375 | } | ||
376 | 156 | ||
377 | /* Uncorrectable Errors. Cause of the error and the address are | 157 | /* Uncorrectable Errors. Cause of the error and the address are |
378 | * recorded in the UE_AFSR and UE_AFAR of PSYCHO. They are errors | 158 | * recorded in the UE_AFSR and UE_AFAR of PSYCHO. They are errors |
@@ -540,150 +320,9 @@ static irqreturn_t psycho_ce_intr(int irq, void *dev_id) | |||
540 | */ | 320 | */ |
541 | #define PSYCHO_PCI_AFSR_A 0x2010UL | 321 | #define PSYCHO_PCI_AFSR_A 0x2010UL |
542 | #define PSYCHO_PCI_AFSR_B 0x4010UL | 322 | #define PSYCHO_PCI_AFSR_B 0x4010UL |
543 | #define PSYCHO_PCIAFSR_PMA 0x8000000000000000UL /* Primary Master Abort Error */ | ||
544 | #define PSYCHO_PCIAFSR_PTA 0x4000000000000000UL /* Primary Target Abort Error */ | ||
545 | #define PSYCHO_PCIAFSR_PRTRY 0x2000000000000000UL /* Primary Excessive Retries */ | ||
546 | #define PSYCHO_PCIAFSR_PPERR 0x1000000000000000UL /* Primary Parity Error */ | ||
547 | #define PSYCHO_PCIAFSR_SMA 0x0800000000000000UL /* Secondary Master Abort Error */ | ||
548 | #define PSYCHO_PCIAFSR_STA 0x0400000000000000UL /* Secondary Target Abort Error */ | ||
549 | #define PSYCHO_PCIAFSR_SRTRY 0x0200000000000000UL /* Secondary Excessive Retries */ | ||
550 | #define PSYCHO_PCIAFSR_SPERR 0x0100000000000000UL /* Secondary Parity Error */ | ||
551 | #define PSYCHO_PCIAFSR_RESV1 0x00ff000000000000UL /* Reserved */ | ||
552 | #define PSYCHO_PCIAFSR_BMSK 0x0000ffff00000000UL /* Bytemask of failed transfer */ | ||
553 | #define PSYCHO_PCIAFSR_BLK 0x0000000080000000UL /* Trans was block operation */ | ||
554 | #define PSYCHO_PCIAFSR_RESV2 0x0000000040000000UL /* Reserved */ | ||
555 | #define PSYCHO_PCIAFSR_MID 0x000000003e000000UL /* MID causing the error */ | ||
556 | #define PSYCHO_PCIAFSR_RESV3 0x0000000001ffffffUL /* Reserved */ | ||
557 | #define PSYCHO_PCI_AFAR_A 0x2018UL | 323 | #define PSYCHO_PCI_AFAR_A 0x2018UL |
558 | #define PSYCHO_PCI_AFAR_B 0x4018UL | 324 | #define PSYCHO_PCI_AFAR_B 0x4018UL |
559 | 325 | ||
560 | static irqreturn_t psycho_pcierr_intr_other(struct pci_pbm_info *pbm) | ||
561 | { | ||
562 | unsigned long csr, csr_error_bits; | ||
563 | irqreturn_t ret = IRQ_NONE; | ||
564 | u16 stat; | ||
565 | |||
566 | csr = psycho_read(pbm->pci_csr); | ||
567 | csr_error_bits = | ||
568 | csr & (PSYCHO_PCICTRL_SBH_ERR | PSYCHO_PCICTRL_SERR); | ||
569 | if (csr_error_bits) { | ||
570 | /* Clear the errors. */ | ||
571 | psycho_write(pbm->pci_csr, csr); | ||
572 | |||
573 | /* Log 'em. */ | ||
574 | if (csr_error_bits & PSYCHO_PCICTRL_SBH_ERR) | ||
575 | printk("%s: PCI streaming byte hole error asserted.\n", | ||
576 | pbm->name); | ||
577 | if (csr_error_bits & PSYCHO_PCICTRL_SERR) | ||
578 | printk("%s: PCI SERR signal asserted.\n", pbm->name); | ||
579 | ret = IRQ_HANDLED; | ||
580 | } | ||
581 | pci_read_config_word(pbm->pci_bus->self, PCI_STATUS, &stat); | ||
582 | if (stat & (PCI_STATUS_PARITY | | ||
583 | PCI_STATUS_SIG_TARGET_ABORT | | ||
584 | PCI_STATUS_REC_TARGET_ABORT | | ||
585 | PCI_STATUS_REC_MASTER_ABORT | | ||
586 | PCI_STATUS_SIG_SYSTEM_ERROR)) { | ||
587 | printk("%s: PCI bus error, PCI_STATUS[%04x]\n", | ||
588 | pbm->name, stat); | ||
589 | pci_write_config_word(pbm->pci_bus->self, PCI_STATUS, 0xffff); | ||
590 | ret = IRQ_HANDLED; | ||
591 | } | ||
592 | return ret; | ||
593 | } | ||
594 | |||
595 | static irqreturn_t psycho_pcierr_intr(int irq, void *dev_id) | ||
596 | { | ||
597 | struct pci_pbm_info *pbm = dev_id; | ||
598 | unsigned long afsr_reg, afar_reg; | ||
599 | unsigned long afsr, afar, error_bits; | ||
600 | int reported; | ||
601 | |||
602 | afsr_reg = pbm->pci_afsr; | ||
603 | afar_reg = pbm->pci_afar; | ||
604 | |||
605 | /* Latch error status. */ | ||
606 | afar = psycho_read(afar_reg); | ||
607 | afsr = psycho_read(afsr_reg); | ||
608 | |||
609 | /* Clear primary/secondary error status bits. */ | ||
610 | error_bits = afsr & | ||
611 | (PSYCHO_PCIAFSR_PMA | PSYCHO_PCIAFSR_PTA | | ||
612 | PSYCHO_PCIAFSR_PRTRY | PSYCHO_PCIAFSR_PPERR | | ||
613 | PSYCHO_PCIAFSR_SMA | PSYCHO_PCIAFSR_STA | | ||
614 | PSYCHO_PCIAFSR_SRTRY | PSYCHO_PCIAFSR_SPERR); | ||
615 | if (!error_bits) | ||
616 | return psycho_pcierr_intr_other(pbm); | ||
617 | psycho_write(afsr_reg, error_bits); | ||
618 | |||
619 | /* Log the error. */ | ||
620 | printk("%s: PCI Error, primary error type[%s]\n", | ||
621 | pbm->name, | ||
622 | (((error_bits & PSYCHO_PCIAFSR_PMA) ? | ||
623 | "Master Abort" : | ||
624 | ((error_bits & PSYCHO_PCIAFSR_PTA) ? | ||
625 | "Target Abort" : | ||
626 | ((error_bits & PSYCHO_PCIAFSR_PRTRY) ? | ||
627 | "Excessive Retries" : | ||
628 | ((error_bits & PSYCHO_PCIAFSR_PPERR) ? | ||
629 | "Parity Error" : "???")))))); | ||
630 | printk("%s: bytemask[%04lx] UPA_MID[%02lx] was_block(%d)\n", | ||
631 | pbm->name, | ||
632 | (afsr & PSYCHO_PCIAFSR_BMSK) >> 32UL, | ||
633 | (afsr & PSYCHO_PCIAFSR_MID) >> 25UL, | ||
634 | (afsr & PSYCHO_PCIAFSR_BLK) ? 1 : 0); | ||
635 | printk("%s: PCI AFAR [%016lx]\n", pbm->name, afar); | ||
636 | printk("%s: PCI Secondary errors [", pbm->name); | ||
637 | reported = 0; | ||
638 | if (afsr & PSYCHO_PCIAFSR_SMA) { | ||
639 | reported++; | ||
640 | printk("(Master Abort)"); | ||
641 | } | ||
642 | if (afsr & PSYCHO_PCIAFSR_STA) { | ||
643 | reported++; | ||
644 | printk("(Target Abort)"); | ||
645 | } | ||
646 | if (afsr & PSYCHO_PCIAFSR_SRTRY) { | ||
647 | reported++; | ||
648 | printk("(Excessive Retries)"); | ||
649 | } | ||
650 | if (afsr & PSYCHO_PCIAFSR_SPERR) { | ||
651 | reported++; | ||
652 | printk("(Parity Error)"); | ||
653 | } | ||
654 | if (!reported) | ||
655 | printk("(none)"); | ||
656 | printk("]\n"); | ||
657 | |||
658 | /* For the error types shown, scan PBM's PCI bus for devices | ||
659 | * which have logged that error type. | ||
660 | */ | ||
661 | |||
662 | /* If we see a Target Abort, this could be the result of an | ||
663 | * IOMMU translation error of some sort. It is extremely | ||
664 | * useful to log this information as usually it indicates | ||
665 | * a bug in the IOMMU support code or a PCI device driver. | ||
666 | */ | ||
667 | if (error_bits & (PSYCHO_PCIAFSR_PTA | PSYCHO_PCIAFSR_STA)) { | ||
668 | psycho_check_iommu_error(pbm, afsr, afar, PCI_ERR); | ||
669 | pci_scan_for_target_abort(pbm, pbm->pci_bus); | ||
670 | } | ||
671 | if (error_bits & (PSYCHO_PCIAFSR_PMA | PSYCHO_PCIAFSR_SMA)) | ||
672 | pci_scan_for_master_abort(pbm, pbm->pci_bus); | ||
673 | |||
674 | /* For excessive retries, PSYCHO/PBM will abort the device | ||
675 | * and there is no way to specifically check for excessive | ||
676 | * retries in the config space status registers. So what | ||
677 | * we hope is that we'll catch it via the master/target | ||
678 | * abort events. | ||
679 | */ | ||
680 | |||
681 | if (error_bits & (PSYCHO_PCIAFSR_PPERR | PSYCHO_PCIAFSR_SPERR)) | ||
682 | pci_scan_for_parity_error(pbm, pbm->pci_bus); | ||
683 | |||
684 | return IRQ_HANDLED; | ||
685 | } | ||
686 | |||
687 | /* XXX What about PowerFail/PowerManagement??? -DaveM */ | 326 | /* XXX What about PowerFail/PowerManagement??? -DaveM */ |
688 | #define PSYCHO_ECC_CTRL 0x0020 | 327 | #define PSYCHO_ECC_CTRL 0x0020 |
689 | #define PSYCHO_ECCCTRL_EE 0x8000000000000000UL /* Enable ECC Checking */ | 328 | #define PSYCHO_ECCCTRL_EE 0x8000000000000000UL /* Enable ECC Checking */ |