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

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

Linux/Unix编程

开发平台：

Unix_Linux

pSeries_pci.c：源码内容
  1. /*
  2.  * pSeries_pci.c
  3.  *
  4.  * pSeries_pcibios_init(void)opyright (C) 2001 Dave Engebretsen, IBM Corporation
  5.  *
  6.  * pSeries specific routines for PCI.
  7.  * 
  8.  * Based on code from pci.c and chrp_pci.c
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *    
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  * 
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  23.  */
  25. #include <linux/kernel.h>
  26. #include <linux/pci.h>
  27. #include <linux/delay.h>
  28. #include <linux/string.h>
  29. #include <linux/init.h>
  30. #include <linux/bootmem.h>
  32. #include <asm/io.h>
  33. #include <asm/pgtable.h>
  34. #include <asm/irq.h>
  35. #include <asm/prom.h>
  36. #include <asm/machdep.h>
  37. #include <asm/init.h>
  38. #include <asm/pci-bridge.h>
  39. #include <asm/ppcdebug.h>
  40. #include <asm/naca.h>
  41. #include <asm/pci_dma.h>
  42. #include <asm/eeh.h>
  44. #include "xics.h"
  45. #include "open_pic.h"
  46. #include "pci.h"
  48. extern struct device_node *allnodes;
  50. /*******************************************************************
  51.  * Forward declares of prototypes. 
  52.  *******************************************************************/
  53. unsigned long find_and_init_phbs(void);
  54. struct pci_controller* alloc_phb(struct device_node *dev, char *model, unsigned int addr_size_words) ;
  55. void pSeries_pcibios_fixup(void);
  56. static int rtas_fake_read(struct device_node *dn, int offset, int nbytes, unsigned long *returnval);
  58. /* RTAS tokens */
  59. static int read_pci_config;
  60. static int write_pci_config;
  61. static int ibm_read_pci_config;
  62. static int ibm_write_pci_config;
  64. static int s7a_workaround;
  66. /******************************************************************************
  67.  *
  68.  * pSeries I/O Operations to access the PCI configuration space.
  69.  *
  70.  *****************************************************************************/
  71. #define RTAS_PCI_READ_OP(size, type, nbytes) 
  72. int __chrp 
  73. rtas_read_config_##size(struct device_node *dn, int offset, type val) {  
  74. unsigned long returnval = ~0L; 
  75. unsigned long buid; 
  76. unsigned int addr; 
  77. int ret; 
  78.  
  79. if (dn == NULL) { 
  80. ret = -2; 
  81. } else { 
  82. addr = (dn->busno << 16) | (dn->devfn << 8) | offset; 
  83. buid = dn->phb->buid; 
  84. if (buid) { 
  85. ret = rtas_call(ibm_read_pci_config, 4, 2, &returnval, addr, buid >> 32, buid & 0xffffffff, nbytes); 
  86.                         if (ret < 0 || (returnval == 0xffffffff)) 
  87.                                ret = rtas_fake_read(dn, offset, nbytes, &returnval); 
  88. } else { 
  89. ret = rtas_call(read_pci_config, 2, 2, &returnval, addr, nbytes); 
  90. } 
  91. } 
  92. *val = returnval; 
  93. return ret; 
  94. } 
  95. int __chrp 
  96. rtas_pci_read_config_##size(struct pci_dev *dev, int offset, type val) {  
  97.         struct device_node *dn = pci_device_to_OF_node(dev); 
  98. int ret = rtas_read_config_##size(dn, offset, val); 
  99.         /* udbg_printf("read bus=%x, devfn=%x, ret=%d phb=%lx, dn=%lxn", dev->bus->number, dev->devfn, ret, dn ? dn->phb : 0, dn); */ 
  100.         return ret ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL; 
  101. }
  103. #define RTAS_PCI_WRITE_OP(size, type, nbytes) 
  104. int __chrp 
  105. rtas_write_config_##size(struct device_node *dn, int offset, type val) { 
  106. unsigned long buid; 
  107. unsigned int addr; 
  108. int ret; 
  109.  
  110. if (dn == NULL) { 
  111. ret = -2; 
  112. } else { 
  113. buid = dn->phb->buid; 
  114. addr = (dn->busno << 16) | (dn->devfn << 8) | offset; 
  115. if (buid) { 
  116. ret = rtas_call(ibm_write_pci_config, 5, 1, NULL, addr, buid >> 32, buid & 0xffffffff, nbytes, (ulong) val); 
  117. } else { 
  118. ret = rtas_call(write_pci_config, 3, 1, NULL, addr, nbytes, (ulong)val); 
  119. } 
  120. } 
  121. return ret; 
  122. } 
  123. int __chrp 
  124. rtas_pci_write_config_##size(struct pci_dev *dev, int offset, type val) { 
  125. struct device_node*  dn = pci_device_to_OF_node(dev); 
  126. int  ret = rtas_write_config_##size(dn, offset, val); 
  127. /* udbg_printf("write bus=%x, devfn=%x, ret=%d phb=%lx, dn=%lxn", dev->bus->number, dev->devfn, ret, dn ? dn->phb : 0, dn); */ 
  128. return ret ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL; 
  129. }
  131. RTAS_PCI_READ_OP(byte, u8 *, 1)
  132. RTAS_PCI_READ_OP(word, u16 *, 2)
  133. RTAS_PCI_READ_OP(dword, u32 *, 4)
  134. RTAS_PCI_WRITE_OP(byte, u8, 1)
  135. RTAS_PCI_WRITE_OP(word, u16, 2)
  136. RTAS_PCI_WRITE_OP(dword, u32, 4)
  138. struct pci_ops rtas_pci_ops = {
  139. rtas_pci_read_config_byte,
  140. rtas_pci_read_config_word,
  141. rtas_pci_read_config_dword,
  142. rtas_pci_write_config_byte,
  143.   rtas_pci_write_config_word,
  144. rtas_pci_write_config_dword,
  145. };
  147. /*
  148.  * Handle the case where rtas refuses to do a pci config read.
  149.  * This currently only happens with some PHBs in which case we totally fake
  150.  * out the values (and call it a speedwagaon -- something we could look up
  151.  * in the device tree).
  152.  */
  153. static int
  154. rtas_fake_read(struct device_node *dn, int offset, int nbytes, unsigned long *returnval)
  155. {
  156. char *device_type = (char *)get_property(dn, "device_type", 0);
  157. u32 *class_code = (u32 *)get_property(dn, "class-code", 0);
  159. *returnval = ~0; /* float by default */
  161. /* udbg_printf("rtas_fake_read dn=%p, offset=0x%02x, nbytes=%d, device_type=%sn", dn, offset, nbytes, device_type ? device_type : "<none>"); */
  162. if (device_type && strcmp(device_type, "pci") != 0)
  163. return -3; /* Not a phb or bridge */
  165. /* NOTE: class_code != NULL => EADS pci bridge.  Else a PHB */
  166. if (nbytes == 1) {
  167. if (offset == PCI_HEADER_TYPE)
  168. *returnval = 0x80; /* multifunction */
  169. else if (offset == PCI_INTERRUPT_PIN || offset == PCI_INTERRUPT_LINE)
  170. *returnval = 0;
  171. } else if (nbytes == 2) {
  172. if (offset == PCI_SUBSYSTEM_VENDOR_ID || offset == PCI_SUBSYSTEM_ID)
  173. *returnval = 0;
  174. else if (offset == PCI_COMMAND)
  175. *returnval = PCI_COMMAND_PARITY|PCI_COMMAND_MASTER|PCI_COMMAND_MEMORY;
  176. } else if (nbytes == 4) {
  177. if (offset == PCI_VENDOR_ID)
  178. *returnval = 0x1014 | ((class_code ? 0x8b : 0x102) << 16); /* a phb */
  179. else if (offset == PCI_REVISION_ID)
  180. *returnval = (class_code ? PCI_CLASS_BRIDGE_PCI : PCI_CLASS_BRIDGE_HOST) << 16; /* revs are zero */
  181. else if ((offset >= PCI_BASE_ADDRESS_0 && offset <= PCI_BASE_ADDRESS_5) || offset == PCI_ROM_ADDRESS)
  182. *returnval = 0;
  183. }
  185. /* printk("fake: %s nbytes=%d, offset=%lx ret=%lxn", class_code ? "EADS" : "PHB", nbytes, offset, *returnval); */
  186. return 0;
  187. }
  189. /******************************************************************
  190.  * pci_read_irq_line
  191.  *
  192.  * Reads the Interrupt Pin to determine if interrupt is use by card.
  193.  * If the interrupt is used, then gets the interrupt line from the 
  194.  * openfirmware and sets it in the pci_dev and pci_config line.
  195.  *
  196.  ******************************************************************/
  197. int 
  198. pci_read_irq_line(struct pci_dev *Pci_Dev)
  199. {
  200. u8 InterruptPin;
  201. struct device_node *Node;
  203.      pci_read_config_byte(Pci_Dev, PCI_INTERRUPT_PIN, &InterruptPin);
  204. if (InterruptPin == 0) {
  205. PPCDBG(PPCDBG_BUSWALK,"tDevice: %s No Interrupt used by device.n",Pci_Dev->slot_name);
  206. return 0;
  207. }
  208. Node = pci_device_to_OF_node(Pci_Dev);
  209. if ( Node == NULL) { 
  210. PPCDBG(PPCDBG_BUSWALK,"tDevice: %s Device Node not found.n",Pci_Dev->slot_name);
  211. return -1;
  212. }
  213. if (Node->n_intrs == 0)  {
  214. PPCDBG(PPCDBG_BUSWALK,"tDevice: %s No Device OF interrupts defined.n",Pci_Dev->slot_name);
  215. return -1;
  216. }
  217. Pci_Dev->irq = Node->intrs[0].line;
  219. if (s7a_workaround) {
  220. if (Pci_Dev->irq > 16)
  221. Pci_Dev->irq -= 3;
  222. }
  224. pci_write_config_byte(Pci_Dev, PCI_INTERRUPT_LINE, Pci_Dev->irq);
  226. PPCDBG(PPCDBG_BUSWALK,"tDevice: %s pci_dev->irq = 0x%02Xn",Pci_Dev->slot_name,Pci_Dev->irq);
  227. return 0;
  228. }
  230. /******************************************************************
  231.  * Find all PHBs in the system and initialize a set of data 
  232.  * structures to represent them.
  233.  ******************************************************************/
  234. unsigned long __init
  235. find_and_init_phbs(void)
  236. {
  237.         struct device_node *Pci_Node;
  238.         struct pci_controller *phb;
  239.         unsigned int root_addr_size_words = 0, this_addr_size_words = 0;
  240. unsigned int this_addr_count = 0, range_stride;
  241.         unsigned int *ui_ptr = NULL, *ranges;
  242.         char *model;
  243. struct pci_range64 range;
  244. struct resource *res;
  245. unsigned int memno, rlen, i, index;
  246. unsigned int *opprop;
  247. int has_isa = 0;
  248.         PPCDBG(PPCDBG_PHBINIT, "find_and_init_phbsn"); 
  250. read_pci_config = rtas_token("read-pci-config");
  251. write_pci_config = rtas_token("write-pci-config");
  252. ibm_read_pci_config = rtas_token("ibm,read-pci-config");
  253. ibm_write_pci_config = rtas_token("ibm,write-pci-config");
  255. eeh_init();
  257. if (naca->interrupt_controller == IC_OPEN_PIC) {
  258. opprop = (unsigned int *)get_property(find_path_device("/"),
  259. "platform-open-pic", NULL);
  260. }
  262. /* Get the root address word size. */
  263. ui_ptr = (unsigned int *) get_property(find_path_device("/"), 
  264.        "#size-cells", NULL);
  265. if (ui_ptr) {
  266. root_addr_size_words = *ui_ptr;
  267. } else {
  268. PPCDBG(PPCDBG_PHBINIT, "tget #size-cells failed.n"); 
  269. return(-1);
  270. }
  272. if (find_type_devices("isa")) {
  273. has_isa = 1;
  274. PPCDBG(PPCDBG_PHBINIT, "tFound an ISA bus.n"); 
  275. }
  277. index = 0;
  279. /******************************************************************
  280. * Find all PHB devices and create an object for them.
  281. ******************************************************************/
  282. for (Pci_Node = find_devices("pci"); Pci_Node != NULL; Pci_Node = Pci_Node->next) {
  283. model = (char *) get_property(Pci_Node, "model", NULL);
  284. if (model != NULL)  {
  285. phb = alloc_phb(Pci_Node, model, root_addr_size_words);
  286. if (phb == NULL) return(-1);
  287. }
  288. else {
  289.           continue;
  290. }
  292. /* Get this node's address word size. */
  293. ui_ptr = (unsigned int *) get_property(Pci_Node, "#size-cells", NULL);
  294. if (ui_ptr)
  295. this_addr_size_words = *ui_ptr;
  296. else
  297. this_addr_size_words = 1;
  298. /* Get this node's address word count. */
  299. ui_ptr = (unsigned int *) get_property(Pci_Node, "#address-cells", NULL);
  300. if (ui_ptr)
  301. this_addr_count = *ui_ptr;
  302. else
  303. this_addr_count = 3;
  305. range_stride = this_addr_count + root_addr_size_words + this_addr_size_words;
  306.       
  307. memno = 0;
  308. phb->io_base_phys = 0;
  309.          
  310. ranges = (unsigned int *) get_property(Pci_Node, "ranges", &rlen);
  311. PPCDBG(PPCDBG_PHBINIT, "trange_stride = 0x%lx, rlen = 0x%xn", range_stride, rlen);
  312.                 
  313. for (i = 0; i < (rlen/sizeof(*ranges)); i+=range_stride) {
  314.    /* Put the PCI addr part of the current element into a 
  315.  * '64' struct. 
  316.  */
  317.    range = *((struct pci_range64 *)(ranges + i));
  319. /* If this is a '32' element, map into a 64 struct. */
  320. if ((range_stride * sizeof(int)) == 
  321.    sizeof(struct pci_range32)) {
  322. range.parent_addr = 
  323. (unsigned long)(*(ranges + i + 3));
  324. range.size = 
  325. (((unsigned long)(*(ranges + i + 4)))<<32) | 
  326. (*(ranges + i + 5));
  327. } else {
  328. range.parent_addr = 
  329. (((unsigned long)(*(ranges + i + 3)))<<32) | 
  330. (*(ranges + i + 4));
  331. range.size = 
  332. (((unsigned long)(*(ranges + i + 5)))<<32) | 
  333. (*(ranges + i + 6));
  334. }
  336. PPCDBG(PPCDBG_PHBINIT, "trange.parent_addr    = 0x%lxn", 
  337.        range.parent_addr);
  338. PPCDBG(PPCDBG_PHBINIT, "trange.child_addr.hi  = 0x%lxn", 
  339.        range.child_addr.a_hi);
  340. PPCDBG(PPCDBG_PHBINIT, "trange.child_addr.mid = 0x%lxn", 
  341.        range.child_addr.a_mid);
  342. PPCDBG(PPCDBG_PHBINIT, "trange.child_addr.lo  = 0x%lxn", 
  343.        range.child_addr.a_lo);
  344. PPCDBG(PPCDBG_PHBINIT, "trange.size           = 0x%lxn", 
  345.        range.size);
  347. res = NULL;
  348.         switch ((range.child_addr.a_hi >> 24) & 0x3) {
  349. case 1: /* I/O space */
  350. PPCDBG(PPCDBG_PHBINIT, "tIO Spacen");
  351. phb->io_base_phys = range.parent_addr;
  352. res = &phb->io_resource;
  353. res->name = Pci_Node->full_name;
  354. res->flags = IORESOURCE_IO;
  355. if (is_eeh_implemented()) {
  356. if (!isa_io_base && has_isa) {
  357. /* map a page for ISA ports.  Not EEH protected. */
  358. isa_io_base = (unsigned long)__ioremap(phb->io_base_phys, PAGE_SIZE, _PAGE_NO_CACHE);
  359. }
  360. res->start = phb->io_base_virt = eeh_token(index, 0, 0, 0);
  361. res->end = eeh_token(index, 0xff, 0xff, 0xffffffff);
  362. } else {
  363. phb->io_base_virt = ioremap(phb->io_base_phys, range.size);
  364. if (!pci_io_base) {
  365. pci_io_base = (unsigned long)phb->io_base_virt;
  366. if (has_isa)
  367. isa_io_base = pci_io_base;
  368. }
  369. res->start = ((((unsigned long) range.child_addr.a_mid) << 32) | (range.child_addr.a_lo));
  370. res->start += (unsigned long)phb->io_base_virt;
  371. res->end =   res->start + range.size - 1;
  372. }
  373. res->parent = NULL;
  374. res->sibling = NULL;
  375. res->child = NULL;
  376. phb->pci_io_offset = range.parent_addr - 
  377. ((((unsigned long)
  378.    range.child_addr.a_mid) << 32) | 
  379.  (range.child_addr.a_lo));
  380. PPCDBG(PPCDBG_PHBINIT, "tpci_io_offset  = 0x%lxn", 
  381.        phb->pci_io_offset);
  382.    break;
  383. case 2: /* mem space */
  384. PPCDBG(PPCDBG_PHBINIT, "tMem Spacen");
  385. phb->pci_mem_offset = range.parent_addr - 
  386. ((((unsigned long)
  387.    range.child_addr.a_mid) << 32) | 
  388.  (range.child_addr.a_lo));
  389. PPCDBG(PPCDBG_PHBINIT, "tpci_mem_offset = 0x%lxn", 
  390.        phb->pci_mem_offset);
  391. if (memno < sizeof(phb->mem_resources)/sizeof(phb->mem_resources[0])) {
  392. res = &(phb->mem_resources[memno]);
  393. ++memno;
  394. res->name = Pci_Node->full_name;
  395. res->flags = IORESOURCE_MEM;
  396. if (is_eeh_implemented()) {
  397. res->start = eeh_token(index, 0, 0, 0);
  398. res->end =   eeh_token(index, 0xff, 0xff, 0xffffffff);
  399. } else {
  400. res->start = range.parent_addr;
  401. res->end =   range.parent_addr + range.size - 1;
  402. }
  403. res->parent = NULL;
  404. res->sibling = NULL;
  405. res->child = NULL;
  406. }
  407.    break;
  408. }
  409. }
  410. PPCDBG(PPCDBG_PHBINIT, "tphb->io_base_phys   = 0x%lxn", 
  411.        phb->io_base_phys); 
  412. PPCDBG(PPCDBG_PHBINIT, "tphb->pci_mem_offset = 0x%lxn", 
  413.        phb->pci_mem_offset); 
  415. if (naca->interrupt_controller == IC_OPEN_PIC) {
  416. int addr = root_addr_size_words * (index + 2) - 1;
  417. openpic_setup_ISU(index, opprop[addr]); 
  418. }
  419. index++;
  420. }
  421. pci_devs_phb_init();
  422. return 0;  /*Success */
  423. }
  425. /******************************************************************
  426.  *
  427.  * Allocate and partially initialize a structure to represent a PHB.
  428.  *
  429.  ******************************************************************/
  430. struct pci_controller *
  431. alloc_phb(struct device_node *dev, char *model, unsigned int addr_size_words)
  432. {
  433. struct pci_controller *phb;
  434. unsigned int *ui_ptr = NULL, len;
  435. struct reg_property64 reg_struct;
  436. int *bus_range;
  437. int *buid_vals;
  439. PPCDBG(PPCDBG_PHBINIT, "alloc_phb: %sn", dev->full_name); 
  440. PPCDBG(PPCDBG_PHBINIT, "tdev             = 0x%lxn", dev); 
  441. PPCDBG(PPCDBG_PHBINIT, "tmodel           = 0x%lxn", model); 
  442. PPCDBG(PPCDBG_PHBINIT, "taddr_size_words = 0x%lxn", addr_size_words); 
  443.   
  444. /* Found a PHB, now figure out where his registers are mapped. */
  445. ui_ptr = (unsigned int *) get_property(dev, "reg", &len);
  446. if (ui_ptr == NULL) {
  447. PPCDBG(PPCDBG_PHBINIT, "tget reg failed.n"); 
  448. return(NULL);
  449. }
  451. if (addr_size_words == 1) {
  452. reg_struct.address = ((struct reg_property32 *)ui_ptr)->address;
  453. reg_struct.size    = ((struct reg_property32 *)ui_ptr)->size;
  454. } else {
  455. reg_struct = *((struct reg_property64 *)ui_ptr);
  456. }
  458. PPCDBG(PPCDBG_PHBINIT, "treg_struct.address = 0x%lxn", reg_struct.address);
  459. PPCDBG(PPCDBG_PHBINIT, "treg_struct.size    = 0x%lxn", reg_struct.size); 
  461. /***************************************************************
  462. * Set chip specific data in the phb, including types & 
  463. * register pointers.
  464. ***************************************************************/
  466. /****************************************************************
  467. * Python
  468. ***************************************************************/
  469. if (strstr(model, "Python")) {
  470. PPCDBG(PPCDBG_PHBINIT, "tCreate pythonn");
  471.         phb = pci_alloc_pci_controller("PHB PY",phb_type_python);
  472. if (phb == NULL) return NULL;
  474.         phb->cfg_addr = (volatile unsigned long *) 
  475. ioremap(reg_struct.address + 0xf8000, PAGE_SIZE);
  476. PPCDBG(PPCDBG_PHBINIT, "tcfg_addr_r = 0x%lxn", 
  477.        reg_struct.address + 0xf8000);
  478. PPCDBG(PPCDBG_PHBINIT, "tcfg_addr_v = 0x%lxn", 
  479.        phb->cfg_addr);
  480. phb->cfg_data = (char*)(phb->cfg_addr + 0x02);
  481.         phb->phb_regs = (volatile unsigned long *) 
  482. ioremap(reg_struct.address + 0xf7000, PAGE_SIZE);
  483. /* Python's register file is 1 MB in size. */
  484. phb->chip_regs = ioremap(reg_struct.address & ~(0xfffffUL), 
  485.  0x100000); 
  487. /* 
  488.  * Firmware doesn't always clear this bit which is critical
  489.  * for good performance - Anton
  490.  */
  491. {
  492. volatile u32 *tmp, i;
  494. #define PRG_CL_RESET_VALID 0x00010000
  496. tmp = (u32 *)((unsigned long)phb->chip_regs + 0xf6030);
  498. if (*tmp & PRG_CL_RESET_VALID) {
  499. printk("Python workaround: ");
  500. *tmp &= ~PRG_CL_RESET_VALID;
  501. /*
  502.  * We must read it back for changes to
  503.  * take effect
  504.  */
  505. i = *tmp;
  506. printk("reg0: %xn", i);
  507. }
  508. }
  510. /***************************************************************
  511. * Speedwagon
  512. *   include Winnipeg as well for the time being.
  513. ***************************************************************/
  514. } else if ((strstr(model, "Speedwagon")) || 
  515.    (strstr(model, "Winnipeg"))) {
  516. PPCDBG(PPCDBG_PHBINIT, "tCreate speedwagonn");
  517.         phb = pci_alloc_pci_controller("PHB SW",phb_type_speedwagon);
  518. if (phb == NULL) return NULL;
  520. if (naca->platform == PLATFORM_PSERIES) {
  521. phb->cfg_addr = (volatile unsigned long *) 
  522.   ioremap(reg_struct.address + 0x140, PAGE_SIZE);
  523. phb->cfg_data = (char*)(phb->cfg_addr - 0x02); /* minus is correct */
  524. phb->phb_regs = (volatile unsigned long *) 
  525.   ioremap(reg_struct.address, PAGE_SIZE);
  526. /* Speedwagon's register file is 1 MB in size. */
  527. phb->chip_regs = ioremap(reg_struct.address & ~(0xfffffUL),
  528.  0x100000); 
  529. PPCDBG(PPCDBG_PHBINIT, "tmapping chip_regs from 0x%lx -> 0x%lxn", 
  530.        reg_struct.address & 0xfffff, phb->chip_regs);
  531. } else {
  532. phb->cfg_addr = NULL;
  533. phb->cfg_data = NULL; 
  534. phb->phb_regs = NULL;
  535. phb->chip_regs = NULL;
  536. }
  538. phb->local_number = ((reg_struct.address >> 12) & 0xf) - 0x8;
  539. /***************************************************************
  540. * Trying to build a known just gets the code in trouble.
  541. ***************************************************************/
  542. } else { 
  543. PPCDBG(PPCDBG_PHBINIT, "tUnknown PHB Type!n");
  544. printk("PCI: Unknown Phb Type!n");
  545. return NULL;
  546. }
  548. bus_range = (int *) get_property(dev, "bus-range", &len);
  549. if (bus_range == NULL || len < 2 * sizeof(int)) {
  550. PPCDBG(PPCDBG_PHBINIT, "Can't get bus-range for %sn", dev->full_name);
  551. kfree(phb);
  552. return(NULL);
  553. }
  555. /***************************************************************
  556. * Finished with the initialization
  557. ***************************************************************/
  558. phb->first_busno =  bus_range[0];
  559. phb->last_busno  =  bus_range[1];
  561. phb->arch_data   = dev;
  562. phb->ops = &rtas_pci_ops;
  564. buid_vals = (int *) get_property(dev, "ibm,fw-phb-id", &len);
  566.   if (buid_vals == NULL) {
  567. phb->buid = 0;
  568. } 
  569.   else {
  570. struct pci_bus check;
  571. if (sizeof(check.number) == 1 || sizeof(check.primary) == 1 ||
  572.     sizeof(check.secondary) == 1 || sizeof(check.subordinate) == 1) {
  573. udbg_printf("pSeries_pci:  this system has large bus numbers and the kernel was notn"
  574.       "built with the patch that fixes include/linux/pci.h struct pci_bus son"
  575.       "number, primary, secondary and subordinate are ints.n");
  576. panic("pSeries_pci:  this system has large bus numbers and the kernel was notn"
  577.       "built with the patch that fixes include/linux/pci.h struct pci_bus son"
  578.       "number, primary, secondary and subordinate are ints.n");
  579.     }
  580.     
  581.     if (len < 2 * sizeof(int))
  582.       phb->buid = (unsigned long)buid_vals[0];  // Support for new OF that only has 1 integer for buid.
  583.     else
  584.       phb->buid = (((unsigned long)buid_vals[0]) << 32UL) |
  585.                   (((unsigned long)buid_vals[1]) & 0xffffffff);
  586.   
  587. phb->first_busno += (phb->global_number << 8);
  588. phb->last_busno += (phb->global_number << 8);
  589. }
  591. /* Dump PHB information for Debug */
  592. PPCDBGCALL(PPCDBG_PHBINIT,dumpPci_Controller(phb) );
  594. return phb;
  595. }
  597. void 
  598. fixup_resources(struct pci_dev *dev)
  599. {
  600.   int i;
  601.   struct pci_controller *phb = PCI_GET_PHB_PTR(dev);
  602. struct device_node *dn;
  603. unsigned long eeh_disable_bit;
  605. /* Add IBM loc code (slot) as a prefix to the device names for service */
  606. dn = pci_device_to_OF_node(dev);
  607. if (dn) {
  608. char *loc_code = get_property(dn, "ibm,loc-code", 0);
  609. if (loc_code) {
  610. int loc_len = strlen(loc_code);
  611. if (loc_len < sizeof(dev->name)) {
  612. memmove(dev->name+loc_len+1, dev->name, sizeof(dev->name)-loc_len-1);
  613. memcpy(dev->name, loc_code, loc_len);
  614. dev->name[loc_len] = ' ';
  615. dev->name[sizeof(dev->name)-1] = '';
  616. }
  617. }
  618. }
  620. if (is_eeh_implemented()) {
  621. if (is_eeh_configured(dev)) {
  622. eeh_disable_bit = 0;
  623. if (eeh_set_option(dev, EEH_ENABLE) != 0) {
  624. printk("PCI: failed to enable EEH for %s %sn", dev->slot_name, dev->name);
  625. eeh_disable_bit = EEH_TOKEN_DISABLED;
  626. }
  627. } else {
  628. /* Assume device is by default EEH_DISABLE'd */
  629. printk("PCI: eeh NOT configured for %s %sn", dev->slot_name, dev->name);
  630. eeh_disable_bit = EEH_TOKEN_DISABLED;
  631. }
  632. }
  634. PPCDBG(PPCDBG_PHBINIT, "fixup_resources:n"); 
  635. PPCDBG(PPCDBG_PHBINIT, "tphb                 = 0x%016LXn", phb); 
  636. PPCDBG(PPCDBG_PHBINIT, "tphb->pci_io_offset  = 0x%016LXn", phb->pci_io_offset); 
  637. PPCDBG(PPCDBG_PHBINIT, "tphb->pci_mem_offset = 0x%016LXn", phb->pci_mem_offset); 
  639. PPCDBG(PPCDBG_PHBINIT, "tdev->name   = %sn", dev->name);
  640. PPCDBG(PPCDBG_PHBINIT, "tdev->vendor:device = 0x%04X : 0x%04Xn", dev->vendor, dev->device);
  642. if (phb == NULL)
  643. return;
  645.   for (i = 0; i <  DEVICE_COUNT_RESOURCE; ++i) {
  646. PPCDBG(PPCDBG_PHBINIT, "tdevice %x.%x[%d] (flags %x) [%lx..%lx]n",
  647.     dev->bus->number, dev->devfn, i,
  648.     dev->resource[i].flags,
  649.     dev->resource[i].start,
  650.     dev->resource[i].end);
  652. if ((dev->resource[i].start == 0) && (dev->resource[i].end == 0)) {
  653. continue;
  654. }
  656. if (dev->resource[i].start > dev->resource[i].end) {
  657. /* Bogus resource.  Just clear it out. */
  658. dev->resource[i].start = dev->resource[i].end = 0;
  659. continue;
  660. }
  663. if (dev->resource[i].flags & IORESOURCE_IO) {
  664. if (is_eeh_implemented()) {
  665. unsigned int busno = dev->bus ? dev->bus->number : 0;
  666. unsigned long size = dev->resource[i].end - dev->resource[i].start;
  667. unsigned long addr = (unsigned long)__ioremap(dev->resource[i].start + phb->io_base_phys, size, _PAGE_NO_CACHE);
  668. if (!addr)
  669. panic("fixup_resources: io ioremap failed!n");
  670. dev->resource[i].start = eeh_token(phb->global_number, busno, dev->devfn, addr) | eeh_disable_bit;
  671. dev->resource[i].end = dev->resource[i].start + size;
  672. } else {
  673. unsigned long offset = (unsigned long)phb->io_base_virt;
  674. dev->resource[i].start += offset;
  675. dev->resource[i].end += offset;
  676. }
  677. PPCDBG(PPCDBG_PHBINIT, "tt-> now [%lx .. %lx]n",
  678.        dev->resource[i].start, dev->resource[i].end);
  679. } else if (dev->resource[i].flags & IORESOURCE_MEM) {
  680. if (dev->resource[i].start == 0) {
  681. /* Bogus.  Probably an unused bridge. */
  682. dev->resource[i].end = 0;
  683. } else {
  684. if (is_eeh_implemented()) {
  685. unsigned int busno = dev->bus ? dev->bus->number : 0;
  686. unsigned long size = dev->resource[i].end - dev->resource[i].start;
  687. unsigned long addr = (unsigned long)__ioremap(dev->resource[i].start + phb->pci_mem_offset, size, _PAGE_NO_CACHE);
  688. if (!addr)
  689. panic("fixup_resources: mem ioremap failed!n");
  690. dev->resource[i].start = eeh_token(phb->global_number, busno, dev->devfn, addr) | eeh_disable_bit;
  691. dev->resource[i].end = dev->resource[i].start + size;
  692. } else {
  693. dev->resource[i].start += phb->pci_mem_offset;
  694. dev->resource[i].end += phb->pci_mem_offset;
  695. }
  696. }
  697. PPCDBG(PPCDBG_PHBINIT, "tt-> now [%lx..%lx]n",
  698.        dev->resource[i].start, dev->resource[i].end);
  700. } else {
  701. continue;
  702. }
  704.   /* zap the 2nd function of the winbond chip */
  705.   if (dev->resource[i].flags & IORESOURCE_IO
  706.       && dev->bus->number == 0 && dev->devfn == 0x81)
  707.   dev->resource[i].flags &= ~IORESOURCE_IO;
  708.   }
  709. }   
  711. static void check_s7a(void)
  712. {
  713. struct device_node *root;
  714. char *model;
  716. root = find_path_device("/");
  717. if (root) {
  718. model = get_property(root, "model", NULL);
  719. if (model && !strcmp(model, "IBM,7013-S7A"))
  720. s7a_workaround = 1;
  721. }
  722. }
  724. void __init
  725. pSeries_pcibios_fixup(void)
  726. {
  727. struct pci_dev *dev;
  729. PPCDBG(PPCDBG_PHBINIT, "pSeries_pcibios_fixup: startn");
  730. pci_assign_all_busses = 0;
  732. check_s7a();
  734. pci_for_each_dev(dev) {
  735. pci_read_irq_line(dev);
  736. PPCDBGCALL(PPCDBG_PHBINIT, dumpPci_Dev(dev) );
  737. }
  739. if (naca->interrupt_controller == IC_PPC_XIC) {
  740. xics_isa_init(); 
  741. }
  742. }
  744. /*********************************************************************** 
  745.  * pci_find_hose_for_OF_device
  746.  *
  747.  * This function finds the PHB that matching device_node in the 
  748.  * OpenFirmware by scanning all the pci_controllers.
  749.  * 
  750.  ***********************************************************************/
  751. struct pci_controller*
  752. pci_find_hose_for_OF_device(struct device_node *node)
  753. {
  754. while (node) {
  755. struct pci_controller *hose;
  756. for (hose=hose_head;hose;hose=hose->next)
  757. if (hose->arch_data == node)
  758. return hose;
  759. node=node->parent;
  760. }
  761. return NULL;
  762. }
  764. /*********************************************************************** 
  765.  * ppc64_pcibios_init
  766.  *  
  767.  * Chance to initialize and structures or variable before PCI Bus walk.
  768.  *  
  769.  ***********************************************************************/
  770. void 
  771. pSeries_pcibios_init(void)
  772. {
  773. PPCDBG(PPCDBG_PHBINIT, "tppc64_pcibios_init Entry.n"); 
  775. if (get_property(find_path_device("/rtas"),"ibm,fw-phb-id",NULL) != NULL) {
  776. PPCDBG(PPCDBG_PHBINIT, "tFound: ibm,fw-phb-idn"); 
  777. Pci_Large_Bus_System = 1;
  778. }
  779. }
  781. /*
  782.  * This is called very early before the page table is setup.
  783.  */
  784. void 
  785. pSeries_pcibios_init_early(void)
  786. {
  787. ppc_md.pcibios_read_config_byte = rtas_read_config_byte;
  788. ppc_md.pcibios_read_config_word = rtas_read_config_word;
  789. ppc_md.pcibios_read_config_dword = rtas_read_config_dword;
  790. ppc_md.pcibios_write_config_byte = rtas_write_config_byte;
  791. ppc_md.pcibios_write_config_word = rtas_write_config_word;
  792. ppc_md.pcibios_write_config_dword = rtas_write_config_dword;
  793. }
  794. /************************************************************************/
  795. /* Get a char* of the device physical location(U0.3-P1-I8)              */
  796. /* See the Product Topology in the RS/6000 Architecture.                */
  797. /************************************************************************/
  798. int device_Location(struct pci_dev *PciDev, char *BufPtr)
  799. {
  800. struct device_node *DevNode = (struct device_node *)PciDev->sysdata;
  801. return sprintf(BufPtr,"PCI: Bus%3d, Device%3d, Vendor %04X, Location %-12s",
  802.        PciDev->bus->number,
  803.        PCI_SLOT(PciDev->devfn),
  804.        PciDev->vendor,
  805.        (char*)get_property(DevNode,"ibm,loc-code",0));
  806. }
  807. /************************************************************************/
  808. /* Set the slot reset line to the state passed in.                      */
  809. /* This is the platform specific for code for the pci_reset_device      */
  810. /* function.                                                            */
  811. /************************************************************************/
  812. int pci_set_reset(struct pci_dev *PciDev, int state)
  813. {
  814. return -1;
  815. }