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

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

Linux/Unix编程

开发平台：

Unix_Linux

pci_sabre.c：源码内容
  1. /* $Id: pci_sabre.c,v 1.41.2.1 2002/03/03 10:31:56 davem Exp $
  2.  * pci_sabre.c: Sabre specific PCI controller support.
  3.  *
  4.  * Copyright (C) 1997, 1998, 1999 David S. Miller (davem@caipfs.rutgers.edu)
  5.  * Copyright (C) 1998, 1999 Eddie C. Dost   (ecd@skynet.be)
  6.  * Copyright (C) 1999 Jakub Jelinek   (jakub@redhat.com)
  7.  */
  9. #include <linux/kernel.h>
  10. #include <linux/types.h>
  11. #include <linux/pci.h>
  12. #include <linux/init.h>
  13. #include <linux/slab.h>
  15. #include <asm/apb.h>
  16. #include <asm/pbm.h>
  17. #include <asm/iommu.h>
  18. #include <asm/irq.h>
  19. #include <asm/smp.h>
  21. #include "pci_impl.h"
  22. #include "iommu_common.h"
  24. /* All SABRE registers are 64-bits.  The following accessor
  25.  * routines are how they are accessed.  The REG parameter
  26.  * is a physical address.
  27.  */
  28. #define sabre_read(__reg) 
  29. ({ u64 __ret; 
  30. __asm__ __volatile__("ldxa [%1] %2, %0" 
  31.      : "=r" (__ret) 
  32.      : "r" (__reg), "i" (ASI_PHYS_BYPASS_EC_E) 
  33.      : "memory"); 
  34. __ret; 
  35. })
  36. #define sabre_write(__reg, __val) 
  37. __asm__ __volatile__("stxa %0, [%1] %2" 
  38.      : /* no outputs */ 
  39.      : "r" (__val), "r" (__reg), 
  40.        "i" (ASI_PHYS_BYPASS_EC_E) 
  41.      : "memory")
  43. /* SABRE PCI controller register offsets and definitions. */
  44. #define SABRE_UE_AFSR 0x0030UL
  45. #define  SABRE_UEAFSR_PDRD  0x4000000000000000UL /* Primary PCI DMA Read */
  46. #define  SABRE_UEAFSR_PDWR  0x2000000000000000UL /* Primary PCI DMA Write */
  47. #define  SABRE_UEAFSR_SDRD  0x0800000000000000UL /* Secondary PCI DMA Read */
  48. #define  SABRE_UEAFSR_SDWR  0x0400000000000000UL /* Secondary PCI DMA Write */
  49. #define  SABRE_UEAFSR_SDTE  0x0200000000000000UL /* Secondary DMA Translation Error */
  50. #define  SABRE_UEAFSR_PDTE  0x0100000000000000UL /* Primary DMA Translation Error */
  51. #define  SABRE_UEAFSR_BMSK  0x0000ffff00000000UL /* Bytemask */
  52. #define  SABRE_UEAFSR_OFF  0x00000000e0000000UL /* Offset (AFAR bits [5:3] */
  53. #define  SABRE_UEAFSR_BLK  0x0000000000800000UL /* Was block operation */
  54. #define SABRE_UECE_AFAR 0x0038UL
  55. #define SABRE_CE_AFSR 0x0040UL
  56. #define  SABRE_CEAFSR_PDRD  0x4000000000000000UL /* Primary PCI DMA Read */
  57. #define  SABRE_CEAFSR_PDWR  0x2000000000000000UL /* Primary PCI DMA Write */
  58. #define  SABRE_CEAFSR_SDRD  0x0800000000000000UL /* Secondary PCI DMA Read */
  59. #define  SABRE_CEAFSR_SDWR  0x0400000000000000UL /* Secondary PCI DMA Write */
  60. #define  SABRE_CEAFSR_ESYND  0x00ff000000000000UL /* ECC Syndrome */
  61. #define  SABRE_CEAFSR_BMSK  0x0000ffff00000000UL /* Bytemask */
  62. #define  SABRE_CEAFSR_OFF  0x00000000e0000000UL /* Offset */
  63. #define  SABRE_CEAFSR_BLK  0x0000000000800000UL /* Was block operation */
  64. #define SABRE_UECE_AFAR_ALIAS 0x0048UL /* Aliases to 0x0038 */
  65. #define SABRE_IOMMU_CONTROL 0x0200UL
  66. #define  SABRE_IOMMUCTRL_ERRSTS  0x0000000006000000UL /* Error status bits */
  67. #define  SABRE_IOMMUCTRL_ERR  0x0000000001000000UL /* Error present in IOTLB */
  68. #define  SABRE_IOMMUCTRL_LCKEN  0x0000000000800000UL /* IOTLB lock enable */
  69. #define  SABRE_IOMMUCTRL_LCKPTR  0x0000000000780000UL /* IOTLB lock pointer */
  70. #define  SABRE_IOMMUCTRL_TSBSZ  0x0000000000070000UL /* TSB Size */
  71. #define  SABRE_IOMMU_TSBSZ_1K   0x0000000000000000
  72. #define  SABRE_IOMMU_TSBSZ_2K   0x0000000000010000
  73. #define  SABRE_IOMMU_TSBSZ_4K   0x0000000000020000
  74. #define  SABRE_IOMMU_TSBSZ_8K   0x0000000000030000
  75. #define  SABRE_IOMMU_TSBSZ_16K  0x0000000000040000
  76. #define  SABRE_IOMMU_TSBSZ_32K  0x0000000000050000
  77. #define  SABRE_IOMMU_TSBSZ_64K  0x0000000000060000
  78. #define  SABRE_IOMMU_TSBSZ_128K 0x0000000000070000
  79. #define  SABRE_IOMMUCTRL_TBWSZ  0x0000000000000004UL /* TSB assumed page size */
  80. #define  SABRE_IOMMUCTRL_DENAB  0x0000000000000002UL /* Diagnostic Mode Enable */
  81. #define  SABRE_IOMMUCTRL_ENAB  0x0000000000000001UL /* IOMMU Enable */
  82. #define SABRE_IOMMU_TSBBASE 0x0208UL
  83. #define SABRE_IOMMU_FLUSH 0x0210UL
  84. #define SABRE_IMAP_A_SLOT0 0x0c00UL
  85. #define SABRE_IMAP_B_SLOT0 0x0c20UL
  86. #define SABRE_IMAP_SCSI 0x1000UL
  87. #define SABRE_IMAP_ETH 0x1008UL
  88. #define SABRE_IMAP_BPP 0x1010UL
  89. #define SABRE_IMAP_AU_REC 0x1018UL
  90. #define SABRE_IMAP_AU_PLAY 0x1020UL
  91. #define SABRE_IMAP_PFAIL 0x1028UL
  92. #define SABRE_IMAP_KMS 0x1030UL
  93. #define SABRE_IMAP_FLPY 0x1038UL
  94. #define SABRE_IMAP_SHW 0x1040UL
  95. #define SABRE_IMAP_KBD 0x1048UL
  96. #define SABRE_IMAP_MS 0x1050UL
  97. #define SABRE_IMAP_SER 0x1058UL
  98. #define SABRE_IMAP_UE 0x1070UL
  99. #define SABRE_IMAP_CE 0x1078UL
  100. #define SABRE_IMAP_PCIERR 0x1080UL
  101. #define SABRE_IMAP_GFX 0x1098UL
  102. #define SABRE_IMAP_EUPA 0x10a0UL
  103. #define SABRE_ICLR_A_SLOT0 0x1400UL
  104. #define SABRE_ICLR_B_SLOT0 0x1480UL
  105. #define SABRE_ICLR_SCSI 0x1800UL
  106. #define SABRE_ICLR_ETH 0x1808UL
  107. #define SABRE_ICLR_BPP 0x1810UL
  108. #define SABRE_ICLR_AU_REC 0x1818UL
  109. #define SABRE_ICLR_AU_PLAY 0x1820UL
  110. #define SABRE_ICLR_PFAIL 0x1828UL
  111. #define SABRE_ICLR_KMS 0x1830UL
  112. #define SABRE_ICLR_FLPY 0x1838UL
  113. #define SABRE_ICLR_SHW 0x1840UL
  114. #define SABRE_ICLR_KBD 0x1848UL
  115. #define SABRE_ICLR_MS 0x1850UL
  116. #define SABRE_ICLR_SER 0x1858UL
  117. #define SABRE_ICLR_UE 0x1870UL
  118. #define SABRE_ICLR_CE 0x1878UL
  119. #define SABRE_ICLR_PCIERR 0x1880UL
  120. #define SABRE_WRSYNC 0x1c20UL
  121. #define SABRE_PCICTRL 0x2000UL
  122. #define  SABRE_PCICTRL_MRLEN  0x0000001000000000UL /* Use MemoryReadLine for block loads/stores */
  123. #define  SABRE_PCICTRL_SERR  0x0000000400000000UL /* Set when SERR asserted on PCI bus */
  124. #define  SABRE_PCICTRL_ARBPARK  0x0000000000200000UL /* Bus Parking 0=Ultra-IIi 1=prev-bus-owner */
  125. #define  SABRE_PCICTRL_CPUPRIO  0x0000000000100000UL /* Ultra-IIi granted every other bus cycle */
  126. #define  SABRE_PCICTRL_ARBPRIO  0x00000000000f0000UL /* Slot which is granted every other bus cycle */
  127. #define  SABRE_PCICTRL_ERREN  0x0000000000000100UL /* PCI Error Interrupt Enable */
  128. #define  SABRE_PCICTRL_RTRYWE  0x0000000000000080UL /* DMA Flow Control 0=wait-if-possible 1=retry */
  129. #define  SABRE_PCICTRL_AEN  0x000000000000000fUL /* Slot PCI arbitration enables */
  130. #define SABRE_PIOAFSR 0x2010UL
  131. #define  SABRE_PIOAFSR_PMA  0x8000000000000000UL /* Primary Master Abort */
  132. #define  SABRE_PIOAFSR_PTA  0x4000000000000000UL /* Primary Target Abort */
  133. #define  SABRE_PIOAFSR_PRTRY  0x2000000000000000UL /* Primary Excessive Retries */
  134. #define  SABRE_PIOAFSR_PPERR  0x1000000000000000UL /* Primary Parity Error */
  135. #define  SABRE_PIOAFSR_SMA  0x0800000000000000UL /* Secondary Master Abort */
  136. #define  SABRE_PIOAFSR_STA  0x0400000000000000UL /* Secondary Target Abort */
  137. #define  SABRE_PIOAFSR_SRTRY  0x0200000000000000UL /* Secondary Excessive Retries */
  138. #define  SABRE_PIOAFSR_SPERR  0x0100000000000000UL /* Secondary Parity Error */
  139. #define  SABRE_PIOAFSR_BMSK  0x0000ffff00000000UL /* Byte Mask */
  140. #define  SABRE_PIOAFSR_BLK  0x0000000080000000UL /* Was Block Operation */
  141. #define SABRE_PIOAFAR 0x2018UL
  142. #define SABRE_PCIDIAG 0x2020UL
  143. #define  SABRE_PCIDIAG_DRTRY  0x0000000000000040UL /* Disable PIO Retry Limit */
  144. #define  SABRE_PCIDIAG_IPAPAR  0x0000000000000008UL /* Invert PIO Address Parity */
  145. #define  SABRE_PCIDIAG_IPDPAR  0x0000000000000004UL /* Invert PIO Data Parity */
  146. #define  SABRE_PCIDIAG_IDDPAR  0x0000000000000002UL /* Invert DMA Data Parity */
  147. #define  SABRE_PCIDIAG_ELPBK  0x0000000000000001UL /* Loopback Enable - not supported */
  148. #define SABRE_PCITASR 0x2028UL
  149. #define  SABRE_PCITASR_EF  0x0000000000000080UL /* Respond to 0xe0000000-0xffffffff */
  150. #define  SABRE_PCITASR_CD  0x0000000000000040UL /* Respond to 0xc0000000-0xdfffffff */
  151. #define  SABRE_PCITASR_AB  0x0000000000000020UL /* Respond to 0xa0000000-0xbfffffff */
  152. #define  SABRE_PCITASR_89  0x0000000000000010UL /* Respond to 0x80000000-0x9fffffff */
  153. #define  SABRE_PCITASR_67  0x0000000000000008UL /* Respond to 0x60000000-0x7fffffff */
  154. #define  SABRE_PCITASR_45  0x0000000000000004UL /* Respond to 0x40000000-0x5fffffff */
  155. #define  SABRE_PCITASR_23  0x0000000000000002UL /* Respond to 0x20000000-0x3fffffff */
  156. #define  SABRE_PCITASR_01  0x0000000000000001UL /* Respond to 0x00000000-0x1fffffff */
  157. #define SABRE_PIOBUF_DIAG 0x5000UL
  158. #define SABRE_DMABUF_DIAGLO 0x5100UL
  159. #define SABRE_DMABUF_DIAGHI 0x51c0UL
  160. #define SABRE_IMAP_GFX_ALIAS 0x6000UL /* Aliases to 0x1098 */
  161. #define SABRE_IMAP_EUPA_ALIAS 0x8000UL /* Aliases to 0x10a0 */
  162. #define SABRE_IOMMU_VADIAG 0xa400UL
  163. #define SABRE_IOMMU_TCDIAG 0xa408UL
  164. #define SABRE_IOMMU_TAG 0xa580UL
  165. #define  SABRE_IOMMUTAG_ERRSTS  0x0000000001800000UL /* Error status bits */
  166. #define  SABRE_IOMMUTAG_ERR  0x0000000000400000UL /* Error present */
  167. #define  SABRE_IOMMUTAG_WRITE  0x0000000000200000UL /* Page is writable */
  168. #define  SABRE_IOMMUTAG_STREAM  0x0000000000100000UL /* Streamable bit - unused */
  169. #define  SABRE_IOMMUTAG_SIZE  0x0000000000080000UL /* 0=8k 1=16k */
  170. #define  SABRE_IOMMUTAG_VPN  0x000000000007ffffUL /* Virtual Page Number [31:13] */
  171. #define SABRE_IOMMU_DATA 0xa600UL
  172. #define SABRE_IOMMUDATA_VALID  0x0000000040000000UL /* Valid */
  173. #define SABRE_IOMMUDATA_USED  0x0000000020000000UL /* Used (for LRU algorithm) */
  174. #define SABRE_IOMMUDATA_CACHE  0x0000000010000000UL /* Cacheable */
  175. #define SABRE_IOMMUDATA_PPN  0x00000000001fffffUL /* Physical Page Number [33:13] */
  176. #define SABRE_PCI_IRQSTATE 0xa800UL
  177. #define SABRE_OBIO_IRQSTATE 0xa808UL
  178. #define SABRE_FFBCFG 0xf000UL
  179. #define  SABRE_FFBCFG_SPRQS  0x000000000f000000 /* Slave P_RQST queue size */
  180. #define  SABRE_FFBCFG_ONEREAD  0x0000000000004000 /* Slave supports one outstanding read */
  181. #define SABRE_MCCTRL0 0xf010UL
  182. #define  SABRE_MCCTRL0_RENAB  0x0000000080000000 /* Refresh Enable */
  183. #define  SABRE_MCCTRL0_EENAB  0x0000000010000000 /* Enable all ECC functions */
  184. #define  SABRE_MCCTRL0_11BIT  0x0000000000001000 /* Enable 11-bit column addressing */
  185. #define  SABRE_MCCTRL0_DPP  0x0000000000000f00 /* DIMM Pair Present Bits */
  186. #define  SABRE_MCCTRL0_RINTVL  0x00000000000000ff /* Refresh Interval */
  187. #define SABRE_MCCTRL1 0xf018UL
  188. #define  SABRE_MCCTRL1_AMDC  0x0000000038000000 /* Advance Memdata Clock */
  189. #define  SABRE_MCCTRL1_ARDC  0x0000000007000000 /* Advance DRAM Read Data Clock */
  190. #define  SABRE_MCCTRL1_CSR  0x0000000000e00000 /* CAS to RAS delay for CBR refresh */
  191. #define  SABRE_MCCTRL1_CASRW  0x00000000001c0000 /* CAS length for read/write */
  192. #define  SABRE_MCCTRL1_RCD  0x0000000000038000 /* RAS to CAS delay */
  193. #define  SABRE_MCCTRL1_CP  0x0000000000007000 /* CAS Precharge */
  194. #define  SABRE_MCCTRL1_RP  0x0000000000000e00 /* RAS Precharge */
  195. #define  SABRE_MCCTRL1_RAS  0x00000000000001c0 /* Length of RAS for refresh */
  196. #define  SABRE_MCCTRL1_CASRW2  0x0000000000000038 /* Must be same as CASRW */
  197. #define  SABRE_MCCTRL1_RSC  0x0000000000000007 /* RAS after CAS hold time */
  198. #define SABRE_RESETCTRL 0xf020UL
  200. #define SABRE_CONFIGSPACE 0x001000000UL
  201. #define SABRE_IOSPACE 0x002000000UL
  202. #define SABRE_IOSPACE_SIZE 0x000ffffffUL
  203. #define SABRE_MEMSPACE 0x100000000UL
  204. #define SABRE_MEMSPACE_SIZE 0x07fffffffUL
  206. /* UltraSparc-IIi Programmer's Manual, page 325, PCI
  207.  * configuration space address format:
  208.  * 
  209.  *  32             24 23 16 15    11 10       8 7   2  1 0
  210.  * ---------------------------------------------------------
  211.  * |0 0 0 0 0 0 0 0 1| bus | device | function | reg | 0 0 |
  212.  * ---------------------------------------------------------
  213.  */
  214. #define SABRE_CONFIG_BASE(PBM)
  215. ((PBM)->config_space | (1UL << 24))
  216. #define SABRE_CONFIG_ENCODE(BUS, DEVFN, REG)
  217. (((unsigned long)(BUS)   << 16) |
  218.  ((unsigned long)(DEVFN) << 8)  |
  219.  ((unsigned long)(REG)))
  221. static int hummingbird_p;
  223. static void *sabre_pci_config_mkaddr(struct pci_pbm_info *pbm,
  224.      unsigned char bus,
  225.      unsigned int devfn,
  226.      int where)
  227. {
  228. if (!pbm)
  229. return NULL;
  230. return (void *)
  231. (SABRE_CONFIG_BASE(pbm) |
  232.  SABRE_CONFIG_ENCODE(bus, devfn, where));
  233. }
  235. static int sabre_out_of_range(unsigned char devfn)
  236. {
  237. if (hummingbird_p)
  238. return 0;
  240. return (((PCI_SLOT(devfn) == 0) && (PCI_FUNC(devfn) > 0)) ||
  241. ((PCI_SLOT(devfn) == 1) && (PCI_FUNC(devfn) > 1)) ||
  242. (PCI_SLOT(devfn) > 1));
  243. }
  245. static int __sabre_out_of_range(struct pci_pbm_info *pbm,
  246. unsigned char bus,
  247. unsigned char devfn)
  248. {
  249. if (hummingbird_p)
  250. return 0;
  252. return ((pbm->parent == 0) ||
  253. ((pbm == &pbm->parent->pbm_B) &&
  254.  (bus == pbm->pci_first_busno) &&
  255.  PCI_SLOT(devfn) > 8) ||
  256. ((pbm == &pbm->parent->pbm_A) &&
  257.  (bus == pbm->pci_first_busno) &&
  258.  PCI_SLOT(devfn) > 8));
  259. }
  261. static int __sabre_read_byte(struct pci_dev *dev, int where, u8 *value)
  262. {
  263. struct pci_pbm_info *pbm = pci_bus2pbm[dev->bus->number];
  264. unsigned char bus = dev->bus->number;
  265. unsigned int devfn = dev->devfn;
  266. u8 *addr;
  268. *value = 0xff;
  269. addr = sabre_pci_config_mkaddr(pbm, bus, devfn, where);
  270. if (!addr)
  271. return PCIBIOS_SUCCESSFUL;
  273. if (__sabre_out_of_range(pbm, bus, devfn))
  274. return PCIBIOS_SUCCESSFUL;
  275. pci_config_read8(addr, value);
  276. return PCIBIOS_SUCCESSFUL;
  277. }
  279. static int __sabre_read_word(struct pci_dev *dev, int where, u16 *value)
  280. {
  281. struct pci_pbm_info *pbm = pci_bus2pbm[dev->bus->number];
  282. unsigned char bus = dev->bus->number;
  283. unsigned int devfn = dev->devfn;
  284. u16 *addr;
  286. *value = 0xffff;
  287. addr = sabre_pci_config_mkaddr(pbm, bus, devfn, where);
  288. if (!addr)
  289. return PCIBIOS_SUCCESSFUL;
  291. if (__sabre_out_of_range(pbm, bus, devfn))
  292. return PCIBIOS_SUCCESSFUL;
  294. if (where & 0x01) {
  295. printk("pcibios_read_config_word: misaligned reg [%x]n",
  296.        where);
  297. return PCIBIOS_SUCCESSFUL;
  298. }
  299. pci_config_read16(addr, value);
  300. return PCIBIOS_SUCCESSFUL;
  301. }
  303. static int __sabre_read_dword(struct pci_dev *dev, int where, u32 *value)
  304. {
  305. struct pci_pbm_info *pbm = pci_bus2pbm[dev->bus->number];
  306. unsigned char bus = dev->bus->number;
  307. unsigned int devfn = dev->devfn;
  308. u32 *addr;
  310. *value = 0xffffffff;
  311. addr = sabre_pci_config_mkaddr(pbm, bus, devfn, where);
  312. if (!addr)
  313. return PCIBIOS_SUCCESSFUL;
  315. if (__sabre_out_of_range(pbm, bus, devfn))
  316. return PCIBIOS_SUCCESSFUL;
  318. if (where & 0x03) {
  319. printk("pcibios_read_config_dword: misaligned reg [%x]n",
  320.        where);
  321. return PCIBIOS_SUCCESSFUL;
  322. }
  323. pci_config_read32(addr, value);
  324. return PCIBIOS_SUCCESSFUL;
  325. }
  327. static int sabre_read_byte(struct pci_dev *dev, int where, u8 *value)
  328. {
  329. if (dev->bus->number)
  330. return __sabre_read_byte(dev, where, value);
  332. if (sabre_out_of_range(dev->devfn)) {
  333. *value = 0xff;
  334. return PCIBIOS_SUCCESSFUL;
  335. }
  337. if (where < 8) {
  338. u16 tmp;
  340. __sabre_read_word(dev, where & ~1, &tmp);
  341. if (where & 1)
  342. *value = tmp >> 8;
  343. else
  344. *value = tmp & 0xff;
  345. return PCIBIOS_SUCCESSFUL;
  346. } else
  347. return __sabre_read_byte(dev, where, value);
  348. }
  350. static int sabre_read_word(struct pci_dev *dev, int where, u16 *value)
  351. {
  352. if (dev->bus->number)
  353. return __sabre_read_word(dev, where, value);
  355. if (sabre_out_of_range(dev->devfn)) {
  356. *value = 0xffff;
  357. return PCIBIOS_SUCCESSFUL;
  358. }
  360. if (where < 8)
  361. return __sabre_read_word(dev, where, value);
  362. else {
  363. u8 tmp;
  365. __sabre_read_byte(dev, where, &tmp);
  366. *value = tmp;
  367. __sabre_read_byte(dev, where + 1, &tmp);
  368. *value |= tmp << 8;
  369. return PCIBIOS_SUCCESSFUL;
  370. }
  371. }
  373. static int sabre_read_dword(struct pci_dev *dev, int where, u32 *value)
  374. {
  375. u16 tmp;
  377. if (dev->bus->number)
  378. return __sabre_read_dword(dev, where, value);
  380. if (sabre_out_of_range(dev->devfn)) {
  381. *value = 0xffffffff;
  382. return PCIBIOS_SUCCESSFUL;
  383. }
  385. sabre_read_word(dev, where, &tmp);
  386. *value = tmp;
  387. sabre_read_word(dev, where + 2, &tmp);
  388. *value |= tmp << 16;
  389. return PCIBIOS_SUCCESSFUL;
  390. }
  392. static int __sabre_write_byte(struct pci_dev *dev, int where, u8 value)
  393. {
  394. struct pci_pbm_info *pbm = pci_bus2pbm[dev->bus->number];
  395. unsigned char bus = dev->bus->number;
  396. unsigned int devfn = dev->devfn;
  397. u8 *addr;
  399. addr = sabre_pci_config_mkaddr(pbm, bus, devfn, where);
  400. if (!addr)
  401. return PCIBIOS_SUCCESSFUL;
  403. if (__sabre_out_of_range(pbm, bus, devfn))
  404. return PCIBIOS_SUCCESSFUL;
  405. pci_config_write8(addr, value);
  406. return PCIBIOS_SUCCESSFUL;
  407. }
  409. static int __sabre_write_word(struct pci_dev *dev, int where, u16 value)
  410. {
  411. struct pci_pbm_info *pbm = pci_bus2pbm[dev->bus->number];
  412. unsigned char bus = dev->bus->number;
  413. unsigned int devfn = dev->devfn;
  414. u16 *addr;
  416. addr = sabre_pci_config_mkaddr(pbm, bus, devfn, where);
  417. if (!addr)
  418. return PCIBIOS_SUCCESSFUL;
  420. if (__sabre_out_of_range(pbm, bus, devfn))
  421. return PCIBIOS_SUCCESSFUL;
  423. if (where & 0x01) {
  424. printk("pcibios_write_config_word: misaligned reg [%x]n",
  425.        where);
  426. return PCIBIOS_SUCCESSFUL;
  427. }
  428. pci_config_write16(addr, value);
  429. return PCIBIOS_SUCCESSFUL;
  430. }
  432. static int __sabre_write_dword(struct pci_dev *dev, int where, u32 value)
  433. {
  434. struct pci_pbm_info *pbm = pci_bus2pbm[dev->bus->number];
  435. unsigned char bus = dev->bus->number;
  436. unsigned int devfn = dev->devfn;
  437. u32 *addr;
  439. addr = sabre_pci_config_mkaddr(pbm, bus, devfn, where);
  440. if (!addr)
  441. return PCIBIOS_SUCCESSFUL;
  443. if (__sabre_out_of_range(pbm, bus, devfn))
  444. return PCIBIOS_SUCCESSFUL;
  446. if (where & 0x03) {
  447. printk("pcibios_write_config_dword: misaligned reg [%x]n",
  448.        where);
  449. return PCIBIOS_SUCCESSFUL;
  450. }
  451. pci_config_write32(addr, value);
  452. return PCIBIOS_SUCCESSFUL;
  453. }
  455. static int sabre_write_byte(struct pci_dev *dev, int where, u8 value)
  456. {
  457. if (dev->bus->number)
  458. return __sabre_write_byte(dev, where, value);
  460. if (sabre_out_of_range(dev->devfn))
  461. return PCIBIOS_SUCCESSFUL;
  463. if (where < 8) {
  464. u16 tmp;
  466. __sabre_read_word(dev, where & ~1, &tmp);
  467. if (where & 1) {
  468. value &= 0x00ff;
  469. value |= tmp << 8;
  470. } else {
  471. value &= 0xff00;
  472. value |= tmp;
  473. }
  474. return __sabre_write_word(dev, where & ~1, tmp);
  475. } else
  476. return __sabre_write_byte(dev, where, value);
  477. }
  479. static int sabre_write_word(struct pci_dev *dev, int where, u16 value)
  480. {
  481. if (dev->bus->number)
  482. return __sabre_write_word(dev, where, value);
  484. if (sabre_out_of_range(dev->devfn))
  485. return PCIBIOS_SUCCESSFUL;
  487. if (where < 8)
  488. return __sabre_write_word(dev, where, value);
  489. else {
  490. __sabre_write_byte(dev, where, value & 0xff);
  491. __sabre_write_byte(dev, where + 1, value >> 8);
  492. return PCIBIOS_SUCCESSFUL;
  493. }
  494. }
  496. static int sabre_write_dword(struct pci_dev *dev, int where, u32 value)
  497. {
  498. if (dev->bus->number)
  499. return __sabre_write_dword(dev, where, value);
  501. if (sabre_out_of_range(dev->devfn))
  502. return PCIBIOS_SUCCESSFUL;
  504. sabre_write_word(dev, where, value & 0xffff);
  505. sabre_write_word(dev, where + 2, value >> 16);
  506. return PCIBIOS_SUCCESSFUL;
  507. }
  509. static struct pci_ops sabre_ops = {
  510. sabre_read_byte,
  511. sabre_read_word,
  512. sabre_read_dword,
  513. sabre_write_byte,
  514. sabre_write_word,
  515. sabre_write_dword
  516. };
  518. static unsigned long sabre_pcislot_imap_offset(unsigned long ino)
  519. {
  520. unsigned int bus =  (ino & 0x10) >> 4;
  521. unsigned int slot = (ino & 0x0c) >> 2;
  523. if (bus == 0)
  524. return SABRE_IMAP_A_SLOT0 + (slot * 8);
  525. else
  526. return SABRE_IMAP_B_SLOT0 + (slot * 8);
  527. }
  529. static unsigned long __onboard_imap_off[] = {
  530. /*0x20*/ SABRE_IMAP_SCSI,
  531. /*0x21*/ SABRE_IMAP_ETH,
  532. /*0x22*/ SABRE_IMAP_BPP,
  533. /*0x23*/ SABRE_IMAP_AU_REC,
  534. /*0x24*/ SABRE_IMAP_AU_PLAY,
  535. /*0x25*/ SABRE_IMAP_PFAIL,
  536. /*0x26*/ SABRE_IMAP_KMS,
  537. /*0x27*/ SABRE_IMAP_FLPY,
  538. /*0x28*/ SABRE_IMAP_SHW,
  539. /*0x29*/ SABRE_IMAP_KBD,
  540. /*0x2a*/ SABRE_IMAP_MS,
  541. /*0x2b*/ SABRE_IMAP_SER,
  542. /*0x2c*/ 0 /* reserved */,
  543. /*0x2d*/ 0 /* reserved */,
  544. /*0x2e*/ SABRE_IMAP_UE,
  545. /*0x2f*/ SABRE_IMAP_CE,
  546. /*0x30*/ SABRE_IMAP_PCIERR,
  547. };
  548. #define SABRE_ONBOARD_IRQ_BASE 0x20
  549. #define SABRE_ONBOARD_IRQ_LAST 0x30
  550. #define sabre_onboard_imap_offset(__ino) 
  551. __onboard_imap_off[(__ino) - SABRE_ONBOARD_IRQ_BASE]
  553. #define sabre_iclr_offset(ino)       
  554. ((ino & 0x20) ? (SABRE_ICLR_SCSI + (((ino) & 0x1f) << 3)) :  
  555. (SABRE_ICLR_A_SLOT0 + (((ino) & 0x1f)<<3)))
  557. /* PCI SABRE INO number to Sparc PIL level. */
  558. static unsigned char sabre_pil_table[] = {
  559. /*0x00*/0, 0, 0, 0, /* PCI A slot 0  Int A, B, C, D */
  560. /*0x04*/0, 0, 0, 0, /* PCI A slot 1  Int A, B, C, D */
  561. /*0x08*/0, 0, 0, 0, /* PCI A slot 2  Int A, B, C, D */
  562. /*0x0c*/0, 0, 0, 0, /* PCI A slot 3  Int A, B, C, D */
  563. /*0x10*/0, 0, 0, 0, /* PCI B slot 0  Int A, B, C, D */
  564. /*0x14*/0, 0, 0, 0, /* PCI B slot 1  Int A, B, C, D */
  565. /*0x18*/0, 0, 0, 0, /* PCI B slot 2  Int A, B, C, D */
  566. /*0x1c*/0, 0, 0, 0, /* PCI B slot 3  Int A, B, C, D */
  567. /*0x20*/4, /* SCSI */
  568. /*0x21*/5, /* Ethernet */
  569. /*0x22*/8, /* Parallel Port */
  570. /*0x23*/13, /* Audio Record */
  571. /*0x24*/14, /* Audio Playback */
  572. /*0x25*/15, /* PowerFail */
  573. /*0x26*/4, /* second SCSI */
  574. /*0x27*/11, /* Floppy */
  575. /*0x28*/4, /* Spare Hardware */
  576. /*0x29*/9, /* Keyboard */
  577. /*0x2a*/4, /* Mouse */
  578. /*0x2b*/12, /* Serial */
  579. /*0x2c*/10, /* Timer 0 */
  580. /*0x2d*/11, /* Timer 1 */
  581. /*0x2e*/15, /* Uncorrectable ECC */
  582. /*0x2f*/15, /* Correctable ECC */
  583. /*0x30*/15, /* PCI Bus A Error */
  584. /*0x31*/15, /* PCI Bus B Error */
  585. /*0x32*/15, /* Power Management */
  586. };
  588. static int __init sabre_ino_to_pil(struct pci_dev *pdev, unsigned int ino)
  589. {
  590. int ret;
  592. if (pdev &&
  593.     pdev->vendor == PCI_VENDOR_ID_SUN &&
  594.     pdev->device == PCI_DEVICE_ID_SUN_RIO_USB)
  595. return 9;
  597. ret = sabre_pil_table[ino];
  598. if (ret == 0 && pdev == NULL) {
  599. ret = 4;
  600. } else if (ret == 0) {
  601. switch ((pdev->class >> 16) & 0xff) {
  602. case PCI_BASE_CLASS_STORAGE:
  603. ret = 4;
  604. break;
  606. case PCI_BASE_CLASS_NETWORK:
  607. ret = 6;
  608. break;
  610. case PCI_BASE_CLASS_DISPLAY:
  611. ret = 9;
  612. break;
  614. case PCI_BASE_CLASS_MULTIMEDIA:
  615. case PCI_BASE_CLASS_MEMORY:
  616. case PCI_BASE_CLASS_BRIDGE:
  617. case PCI_BASE_CLASS_SERIAL:
  618. ret = 10;
  619. break;
  621. default:
  622. ret = 4;
  623. break;
  624. };
  625. }
  626. return ret;
  627. }
  629. static unsigned int __init sabre_irq_build(struct pci_pbm_info *pbm,
  630.    struct pci_dev *pdev,
  631.    unsigned int ino)
  632. {
  633. struct pci_controller_info *p = pbm->parent;
  634. struct ino_bucket *bucket;
  635. unsigned long imap, iclr;
  636. unsigned long imap_off, iclr_off;
  637. int pil, inofixup = 0;
  639. ino &= PCI_IRQ_INO;
  640. if (ino < SABRE_ONBOARD_IRQ_BASE) {
  641. /* PCI slot */
  642. imap_off = sabre_pcislot_imap_offset(ino);
  643. } else {
  644. /* onboard device */
  645. if (ino > SABRE_ONBOARD_IRQ_LAST) {
  646. prom_printf("sabre_irq_build: Wacky INO [%x]n", ino);
  647. prom_halt();
  648. }
  649. imap_off = sabre_onboard_imap_offset(ino);
  650. }
  652. /* Now build the IRQ bucket. */
  653. pil = sabre_ino_to_pil(pdev, ino);
  655. if (PIL_RESERVED(pil))
  656. BUG();
  658. imap = p->controller_regs + imap_off;
  659. imap += 4;
  661. iclr_off = sabre_iclr_offset(ino);
  662. iclr = p->controller_regs + iclr_off;
  663. iclr += 4;
  665. if ((ino & 0x20) == 0)
  666. inofixup = ino & 0x03;
  668. bucket = __bucket(build_irq(pil, inofixup, iclr, imap));
  669. bucket->flags |= IBF_PCI;
  671. if (pdev) {
  672. struct pcidev_cookie *pcp = pdev->sysdata;
  674. /* When a device lives behind a bridge deeper in the
  675.  * PCI bus topology than APB, a special sequence must
  676.  * run to make sure all pending DMA transfers at the
  677.  * time of IRQ delivery are visible in the coherency
  678.  * domain by the cpu.  This sequence is to perform
  679.  * a read on the far side of the non-APB bridge, then
  680.  * perform a read of Sabre's DMA write-sync register.
  681.  *
  682.  * Currently, the PCI_CONFIG register for the device
  683.  * is used for this read from the far side of the bridge.
  684.  */
  685. if (pdev->bus->number != pcp->pbm->pci_first_busno) {
  686. bucket->flags |= IBF_DMA_SYNC;
  687. bucket->synctab_ent = dma_sync_reg_table_entry++;
  688. dma_sync_reg_table[bucket->synctab_ent] =
  689. (unsigned long) sabre_pci_config_mkaddr(
  690. pcp->pbm,
  691. pdev->bus->number, pdev->devfn, PCI_COMMAND);
  692. }
  693. }
  694. return __irq(bucket);
  695. }
  697. /* SABRE error handling support. */
  698. static void sabre_check_iommu_error(struct pci_controller_info *p,
  699.     unsigned long afsr,
  700.     unsigned long afar)
  701. {
  702. struct pci_iommu *iommu = p->pbm_A.iommu;
  703. unsigned long iommu_tag[16];
  704. unsigned long iommu_data[16];
  705. unsigned long flags;
  706. u64 control;
  707. int i;
  709. spin_lock_irqsave(&iommu->lock, flags);
  710. control = sabre_read(iommu->iommu_control);
  711. if (control & SABRE_IOMMUCTRL_ERR) {
  712. char *type_string;
  714. /* Clear the error encountered bit.
  715.  * NOTE: On Sabre this is write 1 to clear,
  716.  *       which is different from Psycho.
  717.  */
  718. sabre_write(iommu->iommu_control, control);
  719. switch((control & SABRE_IOMMUCTRL_ERRSTS) >> 25UL) {
  720. case 1:
  721. type_string = "Invalid Error";
  722. break;
  723. case 3:
  724. type_string = "ECC Error";
  725. break;
  726. default:
  727. type_string = "Unknown";
  728. break;
  729. };
  730. printk("SABRE%d: IOMMU Error, type[%s]n",
  731.        p->index, type_string);
  733. /* Enter diagnostic mode and probe for error'd
  734.  * entries in the IOTLB.
  735.  */
  736. control &= ~(SABRE_IOMMUCTRL_ERRSTS | SABRE_IOMMUCTRL_ERR);
  737. sabre_write(iommu->iommu_control,
  738.     (control | SABRE_IOMMUCTRL_DENAB));
  739. for (i = 0; i < 16; i++) {
  740. unsigned long base = p->controller_regs;
  742. iommu_tag[i] =
  743. sabre_read(base + SABRE_IOMMU_TAG + (i * 8UL));
  744. iommu_data[i] =
  745. sabre_read(base + SABRE_IOMMU_DATA + (i * 8UL));
  746. sabre_write(base + SABRE_IOMMU_TAG + (i * 8UL), 0);
  747. sabre_write(base + SABRE_IOMMU_DATA + (i * 8UL), 0);
  748. }
  749. sabre_write(iommu->iommu_control, control);
  751. for (i = 0; i < 16; i++) {
  752. unsigned long tag, data;
  754. tag = iommu_tag[i];
  755. if (!(tag & SABRE_IOMMUTAG_ERR))
  756. continue;
  758. data = iommu_data[i];
  759. switch((tag & SABRE_IOMMUTAG_ERRSTS) >> 23UL) {
  760. case 1:
  761. type_string = "Invalid Error";
  762. break;
  763. case 3:
  764. type_string = "ECC Error";
  765. break;
  766. default:
  767. type_string = "Unknown";
  768. break;
  769. };
  770. printk("SABRE%d: IOMMU TAG(%d)[RAW(%016lx)error(%s)wr(%d)sz(%dK)vpg(%08lx)]n",
  771.        p->index, i, tag, type_string,
  772.        ((tag & SABRE_IOMMUTAG_WRITE) ? 1 : 0),
  773.        ((tag & SABRE_IOMMUTAG_SIZE) ? 64 : 8),
  774.        ((tag & SABRE_IOMMUTAG_VPN) << IOMMU_PAGE_SHIFT));
  775. printk("SABRE%d: IOMMU DATA(%d)[RAW(%016lx)valid(%d)used(%d)cache(%d)ppg(%016lx)n",
  776.        p->index, i, data,
  777.        ((data & SABRE_IOMMUDATA_VALID) ? 1 : 0),
  778.        ((data & SABRE_IOMMUDATA_USED) ? 1 : 0),
  779.        ((data & SABRE_IOMMUDATA_CACHE) ? 1 : 0),
  780.        ((data & SABRE_IOMMUDATA_PPN) << IOMMU_PAGE_SHIFT));
  781. }
  782. }
  783. spin_unlock_irqrestore(&iommu->lock, flags);
  784. }
  786. static void sabre_ue_intr(int irq, void *dev_id, struct pt_regs *regs)
  787. {
  788. struct pci_controller_info *p = dev_id;
  789. unsigned long afsr_reg = p->controller_regs + SABRE_UE_AFSR;
  790. unsigned long afar_reg = p->controller_regs + SABRE_UECE_AFAR;
  791. unsigned long afsr, afar, error_bits;
  792. int reported;
  794. /* Latch uncorrectable error status. */
  795. afar = sabre_read(afar_reg);
  796. afsr = sabre_read(afsr_reg);
  798. /* Clear the primary/secondary error status bits. */
  799. error_bits = afsr &
  800. (SABRE_UEAFSR_PDRD | SABRE_UEAFSR_PDWR |
  801.  SABRE_UEAFSR_SDRD | SABRE_UEAFSR_SDWR |
  802.  SABRE_UEAFSR_SDTE | SABRE_UEAFSR_PDTE);
  803. if (!error_bits)
  804. return;
  805. sabre_write(afsr_reg, error_bits);
  807. /* Log the error. */
  808. printk("SABRE%d: Uncorrectable Error, primary error type[%s%s]n",
  809.        p->index,
  810.        ((error_bits & SABRE_UEAFSR_PDRD) ?
  811. "DMA Read" :
  812. ((error_bits & SABRE_UEAFSR_PDWR) ?
  813.  "DMA Write" : "???")),
  814.        ((error_bits & SABRE_UEAFSR_PDTE) ?
  815. ":Translation Error" : ""));
  816. printk("SABRE%d: bytemask[%04lx] dword_offset[%lx] was_block(%d)n",
  817.        p->index,
  818.        (afsr & SABRE_UEAFSR_BMSK) >> 32UL,
  819.        (afsr & SABRE_UEAFSR_OFF) >> 29UL,
  820.        ((afsr & SABRE_UEAFSR_BLK) ? 1 : 0));
  821. printk("SABRE%d: UE AFAR [%016lx]n", p->index, afar);
  822. printk("SABRE%d: UE Secondary errors [", p->index);
  823. reported = 0;
  824. if (afsr & SABRE_UEAFSR_SDRD) {
  825. reported++;
  826. printk("(DMA Read)");
  827. }
  828. if (afsr & SABRE_UEAFSR_SDWR) {
  829. reported++;
  830. printk("(DMA Write)");
  831. }
  832. if (afsr & SABRE_UEAFSR_SDTE) {
  833. reported++;
  834. printk("(Translation Error)");
  835. }
  836. if (!reported)
  837. printk("(none)");
  838. printk("]n");
  840. /* Interrogate IOMMU for error status. */
  841. sabre_check_iommu_error(p, afsr, afar);
  842. }
  844. static void sabre_ce_intr(int irq, void *dev_id, struct pt_regs *regs)
  845. {
  846. struct pci_controller_info *p = dev_id;
  847. unsigned long afsr_reg = p->controller_regs + SABRE_CE_AFSR;
  848. unsigned long afar_reg = p->controller_regs + SABRE_UECE_AFAR;
  849. unsigned long afsr, afar, error_bits;
  850. int reported;
  852. /* Latch error status. */
  853. afar = sabre_read(afar_reg);
  854. afsr = sabre_read(afsr_reg);
  856. /* Clear primary/secondary error status bits. */
  857. error_bits = afsr &
  858. (SABRE_CEAFSR_PDRD | SABRE_CEAFSR_PDWR |
  859.  SABRE_CEAFSR_SDRD | SABRE_CEAFSR_SDWR);
  860. if (!error_bits)
  861. return;
  862. sabre_write(afsr_reg, error_bits);
  864. /* Log the error. */
  865. printk("SABRE%d: Correctable Error, primary error type[%s]n",
  866.        p->index,
  867.        ((error_bits & SABRE_CEAFSR_PDRD) ?
  868. "DMA Read" :
  869. ((error_bits & SABRE_CEAFSR_PDWR) ?
  870.  "DMA Write" : "???")));
  872. /* XXX Use syndrome and afar to print out module string just like
  873.  * XXX UDB CE trap handler does... -DaveM
  874.  */
  875. printk("SABRE%d: syndrome[%02lx] bytemask[%04lx] dword_offset[%lx] "
  876.        "was_block(%d)n",
  877.        p->index,
  878.        (afsr & SABRE_CEAFSR_ESYND) >> 48UL,
  879.        (afsr & SABRE_CEAFSR_BMSK) >> 32UL,
  880.        (afsr & SABRE_CEAFSR_OFF) >> 29UL,
  881.        ((afsr & SABRE_CEAFSR_BLK) ? 1 : 0));
  882. printk("SABRE%d: CE AFAR [%016lx]n", p->index, afar);
  883. printk("SABRE%d: CE Secondary errors [", p->index);
  884. reported = 0;
  885. if (afsr & SABRE_CEAFSR_SDRD) {
  886. reported++;
  887. printk("(DMA Read)");
  888. }
  889. if (afsr & SABRE_CEAFSR_SDWR) {
  890. reported++;
  891. printk("(DMA Write)");
  892. }
  893. if (!reported)
  894. printk("(none)");
  895. printk("]n");
  896. }
  898. static void sabre_pcierr_intr(int irq, void *dev_id, struct pt_regs *regs)
  899. {
  900. struct pci_controller_info *p = dev_id;
  901. unsigned long afsr_reg, afar_reg;
  902. unsigned long afsr, afar, error_bits;
  903. int reported;
  905. afsr_reg = p->controller_regs + SABRE_PIOAFSR;
  906. afar_reg = p->controller_regs + SABRE_PIOAFAR;
  908. /* Latch error status. */
  909. afar = sabre_read(afar_reg);
  910. afsr = sabre_read(afsr_reg);
  912. /* Clear primary/secondary error status bits. */
  913. error_bits = afsr &
  914. (SABRE_PIOAFSR_PMA | SABRE_PIOAFSR_PTA |
  915.  SABRE_PIOAFSR_PRTRY | SABRE_PIOAFSR_PPERR |
  916.  SABRE_PIOAFSR_SMA | SABRE_PIOAFSR_STA |
  917.  SABRE_PIOAFSR_SRTRY | SABRE_PIOAFSR_SPERR);
  918. if (!error_bits)
  919. return;
  920. sabre_write(afsr_reg, error_bits);
  922. /* Log the error. */
  923. printk("SABRE%d: PCI Error, primary error type[%s]n",
  924.        p->index,
  925.        (((error_bits & SABRE_PIOAFSR_PMA) ?
  926.  "Master Abort" :
  927.  ((error_bits & SABRE_PIOAFSR_PTA) ?
  928.   "Target Abort" :
  929.   ((error_bits & SABRE_PIOAFSR_PRTRY) ?
  930.    "Excessive Retries" :
  931.    ((error_bits & SABRE_PIOAFSR_PPERR) ?
  932.     "Parity Error" : "???"))))));
  933. printk("SABRE%d: bytemask[%04lx] was_block(%d)n",
  934.        p->index,
  935.        (afsr & SABRE_PIOAFSR_BMSK) >> 32UL,
  936.        (afsr & SABRE_PIOAFSR_BLK) ? 1 : 0);
  937. printk("SABRE%d: PCI AFAR [%016lx]n", p->index, afar);
  938. printk("SABRE%d: PCI Secondary errors [", p->index);
  939. reported = 0;
  940. if (afsr & SABRE_PIOAFSR_SMA) {
  941. reported++;
  942. printk("(Master Abort)");
  943. }
  944. if (afsr & SABRE_PIOAFSR_STA) {
  945. reported++;
  946. printk("(Target Abort)");
  947. }
  948. if (afsr & SABRE_PIOAFSR_SRTRY) {
  949. reported++;
  950. printk("(Excessive Retries)");
  951. }
  952. if (afsr & SABRE_PIOAFSR_SPERR) {
  953. reported++;
  954. printk("(Parity Error)");
  955. }
  956. if (!reported)
  957. printk("(none)");
  958. printk("]n");
  960. /* For the error types shown, scan both PCI buses for devices
  961.  * which have logged that error type.
  962.  */
  964. /* If we see a Target Abort, this could be the result of an
  965.  * IOMMU translation error of some sort.  It is extremely
  966.  * useful to log this information as usually it indicates
  967.  * a bug in the IOMMU support code or a PCI device driver.
  968.  */
  969. if (error_bits & (SABRE_PIOAFSR_PTA | SABRE_PIOAFSR_STA)) {
  970. sabre_check_iommu_error(p, afsr, afar);
  971. pci_scan_for_target_abort(p, &p->pbm_A, p->pbm_A.pci_bus);
  972. pci_scan_for_target_abort(p, &p->pbm_B, p->pbm_B.pci_bus);
  973. }
  974. if (error_bits & (SABRE_PIOAFSR_PMA | SABRE_PIOAFSR_SMA)) {
  975. pci_scan_for_master_abort(p, &p->pbm_A, p->pbm_A.pci_bus);
  976. pci_scan_for_master_abort(p, &p->pbm_B, p->pbm_B.pci_bus);
  977. }
  978. /* For excessive retries, SABRE/PBM will abort the device
  979.  * and there is no way to specifically check for excessive
  980.  * retries in the config space status registers.  So what
  981.  * we hope is that we'll catch it via the master/target
  982.  * abort events.
  983.  */
  985. if (error_bits & (SABRE_PIOAFSR_PPERR | SABRE_PIOAFSR_SPERR)) {
  986. pci_scan_for_parity_error(p, &p->pbm_A, p->pbm_A.pci_bus);
  987. pci_scan_for_parity_error(p, &p->pbm_B, p->pbm_B.pci_bus);
  988. }
  989. }
  991. /* XXX What about PowerFail/PowerManagement??? -DaveM */
  992. #define SABRE_UE_INO 0x2e
  993. #define SABRE_CE_INO 0x2f
  994. #define SABRE_PCIERR_INO 0x30
  995. static void __init sabre_register_error_handlers(struct pci_controller_info *p)
  996. {
  997. struct pci_pbm_info *pbm = &p->pbm_A; /* arbitrary */
  998. unsigned long base = p->controller_regs;
  999. unsigned long irq, portid = p->portid;
  1000. u64 tmp;
  1002. /* We clear the error bits in the appropriate AFSR before
  1003.  * registering the handler so that we don't get spurious
  1004.  * interrupts.
  1005.  */
  1006. sabre_write(base + SABRE_UE_AFSR,
  1007.     (SABRE_UEAFSR_PDRD | SABRE_UEAFSR_PDWR |
  1008.      SABRE_UEAFSR_SDRD | SABRE_UEAFSR_SDWR |
  1009.      SABRE_UEAFSR_SDTE | SABRE_UEAFSR_PDTE));
  1010. irq = sabre_irq_build(pbm, NULL, (portid << 6) | SABRE_UE_INO);
  1011. if (request_irq(irq, sabre_ue_intr,
  1012. SA_SHIRQ, "SABRE UE", p) < 0) {
  1013. prom_printf("SABRE%d: Cannot register UE interrupt.n",
  1014.     p->index);
  1015. prom_halt();
  1016. }
  1018. sabre_write(base + SABRE_CE_AFSR,
  1019.     (SABRE_CEAFSR_PDRD | SABRE_CEAFSR_PDWR |
  1020.      SABRE_CEAFSR_SDRD | SABRE_CEAFSR_SDWR));
  1021. irq = sabre_irq_build(pbm, NULL, (portid << 6) | SABRE_CE_INO);
  1022. if (request_irq(irq, sabre_ce_intr,
  1023. SA_SHIRQ, "SABRE CE", p) < 0) {
  1024. prom_printf("SABRE%d: Cannot register CE interrupt.n",
  1025.     p->index);
  1026. prom_halt();
  1027. }
  1029. irq = sabre_irq_build(pbm, NULL, (portid << 6) | SABRE_PCIERR_INO);
  1030. if (request_irq(irq, sabre_pcierr_intr,
  1031. SA_SHIRQ, "SABRE PCIERR", p) < 0) {
  1032. prom_printf("SABRE%d: Cannot register PciERR interrupt.n",
  1033.     p->index);
  1034. prom_halt();
  1035. }
  1037. tmp = sabre_read(base + SABRE_PCICTRL);
  1038. tmp |= SABRE_PCICTRL_ERREN;
  1039. sabre_write(base + SABRE_PCICTRL, tmp);
  1040. }
  1042. static void __init sabre_resource_adjust(struct pci_dev *pdev,
  1043.  struct resource *res,
  1044.  struct resource *root)
  1045. {
  1046. struct pci_pbm_info *pbm = pci_bus2pbm[pdev->bus->number];
  1047. struct pci_controller_info *p = pbm->parent;
  1048. unsigned long base;
  1050. if (res->flags & IORESOURCE_IO)
  1051. base = p->controller_regs + SABRE_IOSPACE;
  1052. else
  1053. base = p->controller_regs + SABRE_MEMSPACE;
  1055. res->start += base;
  1056. res->end += base;
  1057. }
  1059. static void __init sabre_base_address_update(struct pci_dev *pdev, int resource)
  1060. {
  1061. struct pcidev_cookie *pcp = pdev->sysdata;
  1062. struct pci_pbm_info *pbm = pcp->pbm;
  1063. struct pci_controller_info *p = pbm->parent;
  1064. struct resource *res;
  1065. unsigned long base;
  1066. u32 reg;
  1067. int where, size, is_64bit;
  1069. res = &pdev->resource[resource];
  1070. if (resource < 6) {
  1071. where = PCI_BASE_ADDRESS_0 + (resource * 4);
  1072. } else if (resource == PCI_ROM_RESOURCE) {
  1073. where = pdev->rom_base_reg;
  1074. } else {
  1075. /* Somebody might have asked allocation of a non-standard resource */
  1076. return;
  1077. }
  1079. is_64bit = 0;
  1080. if (res->flags & IORESOURCE_IO)
  1081. base = p->controller_regs + SABRE_IOSPACE;
  1082. else {
  1083. base = p->controller_regs + SABRE_MEMSPACE;
  1084. if ((res->flags & PCI_BASE_ADDRESS_MEM_TYPE_MASK)
  1085.     == PCI_BASE_ADDRESS_MEM_TYPE_64)
  1086. is_64bit = 1;
  1087. }
  1089. size = res->end - res->start;
  1090. pci_read_config_dword(pdev, where, &reg);
  1091. reg = ((reg & size) |
  1092.        (((u32)(res->start - base)) & ~size));
  1093. if (resource == PCI_ROM_RESOURCE) {
  1094. reg |= PCI_ROM_ADDRESS_ENABLE;
  1095. res->flags |= PCI_ROM_ADDRESS_ENABLE;
  1096. }
  1097. pci_write_config_dword(pdev, where, reg);
  1099. /* This knows that the upper 32-bits of the address
  1100.  * must be zero.  Our PCI common layer enforces this.
  1101.  */
  1102. if (is_64bit)
  1103. pci_write_config_dword(pdev, where + 4, 0);
  1104. }
  1106. static void __init apb_init(struct pci_controller_info *p, struct pci_bus *sabre_bus)
  1107. {
  1108. struct list_head *walk = &sabre_bus->devices;
  1110. for (walk = walk->next; walk != &sabre_bus->devices; walk = walk->next) {
  1111. struct pci_dev *pdev = pci_dev_b(walk);
  1113. if (pdev->vendor == PCI_VENDOR_ID_SUN &&
  1114.     pdev->device == PCI_DEVICE_ID_SUN_SIMBA) {
  1115. u16 word;
  1117. sabre_read_word(pdev, PCI_COMMAND, &word);
  1118. word |= PCI_COMMAND_SERR | PCI_COMMAND_PARITY |
  1119. PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY |
  1120. PCI_COMMAND_IO;
  1121. sabre_write_word(pdev, PCI_COMMAND, word);
  1123. /* Status register bits are "write 1 to clear". */
  1124. sabre_write_word(pdev, PCI_STATUS, 0xffff);
  1125. sabre_write_word(pdev, PCI_SEC_STATUS, 0xffff);
  1127. /* Use a primary/seconday latency timer value
  1128.  * of 64.
  1129.  */
  1130. sabre_write_byte(pdev, PCI_LATENCY_TIMER, 64);
  1131. sabre_write_byte(pdev, PCI_SEC_LATENCY_TIMER, 64);
  1133. /* Enable reporting/forwarding of master aborts,
  1134.  * parity, and SERR.
  1135.  */
  1136. sabre_write_byte(pdev, PCI_BRIDGE_CONTROL,
  1137.  (PCI_BRIDGE_CTL_PARITY |
  1138.   PCI_BRIDGE_CTL_SERR |
  1139.   PCI_BRIDGE_CTL_MASTER_ABORT));
  1140. }
  1141. }
  1142. }
  1144. static struct pcidev_cookie *alloc_bridge_cookie(struct pci_pbm_info *pbm)
  1145. {
  1146. struct pcidev_cookie *cookie = kmalloc(sizeof(*cookie), GFP_KERNEL);
  1148. if (!cookie) {
  1149. prom_printf("SABRE: Critical allocation failure.n");
  1150. prom_halt();
  1151. }
  1153. /* All we care about is the PBM. */
  1154. memset(cookie, 0, sizeof(*cookie));
  1155. cookie->pbm = pbm;
  1157. return cookie;
  1158. }
  1160. static void __init sabre_scan_bus(struct pci_controller_info *p)
  1161. {
  1162. static int once;
  1163. struct pci_bus *sabre_bus;
  1164. struct pci_pbm_info *pbm;
  1165. struct pcidev_cookie *cookie;
  1166. struct list_head *walk;
  1167. int sabres_scanned;
  1169. /* The APB bridge speaks to the Sabre host PCI bridge
  1170.  * at 66Mhz, but the front side of APB runs at 33Mhz
  1171.  * for both segments.
  1172.  */
  1173. p->pbm_A.is_66mhz_capable = 0;
  1174. p->pbm_B.is_66mhz_capable = 0;
  1176. /* Unlike for PSYCHO, we can only have one SABRE
  1177.  * in a system.  Having multiple SABREs is thus
  1178.  * and error, and as a consequence we do not need
  1179.  * to do any bus renumbering but we do have to have
  1180.  * the pci_bus2pbm array setup properly.
  1181.  *
  1182.  * Also note that the SABRE host bridge is hardwired
  1183.  * to live at bus 0.
  1184.  */
  1185. if (once != 0) {
  1186. prom_printf("SABRE: Multiple controllers unsupported.n");
  1187. prom_halt();
  1188. }
  1189. once++;
  1191. cookie = alloc_bridge_cookie(&p->pbm_A);
  1193. /* The pci_bus2pbm table has already been setup in sabre_init. */
  1194. sabre_bus = pci_scan_bus(p->pci_first_busno,
  1195.  p->pci_ops,
  1196.  &p->pbm_A);
  1197. pci_fixup_host_bridge_self(sabre_bus);
  1198. sabre_bus->self->sysdata = cookie;
  1200. apb_init(p, sabre_bus);
  1202. sabres_scanned = 0;
  1204. walk = &sabre_bus->children;
  1205. for (walk = walk->next; walk != &sabre_bus->children; walk = walk->next) {
  1206. struct pci_bus *pbus = pci_bus_b(walk);
  1208. if (pbus->number == p->pbm_A.pci_first_busno) {
  1209. pbm = &p->pbm_A;
  1210. } else if (pbus->number == p->pbm_B.pci_first_busno) {
  1211. pbm = &p->pbm_B;
  1212. } else
  1213. continue;
  1215. cookie = alloc_bridge_cookie(pbm);
  1216. pbus->self->sysdata = cookie;
  1218. sabres_scanned++;
  1220. pbus->sysdata = pbm;
  1221. pbm->pci_bus = pbus;
  1222. pci_fill_in_pbm_cookies(pbus, pbm, pbm->prom_node);
  1223. pci_record_assignments(pbm, pbus);
  1224. pci_assign_unassigned(pbm, pbus);
  1225. pci_fixup_irq(pbm, pbus);
  1226. pci_determine_66mhz_disposition(pbm, pbus);
  1227. pci_setup_busmastering(pbm, pbus);
  1228. }
  1230. if (!sabres_scanned) {
  1231. /* Hummingbird, no APBs. */
  1232. pbm = &p->pbm_A;
  1233. sabre_bus->sysdata = pbm;
  1234. pbm->pci_bus = sabre_bus;
  1235. pci_fill_in_pbm_cookies(sabre_bus, pbm, pbm->prom_node);
  1236. pci_record_assignments(pbm, sabre_bus);
  1237. pci_assign_unassigned(pbm, sabre_bus);
  1238. pci_fixup_irq(pbm, sabre_bus);
  1239. pci_determine_66mhz_disposition(pbm, sabre_bus);
  1240. pci_setup_busmastering(pbm, sabre_bus);
  1241. }
  1243. sabre_register_error_handlers(p);
  1244. }
  1246. static void __init sabre_iommu_init(struct pci_controller_info *p,
  1247.     int tsbsize, unsigned long dvma_offset,
  1248.     u32 dma_mask)
  1249. {
  1250. struct pci_iommu *iommu = p->pbm_A.iommu;
  1251. unsigned long tsbbase, i, order;
  1252. u64 control;
  1254. /* Setup initial software IOMMU state. */
  1255. spin_lock_init(&iommu->lock);
  1256. iommu->iommu_cur_ctx = 0;
  1258. /* Register addresses. */
  1259. iommu->iommu_control  = p->controller_regs + SABRE_IOMMU_CONTROL;
  1260. iommu->iommu_tsbbase  = p->controller_regs + SABRE_IOMMU_TSBBASE;
  1261. iommu->iommu_flush    = p->controller_regs + SABRE_IOMMU_FLUSH;
  1262. iommu->write_complete_reg = p->controller_regs + SABRE_WRSYNC;
  1263. /* Sabre's IOMMU lacks ctx flushing. */
  1264. iommu->iommu_ctxflush = 0;
  1265.                                         
  1266. /* Invalidate TLB Entries. */
  1267. control = sabre_read(p->controller_regs + SABRE_IOMMU_CONTROL);
  1268. control |= SABRE_IOMMUCTRL_DENAB;
  1269. sabre_write(p->controller_regs + SABRE_IOMMU_CONTROL, control);
  1271. for(i = 0; i < 16; i++) {
  1272. sabre_write(p->controller_regs + SABRE_IOMMU_TAG + (i * 8UL), 0);
  1273. sabre_write(p->controller_regs + SABRE_IOMMU_DATA + (i * 8UL), 0);
  1274. }
  1276. /* Leave diag mode enabled for full-flushing done
  1277.  * in pci_iommu.c
  1278.  */
  1280. tsbbase = __get_free_pages(GFP_KERNEL, order = get_order(tsbsize * 1024 * 8));
  1281. if (!tsbbase) {
  1282. prom_printf("SABRE_IOMMU: Error, gfp(tsb) failed.n");
  1283. prom_halt();
  1284. }
  1285. iommu->page_table = (iopte_t *)tsbbase;
  1286. iommu->page_table_map_base = dvma_offset;
  1287. iommu->dma_addr_mask = dma_mask;
  1288. memset((char *)tsbbase, 0, PAGE_SIZE << order);
  1290. sabre_write(p->controller_regs + SABRE_IOMMU_TSBBASE, __pa(tsbbase));
  1292. control = sabre_read(p->controller_regs + SABRE_IOMMU_CONTROL);
  1293. control &= ~(SABRE_IOMMUCTRL_TSBSZ | SABRE_IOMMUCTRL_TBWSZ);
  1294. control |= SABRE_IOMMUCTRL_ENAB;
  1295. switch(tsbsize) {
  1296. case 64:
  1297. control |= SABRE_IOMMU_TSBSZ_64K;
  1298. iommu->page_table_sz_bits = 16;
  1299. break;
  1300. case 128:
  1301. control |= SABRE_IOMMU_TSBSZ_128K;
  1302. iommu->page_table_sz_bits = 17;
  1303. break;
  1304. default:
  1305. prom_printf("iommu_init: Illegal TSB size %dn", tsbsize);
  1306. prom_halt();
  1307. break;
  1308. }
  1309. sabre_write(p->controller_regs + SABRE_IOMMU_CONTROL, control);
  1311. /* We start with no consistent mappings. */
  1312. iommu->lowest_consistent_map =
  1313. 1 << (iommu->page_table_sz_bits - PBM_LOGCLUSTERS);
  1315. for (i = 0; i < PBM_NCLUSTERS; i++) {
  1316. iommu->alloc_info[i].flush = 0;
  1317. iommu->alloc_info[i].next = 0;
  1318. }
  1319. }
  1321. static void __init pbm_register_toplevel_resources(struct pci_controller_info *p,
  1322.    struct pci_pbm_info *pbm)
  1323. {
  1324. char *name = pbm->name;
  1325. unsigned long ibase = p->controller_regs + SABRE_IOSPACE;
  1326. unsigned long mbase = p->controller_regs + SABRE_MEMSPACE;
  1327. unsigned int devfn;
  1328. unsigned long first, last, i;
  1329. u8 *addr, map;
  1331. sprintf(name, "SABRE%d PBM%c",
  1332. p->index,
  1333. (pbm == &p->pbm_A ? 'A' : 'B'));
  1334. pbm->io_space.name = pbm->mem_space.name = name;
  1336. devfn = PCI_DEVFN(1, (pbm == &p->pbm_A) ? 0 : 1);
  1337. addr = sabre_pci_config_mkaddr(pbm, 0, devfn, APB_IO_ADDRESS_MAP);
  1338. map = 0;
  1339. pci_config_read8(addr, &map);
  1341. first = 8;
  1342. last = 0;
  1343. for (i = 0; i < 8; i++) {
  1344. if ((map & (1 << i)) != 0) {
  1345. if (first > i)
  1346. first = i;
  1347. if (last < i)
  1348. last = i;
  1349. }
  1350. }
  1351. pbm->io_space.start = ibase + (first << 21UL);
  1352. pbm->io_space.end   = ibase + (last << 21UL) + ((1 << 21UL) - 1);
  1353. pbm->io_space.flags = IORESOURCE_IO;
  1355. addr = sabre_pci_config_mkaddr(pbm, 0, devfn, APB_MEM_ADDRESS_MAP);
  1356. map = 0;
  1357. pci_config_read8(addr, &map);
  1359. first = 8;
  1360. last = 0;
  1361. for (i = 0; i < 8; i++) {
  1362. if ((map & (1 << i)) != 0) {
  1363. if (first > i)
  1364. first = i;
  1365. if (last < i)
  1366. last = i;
  1367. }
  1368. }
  1369. pbm->mem_space.start = mbase + (first << 29UL);
  1370. pbm->mem_space.end   = mbase + (last << 29UL) + ((1 << 29UL) - 1);
  1371. pbm->mem_space.flags = IORESOURCE_MEM;
  1373. if (request_resource(&ioport_resource, &pbm->io_space) < 0) {
  1374. prom_printf("Cannot register PBM-%c's IO space.n",
  1375.     (pbm == &p->pbm_A ? 'A' : 'B'));
  1376. prom_halt();
  1377. }
  1378. if (request_resource(&iomem_resource, &pbm->mem_space) < 0) {
  1379. prom_printf("Cannot register PBM-%c's MEM space.n",
  1380.     (pbm == &p->pbm_A ? 'A' : 'B'));
  1381. prom_halt();
  1382. }
  1384. /* Register legacy regions if this PBM covers that area. */
  1385. if (pbm->io_space.start == ibase &&
  1386.     pbm->mem_space.start == mbase)
  1387. pci_register_legacy_regions(&pbm->io_space,
  1388.     &pbm->mem_space);
  1389. }
  1391. static void __init sabre_pbm_init(struct pci_controller_info *p, int sabre_node, u32 dma_begin)
  1392. {
  1393. struct pci_pbm_info *pbm;
  1394. char namebuf[128];
  1395. u32 busrange[2];
  1396. int node, simbas_found;
  1398. simbas_found = 0;
  1399. node = prom_getchild(sabre_node);
  1400. while ((node = prom_searchsiblings(node, "pci")) != 0) {
  1401. int err;
  1403. err = prom_getproperty(node, "model", namebuf, sizeof(namebuf));
  1404. if ((err <= 0) || strncmp(namebuf, "SUNW,simba", err))
  1405. goto next_pci;
  1407. err = prom_getproperty(node, "bus-range",
  1408.        (char *)&busrange[0], sizeof(busrange));
  1409. if (err == 0 || err == -1) {
  1410. prom_printf("APB: Error, cannot get PCI bus-range.n");
  1411. prom_halt();
  1412. }
  1414. simbas_found++;
  1415. if (busrange[0] == 1)
  1416. pbm = &p->pbm_B;
  1417. else
  1418. pbm = &p->pbm_A;
  1419. pbm->parent = p;
  1420. pbm->prom_node = node;
  1421. pbm->pci_first_slot = 1;
  1422. pbm->pci_first_busno = busrange[0];
  1423. pbm->pci_last_busno = busrange[1];
  1424. for (err = pbm->pci_first_busno;
  1425.      err <= pbm->pci_last_busno;
  1426.      err++)
  1427. pci_bus2pbm[err] = pbm;
  1430. prom_getstring(node, "name", pbm->prom_name, sizeof(pbm->prom_name));
  1431. err = prom_getproperty(node, "ranges",
  1432.        (char *)pbm->pbm_ranges,
  1433.        sizeof(pbm->pbm_ranges));
  1434. if (err != -1)
  1435. pbm->num_pbm_ranges =
  1436. (err / sizeof(struct linux_prom_pci_ranges));
  1437. else
  1438. pbm->num_pbm_ranges = 0;
  1440. err = prom_getproperty(node, "interrupt-map",
  1441.        (char *)pbm->pbm_intmap,
  1442.        sizeof(pbm->pbm_intmap));
  1443. if (err != -1) {
  1444. pbm->num_pbm_intmap = (err / sizeof(struct linux_prom_pci_intmap));
  1445. err = prom_getproperty(node, "interrupt-map-mask",
  1446.        (char *)&pbm->pbm_intmask,
  1447.        sizeof(pbm->pbm_intmask));
  1448. if (err == -1) {
  1449. prom_printf("APB: Fatal error, no interrupt-map-mask.n");
  1450. prom_halt();
  1451. }
  1452. } else {
  1453. pbm->num_pbm_intmap = 0;
  1454. memset(&pbm->pbm_intmask, 0, sizeof(pbm->pbm_intmask));
  1455. }
  1457. pbm_register_toplevel_resources(p, pbm);
  1459. next_pci:
  1460. node = prom_getsibling(node);
  1461. if (!node)
  1462. break;
  1463. }
  1464. if (simbas_found == 0) {
  1465. int err;
  1467. /* No APBs underneath, probably this is a hummingbird
  1468.  * system.
  1469.  */
  1470. pbm = &p->pbm_A;
  1471. pbm->parent = p;
  1472. pbm->prom_node = sabre_node;
  1473. pbm->pci_first_busno = p->pci_first_busno;
  1474. pbm->pci_last_busno = p->pci_last_busno;
  1475. for (err = pbm->pci_first_busno;
  1476.      err <= pbm->pci_last_busno;
  1477.      err++)
  1478. pci_bus2pbm[err] = pbm;
  1480. prom_getstring(sabre_node, "name", pbm->prom_name, sizeof(pbm->prom_name));
  1481. err = prom_getproperty(sabre_node, "ranges",
  1482.        (char *) pbm->pbm_ranges,
  1483.        sizeof(pbm->pbm_ranges));
  1484. if (err != -1)
  1485. pbm->num_pbm_ranges =
  1486. (err / sizeof(struct linux_prom_pci_ranges));
  1487. else
  1488. pbm->num_pbm_ranges = 0;
  1490. err = prom_getproperty(sabre_node, "interrupt-map",
  1491.        (char *) pbm->pbm_intmap,
  1492.        sizeof(pbm->pbm_intmap));
  1494. if (err != -1) {
  1495. pbm->num_pbm_intmap = (err / sizeof(struct linux_prom_pci_intmap));
  1496. err = prom_getproperty(sabre_node, "interrupt-map-mask",
  1497.        (char *)&pbm->pbm_intmask,
  1498.        sizeof(pbm->pbm_intmask));
  1499. if (err == -1) {
  1500. prom_printf("Hummingbird: Fatal error, no interrupt-map-mask.n");
  1501. prom_halt();
  1502. }
  1503. } else {
  1504. pbm->num_pbm_intmap = 0;
  1505. memset(&pbm->pbm_intmask, 0, sizeof(pbm->pbm_intmask));
  1506. }
  1509. sprintf(pbm->name, "SABRE%d PBM%c", p->index,
  1510. (pbm == &p->pbm_A ? 'A' : 'B'));
  1511. pbm->io_space.name = pbm->mem_space.name = pbm->name;
  1513. /* Hack up top-level resources. */
  1514. pbm->io_space.start = p->controller_regs + SABRE_IOSPACE;
  1515. pbm->io_space.end   = pbm->io_space.start + (1UL << 24) - 1UL;
  1516. pbm->io_space.flags = IORESOURCE_IO;
  1518. pbm->mem_space.start = p->controller_regs + SABRE_MEMSPACE;
  1519. pbm->mem_space.end   = pbm->mem_space.start + (unsigned long)dma_begin - 1UL;
  1520. pbm->mem_space.flags = IORESOURCE_MEM;
  1522. if (request_resource(&ioport_resource, &pbm->io_space) < 0) {
  1523. prom_printf("Cannot register Hummingbird's IO space.n");
  1524. prom_halt();
  1525. }
  1526. if (request_resource(&iomem_resource, &pbm->mem_space) < 0) {
  1527. prom_printf("Cannot register Hummingbird's MEM space.n");
  1528. prom_halt();
  1529. }
  1531. pci_register_legacy_regions(&pbm->io_space,
  1532.     &pbm->mem_space);
  1533. }
  1534. }
  1536. void __init sabre_init(int pnode, char *model_name)
  1537. {
  1538. struct linux_prom64_registers pr_regs[2];
  1539. struct pci_controller_info *p;
  1540. struct pci_iommu *iommu;
  1541. unsigned long flags;
  1542. int tsbsize, err;
  1543. u32 busrange[2];
  1544. u32 vdma[2];
  1545. u32 upa_portid, dma_mask;
  1546. int bus;
  1548. hummingbird_p = 0;
  1549. if (!strcmp(model_name, "pci108e,a001"))
  1550. hummingbird_p = 1;
  1551. else if (!strcmp(model_name, "SUNW,sabre")) {
  1552. char compat[64];
  1554. if (prom_getproperty(pnode, "compatible",
  1555.      compat, sizeof(compat)) > 0 &&
  1556.     !strcmp(compat, "pci108e,a001")) {
  1557. hummingbird_p = 1;
  1558. } else {
  1559. int cpu_node = linux_cpus[0].prom_node;
  1561. /* Of course, Sun has to encode things a thousand
  1562.  * different ways, inconsistently.
  1563.  */
  1564. if (prom_getproperty(cpu_node, "name",
  1565.      compat, sizeof(compat)) > 0 &&
  1566.     !strcmp(compat, "SUNW,UltraSPARC-IIe"))
  1567. hummingbird_p = 1;
  1568. }
  1569. }
  1571. p = kmalloc(sizeof(*p), GFP_ATOMIC);
  1572. if (!p) {
  1573. prom_printf("SABRE: Error, kmalloc(pci_controller_info) failed.n");
  1574. prom_halt();
  1575. }
  1576. memset(p, 0, sizeof(*p));
  1578. iommu = kmalloc(sizeof(*iommu), GFP_ATOMIC);
  1579. if (!iommu) {
  1580. prom_printf("SABRE: Error, kmalloc(pci_iommu) failed.n");
  1581. prom_halt();
  1582. }
  1583. memset(iommu, 0, sizeof(*iommu));
  1584. p->pbm_A.iommu = p->pbm_B.iommu = iommu;
  1586. upa_portid = prom_getintdefault(pnode, "upa-portid", 0xff);
  1588. spin_lock_irqsave(&pci_controller_lock, flags);
  1589. p->next = pci_controller_root;
  1590. pci_controller_root = p;
  1591. spin_unlock_irqrestore(&pci_controller_lock, flags);
  1593. p->portid = upa_portid;
  1594. p->index = pci_num_controllers++;
  1595. p->pbms_same_domain = 1;
  1596. p->scan_bus = sabre_scan_bus;
  1597. p->irq_build = sabre_irq_build;
  1598. p->base_address_update = sabre_base_address_update;
  1599. p->resource_adjust = sabre_resource_adjust;
  1600. p->pci_ops = &sabre_ops;
  1602. /*
  1603.  * Map in SABRE register set and report the presence of this SABRE.
  1604.  */
  1605. err = prom_getproperty(pnode, "reg",
  1606.        (char *)&pr_regs[0], sizeof(pr_regs));
  1607. if(err == 0 || err == -1) {
  1608. prom_printf("SABRE: Error, cannot get U2P registers "
  1609.     "from PROM.n");
  1610. prom_halt();
  1611. }
  1613. /*
  1614.  * First REG in property is base of entire SABRE register space.
  1615.  */
  1616. p->controller_regs = pr_regs[0].phys_addr;
  1617. pci_dma_wsync = p->controller_regs + SABRE_WRSYNC;
  1619. printk("PCI: Found SABRE, main regs at %016lx, wsync at %016lxn",
  1620.        p->controller_regs, pci_dma_wsync);
  1622. /* Error interrupts are enabled later after the bus scan. */
  1623. sabre_write(p->controller_regs + SABRE_PCICTRL,
  1624.     (SABRE_PCICTRL_MRLEN   | SABRE_PCICTRL_SERR |
  1625.      SABRE_PCICTRL_ARBPARK | SABRE_PCICTRL_AEN));
  1627. /* Now map in PCI config space for entire SABRE. */
  1628. p->pbm_A.config_space = p->pbm_B.config_space =
  1629. (p->controller_regs + SABRE_CONFIGSPACE);
  1630. printk("SABRE: Shared PCI config space at %016lxn",
  1631.        p->pbm_A.config_space);
  1633. err = prom_getproperty(pnode, "virtual-dma",
  1634.        (char *)&vdma[0], sizeof(vdma));
  1635. if(err == 0 || err == -1) {
  1636. prom_printf("SABRE: Error, cannot get virtual-dma property "
  1637.     "from PROM.n");
  1638. prom_halt();
  1639. }
  1641. dma_mask = vdma[0];
  1642. switch(vdma[1]) {
  1643. case 0x20000000:
  1644. dma_mask |= 0x1fffffff;
  1645. tsbsize = 64;
  1646. break;
  1647. case 0x40000000:
  1648. dma_mask |= 0x3fffffff;
  1649. tsbsize = 128;
  1650. break;
  1652. case 0x80000000:
  1653. dma_mask |= 0x7fffffff;
  1654. tsbsize = 128;
  1655. break;
  1656. default:
  1657. prom_printf("SABRE: strange virtual-dma size.n");
  1658. prom_halt();
  1659. }
  1661. sabre_iommu_init(p, tsbsize, vdma[0], dma_mask);
  1663. printk("SABRE: DVMA at %08x [%08x]n", vdma[0], vdma[1]);
  1665. err = prom_getproperty(pnode, "bus-range",
  1666.        (char *)&busrange[0], sizeof(busrange));
  1667. if(err == 0 || err == -1) {
  1668. prom_printf("SABRE: Error, cannot get PCI bus-range "
  1669.     " from PROM.n");
  1670. prom_halt();
  1671. }
  1673. p->pci_first_busno = busrange[0];
  1674. p->pci_last_busno = busrange[1];
  1676. /*
  1677.  * Handle config space reads through any Simba on APB.
  1678.  */
  1679. for (bus = p->pci_first_busno; bus <= p->pci_last_busno; bus++)
  1680. pci_bus2pbm[bus] = &p->pbm_A;
  1682. /*
  1683.  * Look for APB underneath.
  1684.  */
  1685. sabre_pbm_init(p, pnode, vdma[0]);
  1686. }