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

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

Linux/Unix编程

开发平台：

Unix_Linux

pci_bios.c：源码内容
  1. /*
  2.  * BRIEF MODULE DESCRIPTION
  3.  * Galileo Evaluation Boards PCI support.
  4.  *
  5.  * The general-purpose functions to read/write and configure the GT64120A's
  6.  * PCI registers (function names start with pci0 or pci1) are either direct
  7.  * copies of functions written by Galileo Technology, or are modifications
  8.  * of their functions to work with Linux 2.4 vs Linux 2.2.  These functions
  9.  * are Copyright - Galileo Technology.
  10.  *
  11.  * Other functions are derived from other MIPS PCI implementations, or were
  12.  * written by RidgeRun, Inc,  Copyright (C) 2000 RidgeRun, Inc.
  13.  *   glonnon@ridgerun.com, skranz@ridgerun.com, stevej@ridgerun.com
  14.  *
  15.  *  This program is free software; you can redistribute  it and/or modify it
  16.  *  under  the terms of  the GNU General  Public License as published by the
  17.  *  Free Software Foundation;  either version 2 of the  License, or (at your
  18.  *  option) any later version.
  19.  *
  20.  *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
  21.  *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
  22.  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
  23.  *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
  24.  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25.  *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
  26.  *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  27.  *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
  28.  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  29.  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30.  *
  31.  *  You should have received a copy of the  GNU General Public License along
  32.  *  with this program; if not, write  to the Free Software Foundation, Inc.,
  33.  *  675 Mass Ave, Cambridge, MA 02139, USA.
  34.  */
  35. #include <linux/config.h>
  36. #include <linux/types.h>
  37. #include <linux/pci.h>
  38. #include <linux/kernel.h>
  39. #include <linux/slab.h>
  40. #include <linux/version.h>
  41. #include <asm/pci.h>
  42. #include <asm/io.h>
  43. #include <asm/galileo-boards/ev64120.h>
  44. #include <asm/gt64120.h>
  46. #include <linux/init.h>
  48. #undef PCI_DEBUG
  50. #ifdef PCI_DEBUG
  51. #define DBG(x...) printk(x)
  52. #else
  53. #define DBG(x...)
  54. #endif
  56. #ifdef CONFIG_PCI
  58. #define SELF 0
  60. /*
  61.  * These functions and structures provide the BIOS scan and mapping of the PCI
  62.  * devices.
  63.  */
  65. #define MAX_PCI_DEVS 10
  67. struct pci_device {
  68. u32 slot;
  69. u32 BARtype[6];
  70. u32 BARsize[6];
  71. };
  73. static void __init scan_and_initialize_pci(void);
  74. static u32 __init scan_pci_bus(struct pci_device *pci_devices);
  75. static void __init allocate_pci_space(struct pci_device *pci_devices);
  77. static void __init galileo_pcibios_fixup_bus(struct pci_bus *bus);
  79. /*
  80.  * The functions that actually read and write to the controller.
  81.  * Copied from or modified from Galileo Technology code.
  82.  */
  83. static unsigned int pci0ReadConfigReg(int offset, struct pci_dev *device);
  84. static void pci0WriteConfigReg(unsigned int offset,
  85.        struct pci_dev *device, unsigned int data);
  86. static unsigned int pci1ReadConfigReg(int offset, struct pci_dev *device);
  87. static void pci1WriteConfigReg(unsigned int offset,
  88.        struct pci_dev *device, unsigned int data);
  90. static void pci0MapIOspace(unsigned int pci0IoBase,
  91.    unsigned int pci0IoLength);
  92. static void pci1MapIOspace(unsigned int pci1IoBase,
  93.    unsigned int pci1IoLength);
  94. static void pci0MapMemory0space(unsigned int pci0Mem0Base,
  95. unsigned int pci0Mem0Length);
  96. static void pci1MapMemory0space(unsigned int pci1Mem0Base,
  97. unsigned int pci1Mem0Length);
  98. static void pci0MapMemory1space(unsigned int pci0Mem1Base,
  99. unsigned int pci0Mem1Length);
  100. static void pci1MapMemory1space(unsigned int pci1Mem1Base,
  101. unsigned int pci1Mem1Length);
  102. static unsigned int pci0GetIOspaceBase(void);
  103. static unsigned int pci0GetIOspaceSize(void);
  104. static unsigned int pci0GetMemory0Base(void);
  105. static unsigned int pci0GetMemory0Size(void);
  106. static unsigned int pci0GetMemory1Base(void);
  107. static unsigned int pci0GetMemory1Size(void);
  108. static unsigned int pci1GetIOspaceBase(void);
  109. static unsigned int pci1GetIOspaceSize(void);
  110. static unsigned int pci1GetMemory0Base(void);
  111. static unsigned int pci1GetMemory0Size(void);
  112. static unsigned int pci1GetMemory1Base(void);
  113. static unsigned int pci1GetMemory1Size(void);
  116. /*  Functions to implement "pci ops"  */
  117. static int galileo_pcibios_read_config_word(struct pci_dev *dev,
  118.     int offset, u16 * val);
  119. static int galileo_pcibios_read_config_byte(struct pci_dev *dev,
  120.     int offset, u8 * val);
  121. static int galileo_pcibios_read_config_dword(struct pci_dev *dev,
  122.      int offset, u32 * val);
  123. static int galileo_pcibios_write_config_byte(struct pci_dev *dev,
  124.      int offset, u8 val);
  125. static int galileo_pcibios_write_config_word(struct pci_dev *dev,
  126.      int offset, u16 val);
  127. static int galileo_pcibios_write_config_dword(struct pci_dev *dev,
  128.       int offset, u32 val);
  129. static void galileo_pcibios_set_master(struct pci_dev *dev);
  131. /*
  132.  * General-purpose PCI functions.
  133.  */
  135. /*
  136.  * pci0MapIOspace - Maps PCI0 IO space for the master.
  137.  * Inputs: base and length of pci0Io
  138.  */
  139. static void pci0MapIOspace(unsigned int pci0IoBase, unsigned int pci0IoLength)
  140. {
  141. unsigned int pci0IoTop =
  142.     (unsigned int) (pci0IoBase + pci0IoLength);
  144. if (pci0IoLength == 0)
  145. pci0IoTop++;
  147. pci0IoBase = (unsigned int) (pci0IoBase >> 21);
  148. pci0IoTop = (unsigned int) (((pci0IoTop - 1) & 0x0fffffff) >> 21);
  149. GT_WRITE(GT_PCI0IOLD_OFS, pci0IoBase);
  150. GT_WRITE(GT_PCI0IOHD_OFS, pci0IoTop);
  151. }
  153. /*
  154.  * pci1MapIOspace - Maps PCI1 IO space for the master.
  155.  * Inputs: base and length of pci1Io
  156.  */
  158. static void pci1MapIOspace(unsigned int pci1IoBase,
  159.    unsigned int pci1IoLength)
  160. {
  161. unsigned int pci1IoTop =
  162.     (unsigned int) (pci1IoBase + pci1IoLength);
  164. if (pci1IoLength == 0)
  165. pci1IoTop++;
  167. pci1IoBase = (unsigned int) (pci1IoBase >> 21);
  168. pci1IoTop = (unsigned int) (((pci1IoTop - 1) & 0x0fffffff) >> 21);
  169. GT_WRITE(GT_PCI1IOLD_OFS, pci1IoBase);
  170. GT_WRITE(GT_PCI1IOHD_OFS, pci1IoTop);
  171. }
  173. /*
  174.  * pci0MapMemory0space - Maps PCI0 memory0 space for the master.
  175.  * Inputs: base and length of pci0Mem0
  176.  */
  178. static void pci0MapMemory0space(unsigned int pci0Mem0Base,
  179. unsigned int pci0Mem0Length)
  180. {
  181. unsigned int pci0Mem0Top = pci0Mem0Base + pci0Mem0Length;
  183. if (pci0Mem0Length == 0)
  184. pci0Mem0Top++;
  186. pci0Mem0Base = pci0Mem0Base >> 21;
  187. pci0Mem0Top = ((pci0Mem0Top - 1) & 0x0fffffff) >> 21;
  188. GT_WRITE(GT_PCI0M0LD_OFS, pci0Mem0Base);
  189. GT_WRITE(GT_PCI0M0HD_OFS, pci0Mem0Top);
  190. }
  192. /*
  193.  * pci1MapMemory0space - Maps PCI1 memory0 space for the master.
  194.  * Inputs: base and length of pci1Mem0
  195.  */
  197. static void pci1MapMemory0space(unsigned int pci1Mem0Base,
  198. unsigned int pci1Mem0Length)
  199. {
  200. unsigned int pci1Mem0Top = pci1Mem0Base + pci1Mem0Length;
  202. if (pci1Mem0Length == 0)
  203. pci1Mem0Top++;
  205. pci1Mem0Base = pci1Mem0Base >> 21;
  206. pci1Mem0Top = ((pci1Mem0Top - 1) & 0x0fffffff) >> 21;
  207. GT_WRITE(GT_PCI1M0LD_OFS, pci1Mem0Base);
  208. GT_WRITE(GT_PCI1M0HD_OFS, pci1Mem0Top);
  209. }
  211. /*
  212.  * pci0MapMemory1space - Maps PCI0 memory1 space for the master.
  213.  * Inputs: base and length of pci0Mem1
  214.  */
  216. static void pci0MapMemory1space(unsigned int pci0Mem1Base,
  217. unsigned int pci0Mem1Length)
  218. {
  219. unsigned int pci0Mem1Top = pci0Mem1Base + pci0Mem1Length;
  221. if (pci0Mem1Length == 0)
  222. pci0Mem1Top++;
  224. pci0Mem1Base = pci0Mem1Base >> 21;
  225. pci0Mem1Top = ((pci0Mem1Top - 1) & 0x0fffffff) >> 21;
  226. GT_WRITE(GT_PCI0M1LD_OFS, pci0Mem1Base);
  227. GT_WRITE(GT_PCI0M1HD_OFS, pci0Mem1Top);
  229. }
  231. /*
  232.  * pci1MapMemory1space - Maps PCI1 memory1 space for the master.
  233.  * Inputs: base and length of pci1Mem1
  234.  */
  236. static void pci1MapMemory1space(unsigned int pci1Mem1Base,
  237. unsigned int pci1Mem1Length)
  238. {
  239. unsigned int pci1Mem1Top = pci1Mem1Base + pci1Mem1Length;
  241. if (pci1Mem1Length == 0)
  242. pci1Mem1Top++;
  244. pci1Mem1Base = pci1Mem1Base >> 21;
  245. pci1Mem1Top = ((pci1Mem1Top - 1) & 0x0fffffff) >> 21;
  246. GT_WRITE(GT_PCI1M1LD_OFS, pci1Mem1Base);
  247. GT_WRITE(GT_PCI1M1HD_OFS, pci1Mem1Top);
  248. }
  250. /*
  251.  * pci0GetIOspaceBase - Return PCI0 IO Base Address.
  252.  * Inputs: N/A
  253.  * Returns: PCI0 IO Base Address.
  254.  */
  256. static unsigned int pci0GetIOspaceBase(void)
  257. {
  258. unsigned int base;
  259. GT_READ(GT_PCI0IOLD_OFS, &base);
  260. base = base << 21;
  261. return base;
  262. }
  264. /*
  265.  * pci0GetIOspaceSize - Return PCI0 IO Bar Size.
  266.  * Inputs: N/A
  267.  * Returns: PCI0 IO Bar Size.
  268.  */
  269. static unsigned int pci0GetIOspaceSize(void)
  270. {
  271. unsigned int top, base, size;
  272. GT_READ(GT_PCI0IOLD_OFS, &base);
  273. base = base << 21;
  274. GT_READ(GT_PCI0IOHD_OFS, &top);
  275. top = (top << 21);
  276. size = ((top - base) & 0xfffffff);
  277. size = size | 0x1fffff;
  278. return (size + 1);
  279. }
  281. /*
  282.  * pci0GetMemory0Base - Return PCI0 Memory 0 Base Address.
  283.  * Inputs: N/A
  284.  * Returns: PCI0 Memory 0 Base Address.
  285.  */
  286. static unsigned int pci0GetMemory0Base(void)
  287. {
  288. unsigned int base;
  289. GT_READ(GT_PCI0M0LD_OFS, &base);
  290. base = base << 21;
  291. return base;
  292. }
  294. /*
  295.  * pci0GetMemory0Size - Return PCI0 Memory 0 Bar Size.
  296.  * Inputs: N/A
  297.  * Returns: PCI0 Memory 0 Bar Size.
  298.  */
  299. static unsigned int pci0GetMemory0Size(void)
  300. {
  301. unsigned int top, base, size;
  302. GT_READ(GT_PCI0M0LD_OFS, &base);
  303. base = base << 21;
  304. GT_READ(GT_PCI0M0HD_OFS, &top);
  305. top = (top << 21);
  306. size = ((top - base) & 0xfffffff);
  307. size = size | 0x1fffff;
  308. return (size + 1);
  309. }
  311. /*
  312.  * pci0GetMemory1Base - Return PCI0 Memory 1 Base Address.
  313.  * Inputs: N/A
  314.  * Returns: PCI0 Memory 1 Base Address.
  315.  */
  316. static unsigned int pci0GetMemory1Base(void)
  317. {
  318. unsigned int base;
  319. GT_READ(GT_PCI0M1LD_OFS, &base);
  320. base = base << 21;
  321. return base;
  322. }
  324. /*
  325.  * pci0GetMemory1Size - Return PCI0 Memory 1 Bar Size.
  326.  * Inputs: N/A
  327.  * Returns: PCI0 Memory 1 Bar Size.
  328.  */
  330. static unsigned int pci0GetMemory1Size(void)
  331. {
  332. unsigned int top, base, size;
  333. GT_READ(GT_PCI0M1LD_OFS, &base);
  334. base = base << 21;
  335. GT_READ(GT_PCI0M1HD_OFS, &top);
  336. top = (top << 21);
  337. size = ((top - base) & 0xfffffff);
  338. size = size | 0x1fffff;
  339. return (size + 1);
  340. }
  342. /*
  343.  * pci1GetIOspaceBase - Return PCI1 IO Base Address.
  344.  * Inputs: N/A
  345.  * Returns: PCI1 IO Base Address.
  346.  */
  348. static unsigned int pci1GetIOspaceBase(void)
  349. {
  350. unsigned int base;
  351. GT_READ(GT_PCI1IOLD_OFS, &base);
  352. base = base << 21;
  353. return base;
  354. }
  356. /*
  357.  * pci1GetIOspaceSize - Return PCI1 IO Bar Size.
  358.  * Inputs: N/A
  359.  * Returns: PCI1 IO Bar Size.
  360.  */
  362. static unsigned int pci1GetIOspaceSize(void)
  363. {
  364. unsigned int top, base, size;
  365. GT_READ(GT_PCI1IOLD_OFS, &base);
  366. base = base << 21;
  367. GT_READ(GT_PCI1IOHD_OFS, &top);
  368. top = (top << 21);
  369. size = ((top - base) & 0xfffffff);
  370. size = size | 0x1fffff;
  371. return (size + 1);
  372. }
  374. /*
  375.  * pci1GetMemory0Base - Return PCI1 Memory 0 Base Address.
  376.  * Inputs: N/A
  377.  * Returns: PCI1 Memory 0 Base Address.
  378.  */
  380. static unsigned int pci1GetMemory0Base(void)
  381. {
  382. unsigned int base;
  383. GT_READ(GT_PCI1M0LD_OFS, &base);
  384. base = base << 21;
  385. return base;
  386. }
  388. /*
  389.  * pci1GetMemory0Size - Return PCI1 Memory 0 Bar Size.
  390.  * Inputs: N/A
  391.  * Returns: PCI1 Memory 0 Bar Size.
  392.  */
  394. static unsigned int pci1GetMemory0Size(void)
  395. {
  396. unsigned int top, base, size;
  397. GT_READ(GT_PCI1M1LD_OFS, &base);
  398. base = base << 21;
  399. GT_READ(GT_PCI1M1HD_OFS, &top);
  400. top = (top << 21);
  401. size = ((top - base) & 0xfffffff);
  402. size = size | 0x1fffff;
  403. return (size + 1);
  404. }
  406. /*
  407.  * pci1GetMemory1Base - Return PCI1 Memory 1 Base Address.
  408.  * Inputs: N/A
  409.  * Returns: PCI1 Memory 1 Base Address.
  410.  */
  412. static unsigned int pci1GetMemory1Base(void)
  413. {
  414. unsigned int base;
  415. GT_READ(GT_PCI1M1LD_OFS, &base);
  416. base = base << 21;
  417. return base;
  418. }
  420. /*
  421.  * pci1GetMemory1Size - Return PCI1 Memory 1 Bar Size.
  422.  * Inputs: N/A
  423.  * Returns: PCI1 Memory 1 Bar Size.
  424.  */
  426. static unsigned int pci1GetMemory1Size(void)
  427. {
  428. unsigned int top, base, size;
  429. GT_READ(GT_PCI1M1LD_OFS, &base);
  430. base = base << 21;
  431. GT_READ(GT_PCI1M1HD_OFS, &top);
  432. top = (top << 21);
  433. size = ((top - base) & 0xfffffff);
  434. size = size | 0x1fffff;
  435. return (size + 1);
  436. }
  440. /*
  441.  * pci_range_ck -
  442.  *
  443.  * Check if the pci device that are trying to access does really exists
  444.  * on the evaluation board.
  445.  *
  446.  * Inputs :
  447.  * bus - bus number (0 for PCI 0 ; 1 for PCI 1)
  448.  * dev - number of device on the specific pci bus
  449.  *
  450.  * Outpus :
  451.  * 0 - if OK , 1 - if failure
  452.  */
  453. static __inline__ int pci_range_ck(unsigned char bus, unsigned char dev)
  454. {
  455. //DBG(KERN_INFO "p_r_c %d %dn",bus,dev);
  456. if (((bus == 0) || (bus == 1)) && (dev >= 6) && (dev <= 8))
  457. return 0; // Bus/Device Number OK
  458. return -1; // Bus/Device Number not OK
  459. }
  461. /*
  462.  * pciXReadConfigReg  - Read from a PCI configuration register
  463.  *                    - Make sure the GT is configured as a master before
  464.  *                      reading from another device on the PCI.
  465.  *                   - The function takes care of Big/Little endian conversion.
  466.  * INPUTS:   regOffset: The register offset as it apears in the GT spec (or PCI
  467.  *                        spec)
  468.  *           pciDevNum: The device number needs to be addressed.
  469.  * RETURNS: data , if the data == 0xffffffff check the master abort bit in the
  470.  *                 cause register to make sure the data is valid
  471.  *
  472.  *  Configuration Address 0xCF8:
  473.  *
  474.  *       31 30    24 23  16 15  11 10     8 7      2  0     <=bit Number
  475.  *  |congif|Reserved|  Bus |Device|Function|Register|00|
  476.  *  |Enable|        |Number|Number| Number | Number |  |    <=field Name
  477.  *
  478.  */
  479. static unsigned int pci0ReadConfigReg(int offset, struct pci_dev *device)
  480. {
  481. unsigned int DataForRegCf8;
  482. unsigned int data;
  484. DataForRegCf8 = ((PCI_SLOT(device->devfn) << 11) |
  485.  (PCI_FUNC(device->devfn) << 8) |
  486.  (offset & ~0x3)) | 0x80000000;
  487. GT_WRITE(GT_PCI0_CFGADDR_OFS, DataForRegCf8);
  489. /*  The casual observer might wonder why the READ is duplicated here,
  490.    rather than immediately following the WRITE, and just have the
  491.    swap in the "if".  That's because there is a latency problem
  492.    with trying to read immediately after setting up the address
  493.    register.  The "if" check gives enough time for the address
  494.    to stabilize, so the READ can work.
  495.  */
  496. if (PCI_SLOT(device->devfn) == SELF) { /* This board */
  497. GT_READ(GT_PCI0_CFGDATA_OFS, &data);
  498. return data;
  499. } else { /* The PCI is working in LE Mode so swap the Data. */
  500. GT_READ(GT_PCI0_CFGDATA_OFS, &data);
  501. return cpu_to_le32(data);
  502. }
  503. }
  505. static unsigned int pci1ReadConfigReg(int offset, struct pci_dev *device)
  506. {
  507. unsigned int DataForRegCf8;
  508. unsigned int data;
  510. DataForRegCf8 = ((PCI_SLOT(device->devfn) << 11) |
  511.  (PCI_FUNC(device->devfn) << 8) |
  512.  (offset & ~0x3)) | 0x80000000;
  513. /*  The casual observer might wonder why the READ is duplicated here,
  514.    rather than immediately following the WRITE, and just have the
  515.    swap in the "if".  That's because there is a latency problem
  516.    with trying to read immediately after setting up the address
  517.    register.  The "if" check gives enough time for the address
  518.    to stabilize, so the READ can work.
  519.  */
  520. if (PCI_SLOT(device->devfn) == SELF) { /* This board */
  521. /* when configurating our own PCI 1 L-unit the access is through
  522.    the PCI 0 interface with reg number = reg number + 0x80 */
  523. DataForRegCf8 |= 0x80;
  524. GT_WRITE(GT_PCI0_CFGADDR_OFS, DataForRegCf8);
  525. } else { /* The PCI is working in LE Mode so swap the Data. */
  526. GT_WRITE(GT_PCI1_CFGADDR_OFS, DataForRegCf8);
  527. }
  528. if (PCI_SLOT(device->devfn) == SELF) { /* This board */
  529. GT_READ(GT_PCI0_CFGDATA_OFS, &data);
  530. return data;
  531. } else {
  532. GT_READ(GT_PCI1_CFGDATA_OFS, &data);
  533. return cpu_to_le32(data);
  534. }
  535. }
  539. /*
  540.  * pciXWriteConfigReg - Write to a PCI configuration register
  541.  *                    - Make sure the GT is configured as a master before
  542.  *                      writingto another device on the PCI.
  543.  *                    - The function takes care of Big/Little endian conversion.
  544.  * Inputs:   unsigned int regOffset: The register offset as it apears in the
  545.  *           GT spec
  546.  *                   (or any other PCI device spec)
  547.  *           pciDevNum: The device number needs to be addressed.
  548.  *
  549.  *  Configuration Address 0xCF8:
  550.  *
  551.  *       31 30    24 23  16 15  11 10     8 7      2  0     <=bit Number
  552.  *  |congif|Reserved|  Bus |Device|Function|Register|00|
  553.  *  |Enable|        |Number|Number| Number | Number |  |    <=field Name
  554.  *
  555.  */
  556. static void pci0WriteConfigReg(unsigned int offset,
  557.        struct pci_dev *device, unsigned int data)
  558. {
  559. unsigned int DataForRegCf8;
  561. DataForRegCf8 = ((PCI_SLOT(device->devfn) << 11) |
  562.  (PCI_FUNC(device->devfn) << 8) |
  563.  (offset & ~0x3)) | 0x80000000;
  564. GT_WRITE(GT_PCI0_CFGADDR_OFS, DataForRegCf8);
  565. if (PCI_SLOT(device->devfn) == SELF) { /* This board */
  566. GT_WRITE(GT_PCI0_CFGDATA_OFS, data);
  567. } else { /* configuration Transaction over the pci. */
  568. /* The PCI is working in LE Mode so swap the Data. */
  569. GT_WRITE(GT_PCI0_CFGDATA_OFS, le32_to_cpu(data));
  570. }
  571. }
  573. static void pci1WriteConfigReg(unsigned int offset,
  574.        struct pci_dev *device, unsigned int data)
  575. {
  576. unsigned int DataForRegCf8;
  578. DataForRegCf8 = ((PCI_SLOT(device->devfn) << 11) |
  579.  (PCI_FUNC(device->devfn) << 8) |
  580.  (offset & ~0x3)) | 0x80000000;
  581. /*  There is a latency problem
  582.    with trying to read immediately after setting up the address
  583.    register.  The "if" check gives enough time for the address
  584.    to stabilize, so the WRITE can work.
  585.  */
  586. if (PCI_SLOT(device->devfn) == SELF) { /* This board */
  587. /* when configurating our own PCI 1 L-unit the access is through
  588.    the PCI 0 interface with reg number = reg number + 0x80 */
  589. DataForRegCf8 |= 0x80;
  590. GT_WRITE(GT_PCI0_CFGADDR_OFS, DataForRegCf8);
  591. } else { /* configuration Transaction over the pci. */
  592. /* The PCI is working in LE Mode so swap the Data. */
  593. GT_WRITE(GT_PCI1_CFGADDR_OFS, DataForRegCf8);
  594. }
  595. if (PCI_SLOT(device->devfn) == SELF) { /* This board */
  596. GT_WRITE(GT_PCI0_CFGDATA_OFS, data);
  597. } else { /* configuration Transaction over the pci. */
  598. GT_WRITE(GT_PCI1_CFGADDR_OFS, le32_to_cpu(data));
  599. }
  600. }
  603. /*
  604.  * galileo_pcibios_(read/write)_config_(dword/word/byte) -
  605.  *
  606.  * reads/write a dword/word/byte register from the configuration space
  607.  * of a device.
  608.  *
  609.  * Inputs :
  610.  * bus - bus number
  611.  * dev - device number
  612.  * offset - register offset in the configuration space
  613.  * val - value to be written / read
  614.  *
  615.  * Outputs :
  616.  * PCIBIOS_SUCCESSFUL when operation was succesfull
  617.  * PCIBIOS_DEVICE_NOT_FOUND when the bus or dev is errorneous
  618.  * PCIBIOS_BAD_REGISTER_NUMBER when accessing non aligned
  619.  */
  621. static int galileo_pcibios_read_config_dword(struct pci_dev *device,
  622.      int offset, u32 * val)
  623. {
  624. int dev, bus;
  625. //DBG(KERN_INFO "rcd entry n",offset,val);
  626. bus = device->bus->number;
  627. dev = PCI_SLOT(device->devfn);
  629. if (pci_range_ck(bus, dev)) {
  630. *val = 0xffffffff;
  631. return PCIBIOS_DEVICE_NOT_FOUND;
  632. }
  633. if (offset & 0x3)
  634. return PCIBIOS_BAD_REGISTER_NUMBER;
  635. if (bus == 0)
  636. *val = pci0ReadConfigReg(offset, device);
  637. //  if (bus == 1) *val = pci1ReadConfigReg (offset,device);
  638. DBG(KERN_INFO "rr: rcd dev %d offset %x %xn", dev, offset, *val);
  640. /*
  641.  * This is so that the upper PCI layer will get the correct return
  642.  * value if we're not attached to anything.
  643.  */
  644. if ((offset == 0) && (*val == 0xffffffff)) {
  645. return PCIBIOS_DEVICE_NOT_FOUND;
  646. }
  648. return PCIBIOS_SUCCESSFUL;
  649. }
  651. static int galileo_pcibios_read_config_word(struct pci_dev *device,
  652.     int offset, u16 * val)
  653. {
  654. int dev, bus;
  656. bus = device->bus->number;
  657. dev = PCI_SLOT(device->devfn);
  659. if (pci_range_ck(bus, dev)) {
  660. *val = 0xffff;
  661. return PCIBIOS_DEVICE_NOT_FOUND;
  662. }
  663. if (offset & 0x1)
  664. return PCIBIOS_BAD_REGISTER_NUMBER;
  666. if (bus == 0)
  667. *val = (unsigned short) (pci0ReadConfigReg(offset, device) >>
  668.          ((offset & ~0x3) * 8));
  669. //  if (bus == 1) *val = (unsigned short) (pci1ReadConfigReg(offset,device) >> ((offset & ~0x3) * 8));
  671. DBG(KERN_INFO "rr: rcw dev %d offset %x %xn", dev, offset, *val);
  673. return PCIBIOS_SUCCESSFUL;
  674. }
  676. static int galileo_pcibios_read_config_byte(struct pci_dev *device,
  677.     int offset, u8 * val)
  678. {
  679. int dev, bus;
  681. bus = device->bus->number;
  682. dev = PCI_SLOT(device->devfn);
  684. if (pci_range_ck(bus, dev)) {
  685. *val = 0xff;
  686. return PCIBIOS_DEVICE_NOT_FOUND;
  687. }
  689. if (bus == 0)
  690. *val =
  691.     (unsigned char) (pci0ReadConfigReg(offset, device) >>
  692.      ((offset & ~0x3) * 8));
  693. //  if (bus == 1) *val = (unsigned char) (pci1ReadConfigReg(offset,device) >> ((offset & ~0x3) * 8));
  695. DBG(KERN_INFO "rr: rcb dev %d offset %x %xn", dev, offset, *val);
  697. /*  This is so that the upper PCI layer will get the correct return value if
  698.    we're not attached to anything.  */
  699. if ((offset == 0xe) && (*val == 0xff)) {
  700. u32 MasterAbort;
  701. GT_READ(GT_INTRCAUSE_OFS, &MasterAbort);
  702. if (MasterAbort & 0x40000) {
  703. DBG(KERN_INFO "PCI Master Abort, ICR %xn",
  704.     MasterAbort);
  705. GT_WRITE(GT_INTRCAUSE_OFS,
  706.  (MasterAbort & 0xfffbffff));
  707. return PCIBIOS_DEVICE_NOT_FOUND;
  708. }
  709. }
  711. return PCIBIOS_SUCCESSFUL;
  712. }
  714. static int galileo_pcibios_write_config_dword(struct pci_dev *device,
  715.       int offset, u32 val)
  716. {
  717. int dev, bus;
  719. bus = device->bus->number;
  720. dev = PCI_SLOT(device->devfn);
  722. if (pci_range_ck(bus, dev))
  723. return PCIBIOS_DEVICE_NOT_FOUND;
  724. if (offset & 0x3)
  725. return PCIBIOS_BAD_REGISTER_NUMBER;
  726. if (bus == 0)
  727. pci0WriteConfigReg(offset, device, val);
  728. //  if (bus == 1) pci1WriteConfigReg (offset,device,val);
  730. DBG(KERN_INFO "rr: wcd dev %d, offset %x, val %xn", dev, offset,
  731.     val);
  732. return PCIBIOS_SUCCESSFUL;
  733. }
  736. static int galileo_pcibios_write_config_word(struct pci_dev *device,
  737.      int offset, u16 val)
  738. {
  739. int dev, bus;
  740. unsigned long tmp;
  742. bus = device->bus->number;
  743. dev = PCI_SLOT(device->devfn);
  745. if (pci_range_ck(bus, dev))
  746. return PCIBIOS_DEVICE_NOT_FOUND;
  747. if (offset & 0x1)
  748. return PCIBIOS_BAD_REGISTER_NUMBER;
  749. if (bus == 0)
  750. tmp = pci0ReadConfigReg(offset, device);
  751. //  if (bus == 1) tmp = pci1ReadConfigReg (offset,device);
  753. if ((offset % 4) == 0)
  754. tmp = (tmp & 0xffff0000) | (val & 0xffff);
  755. if ((offset % 4) == 2)
  756. tmp = (tmp & 0x0000ffff) | ((val & 0xffff) << 16);
  758. if (bus == 0)
  759. pci0WriteConfigReg(offset, device, tmp);
  760. //  if (bus == 1) pci1WriteConfigReg (offset,device,tmp);
  761. DBG(KERN_INFO "rr: wcw dev %d, offset %x, val %xn", dev, offset,
  762.     val);
  763. return PCIBIOS_SUCCESSFUL;
  764. }
  766. static int galileo_pcibios_write_config_byte(struct pci_dev *device,
  767.      int offset, u8 val)
  768. {
  769. int dev, bus;
  770. unsigned long tmp;
  772. bus = device->bus->number;
  773. dev = PCI_SLOT(device->devfn);
  775. if (pci_range_ck(bus, dev))
  776. return PCIBIOS_DEVICE_NOT_FOUND;
  777. if (bus == 0)
  778. tmp = pci0ReadConfigReg(offset, device);
  779. //  if (bus == 1) tmp = pci1ReadConfigReg (offset,device);
  781. if ((offset % 4) == 0)
  782. tmp = (tmp & 0xffffff00) | (val & 0xff);
  783. if ((offset % 4) == 1)
  784. tmp = (tmp & 0xffff00ff) | ((val & 0xff) << 8);
  785. if ((offset % 4) == 2)
  786. tmp = (tmp & 0xff00ffff) | ((val & 0xff) << 16);
  787. if ((offset % 4) == 3)
  788. tmp = (tmp & 0x00ffffff) | ((val & 0xff) << 24);
  790. if (bus == 0)
  791. pci0WriteConfigReg(offset, device, tmp);
  792. //  if (bus == 1) pci1WriteConfigReg (offset,device,tmp);
  793. DBG(KERN_INFO "rr: wcb dev %d, offset %x, val %xn", dev, offset,
  794.     val);
  796. return PCIBIOS_SUCCESSFUL;
  797. }
  799. static void galileo_pcibios_set_master(struct pci_dev *dev)
  800. {
  801. u16 cmd;
  803. DBG(KERN_INFO "rr: galileo_pcibios_set_mastern");
  805. galileo_pcibios_read_config_word(dev, PCI_COMMAND, &cmd);
  806. cmd |= PCI_COMMAND_MASTER;
  807. galileo_pcibios_write_config_word(dev, PCI_COMMAND, cmd);
  808. DBG("PCI: Enabling device %s (%04x)n", dev->slot_name, cmd);
  809. }
  811. /*  Externally-expected functions.  Do not change function names  */
  813. int pcibios_enable_resources(struct pci_dev *dev)
  814. {
  815. u16 cmd, old_cmd;
  816. u16 tmp;
  817. u8 tmp1;
  818. int idx;
  819. struct resource *r;
  821. DBG(KERN_INFO "rr: pcibios_enable_resourcesn");
  823. galileo_pcibios_read_config_word(dev, PCI_COMMAND, &cmd);
  824. old_cmd = cmd;
  825. for (idx = 0; idx < 6; idx++) {
  826. r = &dev->resource[idx];
  827. DBG(KERN_INFO
  828.     "rr: BAR %d, start %lx, end %lx, flags %lxn", idx,
  829.     r->start, r->end, r->flags);
  830. if (!r->start && r->end) {
  831. printk(KERN_ERR
  832.        "PCI: Device %s not available because of resource collisionsn",
  833.        dev->slot_name);
  834. return -EINVAL;
  835. }
  836. if (r->flags & IORESOURCE_IO)
  837. cmd |= PCI_COMMAND_IO;
  838. if (r->flags & IORESOURCE_MEM)
  839. cmd |= PCI_COMMAND_MEMORY;
  840. }
  841. if (cmd != old_cmd) {
  842. DBG(KERN_INFO "PCI: Enabling device %s (%04x -> %04x)n",
  843.     dev->slot_name, old_cmd, cmd);
  844. galileo_pcibios_write_config_word(dev, PCI_COMMAND, cmd);
  845. }
  847. /*
  848.    Let's fix up the latency timer and cache line size here.  Cache line size =
  849.    32 bytes / sizeof dword (4) = 8.
  850.    Latency timer must be > 8.  32 is random but appears to work.
  851.  */
  852. galileo_pcibios_read_config_byte(dev, PCI_CACHE_LINE_SIZE, &tmp1);
  853. if (tmp1 != 8) {
  854. DBG(KERN_INFO
  855.     "rr: PCI setting cache line size to 8 from %dn",
  856.     tmp1);
  857. galileo_pcibios_write_config_byte(dev, PCI_CACHE_LINE_SIZE,
  858.   8);
  859. }
  860. galileo_pcibios_read_config_byte(dev, PCI_LATENCY_TIMER, &tmp1);
  861. if (tmp1 < 32) {
  862. DBG(KERN_INFO
  863.     "rr: PCI setting latency timer to 32 from %dn", tmp1);
  864. galileo_pcibios_write_config_byte(dev, PCI_LATENCY_TIMER,
  865.   32);
  866. }
  868. return 0;
  869. }
  871. int pcibios_enable_device(struct pci_dev *dev)
  872. {
  873. DBG(KERN_INFO "rr: pcibios_enable_devicen");
  874. return pcibios_enable_resources(dev);
  875. }
  877. void pcibios_update_resource(struct pci_dev *dev, struct resource *root,
  878.      struct resource *res, int resource)
  879. {
  880. u32 new, check;
  881. int reg;
  883. DBG(KERN_INFO "rr: pcibios_update_resourcen");
  884. return;
  886. new = res->start | (res->flags & PCI_REGION_FLAG_MASK);
  887. if (resource < 6) {
  888. reg = PCI_BASE_ADDRESS_0 + 4 * resource;
  889. } else if (resource == PCI_ROM_RESOURCE) {
  890. res->flags |= PCI_ROM_ADDRESS_ENABLE;
  891. reg = dev->rom_base_reg;
  892. } else {
  893. /* Somebody might have asked allocation of a non-standard resource */
  894. return;
  895. }
  897. pci_write_config_dword(dev, reg, new);
  898. pci_read_config_dword(dev, reg, &check);
  899. if ((new ^ check) &
  900.     ((new & PCI_BASE_ADDRESS_SPACE_IO) ? PCI_BASE_ADDRESS_IO_MASK :
  901.      PCI_BASE_ADDRESS_MEM_MASK)) {
  902. DBG(KERN_ERR "PCI: Error while updating region "
  903.     "%s/%d (%08x != %08x)n", dev->slot_name, resource,
  904.     new, check);
  905. }
  906. }
  908. void pcibios_align_resource(void *data, struct resource *res,
  909.     unsigned long size, unsigned long align)
  910. {
  911. struct pci_dev *dev = data;
  913. DBG(KERN_INFO "pcibios_align_resourcen");
  915. if (res->flags & IORESOURCE_IO) {
  916. unsigned long start = res->start;
  918. /* We need to avoid collisions with `mirrored' VGA ports
  919.    and other strange ISA hardware, so we always want the
  920.    addresses kilobyte aligned.  */
  921. if (size > 0x100) {
  922. DBG(KERN_ERR "PCI: I/O Region %s/%d too large"
  923.     " (%ld bytes)n", dev->slot_name,
  924.     dev->resource - res, size);
  925. }
  927. start = (start + 1024 - 1) & ~(1024 - 1);
  928. res->start = start;
  929. }
  930. }
  932. /*
  933.  * structure galileo_pci_ops
  934.  *
  935.  * This structure holds the pointers for the PCI configuration space
  936.  * access, and the fixup for the interrupts.
  937.  * This structure is registered to the operating system in boot time
  938.  */
  939. struct pci_ops galileo_pci_ops = {
  940. galileo_pcibios_read_config_byte,
  941. galileo_pcibios_read_config_word,
  942. galileo_pcibios_read_config_dword,
  943. galileo_pcibios_write_config_byte,
  944. galileo_pcibios_write_config_word,
  945. galileo_pcibios_write_config_dword
  946. };
  948. /*
  949.  * galileo_pcibios_fixup_bus -
  950.  *
  951.  * After detecting all agents over the PCI , this function is called
  952.  * in order to give an interrupt number for each PCI device starting
  953.  * from IRQ 20. It does also enables master for each device.
  954.  *
  955.  * Inputs :
  956.  * mem_start , mem_end are not relevant in MIPS architecture.
  957.  *
  958.  * Outpus :
  959.  * return always mem_start
  960.  */
  961. static void __init galileo_pcibios_fixup_bus(struct pci_bus *bus)
  962. {
  963. unsigned int Current_IRQ = 20;
  964. struct pci_bus *current_bus = bus;
  965. struct pci_dev *devices;
  966. struct list_head *devices_link;
  968. list_for_each(devices_link, &(current_bus->devices)) {
  969. devices = pci_dev_b(devices_link);
  970. if (devices != NULL) {
  971. devices->irq = Current_IRQ++;
  973. /* Assign an interrupt number for the device */
  974. galileo_pcibios_write_config_byte(devices,
  975.   PCI_INTERRUPT_LINE,
  976.   Current_IRQ);
  977. galileo_pcibios_set_master(devices);
  979. }
  980. }
  982. }
  984. struct pci_fixup pcibios_fixups[] = {
  985. //    { PCI_FIXUP_HEADER, 0x4620, 0x11ab, galileo_pcibios_fixup },
  986. {0}
  987. };
  989. void __init pcibios_fixup_bus(struct pci_bus *c)
  990. {
  991. DBG(KERN_INFO "rr: pcibios_fixup_busn");
  992. galileo_pcibios_fixup_bus(c);
  993. }
  995. /*
  996.  * This code was derived from Galileo Technology's example
  997.  * and significantly reworked.
  998.  *
  999.  * This is very simple.  It does not scan multiple function devices.  It does
  1000.  * not scan behind bridges.  Those would be simple to implement, but we don't
  1001.  * currently need this.
  1002.  */
  1003. static void __init scan_and_initialize_pci(void)
  1004. {
  1005. struct pci_device pci_devices[MAX_PCI_DEVS];
  1007. if (scan_pci_bus(pci_devices)) {
  1008. allocate_pci_space(pci_devices);
  1009. }
  1010. }
  1012. /*
  1013.  * This is your basic PCI scan.  It goes through each slot and checks to
  1014.  * see if there's something that responds.  If so, then get the size and
  1015.  * type of each of the responding BARs.  Save them for later.
  1016.  */
  1018. static u32 __init scan_pci_bus(struct pci_device *pci_devices)
  1019. {
  1020. u32 arrayCounter = 0;
  1021. u32 memType;
  1022. u32 memSize;
  1023. u32 pci_slot, bar;
  1024. u32 id;
  1025. u32 c18RegValue;
  1026. struct pci_dev device;
  1028. DBG(KERN_INFO "rr: scan_pci_busn");
  1030. /*
  1031.    According to PCI REV 2.1 MAX agents on the bus are 21.
  1032.    We don't bother scanning ourselves (slot 0).
  1033.  */
  1034. for (pci_slot = 1; pci_slot < 22; pci_slot++) {
  1036. device.devfn = PCI_DEVFN(pci_slot, 0);
  1037. id = pci0ReadConfigReg(PCI_VENDOR_ID, &device);
  1039. /*  Check for a PCI Master Abort (nothing responds in the slot) */
  1040. GT_READ(GT_INTRCAUSE_OFS, &c18RegValue);
  1041. /* Clearing bit 18 of in the Cause Register 0xc18 by writting 0. */
  1042. GT_WRITE(GT_INTRCAUSE_OFS, (c18RegValue & 0xfffbffff));
  1043. if ((id != 0xffffffff) && !(c18RegValue & 0x40000)) {
  1044. DBG(KERN_INFO "rr: found device %x, slot %dn", id,
  1045.     pci_slot);
  1046. pci_devices[arrayCounter].slot = pci_slot;
  1047. for (bar = 0; bar < 6; bar++) {
  1048. memType =
  1049.     pci0ReadConfigReg(PCI_BASE_ADDRESS_0 +
  1050.       (bar * 4), &device);
  1051. pci_devices[arrayCounter].BARtype[bar] =
  1052.     memType & 1;
  1053. pci0WriteConfigReg(PCI_BASE_ADDRESS_0 +
  1054.    (bar * 4), &device,
  1055.    0xffffffff);
  1056. memSize =
  1057.     pci0ReadConfigReg(PCI_BASE_ADDRESS_0 +
  1058.       (bar * 4), &device);
  1059. if (memType & 1) { /*  IO space  */
  1060. pci_devices[arrayCounter].
  1061.     BARsize[bar] =
  1062.     ~(memSize & 0xfffffffc) + 1;
  1063. } else { /*  memory space */
  1064. pci_devices[arrayCounter].
  1065.     BARsize[bar] =
  1066.     ~(memSize & 0xfffffff0) + 1;
  1067. }
  1068. DBG(KERN_INFO
  1069.     "rr: BAR %d, type %d, size %xn", bar,
  1070.     (memType & 1),
  1071.     pci_devices[arrayCounter].
  1072.     BARsize[bar]);
  1073. } /*  BAR counter  */
  1075. arrayCounter++;
  1076. }
  1077. /*  found a device  */
  1078. } /*  slot counter  */
  1080. DBG(KERN_INFO "rr: found %d devicesn", arrayCounter);
  1081. if (arrayCounter < MAX_PCI_DEVS) {
  1082. pci_devices[arrayCounter].slot = -1;
  1083. }
  1084. return (arrayCounter);
  1085. }
  1087. #define ALIGN(val,align)        (((val) + ((align) - 1)) & ~((align) - 1))
  1088. #define MAX(val1, val2) ((val1) > (val2) ? (val1) : (val2))
  1090. /*
  1091.  * This function goes through the list of devices and allocates the BARs in
  1092.  * either IO or MEM space.  It does it in order of size, which will limit the
  1093.  * amount of fragmentation we have in the IO and MEM spaces.
  1094.  */
  1096. static void __init allocate_pci_space(struct pci_device *pci_devices)
  1097. {
  1098. u32 count, maxcount, bar;
  1099. u32 maxSize, maxDevice, maxBAR;
  1100. u32 alignto;
  1101. u32 base;
  1102. u32 pci0_mem_base = pci0GetMemory0Base();
  1103. u32 pci0_io_base = pci0GetIOspaceBase();
  1104. struct pci_dev device;
  1106. DBG(KERN_INFO "rr: allocate_pci_spacen");
  1108. DBG(KERN_INFO "pci0_io_base %xn", pci0_io_base);
  1109. DBG(KERN_INFO "pci0_mem_base %xn", pci0_mem_base);
  1111. /*  How many PCI devices do we have?  */
  1112. maxcount = MAX_PCI_DEVS;
  1113. for (count = 0; count < MAX_PCI_DEVS; count++) {
  1114. if (pci_devices[count].slot == -1) {
  1115. maxcount = count;
  1116. break;
  1117. }
  1118. }
  1120. //    DBG(KERN_INFO "Found %d devicesn", maxcount);
  1122. do {
  1123. /*  Find the largest size BAR we need to allocate  */
  1124. maxSize = 0;
  1125. for (count = 0; count < maxcount; count++) {
  1126. for (bar = 0; bar < 6; bar++) {
  1127. if (pci_devices[count].BARsize[bar] >
  1128.     maxSize) {
  1129. maxSize =
  1130.     pci_devices[count].
  1131.     BARsize[bar];
  1132. maxDevice = count;
  1133. maxBAR = bar;
  1134. }
  1135. }
  1136. }
  1138. /*
  1139.    We've found the largest BAR.  Allocate it into IO or
  1140.    mem space.  We don't idiot check the bases to make
  1141.    sure they haven't overflowed the current size for that aperture.
  1143.    Don't bother to enable the device's IO or MEM space here.  That will
  1144.    be done in pci_enable_resources if the device is activated by a driver.
  1145.  */
  1146. if (maxSize) {
  1147. device.devfn =
  1148.     PCI_DEVFN(pci_devices[maxDevice].slot, 0);
  1149. if (pci_devices[maxDevice].BARtype[maxBAR] == 1) {
  1150. alignto = MAX(0x1000, maxSize);
  1151. base = ALIGN(pci0_io_base, alignto);
  1152. pci0WriteConfigReg(PCI_BASE_ADDRESS_0 +
  1153.    (maxBAR * 4), &device,
  1154.    base | 0x1);
  1155. pci0_io_base = base + alignto;
  1156. DBG(KERN_INFO
  1157.     "Device %d BAR %d address %xn",
  1158.     pci_devices[maxDevice].slot, maxBAR,
  1159.     base);
  1160. DBG(KERN_INFO "New IO base %xn",
  1161.     pci0_io_base);
  1162. } else {
  1163. alignto = MAX(0x1000, maxSize);
  1164. base = ALIGN(pci0_mem_base, alignto);
  1165. pci0WriteConfigReg(PCI_BASE_ADDRESS_0 +
  1166.    (maxBAR * 4), &device,
  1167.    base);
  1168. pci0_mem_base = base + alignto;
  1169. DBG(KERN_INFO
  1170.     "Device %d BAR %d address %xn",
  1171.     pci_devices[maxDevice].slot, maxBAR,
  1172.     base);
  1173. DBG(KERN_INFO "New mem base %xn",
  1174.     pci0_mem_base);
  1175. }
  1176. /*
  1177.    This entry is finished.  Remove it from the list we'll scan.
  1178.  */
  1179. pci_devices[maxDevice].BARsize[maxBAR] = 0;
  1180. }
  1181. } while (maxSize);
  1182. }
  1184. unsigned __init int pcibios_assign_all_busses(void)
  1185. {
  1186. return 1;
  1187. }
  1189. void __init pcibios_init(void)
  1190. {
  1192. u32 tmp;
  1193. struct pci_dev controller;
  1195. controller.devfn = SELF;
  1197. DBG(KERN_INFO "rr: pcibios_initn");
  1198. GT_READ(GT_PCI0_CMD_OFS, &tmp);
  1199. DBG(KERN_INFO "rr: PCI0 command - %xn", tmp);
  1200. GT_READ(GT_PCI0_BARE_OFS, &tmp);
  1201. DBG(KERN_INFO "rr: BAR0 - %xn", tmp);
  1203. /*
  1204.  * You have to enable bus mastering to configure any other
  1205.  * card on the bus.
  1206.  */
  1207. tmp = pci0ReadConfigReg(PCI_COMMAND, &controller);
  1208. DBG(KERN_INFO "rr: command/status - %xn", tmp);
  1209. tmp |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER | PCI_COMMAND_SERR;
  1210. DBG(KERN_INFO "rr: new command/status - %xn", tmp);
  1211. pci0WriteConfigReg(PCI_COMMAND, &controller, tmp);
  1213. /*  This scans the PCI bus and sets up initial values.  */
  1214. scan_and_initialize_pci();
  1216. /*
  1217.  * Reset PCI I/O and PCI MEM values to ones supported by EVM.
  1218.  */
  1219. ioport_resource.start = 0x10000000;
  1220. ioport_resource.end = 0x11ffffff; /*  32 MB */
  1221. iomem_resource.start = 0x12000000;
  1222. iomem_resource.end = 0x13ffffff; /* 32 MB */
  1224. pci_scan_bus(0, &galileo_pci_ops, NULL);
  1226. }
  1228. char *pcibios_setup(char *str)
  1229. {
  1230. printk(KERN_INFO "rr: pcibios_setupn");
  1231. /* Nothing to do for now.  */
  1233. return str;
  1234. }
  1236. #endif /* CONFIG_PCI */