开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
pci_schizo.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：59k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

pci_schizo.c：源码内容
  1. /* $Id: pci_schizo.c,v 1.23.2.2 2002/03/11 07:55:24 davem Exp $
  2.  * pci_schizo.c: SCHIZO specific PCI controller support.
  3.  *
  4.  * Copyright (C) 2001 David S. Miller (davem@redhat.com)
  5.  */
  7. #include <linux/kernel.h>
  8. #include <linux/types.h>
  9. #include <linux/pci.h>
  10. #include <linux/init.h>
  11. #include <linux/slab.h>
  13. #include <asm/pbm.h>
  14. #include <asm/iommu.h>
  15. #include <asm/irq.h>
  16. #include <asm/upa.h>
  18. #include "pci_impl.h"
  19. #include "iommu_common.h"
  21. /* All SCHIZO registers are 64-bits.  The following accessor
  22.  * routines are how they are accessed.  The REG parameter
  23.  * is a physical address.
  24.  */
  25. #define schizo_read(__reg) 
  26. ({ u64 __ret; 
  27. __asm__ __volatile__("ldxa [%1] %2, %0" 
  28.      : "=r" (__ret) 
  29.      : "r" (__reg), "i" (ASI_PHYS_BYPASS_EC_E) 
  30.      : "memory"); 
  31. __ret; 
  32. })
  33. #define schizo_write(__reg, __val) 
  34. __asm__ __volatile__("stxa %0, [%1] %2" 
  35.      : /* no outputs */ 
  36.      : "r" (__val), "r" (__reg), 
  37.        "i" (ASI_PHYS_BYPASS_EC_E) 
  38.      : "memory")
  40. /* This is a convention that at least Excalibur and Merlin
  41.  * follow.  I suppose the SCHIZO used in Starcat and friends
  42.  * will do similar.
  43.  *
  44.  * The only way I could see this changing is if the newlink
  45.  * block requires more space in Schizo's address space than
  46.  * they predicted, thus requiring an address space reorg when
  47.  * the newer Schizo is taped out.
  48.  *
  49.  * These offsets look weird because I keep in p->controller_regs
  50.  * the second PROM register property minus 0x10000 which is the
  51.  * base of the Safari and UPA64S registers of SCHIZO.
  52.  */
  53. #define SCHIZO_PBM_A_REGS_OFF (0x600000UL - 0x400000UL)
  54. #define SCHIZO_PBM_B_REGS_OFF (0x700000UL - 0x400000UL)
  56. /* Streaming buffer control register. */
  57. #define SCHIZO_STRBUF_CTRL_LPTR    0x00000000000000f0UL /* LRU Lock Pointer */
  58. #define SCHIZO_STRBUF_CTRL_LENAB   0x0000000000000008UL /* LRU Lock Enable */
  59. #define SCHIZO_STRBUF_CTRL_RRDIS   0x0000000000000004UL /* Rerun Disable */
  60. #define SCHIZO_STRBUF_CTRL_DENAB   0x0000000000000002UL /* Diagnostic Mode Enable */
  61. #define SCHIZO_STRBUF_CTRL_ENAB    0x0000000000000001UL /* Streaming Buffer Enable */
  63. /* IOMMU control register. */
  64. #define SCHIZO_IOMMU_CTRL_RESV     0xfffffffff9000000 /* Reserved                      */
  65. #define SCHIZO_IOMMU_CTRL_XLTESTAT 0x0000000006000000 /* Translation Error Status      */
  66. #define SCHIZO_IOMMU_CTRL_XLTEERR  0x0000000001000000 /* Translation Error encountered */
  67. #define SCHIZO_IOMMU_CTRL_LCKEN    0x0000000000800000 /* Enable translation locking    */
  68. #define SCHIZO_IOMMU_CTRL_LCKPTR   0x0000000000780000 /* Translation lock pointer      */
  69. #define SCHIZO_IOMMU_CTRL_TSBSZ    0x0000000000070000 /* TSB Size                      */
  70. #define SCHIZO_IOMMU_TSBSZ_1K      0x0000000000000000 /* TSB Table 1024 8-byte entries */
  71. #define SCHIZO_IOMMU_TSBSZ_2K      0x0000000000010000 /* TSB Table 2048 8-byte entries */
  72. #define SCHIZO_IOMMU_TSBSZ_4K      0x0000000000020000 /* TSB Table 4096 8-byte entries */
  73. #define SCHIZO_IOMMU_TSBSZ_8K      0x0000000000030000 /* TSB Table 8192 8-byte entries */
  74. #define SCHIZO_IOMMU_TSBSZ_16K     0x0000000000040000 /* TSB Table 16k 8-byte entries  */
  75. #define SCHIZO_IOMMU_TSBSZ_32K     0x0000000000050000 /* TSB Table 32k 8-byte entries  */
  76. #define SCHIZO_IOMMU_TSBSZ_64K     0x0000000000060000 /* TSB Table 64k 8-byte entries  */
  77. #define SCHIZO_IOMMU_TSBSZ_128K    0x0000000000070000 /* TSB Table 128k 8-byte entries */
  78. #define SCHIZO_IOMMU_CTRL_RESV2    0x000000000000fff8 /* Reserved                      */
  79. #define SCHIZO_IOMMU_CTRL_TBWSZ    0x0000000000000004 /* Assumed page size, 0=8k 1=64k */
  80. #define SCHIZO_IOMMU_CTRL_DENAB    0x0000000000000002 /* Diagnostic mode enable        */
  81. #define SCHIZO_IOMMU_CTRL_ENAB     0x0000000000000001 /* IOMMU Enable                  */
  83. /* Schizo config space address format is nearly identical to
  84.  * that of PSYCHO:
  85.  *
  86.  *  32             24 23 16 15    11 10       8 7   2  1 0
  87.  * ---------------------------------------------------------
  88.  * |0 0 0 0 0 0 0 0 0| bus | device | function | reg | 0 0 |
  89.  * ---------------------------------------------------------
  90.  */
  91. #define SCHIZO_CONFIG_BASE(PBM) ((PBM)->config_space)
  92. #define SCHIZO_CONFIG_ENCODE(BUS, DEVFN, REG)
  93. (((unsigned long)(BUS)   << 16) |
  94.  ((unsigned long)(DEVFN) << 8)  |
  95.  ((unsigned long)(REG)))
  97. static void *schizo_pci_config_mkaddr(struct pci_pbm_info *pbm,
  98.       unsigned char bus,
  99.       unsigned int devfn,
  100.       int where)
  101. {
  102. if (!pbm)
  103. return NULL;
  104. return (void *)
  105. (SCHIZO_CONFIG_BASE(pbm) |
  106.  SCHIZO_CONFIG_ENCODE(bus, devfn, where));
  107. }
  109. /* 4 slots on pbm A, and 6 slots on pbm B.  In both cases
  110.  * slot 0 is the SCHIZO host bridge itself.
  111.  */
  112. static int schizo_out_of_range(struct pci_pbm_info *pbm,
  113.        unsigned char bus,
  114.        unsigned char devfn)
  115. {
  116. return ((pbm->parent == 0) ||
  117. ((pbm == &pbm->parent->pbm_B) &&
  118.  (bus == pbm->pci_first_busno) &&
  119.  PCI_SLOT(devfn) > 6) ||
  120. ((pbm == &pbm->parent->pbm_A) &&
  121.  (bus == pbm->pci_first_busno) &&
  122.  PCI_SLOT(devfn) > 4));
  123. }
  125. /* SCHIZO PCI configuration space accessors. */
  127. static int schizo_read_byte(struct pci_dev *dev, int where, u8 *value)
  128. {
  129. struct pci_pbm_info *pbm = pci_bus2pbm[dev->bus->number];
  130. unsigned char bus = dev->bus->number;
  131. unsigned int devfn = dev->devfn;
  132. u8 *addr;
  134. *value = 0xff;
  135. addr = schizo_pci_config_mkaddr(pbm, bus, devfn, where);
  136. if (!addr)
  137. return PCIBIOS_SUCCESSFUL;
  139. if (schizo_out_of_range(pbm, bus, devfn))
  140. return PCIBIOS_SUCCESSFUL;
  141. pci_config_read8(addr, value);
  142. return PCIBIOS_SUCCESSFUL;
  143. }
  145. static int schizo_read_word(struct pci_dev *dev, int where, u16 *value)
  146. {
  147. struct pci_pbm_info *pbm = pci_bus2pbm[dev->bus->number];
  148. unsigned char bus = dev->bus->number;
  149. unsigned int devfn = dev->devfn;
  150. u16 *addr;
  152. *value = 0xffff;
  153. addr = schizo_pci_config_mkaddr(pbm, bus, devfn, where);
  154. if (!addr)
  155. return PCIBIOS_SUCCESSFUL;
  157. if (schizo_out_of_range(pbm, bus, devfn))
  158. return PCIBIOS_SUCCESSFUL;
  160. if (where & 0x01) {
  161. printk("pcibios_read_config_word: misaligned reg [%x]n",
  162.        where);
  163. return PCIBIOS_SUCCESSFUL;
  164. }
  165. pci_config_read16(addr, value);
  166. return PCIBIOS_SUCCESSFUL;
  167. }
  169. static int schizo_read_dword(struct pci_dev *dev, int where, u32 *value)
  170. {
  171. struct pci_pbm_info *pbm = pci_bus2pbm[dev->bus->number];
  172. unsigned char bus = dev->bus->number;
  173. unsigned int devfn = dev->devfn;
  174. u32 *addr;
  176. *value = 0xffffffff;
  177. addr = schizo_pci_config_mkaddr(pbm, bus, devfn, where);
  178. if (!addr)
  179. return PCIBIOS_SUCCESSFUL;
  181. if (schizo_out_of_range(pbm, bus, devfn))
  182. return PCIBIOS_SUCCESSFUL;
  184. if (where & 0x03) {
  185. printk("pcibios_read_config_dword: misaligned reg [%x]n",
  186.        where);
  187. return PCIBIOS_SUCCESSFUL;
  188. }
  190. pci_config_read32(addr, value);
  191. return PCIBIOS_SUCCESSFUL;
  192. }
  194. static int schizo_write_byte(struct pci_dev *dev, int where, u8 value)
  195. {
  196. struct pci_pbm_info *pbm = pci_bus2pbm[dev->bus->number];
  197. unsigned char bus = dev->bus->number;
  198. unsigned int devfn = dev->devfn;
  199. u8 *addr;
  201. addr = schizo_pci_config_mkaddr(pbm, bus, devfn, where);
  202. if (!addr)
  203. return PCIBIOS_SUCCESSFUL;
  205. if (schizo_out_of_range(pbm, bus, devfn))
  206. return PCIBIOS_SUCCESSFUL;
  208. pci_config_write8(addr, value);
  209. return PCIBIOS_SUCCESSFUL;
  210. }
  212. static int schizo_write_word(struct pci_dev *dev, int where, u16 value)
  213. {
  214. struct pci_pbm_info *pbm = pci_bus2pbm[dev->bus->number];
  215. unsigned char bus = dev->bus->number;
  216. unsigned int devfn = dev->devfn;
  217. u16 *addr;
  219. addr = schizo_pci_config_mkaddr(pbm, bus, devfn, where);
  220. if (!addr)
  221. return PCIBIOS_SUCCESSFUL;
  223. if (schizo_out_of_range(pbm, bus, devfn))
  224. return PCIBIOS_SUCCESSFUL;
  226. if (where & 0x01) {
  227. printk("pcibios_write_config_word: misaligned reg [%x]n",
  228.        where);
  229. return PCIBIOS_SUCCESSFUL;
  230. }
  231. pci_config_write16(addr, value);
  232. return PCIBIOS_SUCCESSFUL;
  233. }
  235. static int schizo_write_dword(struct pci_dev *dev, int where, u32 value)
  236. {
  237. struct pci_pbm_info *pbm = pci_bus2pbm[dev->bus->number];
  238. unsigned char bus = dev->bus->number;
  239. unsigned int devfn = dev->devfn;
  240. u32 *addr;
  242. addr = schizo_pci_config_mkaddr(pbm, bus, devfn, where);
  243. if (!addr)
  244. return PCIBIOS_SUCCESSFUL;
  246. if (schizo_out_of_range(pbm, bus, devfn))
  247. return PCIBIOS_SUCCESSFUL;
  249. if (where & 0x03) {
  250. printk("pcibios_write_config_dword: misaligned reg [%x]n",
  251.        where);
  252. return PCIBIOS_SUCCESSFUL;
  253. }
  254. pci_config_write32(addr, value);
  255. return PCIBIOS_SUCCESSFUL;
  256. }
  258. static struct pci_ops schizo_ops = {
  259. schizo_read_byte,
  260. schizo_read_word,
  261. schizo_read_dword,
  262. schizo_write_byte,
  263. schizo_write_word,
  264. schizo_write_dword
  265. };
  267. /* SCHIZO interrupt mapping support.  Unlike Psycho, for this controller the
  268.  * imap/iclr registers are per-PBM.
  269.  */
  270. #define SCHIZO_IMAP_BASE 0x1000UL
  271. #define SCHIZO_ICLR_BASE 0x1400UL
  273. static unsigned long schizo_imap_offset(unsigned long ino)
  274. {
  275. return SCHIZO_IMAP_BASE + (ino * 8UL);
  276. }
  278. static unsigned long schizo_iclr_offset(unsigned long ino)
  279. {
  280. return SCHIZO_ICLR_BASE + (ino * 8UL);
  281. }
  283. /* PCI SCHIZO INO number to Sparc PIL level.  This table only matters for
  284.  * INOs which will not have an associated PCI device struct, ie. onboard
  285.  * EBUS devices and PCI controller internal error interrupts.
  286.  */
  287. static unsigned char schizo_pil_table[] = {
  288. /*0x00*/0, 0, 0, 0, /* PCI slot 0  Int A, B, C, D */
  289. /*0x04*/0, 0, 0, 0, /* PCI slot 1  Int A, B, C, D */
  290. /*0x08*/0, 0, 0, 0, /* PCI slot 2  Int A, B, C, D */
  291. /*0x0c*/0, 0, 0, 0, /* PCI slot 3  Int A, B, C, D */
  292. /*0x10*/0, 0, 0, 0, /* PCI slot 4  Int A, B, C, D */
  293. /*0x14*/0, 0, 0, 0, /* PCI slot 5  Int A, B, C, D */
  294. /*0x18*/4, /* SCSI */
  295. /*0x19*/4, /* second SCSI */
  296. /*0x1a*/0, /* UNKNOWN */
  297. /*0x1b*/0, /* UNKNOWN */
  298. /*0x1c*/8, /* Parallel */
  299. /*0x1d*/5, /* Ethernet */
  300. /*0x1e*/8, /* Firewire-1394 */
  301. /*0x1f*/9, /* USB */
  302. /*0x20*/13, /* Audio Record */
  303. /*0x21*/14, /* Audio Playback */
  304. /*0x22*/12, /* Serial */
  305. /*0x23*/4, /* EBUS I2C  */
  306. /*0x24*/10, /* RTC Clock */
  307. /*0x25*/11, /* Floppy */
  308. /*0x26*/0, /* UNKNOWN */
  309. /*0x27*/0, /* UNKNOWN */
  310. /*0x28*/0, /* UNKNOWN */
  311. /*0x29*/0, /* UNKNOWN */
  312. /*0x2a*/10, /* UPA 1 */
  313. /*0x2b*/10, /* UPA 2 */
  314. /*0x2c*/0, /* UNKNOWN */
  315. /*0x2d*/0, /* UNKNOWN */
  316. /*0x2e*/0, /* UNKNOWN */
  317. /*0x2f*/0, /* UNKNOWN */
  318. /*0x30*/15, /* Uncorrectable ECC */
  319. /*0x31*/15, /* Correctable ECC */
  320. /*0x32*/15, /* PCI Bus A Error */
  321. /*0x33*/15, /* PCI Bus B Error */
  322. /*0x34*/15, /* Safari Bus Error */
  323. /*0x35*/0, /* Reserved */
  324. /*0x36*/0, /* Reserved */
  325. /*0x37*/0, /* Reserved */
  326. /*0x38*/0, /* Reserved for NewLink */
  327. /*0x39*/0, /* Reserved for NewLink */
  328. /*0x3a*/0, /* Reserved for NewLink */
  329. /*0x3b*/0, /* Reserved for NewLink */
  330. /*0x3c*/0, /* Reserved for NewLink */
  331. /*0x3d*/0, /* Reserved for NewLink */
  332. /*0x3e*/0, /* Reserved for NewLink */
  333. /*0x3f*/0, /* Reserved for NewLink */
  334. };
  336. static int __init schizo_ino_to_pil(struct pci_dev *pdev, unsigned int ino)
  337. {
  338. int ret;
  340. if (pdev &&
  341.     pdev->vendor == PCI_VENDOR_ID_SUN &&
  342.     pdev->device == PCI_DEVICE_ID_SUN_RIO_USB)
  343. return 9;
  345. ret = schizo_pil_table[ino];
  346. if (ret == 0 && pdev == NULL) {
  347. ret = 4;
  348. } else if (ret == 0) {
  349. switch ((pdev->class >> 16) & 0xff) {
  350. case PCI_BASE_CLASS_STORAGE:
  351. ret = 4;
  352. break;
  354. case PCI_BASE_CLASS_NETWORK:
  355. ret = 6;
  356. break;
  358. case PCI_BASE_CLASS_DISPLAY:
  359. ret = 9;
  360. break;
  362. case PCI_BASE_CLASS_MULTIMEDIA:
  363. case PCI_BASE_CLASS_MEMORY:
  364. case PCI_BASE_CLASS_BRIDGE:
  365. case PCI_BASE_CLASS_SERIAL:
  366. ret = 10;
  367. break;
  369. default:
  370. ret = 4;
  371. break;
  372. };
  373. }
  375. return ret;
  376. }
  378. static unsigned int __init schizo_irq_build(struct pci_pbm_info *pbm,
  379.     struct pci_dev *pdev,
  380.     unsigned int ino)
  381. {
  382. struct pci_controller_info *p = pbm->parent;
  383. struct ino_bucket *bucket;
  384. unsigned long imap, iclr, pbm_off;
  385. unsigned long imap_off, iclr_off;
  386. int pil;
  388. if (pbm == &p->pbm_A)
  389. pbm_off = SCHIZO_PBM_A_REGS_OFF;
  390. else
  391. pbm_off = SCHIZO_PBM_B_REGS_OFF;
  393. ino &= PCI_IRQ_INO;
  394. imap_off = schizo_imap_offset(ino);
  396. /* Now build the IRQ bucket. */
  397. pil = schizo_ino_to_pil(pdev, ino);
  399. if (PIL_RESERVED(pil))
  400. BUG();
  402. imap = p->controller_regs + pbm_off + imap_off;
  403. imap += 4;
  405. iclr_off = schizo_iclr_offset(ino);
  406. iclr = p->controller_regs + pbm_off + iclr_off;
  407. iclr += 4;
  409. /* On Schizo, no inofixup occurs.  This is because each
  410.  * INO has it's own IMAP register.  On Psycho and Sabre
  411.  * there is only one IMAP register for each PCI slot even
  412.  * though four different INOs can be generated by each
  413.  * PCI slot.
  414.  */
  415. bucket = __bucket(build_irq(pil, 0, iclr, imap));
  416. bucket->flags |= IBF_PCI;
  418. return __irq(bucket);
  419. }
  421. /* SCHIZO error handling support. */
  422. enum schizo_error_type {
  423. UE_ERR, CE_ERR, PCI_ERR, SAFARI_ERR
  424. };
  426. static spinlock_t stc_buf_lock = SPIN_LOCK_UNLOCKED;
  427. static unsigned long stc_error_buf[128];
  428. static unsigned long stc_tag_buf[16];
  429. static unsigned long stc_line_buf[16];
  431. static void schizo_clear_other_err_intr(int irq)
  432. {
  433. struct ino_bucket *bucket = __bucket(irq);
  434. unsigned long iclr = bucket->iclr;
  436. iclr += (SCHIZO_PBM_B_REGS_OFF - SCHIZO_PBM_A_REGS_OFF);
  437. upa_writel(ICLR_IDLE, iclr);
  438. }
  440. #define SCHIZO_STC_ERR 0xb800UL /* --> 0xba00 */
  441. #define SCHIZO_STC_TAG 0xba00UL /* --> 0xba80 */
  442. #define SCHIZO_STC_LINE 0xbb00UL /* --> 0xbb80 */
  444. #define SCHIZO_STCERR_WRITE 0x2UL
  445. #define SCHIZO_STCERR_READ 0x1UL
  447. #define SCHIZO_STCTAG_PPN 0x3fffffff00000000UL
  448. #define SCHIZO_STCTAG_VPN 0x00000000ffffe000UL
  449. #define SCHIZO_STCTAG_VALID 0x8000000000000000UL
  450. #define SCHIZO_STCTAG_READ 0x4000000000000000UL
  452. #define SCHIZO_STCLINE_LINDX 0x0000000007800000UL
  453. #define SCHIZO_STCLINE_SPTR 0x000000000007e000UL
  454. #define SCHIZO_STCLINE_LADDR 0x0000000000001fc0UL
  455. #define SCHIZO_STCLINE_EPTR 0x000000000000003fUL
  456. #define SCHIZO_STCLINE_VALID 0x0000000000600000UL
  457. #define SCHIZO_STCLINE_FOFN 0x0000000000180000UL
  459. static void __schizo_check_stc_error_pbm(struct pci_pbm_info *pbm,
  460.  enum schizo_error_type type)
  461. {
  462. struct pci_controller_info *p = pbm->parent;
  463. struct pci_strbuf *strbuf = &pbm->stc;
  464. unsigned long regbase = p->controller_regs;
  465. unsigned long err_base, tag_base, line_base;
  466. u64 control;
  467. char pbm_name = (pbm == &p->pbm_A ? 'A' : 'B');
  468. int i;
  470. if (pbm == &p->pbm_A)
  471. regbase += SCHIZO_PBM_A_REGS_OFF;
  472. else
  473. regbase += SCHIZO_PBM_B_REGS_OFF;
  475. err_base = regbase + SCHIZO_STC_ERR;
  476. tag_base = regbase + SCHIZO_STC_TAG;
  477. line_base = regbase + SCHIZO_STC_LINE;
  479. spin_lock(&stc_buf_lock);
  481. /* This is __REALLY__ dangerous.  When we put the
  482.  * streaming buffer into diagnostic mode to probe
  483.  * it's tags and error status, we _must_ clear all
  484.  * of the line tag valid bits before re-enabling
  485.  * the streaming buffer.  If any dirty data lives
  486.  * in the STC when we do this, we will end up
  487.  * invalidating it before it has a chance to reach
  488.  * main memory.
  489.  */
  490. control = schizo_read(strbuf->strbuf_control);
  491. schizo_write(strbuf->strbuf_control,
  492.      (control | SCHIZO_STRBUF_CTRL_DENAB));
  493. for (i = 0; i < 128; i++) {
  494. unsigned long val;
  496. val = schizo_read(err_base + (i * 8UL));
  497. schizo_write(err_base + (i * 8UL), 0UL);
  498. stc_error_buf[i] = val;
  499. }
  500. for (i = 0; i < 16; i++) {
  501. stc_tag_buf[i] = schizo_read(tag_base + (i * 8UL));
  502. stc_line_buf[i] = schizo_read(line_base + (i * 8UL));
  503. schizo_write(tag_base + (i * 8UL), 0UL);
  504. schizo_write(line_base + (i * 8UL), 0UL);
  505. }
  507. /* OK, state is logged, exit diagnostic mode. */
  508. schizo_write(strbuf->strbuf_control, control);
  510. for (i = 0; i < 16; i++) {
  511. int j, saw_error, first, last;
  513. saw_error = 0;
  514. first = i * 8;
  515. last = first + 8;
  516. for (j = first; j < last; j++) {
  517. unsigned long errval = stc_error_buf[j];
  518. if (errval != 0) {
  519. saw_error++;
  520. printk("SCHIZO%d: PBM-%c STC_ERR(%d)[wr(%d)rd(%d)]n",
  521.        p->index, pbm_name,
  522.        j,
  523.        (errval & SCHIZO_STCERR_WRITE) ? 1 : 0,
  524.        (errval & SCHIZO_STCERR_READ) ? 1 : 0);
  525. }
  526. }
  527. if (saw_error != 0) {
  528. unsigned long tagval = stc_tag_buf[i];
  529. unsigned long lineval = stc_line_buf[i];
  530. printk("SCHIZO%d: PBM-%c STC_TAG(%d)[PA(%016lx)VA(%08lx)V(%d)R(%d)]n",
  531.        p->index, pbm_name,
  532.        i,
  533.        ((tagval & SCHIZO_STCTAG_PPN) >> 19UL),
  534.        (tagval & SCHIZO_STCTAG_VPN),
  535.        ((tagval & SCHIZO_STCTAG_VALID) ? 1 : 0),
  536.        ((tagval & SCHIZO_STCTAG_READ) ? 1 : 0));
  538. /* XXX Should spit out per-bank error information... -DaveM */
  539. printk("SCHIZO%d: PBM-%c STC_LINE(%d)[LIDX(%lx)SP(%lx)LADDR(%lx)EP(%lx)"
  540.        "V(%d)FOFN(%d)]n",
  541.        p->index, pbm_name,
  542.        i,
  543.        ((lineval & SCHIZO_STCLINE_LINDX) >> 23UL),
  544.        ((lineval & SCHIZO_STCLINE_SPTR) >> 13UL),
  545.        ((lineval & SCHIZO_STCLINE_LADDR) >> 6UL),
  546.        ((lineval & SCHIZO_STCLINE_EPTR) >> 0UL),
  547.        ((lineval & SCHIZO_STCLINE_VALID) ? 1 : 0),
  548.        ((lineval & SCHIZO_STCLINE_FOFN) ? 1 : 0));
  549. }
  550. }
  552. spin_unlock(&stc_buf_lock);
  553. }
  555. /* IOMMU is per-PBM in Schizo, so interrogate both for anonymous
  556.  * controller level errors.
  557.  */
  559. #define SCHIZO_IOMMU_TAG 0xa580UL
  560. #define SCHIZO_IOMMU_DATA 0xa600UL
  562. #define SCHIZO_IOMMU_TAG_CTXT 0x0000001ffe000000UL
  563. #define SCHIZO_IOMMU_TAG_ERRSTS 0x0000000001800000UL
  564. #define SCHIZO_IOMMU_TAG_ERR 0x0000000000400000UL
  565. #define SCHIZO_IOMMU_TAG_WRITE 0x0000000000200000UL
  566. #define SCHIZO_IOMMU_TAG_STREAM 0x0000000000100000UL
  567. #define SCHIZO_IOMMU_TAG_SIZE 0x0000000000080000UL
  568. #define SCHIZO_IOMMU_TAG_VPAGE 0x000000000007ffffUL
  570. #define SCHIZO_IOMMU_DATA_VALID 0x0000000100000000UL
  571. #define SCHIZO_IOMMU_DATA_CACHE 0x0000000040000000UL
  572. #define SCHIZO_IOMMU_DATA_PPAGE 0x000000003fffffffUL
  574. static void schizo_check_iommu_error_pbm(struct pci_pbm_info *pbm,
  575.  enum schizo_error_type type)
  576. {
  577. struct pci_controller_info *p = pbm->parent;
  578. struct pci_iommu *iommu = pbm->iommu;
  579. unsigned long iommu_tag[16];
  580. unsigned long iommu_data[16];
  581. unsigned long flags;
  582. u64 control;
  583. char pbm_name = (pbm == &p->pbm_A ? 'A' : 'B');
  584. int i;
  586. spin_lock_irqsave(&iommu->lock, flags);
  587. control = schizo_read(iommu->iommu_control);
  588. if (control & SCHIZO_IOMMU_CTRL_XLTEERR) {
  589. unsigned long base;
  590. char *type_string;
  592. /* Clear the error encountered bit. */
  593. control &= ~SCHIZO_IOMMU_CTRL_XLTEERR;
  594. schizo_write(iommu->iommu_control, control);
  596. switch((control & SCHIZO_IOMMU_CTRL_XLTESTAT) >> 25UL) {
  597. case 0:
  598. type_string = "Protection Error";
  599. break;
  600. case 1:
  601. type_string = "Invalid Error";
  602. break;
  603. case 2:
  604. type_string = "TimeOut Error";
  605. break;
  606. case 3:
  607. default:
  608. type_string = "ECC Error";
  609. break;
  610. };
  611. printk("SCHIZO%d: PBM-%c IOMMU Error, type[%s]n",
  612.        p->index, pbm_name, type_string);
  614. /* Put the IOMMU into diagnostic mode and probe
  615.  * it's TLB for entries with error status.
  616.  *
  617.  * It is very possible for another DVMA to occur
  618.  * while we do this probe, and corrupt the system
  619.  * further.  But we are so screwed at this point
  620.  * that we are likely to crash hard anyways, so
  621.  * get as much diagnostic information to the
  622.  * console as we can.
  623.  */
  624. schizo_write(iommu->iommu_control,
  625.      control | SCHIZO_IOMMU_CTRL_DENAB);
  627. base = p->controller_regs;
  628. if (pbm == &p->pbm_A)
  629. base += SCHIZO_PBM_A_REGS_OFF;
  630. else
  631. base += SCHIZO_PBM_B_REGS_OFF;
  633. for (i = 0; i < 16; i++) {
  634. iommu_tag[i] =
  635. schizo_read(base + SCHIZO_IOMMU_TAG + (i * 8UL));
  636. iommu_data[i] =
  637. schizo_read(base + SCHIZO_IOMMU_DATA + (i * 8UL));
  639. /* Now clear out the entry. */
  640. schizo_write(base + SCHIZO_IOMMU_TAG + (i * 8UL), 0);
  641. schizo_write(base + SCHIZO_IOMMU_DATA + (i * 8UL), 0);
  642. }
  644. /* Leave diagnostic mode. */
  645. schizo_write(iommu->iommu_control, control);
  647. for (i = 0; i < 16; i++) {
  648. unsigned long tag, data;
  650. tag = iommu_tag[i];
  651. if (!(tag & SCHIZO_IOMMU_TAG_ERR))
  652. continue;
  654. data = iommu_data[i];
  655. switch((tag & SCHIZO_IOMMU_TAG_ERRSTS) >> 23UL) {
  656. case 0:
  657. type_string = "Protection Error";
  658. break;
  659. case 1:
  660. type_string = "Invalid Error";
  661. break;
  662. case 2:
  663. type_string = "TimeOut Error";
  664. break;
  665. case 3:
  666. default:
  667. type_string = "ECC Error";
  668. break;
  669. };
  670. printk("SCHIZO%d: PBM-%c IOMMU TAG(%d)[error(%s) ctx(%x) wr(%d) str(%d) "
  671.        "sz(%dK) vpg(%08lx)]n",
  672.        p->index, pbm_name, i, type_string,
  673.        (int)((tag & SCHIZO_IOMMU_TAG_CTXT) >> 25UL),
  674.        ((tag & SCHIZO_IOMMU_TAG_WRITE) ? 1 : 0),
  675.        ((tag & SCHIZO_IOMMU_TAG_STREAM) ? 1 : 0),
  676.        ((tag & SCHIZO_IOMMU_TAG_SIZE) ? 64 : 8),
  677.        (tag & SCHIZO_IOMMU_TAG_VPAGE) << IOMMU_PAGE_SHIFT);
  678. printk("SCHIZO%d: PBM-%c IOMMU DATA(%d)[valid(%d) cache(%d) ppg(%016lx)]n",
  679.        p->index, pbm_name, i,
  680.        ((data & SCHIZO_IOMMU_DATA_VALID) ? 1 : 0),
  681.        ((data & SCHIZO_IOMMU_DATA_CACHE) ? 1 : 0),
  682.        (data & SCHIZO_IOMMU_DATA_PPAGE) << IOMMU_PAGE_SHIFT);
  683. }
  684. }
  685. __schizo_check_stc_error_pbm(pbm, type);
  686. spin_unlock_irqrestore(&iommu->lock, flags);
  687. }
  689. static void schizo_check_iommu_error(struct pci_controller_info *p,
  690.      enum schizo_error_type type)
  691. {
  692. schizo_check_iommu_error_pbm(&p->pbm_A, type);
  693. schizo_check_iommu_error_pbm(&p->pbm_B, type);
  694. }
  696. /* Uncorrectable ECC error status gathering. */
  697. #define SCHIZO_UE_AFSR 0x10030UL
  698. #define SCHIZO_UE_AFAR 0x10038UL
  700. #define SCHIZO_UEAFSR_PPIO 0x8000000000000000UL
  701. #define SCHIZO_UEAFSR_PDRD 0x4000000000000000UL
  702. #define SCHIZO_UEAFSR_PDWR 0x2000000000000000UL
  703. #define SCHIZO_UEAFSR_SPIO 0x1000000000000000UL
  704. #define SCHIZO_UEAFSR_SDMA 0x0800000000000000UL
  705. #define SCHIZO_UEAFSR_ERRPNDG 0x0300000000000000UL
  706. #define SCHIZO_UEAFSR_BMSK 0x000003ff00000000UL
  707. #define SCHIZO_UEAFSR_QOFF 0x00000000c0000000UL
  708. #define SCHIZO_UEAFSR_AID 0x000000001f000000UL
  709. #define SCHIZO_UEAFSR_PARTIAL 0x0000000000800000UL
  710. #define SCHIZO_UEAFSR_OWNEDIN 0x0000000000400000UL
  711. #define SCHIZO_UEAFSR_MTAGSYND 0x00000000000f0000UL
  712. #define SCHIZO_UEAFSR_MTAG 0x000000000000e000UL
  713. #define SCHIZO_UEAFSR_ECCSYND 0x00000000000001ffUL
  715. static void schizo_ue_intr(int irq, void *dev_id, struct pt_regs *regs)
  716. {
  717. struct pci_controller_info *p = dev_id;
  718. unsigned long afsr_reg = p->controller_regs + SCHIZO_UE_AFSR;
  719. unsigned long afar_reg = p->controller_regs + SCHIZO_UE_AFAR;
  720. unsigned long afsr, afar, error_bits;
  721. int reported, limit;
  723. /* Latch uncorrectable error status. */
  724. afar = schizo_read(afar_reg);
  726. /* If either of the error pending bits are set in the
  727.  * AFSR, the error status is being actively updated by
  728.  * the hardware and we must re-read to get a clean value.
  729.  */
  730. limit = 1000;
  731. do {
  732. afsr = schizo_read(afsr_reg);
  733. } while ((afsr & SCHIZO_UEAFSR_ERRPNDG) != 0 && --limit);
  735. /* Clear the primary/secondary error status bits. */
  736. error_bits = afsr &
  737. (SCHIZO_UEAFSR_PPIO | SCHIZO_UEAFSR_PDRD | SCHIZO_UEAFSR_PDWR |
  738.  SCHIZO_UEAFSR_SPIO | SCHIZO_UEAFSR_SDMA);
  739. if (!error_bits)
  740. return;
  741. schizo_write(afsr_reg, error_bits);
  743. /* Log the error. */
  744. printk("SCHIZO%d: Uncorrectable Error, primary error type[%s]n",
  745.        p->index,
  746.        (((error_bits & SCHIZO_UEAFSR_PPIO) ?
  747.  "PIO" :
  748.  ((error_bits & SCHIZO_UEAFSR_PDRD) ?
  749.   "DMA Read" :
  750.   ((error_bits & SCHIZO_UEAFSR_PDWR) ?
  751.    "DMA Write" : "???")))));
  752. printk("SCHIZO%d: bytemask[%04lx] qword_offset[%lx] SAFARI_AID[%02lx]n",
  753.        p->index,
  754.        (afsr & SCHIZO_UEAFSR_BMSK) >> 32UL,
  755.        (afsr & SCHIZO_UEAFSR_QOFF) >> 30UL,
  756.        (afsr & SCHIZO_UEAFSR_AID) >> 24UL);
  757. printk("SCHIZO%d: partial[%d] owned_in[%d] mtag[%lx] mtag_synd[%lx] ecc_sync[%lx]n",
  758.        p->index,
  759.        (afsr & SCHIZO_UEAFSR_PARTIAL) ? 1 : 0,
  760.        (afsr & SCHIZO_UEAFSR_OWNEDIN) ? 1 : 0,
  761.        (afsr & SCHIZO_UEAFSR_MTAG) >> 13UL,
  762.        (afsr & SCHIZO_UEAFSR_MTAGSYND) >> 16UL,
  763.        (afsr & SCHIZO_UEAFSR_ECCSYND) >> 0UL);
  764. printk("SCHIZO%d: UE AFAR [%016lx]n", p->index, afar);
  765. printk("SCHIZO%d: UE Secondary errors [", p->index);
  766. reported = 0;
  767. if (afsr & SCHIZO_UEAFSR_SPIO) {
  768. reported++;
  769. printk("(PIO)");
  770. }
  771. if (afsr & SCHIZO_UEAFSR_SDMA) {
  772. reported++;
  773. printk("(DMA)");
  774. }
  775. if (!reported)
  776. printk("(none)");
  777. printk("]n");
  779. /* Interrogate IOMMU for error status. */
  780. schizo_check_iommu_error(p, UE_ERR);
  782. schizo_clear_other_err_intr(irq);
  783. }
  785. #define SCHIZO_CE_AFSR 0x10040UL
  786. #define SCHIZO_CE_AFAR 0x10048UL
  788. #define SCHIZO_CEAFSR_PPIO 0x8000000000000000UL
  789. #define SCHIZO_CEAFSR_PDRD 0x4000000000000000UL
  790. #define SCHIZO_CEAFSR_PDWR 0x2000000000000000UL
  791. #define SCHIZO_CEAFSR_SPIO 0x1000000000000000UL
  792. #define SCHIZO_CEAFSR_SDMA 0x0800000000000000UL
  793. #define SCHIZO_CEAFSR_ERRPNDG 0x0300000000000000UL
  794. #define SCHIZO_CEAFSR_BMSK 0x000003ff00000000UL
  795. #define SCHIZO_CEAFSR_QOFF 0x00000000c0000000UL
  796. #define SCHIZO_CEAFSR_AID 0x000000001f000000UL
  797. #define SCHIZO_CEAFSR_PARTIAL 0x0000000000800000UL
  798. #define SCHIZO_CEAFSR_OWNEDIN 0x0000000000400000UL
  799. #define SCHIZO_CEAFSR_MTAGSYND 0x00000000000f0000UL
  800. #define SCHIZO_CEAFSR_MTAG 0x000000000000e000UL
  801. #define SCHIZO_CEAFSR_ECCSYND 0x00000000000001ffUL
  803. static void schizo_ce_intr(int irq, void *dev_id, struct pt_regs *regs)
  804. {
  805. struct pci_controller_info *p = dev_id;
  806. unsigned long afsr_reg = p->controller_regs + SCHIZO_CE_AFSR;
  807. unsigned long afar_reg = p->controller_regs + SCHIZO_CE_AFAR;
  808. unsigned long afsr, afar, error_bits;
  809. int reported, limit;
  811. /* Latch error status. */
  812. afar = schizo_read(afar_reg);
  814. /* If either of the error pending bits are set in the
  815.  * AFSR, the error status is being actively updated by
  816.  * the hardware and we must re-read to get a clean value.
  817.  */
  818. limit = 1000;
  819. do {
  820. afsr = schizo_read(afsr_reg);
  821. } while ((afsr & SCHIZO_UEAFSR_ERRPNDG) != 0 && --limit);
  823. /* Clear primary/secondary error status bits. */
  824. error_bits = afsr &
  825. (SCHIZO_CEAFSR_PPIO | SCHIZO_CEAFSR_PDRD | SCHIZO_CEAFSR_PDWR |
  826.  SCHIZO_CEAFSR_SPIO | SCHIZO_CEAFSR_SDMA);
  827. if (!error_bits)
  828. return;
  829. schizo_write(afsr_reg, error_bits);
  831. /* Log the error. */
  832. printk("SCHIZO%d: Correctable Error, primary error type[%s]n",
  833.        p->index,
  834.        (((error_bits & SCHIZO_CEAFSR_PPIO) ?
  835.  "PIO" :
  836.  ((error_bits & SCHIZO_CEAFSR_PDRD) ?
  837.   "DMA Read" :
  838.   ((error_bits & SCHIZO_CEAFSR_PDWR) ?
  839.    "DMA Write" : "???")))));
  841. /* XXX Use syndrome and afar to print out module string just like
  842.  * XXX UDB CE trap handler does... -DaveM
  843.  */
  844. printk("SCHIZO%d: bytemask[%04lx] qword_offset[%lx] SAFARI_AID[%02lx]n",
  845.        p->index,
  846.        (afsr & SCHIZO_UEAFSR_BMSK) >> 32UL,
  847.        (afsr & SCHIZO_UEAFSR_QOFF) >> 30UL,
  848.        (afsr & SCHIZO_UEAFSR_AID) >> 24UL);
  849. printk("SCHIZO%d: partial[%d] owned_in[%d] mtag[%lx] mtag_synd[%lx] ecc_sync[%lx]n",
  850.        p->index,
  851.        (afsr & SCHIZO_UEAFSR_PARTIAL) ? 1 : 0,
  852.        (afsr & SCHIZO_UEAFSR_OWNEDIN) ? 1 : 0,
  853.        (afsr & SCHIZO_UEAFSR_MTAG) >> 13UL,
  854.        (afsr & SCHIZO_UEAFSR_MTAGSYND) >> 16UL,
  855.        (afsr & SCHIZO_UEAFSR_ECCSYND) >> 0UL);
  856. printk("SCHIZO%d: CE AFAR [%016lx]n", p->index, afar);
  857. printk("SCHIZO%d: CE Secondary errors [", p->index);
  858. reported = 0;
  859. if (afsr & SCHIZO_CEAFSR_SPIO) {
  860. reported++;
  861. printk("(PIO)");
  862. }
  863. if (afsr & SCHIZO_CEAFSR_SDMA) {
  864. reported++;
  865. printk("(DMA)");
  866. }
  867. if (!reported)
  868. printk("(none)");
  869. printk("]n");
  871. schizo_clear_other_err_intr(irq);
  872. }
  874. #define SCHIZO_PCI_AFSR 0x2010UL
  875. #define SCHIZO_PCI_AFAR 0x2018UL
  877. #define SCHIZO_PCIAFSR_PMA 0x8000000000000000UL
  878. #define SCHIZO_PCIAFSR_PTA 0x4000000000000000UL
  879. #define SCHIZO_PCIAFSR_PRTRY 0x2000000000000000UL
  880. #define SCHIZO_PCIAFSR_PPERR 0x1000000000000000UL
  881. #define SCHIZO_PCIAFSR_PTTO 0x0800000000000000UL
  882. #define SCHIZO_PCIAFSR_PUNUS 0x0400000000000000UL
  883. #define SCHIZO_PCIAFSR_SMA 0x0200000000000000UL
  884. #define SCHIZO_PCIAFSR_STA 0x0100000000000000UL
  885. #define SCHIZO_PCIAFSR_SRTRY 0x0080000000000000UL
  886. #define SCHIZO_PCIAFSR_SPERR 0x0040000000000000UL
  887. #define SCHIZO_PCIAFSR_STTO 0x0020000000000000UL
  888. #define SCHIZO_PCIAFSR_SUNUS 0x0010000000000000UL
  889. #define SCHIZO_PCIAFSR_BMSK 0x000003ff00000000UL
  890. #define SCHIZO_PCIAFSR_BLK 0x0000000080000000UL
  891. #define SCHIZO_PCIAFSR_CFG 0x0000000040000000UL
  892. #define SCHIZO_PCIAFSR_MEM 0x0000000020000000UL
  893. #define SCHIZO_PCIAFSR_IO 0x0000000010000000UL
  895. static void schizo_pcierr_intr(int irq, void *dev_id, struct pt_regs *regs)
  896. {
  897. struct pci_pbm_info *pbm = dev_id;
  898. struct pci_controller_info *p = pbm->parent;
  899. unsigned long afsr_reg, afar_reg, base;
  900. unsigned long afsr, afar, error_bits;
  901. int reported;
  902. char pbm_name;
  904. base = p->controller_regs;
  905. if (pbm == &pbm->parent->pbm_A) {
  906. base += SCHIZO_PBM_A_REGS_OFF;
  907. pbm_name = 'A';
  908. } else {
  909. base += SCHIZO_PBM_B_REGS_OFF;
  910. pbm_name = 'B';
  911. }
  913. afsr_reg = base + SCHIZO_PCI_AFSR;
  914. afar_reg = base + SCHIZO_PCI_AFAR;
  916. /* Latch error status. */
  917. afar = schizo_read(afar_reg);
  918. afsr = schizo_read(afsr_reg);
  920. /* Clear primary/secondary error status bits. */
  921. error_bits = afsr &
  922. (SCHIZO_PCIAFSR_PMA | SCHIZO_PCIAFSR_PTA |
  923.  SCHIZO_PCIAFSR_PRTRY | SCHIZO_PCIAFSR_PPERR |
  924.  SCHIZO_PCIAFSR_PTTO | SCHIZO_PCIAFSR_PUNUS |
  925.  SCHIZO_PCIAFSR_SMA | SCHIZO_PCIAFSR_STA |
  926.  SCHIZO_PCIAFSR_SRTRY | SCHIZO_PCIAFSR_SPERR |
  927.  SCHIZO_PCIAFSR_STTO | SCHIZO_PCIAFSR_SUNUS);
  928. if (!error_bits)
  929. return;
  930. schizo_write(afsr_reg, error_bits);
  932. /* Log the error. */
  933. printk("SCHIZO%d: PBM-%c PCI Error, primary error type[%s]n",
  934.        p->index, pbm_name,
  935.        (((error_bits & SCHIZO_PCIAFSR_PMA) ?
  936.  "Master Abort" :
  937.  ((error_bits & SCHIZO_PCIAFSR_PTA) ?
  938.   "Target Abort" :
  939.   ((error_bits & SCHIZO_PCIAFSR_PRTRY) ?
  940.    "Excessive Retries" :
  941.    ((error_bits & SCHIZO_PCIAFSR_PPERR) ?
  942.     "Parity Error" :
  943.     ((error_bits & SCHIZO_PCIAFSR_PTTO) ?
  944.      "Timeout" :
  945.      ((error_bits & SCHIZO_PCIAFSR_PUNUS) ?
  946.       "Bus Unusable" : "???"))))))));
  947. printk("SCHIZO%d: PBM-%c bytemask[%04lx] was_block(%d) space(%s)n",
  948.        p->index, pbm_name,
  949.        (afsr & SCHIZO_PCIAFSR_BMSK) >> 32UL,
  950.        (afsr & SCHIZO_PCIAFSR_BLK) ? 1 : 0,
  951.        ((afsr & SCHIZO_PCIAFSR_CFG) ?
  952. "Config" :
  953. ((afsr & SCHIZO_PCIAFSR_MEM) ?
  954.  "Memory" :
  955.  ((afsr & SCHIZO_PCIAFSR_IO) ?
  956.   "I/O" : "???"))));
  957. printk("SCHIZO%d: PBM-%c PCI AFAR [%016lx]n",
  958.        p->index, pbm_name, afar);
  959. printk("SCHIZO%d: PBM-%c PCI Secondary errors [",
  960.        p->index, pbm_name);
  961. reported = 0;
  962. if (afsr & SCHIZO_PCIAFSR_SMA) {
  963. reported++;
  964. printk("(Master Abort)");
  965. }
  966. if (afsr & SCHIZO_PCIAFSR_STA) {
  967. reported++;
  968. printk("(Target Abort)");
  969. }
  970. if (afsr & SCHIZO_PCIAFSR_SRTRY) {
  971. reported++;
  972. printk("(Excessive Retries)");
  973. }
  974. if (afsr & SCHIZO_PCIAFSR_SPERR) {
  975. reported++;
  976. printk("(Parity Error)");
  977. }
  978. if (afsr & SCHIZO_PCIAFSR_STTO) {
  979. reported++;
  980. printk("(Timeout)");
  981. }
  982. if (afsr & SCHIZO_PCIAFSR_SUNUS) {
  983. reported++;
  984. printk("(Bus Unusable)");
  985. }
  986. if (!reported)
  987. printk("(none)");
  988. printk("]n");
  990. /* For the error types shown, scan PBM's PCI bus for devices
  991.  * which have logged that error type.
  992.  */
  994. /* If we see a Target Abort, this could be the result of an
  995.  * IOMMU translation error of some sort.  It is extremely
  996.  * useful to log this information as usually it indicates
  997.  * a bug in the IOMMU support code or a PCI device driver.
  998.  */
  999. if (error_bits & (SCHIZO_PCIAFSR_PTA | SCHIZO_PCIAFSR_STA)) {
  1000. schizo_check_iommu_error(p, PCI_ERR);
  1001. pci_scan_for_target_abort(p, pbm, pbm->pci_bus);
  1002. }
  1003. if (error_bits & (SCHIZO_PCIAFSR_PMA | SCHIZO_PCIAFSR_SMA))
  1004. pci_scan_for_master_abort(p, pbm, pbm->pci_bus);
  1006. /* For excessive retries, PSYCHO/PBM will abort the device
  1007.  * and there is no way to specifically check for excessive
  1008.  * retries in the config space status registers.  So what
  1009.  * we hope is that we'll catch it via the master/target
  1010.  * abort events.
  1011.  */
  1013. if (error_bits & (SCHIZO_PCIAFSR_PPERR | SCHIZO_PCIAFSR_SPERR))
  1014. pci_scan_for_parity_error(p, pbm, pbm->pci_bus);
  1016. schizo_clear_other_err_intr(irq);
  1017. }
  1019. #define SCHIZO_SAFARI_ERRLOG 0x10018UL
  1021. #define SAFARI_ERRLOG_ERROUT 0x8000000000000000UL
  1023. #define SAFARI_ERROR_BADCMD 0x4000000000000000UL
  1024. #define SAFARI_ERROR_SSMDIS 0x2000000000000000UL
  1025. #define SAFARI_ERROR_BADMA 0x1000000000000000UL
  1026. #define SAFARI_ERROR_BADMB 0x0800000000000000UL
  1027. #define SAFARI_ERROR_BADMC 0x0400000000000000UL
  1028. #define SAFARI_ERROR_CPU1PS 0x0000000000002000UL
  1029. #define SAFARI_ERROR_CPU1PB 0x0000000000001000UL
  1030. #define SAFARI_ERROR_CPU0PS 0x0000000000000800UL
  1031. #define SAFARI_ERROR_CPU0PB 0x0000000000000400UL
  1032. #define SAFARI_ERROR_CIQTO 0x0000000000000200UL
  1033. #define SAFARI_ERROR_LPQTO 0x0000000000000100UL
  1034. #define SAFARI_ERROR_SFPQTO 0x0000000000000080UL
  1035. #define SAFARI_ERROR_UFPQTO 0x0000000000000040UL
  1036. #define SAFARI_ERROR_APERR 0x0000000000000020UL
  1037. #define SAFARI_ERROR_UNMAP 0x0000000000000010UL
  1038. #define SAFARI_ERROR_BUSERR 0x0000000000000004UL
  1039. #define SAFARI_ERROR_TIMEOUT 0x0000000000000002UL
  1040. #define SAFARI_ERROR_ILL 0x0000000000000001UL
  1042. /* We only expect UNMAP errors here.  The rest of the Safari errors
  1043.  * are marked fatal and thus cause a system reset.
  1044.  */
  1045. static void schizo_safarierr_intr(int irq, void *dev_id, struct pt_regs *regs)
  1046. {
  1047. struct pci_controller_info *p = dev_id;
  1048. u64 errlog;
  1050. errlog = schizo_read(p->controller_regs + SCHIZO_SAFARI_ERRLOG);
  1051. schizo_write(p->controller_regs + SCHIZO_SAFARI_ERRLOG,
  1052.      errlog & ~(SAFARI_ERRLOG_ERROUT));
  1054. if (!(errlog & SAFARI_ERROR_UNMAP)) {
  1055. printk("SCHIZO%d: Unexpected Safari error interrupt, errlog[%016lx]n",
  1056.        p->index, errlog);
  1058. schizo_clear_other_err_intr(irq);
  1059. return;
  1060. }
  1062. printk("SCHIZO%d: Safari interrupt, UNMAPPED error, interrogating IOMMUs.n",
  1063.        p->index);
  1064. schizo_check_iommu_error(p, SAFARI_ERR);
  1066. schizo_clear_other_err_intr(irq);
  1067. }
  1069. /* Nearly identical to PSYCHO equivalents... */
  1070. #define SCHIZO_ECC_CTRL 0x10020UL
  1071. #define  SCHIZO_ECCCTRL_EE  0x8000000000000000 /* Enable ECC Checking */
  1072. #define  SCHIZO_ECCCTRL_UE  0x4000000000000000 /* Enable UE Interrupts */
  1073. #define  SCHIZO_ECCCTRL_CE  0x2000000000000000 /* Enable CE INterrupts */
  1075. #define SCHIZO_SAFARI_ERRCTRL 0x10008UL
  1076. #define  SCHIZO_SAFERRCTRL_EN  0x8000000000000000UL
  1077. #define SCHIZO_SAFARI_IRQCTRL 0x10010UL
  1078. #define  SCHIZO_SAFIRQCTRL_EN  0x8000000000000000UL
  1080. #define SCHIZO_UE_INO 0x30 /* Uncorrectable ECC error */
  1081. #define SCHIZO_CE_INO 0x31 /* Correctable ECC error */
  1082. #define SCHIZO_PCIERR_A_INO 0x32 /* PBM A PCI bus error */
  1083. #define SCHIZO_PCIERR_B_INO 0x33 /* PBM B PCI bus error */
  1084. #define SCHIZO_SERR_INO 0x34 /* Safari interface error */
  1086. #define SCHIZO_PCIA_CTRL (SCHIZO_PBM_A_REGS_OFF + 0x2000UL)
  1087. #define SCHIZO_PCIB_CTRL (SCHIZO_PBM_B_REGS_OFF + 0x2000UL)
  1088. #define SCHIZO_PCICTRL_BUS_UNUS (1UL << 63UL)
  1089. #define SCHIZO_PCICTRL_ESLCK (1UL << 51UL)
  1090. #define SCHIZO_PCICTRL_ERRSLOT (7UL << 48UL)
  1091. #define SCHIZO_PCICTRL_TTO_ERR (1UL << 38UL)
  1092. #define SCHIZO_PCICTRL_RTRY_ERR (1UL << 37UL)
  1093. #define SCHIZO_PCICTRL_DTO_ERR (1UL << 36UL)
  1094. #define SCHIZO_PCICTRL_SBH_ERR (1UL << 35UL)
  1095. #define SCHIZO_PCICTRL_SERR (1UL << 34UL)
  1096. #define SCHIZO_PCICTRL_PCISPD (1UL << 33UL)
  1097. #define SCHIZO_PCICTRL_PTO (3UL << 24UL)
  1098. #define SCHIZO_PCICTRL_DTO_INT (1UL << 19UL)
  1099. #define SCHIZO_PCICTRL_SBH_INT (1UL << 18UL)
  1100. #define SCHIZO_PCICTRL_EEN (1UL << 17UL)
  1101. #define SCHIZO_PCICTRL_PARK (1UL << 16UL)
  1102. #define SCHIZO_PCICTRL_PCIRST (1UL <<  8UL)
  1103. #define SCHIZO_PCICTRL_ARB (0x3fUL << 0UL)
  1105. static void __init schizo_register_error_handlers(struct pci_controller_info *p)
  1106. {
  1107. struct pci_pbm_info *pbm_a = &p->pbm_A;
  1108. struct pci_pbm_info *pbm_b = &p->pbm_B;
  1109. unsigned long base = p->controller_regs;
  1110. unsigned int irq, portid = p->portid;
  1111. struct ino_bucket *bucket;
  1112. u64 tmp;
  1114. /* Build IRQs and register handlers. */
  1115. irq = schizo_irq_build(pbm_b, NULL, (portid << 6) | SCHIZO_UE_INO);
  1116. if (request_irq(irq, schizo_ue_intr,
  1117. SA_SHIRQ, "SCHIZO UE", p) < 0) {
  1118. prom_printf("SCHIZO%d: Cannot register UE interrupt.n",
  1119.     p->index);
  1120. prom_halt();
  1121. }
  1122. bucket = __bucket(irq);
  1123. tmp = readl(bucket->imap);
  1124. upa_writel(tmp, (base + SCHIZO_PBM_B_REGS_OFF + schizo_imap_offset(SCHIZO_UE_INO) + 4));
  1126. irq = schizo_irq_build(pbm_b, NULL, (portid << 6) | SCHIZO_CE_INO);
  1127. if (request_irq(irq, schizo_ce_intr,
  1128. SA_SHIRQ, "SCHIZO CE", p) < 0) {
  1129. prom_printf("SCHIZO%d: Cannot register CE interrupt.n",
  1130.     p->index);
  1131. prom_halt();
  1132. }
  1133. bucket = __bucket(irq);
  1134. tmp = upa_readl(bucket->imap);
  1135. upa_writel(tmp, (base + SCHIZO_PBM_B_REGS_OFF + schizo_imap_offset(SCHIZO_CE_INO) + 4));
  1137. irq = schizo_irq_build(pbm_a, NULL, (portid << 6) | SCHIZO_PCIERR_A_INO);
  1138. if (request_irq(irq, schizo_pcierr_intr,
  1139. SA_SHIRQ, "SCHIZO PCIERR", pbm_a) < 0) {
  1140. prom_printf("SCHIZO%d(PBMA): Cannot register PciERR interrupt.n",
  1141.     p->index);
  1142. prom_halt();
  1143. }
  1144. bucket = __bucket(irq);
  1145. tmp = upa_readl(bucket->imap);
  1146. upa_writel(tmp, (base + SCHIZO_PBM_A_REGS_OFF + schizo_imap_offset(SCHIZO_PCIERR_A_INO) + 4));
  1148. irq = schizo_irq_build(pbm_b, NULL, (portid << 6) | SCHIZO_PCIERR_B_INO);
  1149. if (request_irq(irq, schizo_pcierr_intr,
  1150. SA_SHIRQ, "SCHIZO PCIERR", pbm_b) < 0) {
  1151. prom_printf("SCHIZO%d(PBMB): Cannot register PciERR interrupt.n",
  1152.     p->index);
  1153. prom_halt();
  1154. }
  1155. bucket = __bucket(irq);
  1156. tmp = upa_readl(bucket->imap);
  1157. upa_writel(tmp, (base + SCHIZO_PBM_B_REGS_OFF + schizo_imap_offset(SCHIZO_PCIERR_B_INO) + 4));
  1159. irq = schizo_irq_build(pbm_b, NULL, (portid << 6) | SCHIZO_SERR_INO);
  1160. if (request_irq(irq, schizo_safarierr_intr,
  1161. SA_SHIRQ, "SCHIZO SERR", p) < 0) {
  1162. prom_printf("SCHIZO%d(PBMB): Cannot register SafariERR interrupt.n",
  1163.     p->index);
  1164. prom_halt();
  1165. }
  1166. bucket = __bucket(irq);
  1167. tmp = upa_readl(bucket->imap);
  1168. upa_writel(tmp, (base + SCHIZO_PBM_B_REGS_OFF + schizo_imap_offset(SCHIZO_SERR_INO) + 4));
  1170. /* Enable UE and CE interrupts for controller. */
  1171. schizo_write(base + SCHIZO_ECC_CTRL,
  1172.      (SCHIZO_ECCCTRL_EE |
  1173.       SCHIZO_ECCCTRL_UE |
  1174.       SCHIZO_ECCCTRL_CE));
  1176. /* Enable PCI Error interrupts and clear error
  1177.  * bits for each PBM.
  1178.  */
  1179. tmp = schizo_read(base + SCHIZO_PCIA_CTRL);
  1180. tmp |= (SCHIZO_PCICTRL_BUS_UNUS |
  1181. SCHIZO_PCICTRL_ESLCK |
  1182. SCHIZO_PCICTRL_TTO_ERR |
  1183. SCHIZO_PCICTRL_RTRY_ERR |
  1184. SCHIZO_PCICTRL_DTO_ERR |
  1185. SCHIZO_PCICTRL_SBH_ERR |
  1186. SCHIZO_PCICTRL_SERR |
  1187. SCHIZO_PCICTRL_SBH_INT |
  1188. SCHIZO_PCICTRL_EEN);
  1189. schizo_write(base + SCHIZO_PCIA_CTRL, tmp);
  1191. tmp = schizo_read(base + SCHIZO_PCIB_CTRL);
  1192. tmp |= (SCHIZO_PCICTRL_BUS_UNUS |
  1193. SCHIZO_PCICTRL_ESLCK |
  1194. SCHIZO_PCICTRL_TTO_ERR |
  1195. SCHIZO_PCICTRL_RTRY_ERR |
  1196. SCHIZO_PCICTRL_DTO_ERR |
  1197. SCHIZO_PCICTRL_SBH_ERR |
  1198. SCHIZO_PCICTRL_SERR |
  1199. SCHIZO_PCICTRL_SBH_INT |
  1200. SCHIZO_PCICTRL_EEN);
  1201. schizo_write(base + SCHIZO_PCIB_CTRL, tmp);
  1203. schizo_write(base + SCHIZO_PBM_A_REGS_OFF + SCHIZO_PCI_AFSR,
  1204.      (SCHIZO_PCIAFSR_PMA | SCHIZO_PCIAFSR_PTA |
  1205.       SCHIZO_PCIAFSR_PRTRY | SCHIZO_PCIAFSR_PPERR |
  1206.       SCHIZO_PCIAFSR_PTTO | SCHIZO_PCIAFSR_PUNUS |
  1207.       SCHIZO_PCIAFSR_SMA | SCHIZO_PCIAFSR_STA |
  1208.       SCHIZO_PCIAFSR_SRTRY | SCHIZO_PCIAFSR_SPERR |
  1209.       SCHIZO_PCIAFSR_STTO | SCHIZO_PCIAFSR_SUNUS));
  1210. schizo_write(base + SCHIZO_PBM_B_REGS_OFF + SCHIZO_PCI_AFSR,
  1211.      (SCHIZO_PCIAFSR_PMA | SCHIZO_PCIAFSR_PTA |
  1212.       SCHIZO_PCIAFSR_PRTRY | SCHIZO_PCIAFSR_PPERR |
  1213.       SCHIZO_PCIAFSR_PTTO | SCHIZO_PCIAFSR_PUNUS |
  1214.       SCHIZO_PCIAFSR_SMA | SCHIZO_PCIAFSR_STA |
  1215.       SCHIZO_PCIAFSR_SRTRY | SCHIZO_PCIAFSR_SPERR |
  1216.       SCHIZO_PCIAFSR_STTO | SCHIZO_PCIAFSR_SUNUS));
  1218. /* Make all Safari error conditions fatal except unmapped errors
  1219.  * which we make generate interrupts.
  1220.  */
  1221. #if 1
  1222. /* XXX Something wrong with some Excalibur systems
  1223.  * XXX Sun is shipping.  The behavior on a 2-cpu
  1224.  * XXX machine is that both CPU1 parity error bits
  1225.  * XXX are set and are immediately set again when
  1226.  * XXX their error status bits are cleared.  Just
  1227.  * XXX ignore them for now.  -DaveM
  1228.  */
  1229. schizo_write(base + SCHIZO_SAFARI_ERRCTRL,
  1230.      (SCHIZO_SAFERRCTRL_EN |
  1231.       (SAFARI_ERROR_BADCMD | SAFARI_ERROR_SSMDIS |
  1232.        SAFARI_ERROR_BADMA | SAFARI_ERROR_BADMB |
  1233.        SAFARI_ERROR_BADMC |
  1234.        SAFARI_ERROR_CIQTO |
  1235.        SAFARI_ERROR_LPQTO | SAFARI_ERROR_SFPQTO |
  1236.        SAFARI_ERROR_UFPQTO | SAFARI_ERROR_APERR |
  1237.        SAFARI_ERROR_BUSERR | SAFARI_ERROR_TIMEOUT |
  1238.        SAFARI_ERROR_ILL)));
  1239. #else
  1240. schizo_write(base + SCHIZO_SAFARI_ERRCTRL,
  1241.      (SCHIZO_SAFERRCTRL_EN |
  1242.       (SAFARI_ERROR_BADCMD | SAFARI_ERROR_SSMDIS |
  1243.        SAFARI_ERROR_BADMA | SAFARI_ERROR_BADMB |
  1244.        SAFARI_ERROR_BADMC |
  1245.        SAFARI_ERROR_CPU1PS | SAFARI_ERROR_CPU1PB |
  1246.        SAFARI_ERROR_CPU0PS | SAFARI_ERROR_CPU0PB |
  1247.        SAFARI_ERROR_CIQTO |
  1248.        SAFARI_ERROR_LPQTO | SAFARI_ERROR_SFPQTO |
  1249.        SAFARI_ERROR_UFPQTO | SAFARI_ERROR_APERR |
  1250.        SAFARI_ERROR_BUSERR | SAFARI_ERROR_TIMEOUT |
  1251.        SAFARI_ERROR_ILL)));
  1252. #endif
  1254. schizo_write(base + SCHIZO_SAFARI_IRQCTRL,
  1255.      (SCHIZO_SAFIRQCTRL_EN | (SAFARI_ERROR_UNMAP)));
  1256. }
  1258. /* We have to do the config space accesses by hand, thus... */
  1259. #define PBM_BRIDGE_BUS 0x40
  1260. #define PBM_BRIDGE_SUBORDINATE 0x41
  1261. static void __init pbm_renumber(struct pci_pbm_info *pbm, u8 orig_busno)
  1262. {
  1263. u8 *addr, busno;
  1264. int nbus;
  1266. busno = pci_highest_busnum;
  1267. nbus = pbm->pci_last_busno - pbm->pci_first_busno;
  1269. addr = schizo_pci_config_mkaddr(pbm, orig_busno,
  1270. 0, PBM_BRIDGE_BUS);
  1271. pci_config_write8(addr, busno);
  1272. addr = schizo_pci_config_mkaddr(pbm, busno,
  1273. 0, PBM_BRIDGE_SUBORDINATE);
  1274. pci_config_write8(addr, busno + nbus);
  1276. pbm->pci_first_busno = busno;
  1277. pbm->pci_last_busno = busno + nbus;
  1278. pci_highest_busnum = busno + nbus + 1;
  1280. do {
  1281. pci_bus2pbm[busno++] = pbm;
  1282. } while (nbus--);
  1283. }
  1285. /* We have to do the config space accesses by hand here since
  1286.  * the pci_bus2pbm array is not ready yet.
  1287.  */
  1288. static void __init pbm_pci_bridge_renumber(struct pci_pbm_info *pbm,
  1289.    u8 busno)
  1290. {
  1291. u32 devfn, l, class;
  1292. u8 hdr_type;
  1293. int is_multi = 0;
  1295. for(devfn = 0; devfn < 0xff; ++devfn) {
  1296. u32 *dwaddr;
  1297. u8 *baddr;
  1299. if (PCI_FUNC(devfn) != 0 && is_multi == 0)
  1300. continue;
  1302. /* Anything there? */
  1303. dwaddr = schizo_pci_config_mkaddr(pbm, busno, devfn, PCI_VENDOR_ID);
  1304. l = 0xffffffff;
  1305. pci_config_read32(dwaddr, &l);
  1306. if (l == 0xffffffff || l == 0x00000000 ||
  1307.     l == 0x0000ffff || l == 0xffff0000) {
  1308. is_multi = 0;
  1309. continue;
  1310. }
  1312. baddr = schizo_pci_config_mkaddr(pbm, busno, devfn, PCI_HEADER_TYPE);
  1313. pci_config_read8(baddr, &hdr_type);
  1314. if (PCI_FUNC(devfn) == 0)
  1315. is_multi = hdr_type & 0x80;
  1317. dwaddr = schizo_pci_config_mkaddr(pbm, busno, devfn, PCI_CLASS_REVISION);
  1318. class = 0xffffffff;
  1319. pci_config_read32(dwaddr, &class);
  1320. if ((class >> 16) == PCI_CLASS_BRIDGE_PCI) {
  1321. u32 buses = 0xffffffff;
  1323. dwaddr = schizo_pci_config_mkaddr(pbm, busno, devfn,
  1324.   PCI_PRIMARY_BUS);
  1325. pci_config_read32(dwaddr, &buses);
  1326. pbm_pci_bridge_renumber(pbm, (buses >> 8) & 0xff);
  1327. buses &= 0xff000000;
  1328. pci_config_write32(dwaddr, buses);
  1329. }
  1330. }
  1331. }
  1333. static void __init pbm_bridge_reconfigure(struct pci_controller_info *p)
  1334. {
  1335. struct pci_pbm_info *pbm;
  1336. u8 *addr;
  1338. /* Clear out primary/secondary/subordinate bus numbers on
  1339.  * all PCI-to-PCI bridges under each PBM.  The generic bus
  1340.  * probing will fix them up.
  1341.  */
  1342. pbm_pci_bridge_renumber(&p->pbm_B, p->pbm_B.pci_first_busno);
  1343. pbm_pci_bridge_renumber(&p->pbm_A, p->pbm_A.pci_first_busno);
  1345. /* Move PBM A out of the way. */
  1346. pbm = &p->pbm_A;
  1347. addr = schizo_pci_config_mkaddr(pbm, pbm->pci_first_busno,
  1348. 0, PBM_BRIDGE_BUS);
  1349. pci_config_write8(addr, 0xff);
  1350. addr = schizo_pci_config_mkaddr(pbm, 0xff,
  1351. 0, PBM_BRIDGE_SUBORDINATE);
  1352. pci_config_write8(addr, 0xff);
  1354. /* Now we can safely renumber both PBMs. */
  1355. pbm_renumber(&p->pbm_B, p->pbm_B.pci_first_busno);
  1356. pbm_renumber(&p->pbm_A, 0xff);
  1357. }
  1359. static void __init pbm_config_busmastering(struct pci_pbm_info *pbm)
  1360. {
  1361. u8 *addr;
  1363. /* Set cache-line size to 64 bytes, this is actually
  1364.  * a nop but I do it for completeness.
  1365.  */
  1366. addr = schizo_pci_config_mkaddr(pbm, pbm->pci_first_busno,
  1367. 0, PCI_CACHE_LINE_SIZE);
  1368. pci_config_write8(addr, 64 / sizeof(u32));
  1370. /* Set PBM latency timer to 64 PCI clocks. */
  1371. addr = schizo_pci_config_mkaddr(pbm, pbm->pci_first_busno,
  1372. 0, PCI_LATENCY_TIMER);
  1373. pci_config_write8(addr, 64);
  1374. }
  1376. static void __init pbm_scan_bus(struct pci_controller_info *p,
  1377. struct pci_pbm_info *pbm)
  1378. {
  1379. struct pcidev_cookie *cookie = kmalloc(sizeof(*cookie), GFP_KERNEL);
  1381. if (!cookie) {
  1382. prom_printf("SCHIZO: Critical allocation failure.n");
  1383. prom_halt();
  1384. }
  1386. /* All we care about is the PBM. */
  1387. memset(cookie, 0, sizeof(*cookie));
  1388. cookie->pbm = pbm;
  1390. pbm->pci_bus = pci_scan_bus(pbm->pci_first_busno,
  1391.     p->pci_ops,
  1392.     pbm);
  1393. pci_fixup_host_bridge_self(pbm->pci_bus);
  1394. pbm->pci_bus->self->sysdata = cookie;
  1396. pci_fill_in_pbm_cookies(pbm->pci_bus, pbm, pbm->prom_node);
  1397. pci_record_assignments(pbm, pbm->pci_bus);
  1398. pci_assign_unassigned(pbm, pbm->pci_bus);
  1399. pci_fixup_irq(pbm, pbm->pci_bus);
  1400. pci_determine_66mhz_disposition(pbm, pbm->pci_bus);
  1401. pci_setup_busmastering(pbm, pbm->pci_bus);
  1402. }
  1404. static void __init schizo_scan_bus(struct pci_controller_info *p)
  1405. {
  1406. pbm_bridge_reconfigure(p);
  1407. pbm_config_busmastering(&p->pbm_B);
  1408. p->pbm_B.is_66mhz_capable = 0;
  1409. pbm_config_busmastering(&p->pbm_A);
  1410. p->pbm_A.is_66mhz_capable = 1;
  1411. pbm_scan_bus(p, &p->pbm_B);
  1412. pbm_scan_bus(p, &p->pbm_A);
  1414. /* After the PCI bus scan is complete, we can register
  1415.  * the error interrupt handlers.
  1416.  */
  1417. schizo_register_error_handlers(p);
  1418. }
  1420. static void __init schizo_base_address_update(struct pci_dev *pdev, int resource)
  1421. {
  1422. struct pcidev_cookie *pcp = pdev->sysdata;
  1423. struct pci_pbm_info *pbm = pcp->pbm;
  1424. struct resource *res, *root;
  1425. u32 reg;
  1426. int where, size, is_64bit;
  1428. res = &pdev->resource[resource];
  1429. if (resource < 6) {
  1430. where = PCI_BASE_ADDRESS_0 + (resource * 4);
  1431. } else if (resource == PCI_ROM_RESOURCE) {
  1432. where = pdev->rom_base_reg;
  1433. } else {
  1434. /* Somebody might have asked allocation of a non-standard resource */
  1435. return;
  1436. }
  1438. is_64bit = 0;
  1439. if (res->flags & IORESOURCE_IO)
  1440. root = &pbm->io_space;
  1441. else {
  1442. root = &pbm->mem_space;
  1443. if ((res->flags & PCI_BASE_ADDRESS_MEM_TYPE_MASK)
  1444.     == PCI_BASE_ADDRESS_MEM_TYPE_64)
  1445. is_64bit = 1;
  1446. }
  1448. size = res->end - res->start;
  1449. pci_read_config_dword(pdev, where, &reg);
  1450. reg = ((reg & size) |
  1451.        (((u32)(res->start - root->start)) & ~size));
  1452. if (resource == PCI_ROM_RESOURCE) {
  1453. reg |= PCI_ROM_ADDRESS_ENABLE;
  1454. res->flags |= PCI_ROM_ADDRESS_ENABLE;
  1455. }
  1456. pci_write_config_dword(pdev, where, reg);
  1458. /* This knows that the upper 32-bits of the address
  1459.  * must be zero.  Our PCI common layer enforces this.
  1460.  */
  1461. if (is_64bit)
  1462. pci_write_config_dword(pdev, where + 4, 0);
  1463. }
  1465. static void __init schizo_resource_adjust(struct pci_dev *pdev,
  1466.   struct resource *res,
  1467.   struct resource *root)
  1468. {
  1469. res->start += root->start;
  1470. res->end += root->start;
  1471. }
  1473. /* Interrogate Safari match/mask registers to figure out where
  1474.  * PCI MEM, I/O, and Config space are for this PCI bus module.
  1475.  */
  1477. #define SCHIZO_PCI_A_MEM_MATCH 0x00040UL
  1478. #define SCHIZO_PCI_A_MEM_MASK 0x00048UL
  1479. #define SCHIZO_PCI_A_IO_MATCH 0x00050UL
  1480. #define SCHIZO_PCI_A_IO_MASK 0x00058UL
  1481. #define SCHIZO_PCI_B_MEM_MATCH 0x00060UL
  1482. #define SCHIZO_PCI_B_MEM_MASK 0x00068UL
  1483. #define SCHIZO_PCI_B_IO_MATCH 0x00070UL
  1484. #define SCHIZO_PCI_B_IO_MASK 0x00078UL
  1486. static void schizo_determine_mem_io_space(struct pci_pbm_info *pbm,
  1487.   int is_pbm_a, unsigned long reg_base)
  1488. {
  1489. u64 mem_match, mem_mask;
  1490. u64 io_match;
  1491. u64 a;
  1493. if (is_pbm_a) {
  1494. mem_match = reg_base + SCHIZO_PCI_A_MEM_MATCH;
  1495. io_match = reg_base + SCHIZO_PCI_A_IO_MATCH;
  1496. } else {
  1497. mem_match = reg_base + SCHIZO_PCI_B_MEM_MATCH;
  1498. io_match = reg_base + SCHIZO_PCI_B_IO_MATCH;
  1499. }
  1500. mem_mask = mem_match + 0x8UL;
  1502. a = schizo_read(mem_match) & ~0x8000000000000000UL;
  1504. /* It should be 2GB in size but the decode is set for the full
  1505.  * 4GB so we have to add the 2G by hand.
  1506.  */
  1507. pbm->mem_space.start = a;
  1508. pbm->mem_space.end = a + 0x80000000;
  1509. pbm->mem_space.flags = IORESOURCE_MEM;
  1511. /* This 32MB area is divided into two pieces.  The first
  1512.  * 16MB is Config space, the next 16MB is I/O space.
  1513.  */
  1515. a = schizo_read(io_match) & ~0x8000000000000000UL;
  1516. pbm->config_space = a;
  1517. printk("SCHIZO PBM%c: Local PCI config space at %016lxn",
  1518.        (is_pbm_a ? 'A' : 'B'), pbm->config_space);
  1520. a += (16UL * 1024UL * 1024UL);
  1521. pbm->io_space.start = a;
  1522. pbm->io_space.end = a + ((16UL * 1024UL * 1024UL) - 1UL);
  1523. pbm->io_space.flags = IORESOURCE_IO;
  1524. }
  1526. static void __init pbm_register_toplevel_resources(struct pci_controller_info *p,
  1527.    struct pci_pbm_info *pbm)
  1528. {
  1529. char *name = pbm->name;
  1531. sprintf(name, "SCHIZO%d PBM%c",
  1532. p->index,
  1533. (pbm == &p->pbm_A ? 'A' : 'B'));
  1534. pbm->io_space.name = pbm->mem_space.name = name;
  1536. request_resource(&ioport_resource, &pbm->io_space);
  1537. request_resource(&iomem_resource, &pbm->mem_space);
  1538. pci_register_legacy_regions(&pbm->io_space,
  1539.     &pbm->mem_space);
  1540. }
  1542. #define SCHIZO_STRBUF_CONTROL_A (SCHIZO_PBM_A_REGS_OFF + 0x02800UL)
  1543. #define SCHIZO_STRBUF_FLUSH_A (SCHIZO_PBM_A_REGS_OFF + 0x02808UL)
  1544. #define SCHIZO_STRBUF_FSYNC_A (SCHIZO_PBM_A_REGS_OFF + 0x02810UL)
  1545. #define SCHIZO_STRBUF_CTXFLUSH_A (SCHIZO_PBM_A_REGS_OFF + 0x02818UL)
  1546. #define SCHIZO_STRBUF_CTXMATCH_A (SCHIZO_PBM_A_REGS_OFF + 0x10000UL)
  1548. #define SCHIZO_STRBUF_CONTROL_B (SCHIZO_PBM_B_REGS_OFF + 0x02800UL)
  1549. #define SCHIZO_STRBUF_FLUSH_B (SCHIZO_PBM_B_REGS_OFF + 0x02808UL)
  1550. #define SCHIZO_STRBUF_FSYNC_B (SCHIZO_PBM_B_REGS_OFF + 0x02810UL)
  1551. #define SCHIZO_STRBUF_CTXFLUSH_B (SCHIZO_PBM_B_REGS_OFF + 0x02818UL)
  1552. #define SCHIZO_STRBUF_CTXMATCH_B (SCHIZO_PBM_B_REGS_OFF + 0x10000UL)
  1554. static void schizo_pbm_strbuf_init(struct pci_controller_info *p,
  1555.    struct pci_pbm_info *pbm,
  1556.    int is_pbm_a)
  1557. {
  1558. unsigned long base = p->controller_regs;
  1559. u64 control;
  1561. /* SCHIZO has context flushing. */
  1562. if (is_pbm_a) {
  1563. pbm->stc.strbuf_control = base + SCHIZO_STRBUF_CONTROL_A;
  1564. pbm->stc.strbuf_pflush = base + SCHIZO_STRBUF_FLUSH_A;
  1565. pbm->stc.strbuf_fsync = base + SCHIZO_STRBUF_FSYNC_A;
  1566. pbm->stc.strbuf_ctxflush = base + SCHIZO_STRBUF_CTXFLUSH_A;
  1567. pbm->stc.strbuf_ctxmatch_base = base + SCHIZO_STRBUF_CTXMATCH_A;
  1568. } else {
  1569. pbm->stc.strbuf_control = base + SCHIZO_STRBUF_CONTROL_B;
  1570. pbm->stc.strbuf_pflush = base + SCHIZO_STRBUF_FLUSH_B;
  1571. pbm->stc.strbuf_fsync = base + SCHIZO_STRBUF_FSYNC_B;
  1572. pbm->stc.strbuf_ctxflush = base + SCHIZO_STRBUF_CTXFLUSH_B;
  1573. pbm->stc.strbuf_ctxmatch_base = base + SCHIZO_STRBUF_CTXMATCH_B;
  1574. }
  1576. pbm->stc.strbuf_flushflag = (volatile unsigned long *)
  1577. ((((unsigned long)&pbm->stc.__flushflag_buf[0])
  1578.   + 63UL)
  1579.  & ~63UL);
  1580. pbm->stc.strbuf_flushflag_pa = (unsigned long)
  1581. __pa(pbm->stc.strbuf_flushflag);
  1583. /* Turn off LRU locking and diag mode, enable the
  1584.  * streaming buffer and leave the rerun-disable
  1585.  * setting however OBP set it.
  1586.  */
  1587. control = schizo_read(pbm->stc.strbuf_control);
  1588. control &= ~(SCHIZO_STRBUF_CTRL_LPTR |
  1589.      SCHIZO_STRBUF_CTRL_LENAB |
  1590.      SCHIZO_STRBUF_CTRL_DENAB);
  1591. control |= SCHIZO_STRBUF_CTRL_ENAB;
  1592. schizo_write(pbm->stc.strbuf_control, control);
  1594. pbm->stc.strbuf_enabled = 1;
  1595. }
  1597. #define SCHIZO_IOMMU_CONTROL_A (SCHIZO_PBM_A_REGS_OFF + 0x00200UL)
  1598. #define SCHIZO_IOMMU_TSBBASE_A (SCHIZO_PBM_A_REGS_OFF + 0x00208UL)
  1599. #define SCHIZO_IOMMU_FLUSH_A (SCHIZO_PBM_A_REGS_OFF + 0x00210UL)
  1600. #define SCHIZO_IOMMU_CTXFLUSH_A (SCHIZO_PBM_A_REGS_OFF + 0x00218UL)
  1601. #define SCHIZO_IOMMU_TAG_A (SCHIZO_PBM_A_REGS_OFF + 0x0a580UL)
  1602. #define SCHIZO_IOMMU_DATA_A (SCHIZO_PBM_A_REGS_OFF + 0x0a600UL)
  1603. #define SCHIZO_IOMMU_CONTROL_B (SCHIZO_PBM_B_REGS_OFF + 0x00200UL)
  1604. #define SCHIZO_IOMMU_TSBBASE_B (SCHIZO_PBM_B_REGS_OFF + 0x00208UL)
  1605. #define SCHIZO_IOMMU_FLUSH_B (SCHIZO_PBM_B_REGS_OFF + 0x00210UL)
  1606. #define SCHIZO_IOMMU_CTXFLUSH_B (SCHIZO_PBM_B_REGS_OFF + 0x00218UL)
  1607. #define SCHIZO_IOMMU_TAG_B (SCHIZO_PBM_B_REGS_OFF + 0x0a580UL)
  1608. #define SCHIZO_IOMMU_DATA_B (SCHIZO_PBM_B_REGS_OFF + 0x0a600UL)
  1610. static void schizo_pbm_iommu_init(struct pci_controller_info *p,
  1611.   struct pci_pbm_info *pbm,
  1612.   int is_pbm_a)
  1613. {
  1614. struct pci_iommu *iommu = pbm->iommu;
  1615. unsigned long tsbbase, i, tagbase, database;
  1616. u64 control;
  1618. /* Setup initial software IOMMU state. */
  1619. spin_lock_init(&iommu->lock);
  1620. iommu->iommu_cur_ctx = 0;
  1622. /* Register addresses, SCHIZO has iommu ctx flushing. */
  1623. if (is_pbm_a) {
  1624. iommu->iommu_control  = p->controller_regs + SCHIZO_IOMMU_CONTROL_A;
  1625. iommu->iommu_tsbbase  = p->controller_regs + SCHIZO_IOMMU_TSBBASE_A;
  1626. iommu->iommu_flush    = p->controller_regs + SCHIZO_IOMMU_FLUSH_A;
  1627. iommu->iommu_ctxflush = p->controller_regs + SCHIZO_IOMMU_CTXFLUSH_A;
  1628. } else {
  1629. iommu->iommu_control  = p->controller_regs + SCHIZO_IOMMU_CONTROL_B;
  1630. iommu->iommu_tsbbase  = p->controller_regs + SCHIZO_IOMMU_TSBBASE_B;
  1631. iommu->iommu_flush    = p->controller_regs + SCHIZO_IOMMU_FLUSH_B;
  1632. iommu->iommu_ctxflush = p->controller_regs + SCHIZO_IOMMU_CTXFLUSH_B;
  1633. }
  1635. /* We use the main control/status register of SCHIZO as the write
  1636.  * completion register.
  1637.  */
  1638. iommu->write_complete_reg = p->controller_regs + 0x10000UL;
  1640. /*
  1641.  * Invalidate TLB Entries.
  1642.  */
  1643. control = schizo_read(iommu->iommu_control);
  1644. control |= SCHIZO_IOMMU_CTRL_DENAB;
  1645. schizo_write(iommu->iommu_control, control);
  1647. if (is_pbm_a)
  1648. tagbase = SCHIZO_IOMMU_TAG_A, database = SCHIZO_IOMMU_DATA_A;
  1649. else
  1650. tagbase = SCHIZO_IOMMU_TAG_B, database = SCHIZO_IOMMU_DATA_B;
  1651. for(i = 0; i < 16; i++) {
  1652. schizo_write(p->controller_regs + tagbase + (i * 8UL), 0);
  1653. schizo_write(p->controller_regs + database + (i * 8UL), 0);
  1654. }
  1656. /* Leave diag mode enabled for full-flushing done
  1657.  * in pci_iommu.c
  1658.  */
  1660. /* Using assumed page size 8K with 128K entries we need 1MB iommu page
  1661.  * table (128K ioptes * 8 bytes per iopte).  This is
  1662.  * page order 7 on UltraSparc.
  1663.  */
  1664. tsbbase = __get_free_pages(GFP_KERNEL, get_order(IO_TSB_SIZE));
  1665. if (!tsbbase) {
  1666. prom_printf("SCHIZO_IOMMU: Error, gfp(tsb) failed.n");
  1667. prom_halt();
  1668. }
  1669. iommu->page_table = (iopte_t *)tsbbase;
  1670. iommu->page_table_sz_bits = 17;
  1671. iommu->page_table_map_base = 0xc0000000;
  1672. iommu->dma_addr_mask = 0xffffffff;
  1673. memset((char *)tsbbase, 0, IO_TSB_SIZE);
  1675. /* We start with no consistent mappings. */
  1676. iommu->lowest_consistent_map =
  1677. 1 << (iommu->page_table_sz_bits - PBM_LOGCLUSTERS);
  1679. for (i = 0; i < PBM_NCLUSTERS; i++) {
  1680. iommu->alloc_info[i].flush = 0;
  1681. iommu->alloc_info[i].next = 0;
  1682. }
  1684. schizo_write(iommu->iommu_tsbbase, __pa(tsbbase));
  1686. control = schizo_read(iommu->iommu_control);
  1687. control &= ~(SCHIZO_IOMMU_CTRL_TSBSZ | SCHIZO_IOMMU_CTRL_TBWSZ);
  1688. control |= (SCHIZO_IOMMU_TSBSZ_128K | SCHIZO_IOMMU_CTRL_ENAB);
  1689. schizo_write(iommu->iommu_control, control);
  1690. }
  1692. static void schizo_pbm_init(struct pci_controller_info *p,
  1693.     int prom_node, int is_pbm_a)
  1694. {
  1695. unsigned int busrange[2];
  1696. struct pci_pbm_info *pbm;
  1697. int err;
  1699. if (is_pbm_a)
  1700. pbm = &p->pbm_A;
  1701. else
  1702. pbm = &p->pbm_B;
  1704. schizo_determine_mem_io_space(pbm, is_pbm_a, p->controller_regs);
  1705. pbm_register_toplevel_resources(p, pbm);
  1707. pbm->parent = p;
  1708. pbm->prom_node = prom_node;
  1709. pbm->pci_first_slot = 1;
  1710. prom_getstring(prom_node, "name",
  1711.        pbm->prom_name,
  1712.        sizeof(pbm->prom_name));
  1714. err = prom_getproperty(prom_node, "ranges",
  1715.        (char *) pbm->pbm_ranges,
  1716.        sizeof(pbm->pbm_ranges));
  1717. if (err != -1)
  1718. pbm->num_pbm_ranges =
  1719. (err / sizeof(struct linux_prom_pci_ranges));
  1720. else
  1721. pbm->num_pbm_ranges = 0;
  1723. err = prom_getproperty(prom_node, "interrupt-map",
  1724.        (char *)pbm->pbm_intmap,
  1725.        sizeof(pbm->pbm_intmap));
  1726. if (err != -1) {
  1727. pbm->num_pbm_intmap = (err / sizeof(struct linux_prom_pci_intmap));
  1728. err = prom_getproperty(prom_node, "interrupt-map-mask",
  1729.        (char *)&pbm->pbm_intmask,
  1730.        sizeof(pbm->pbm_intmask));
  1731. if (err == -1) {
  1732. prom_printf("SCHIZO-PBM: Fatal error, no "
  1733.     "interrupt-map-mask.n");
  1734. prom_halt();
  1735. }
  1736. } else {
  1737. pbm->num_pbm_intmap = 0;
  1738. memset(&pbm->pbm_intmask, 0, sizeof(pbm->pbm_intmask));
  1739. }
  1741. err = prom_getproperty(prom_node, "bus-range",
  1742.        (char *)&busrange[0],
  1743.        sizeof(busrange));
  1744. if (err == 0 || err == -1) {
  1745. prom_printf("SCHIZO-PBM: Fatal error, no bus-range.n");
  1746. prom_halt();
  1747. }
  1748. pbm->pci_first_busno = busrange[0];
  1749. pbm->pci_last_busno = busrange[1];
  1751. schizo_pbm_iommu_init(p, pbm, is_pbm_a);
  1752. schizo_pbm_strbuf_init(p, pbm, is_pbm_a);
  1753. }
  1755. #define SCHIZO_PCIA_IRQ_RETRY (SCHIZO_PBM_A_REGS_OFF + 0x1a00UL)
  1756. #define SCHIZO_PCIB_IRQ_RETRY (SCHIZO_PBM_B_REGS_OFF + 0x1a00UL)
  1757. #define  SCHIZO_IRQ_RETRY_INF  0xffUL
  1759. #define SCHIZO_PCIA_DIAG (SCHIZO_PBM_A_REGS_OFF + 0x2020UL)
  1760. #define SCHIZO_PCIB_DIAG (SCHIZO_PBM_B_REGS_OFF + 0x2020UL)
  1761. #define  SCHIZO_PCIDIAG_D_BADECC (1UL << 10UL) /* Disable BAD ECC errors */
  1762. #define  SCHIZO_PCIDIAG_D_BYPASS (1UL <<  9UL) /* Disable MMU bypass mode */
  1763. #define  SCHIZO_PCIDIAG_D_TTO (1UL <<  8UL) /* Disable TTO errors */
  1764. #define  SCHIZO_PCIDIAG_D_RTRYARB (1UL <<  7UL) /* Disable retry arbitration */
  1765. #define  SCHIZO_PCIDIAG_D_RETRY (1UL <<  6UL) /* Disable retry limit */
  1766. #define  SCHIZO_PCIDIAG_D_INTSYNC (1UL <<  5UL) /* Disable interrupt/DMA synch */
  1767. #define  SCHIZO_PCIDIAG_I_DMA_PARITY (1UL <<  3UL) /* Invert DMA parity */
  1768. #define  SCHIZO_PCIDIAG_I_PIOD_PARITY (1UL <<  2UL) /* Invert PIO data parity */
  1769. #define  SCHIZO_PCIDIAG_I_PIOA_PARITY (1UL <<  1U)L /* Invert PIO address parity */
  1771. static void schizo_controller_hwinit(struct pci_controller_info *p)
  1772. {
  1773. unsigned long pbm_a_base, pbm_b_base;
  1774. u64 tmp;
  1776. pbm_a_base = p->controller_regs + SCHIZO_PBM_A_REGS_OFF;
  1777. pbm_b_base = p->controller_regs + SCHIZO_PBM_B_REGS_OFF;
  1779. /* Set IRQ retry to infinity. */
  1780. schizo_write(p->controller_regs + SCHIZO_PCIA_IRQ_RETRY,
  1781.      SCHIZO_IRQ_RETRY_INF);
  1782. schizo_write(p->controller_regs + SCHIZO_PCIB_IRQ_RETRY,
  1783.      SCHIZO_IRQ_RETRY_INF);
  1785. /* Enable arbiter for all PCI slots.  Also, disable PCI interval
  1786.  * timer so that DTO (Discard TimeOuts) are not reported because
  1787.  * some Schizo revisions report them erroneously.
  1788.  */
  1790. tmp = schizo_read(p->controller_regs + SCHIZO_PCIA_CTRL);
  1791. tmp |= SCHIZO_PCICTRL_ARB;
  1792. tmp &= ~SCHIZO_PCICTRL_PTO;
  1793. schizo_write(p->controller_regs + SCHIZO_PCIA_CTRL, tmp);
  1795. tmp = schizo_read(p->controller_regs + SCHIZO_PCIB_CTRL);
  1796. tmp |= SCHIZO_PCICTRL_ARB;
  1797. tmp &= ~SCHIZO_PCICTRL_PTO;
  1798. schizo_write(p->controller_regs + SCHIZO_PCIB_CTRL, tmp);
  1800. /* Disable TTO error reporting (won't happen anyway since we
  1801.  * disabled the PCI interval timer above) and retry arbitration
  1802.  * (can cause hangs in some Schizo revisions).
  1803.  */
  1804. tmp = schizo_read(p->controller_regs + SCHIZO_PCIA_DIAG);
  1805. tmp |= (SCHIZO_PCIDIAG_D_TTO | SCHIZO_PCIDIAG_D_RTRYARB);
  1806. schizo_write(p->controller_regs + SCHIZO_PCIA_DIAG, tmp);
  1808. tmp = schizo_read(p->controller_regs + SCHIZO_PCIB_DIAG);
  1809. tmp |= (SCHIZO_PCIDIAG_D_TTO | SCHIZO_PCIDIAG_D_RTRYARB);
  1810. schizo_write(p->controller_regs + SCHIZO_PCIB_DIAG, tmp);
  1811. }
  1813. void __init schizo_init(int node, char *model_name)
  1814. {
  1815. struct linux_prom64_registers pr_regs[3];
  1816. struct pci_controller_info *p;
  1817. struct pci_iommu *iommu;
  1818. unsigned long flags;
  1819. u32 portid;
  1820. int is_pbm_a, err;
  1822. portid = prom_getintdefault(node, "portid", 0xff);
  1824. spin_lock_irqsave(&pci_controller_lock, flags);
  1825. for(p = pci_controller_root; p; p = p->next) {
  1826. if (p->portid == portid) {
  1827. spin_unlock_irqrestore(&pci_controller_lock, flags);
  1828. is_pbm_a = (p->pbm_A.prom_node == 0);
  1829. schizo_pbm_init(p, node, is_pbm_a);
  1830. return;
  1831. }
  1832. }
  1833. spin_unlock_irqrestore(&pci_controller_lock, flags);
  1835. p = kmalloc(sizeof(struct pci_controller_info), GFP_ATOMIC);
  1836. if (!p) {
  1837. prom_printf("SCHIZO: Fatal memory allocation error.n");
  1838. prom_halt();
  1839. }
  1840. memset(p, 0, sizeof(*p));
  1842. iommu = kmalloc(sizeof(struct pci_iommu), GFP_ATOMIC);
  1843. if (!iommu) {
  1844. prom_printf("SCHIZO: Fatal memory allocation error.n");
  1845. prom_halt();
  1846. }
  1847. memset(iommu, 0, sizeof(*iommu));
  1848. p->pbm_A.iommu = iommu;
  1850. iommu = kmalloc(sizeof(struct pci_iommu), GFP_ATOMIC);
  1851. if (!iommu) {
  1852. prom_printf("SCHIZO: Fatal memory allocation error.n");
  1853. prom_halt();
  1854. }
  1855. memset(iommu, 0, sizeof(*iommu));
  1856. p->pbm_B.iommu = iommu;
  1858. spin_lock_irqsave(&pci_controller_lock, flags);
  1859. p->next = pci_controller_root;
  1860. pci_controller_root = p;
  1861. spin_unlock_irqrestore(&pci_controller_lock, flags);
  1863. p->portid = portid;
  1864. p->index = pci_num_controllers++;
  1865. p->pbms_same_domain = 0;
  1866. p->scan_bus = schizo_scan_bus;
  1867. p->irq_build = schizo_irq_build;
  1868. p->base_address_update = schizo_base_address_update;
  1869. p->resource_adjust = schizo_resource_adjust;
  1870. p->pci_ops = &schizo_ops;
  1872. /* Three OBP regs:
  1873.  * 1) PBM controller regs
  1874.  * 2) Schizo front-end controller regs (same for both PBMs)
  1875.  * 3) PBM PCI config space
  1876.  */
  1877. err = prom_getproperty(node, "reg",
  1878.        (char *)&pr_regs[0],
  1879.        sizeof(pr_regs));
  1880. if (err == 0 || err == -1) {
  1881. prom_printf("SCHIZO: Fatal error, no reg property.n");
  1882. prom_halt();
  1883. }
  1885. p->controller_regs = pr_regs[1].phys_addr - 0x10000UL;
  1886. printk("PCI: Found SCHIZO, control regs at %016lxn",
  1887.        p->controller_regs);
  1889. /* Like PSYCHO we have a 2GB aligned area for memory space. */
  1890. pci_memspace_mask = 0x7fffffffUL;
  1892. /* Init core controller. */
  1893. schizo_controller_hwinit(p);
  1895. is_pbm_a = ((pr_regs[0].phys_addr & 0x00700000) == 0x00600000);
  1896. schizo_pbm_init(p, node, is_pbm_a);
  1897. }