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

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

Linux/Unix编程

开发平台：

Unix_Linux

pci.c：源码内容
  1. /* PCI.c - PCI functions */
  3. /* Copyright - Galileo technology. */
  5. #ifdef __linux__
  6. #include <asm/galileo-boards/evb64120A/core.h>
  7. #include <asm/galileo-boards/evb64120A/pci.h>
  8. #ifndef PROM
  9. #include <linux/kernel.h>
  10. #endif
  12. #undef PCI_DEBUG
  14. #ifdef PCI_DEBUG
  15. #define DBG(x...) printk(x)
  16. #else
  17. #define DBG(x...)
  18. #endif
  20. #else
  21. #include "core.h"
  22. #include "pci.h"
  23. #include <string.h>
  24. #endif
  26. /********************************************************************
  27. * pci0ScanDevices   - This function scan PCI0 bus, if found any device on
  28. *                     this bus it interrogate the Device for the information
  29. *                     it can discover.
  30. *                     The fields with all information are the following:
  31. *    char            type[20];
  32. *    unsigned int    deviceNum;
  33. *    unsigned int    venID;
  34. *    unsigned int    deviceID;
  35. *    unsigned int    bar0Base;
  36. *    unsigned int    bar0Size;
  37. *    unsigned int    bar1Base;
  38. *    unsigned int    bar1Size;
  39. *    unsigned int    bar2Base;
  40. *    unsigned int    bar2Size;
  41. *    unsigned int    bar3Base;
  42. *    unsigned int    bar3Size;
  43. *    unsigned int    bar4Base;
  44. *    unsigned int    bar4Size;
  45. *    unsigned int    bar5Base;
  46. *    unsigned int    bar5Size;
  47. *
  48. * Inputs:   PCI0_DEVICE* pci0Detect - Pointer to an array of STRUCT PCI0_DEVICE.
  49. *           unsigned int numberOfElment - The PCI0_DEVICE Array length.
  50. * Output:   None.
  51. *********************************************************************/
  53. void pci0ScanDevices(PCI_DEVICE * pci0Detect, unsigned int numberOfElment)
  54. {
  55. PCI_DEVICE *pci0ArrayPointer = pci0Detect;
  56. unsigned int id; /* PCI Configuration register 0x0. */
  57. unsigned int device; /* device`s Counter. */
  58. unsigned int classCode; /* PCI Configuration register 0x8 */
  59. unsigned int arrayCounter = 0;
  60. unsigned int memBaseAddress;
  61. unsigned int memSize;
  62. unsigned int c18RegValue;
  64. PCI0_MASTER_ENABLE(SELF);
  65. /* According to PCI REV 2.1 MAX agents on the bus are -21- */
  66. for (device = 6; device < 8; device++) {
  67. id = pci0ReadConfigReg(PCI_0DEVICE_AND_VENDOR_ID, device);
  68. GT_REG_READ(INTERRUPT_CAUSE_REGISTER, &c18RegValue);
  69. /* Clearing bit 18 of in the Cause Register 0xc18 by writting 0. */
  70. GT_REG_WRITE(INTERRUPT_CAUSE_REGISTER,
  71.      c18RegValue & 0xfffbffff);
  72. if ((id != 0xffffffff) && !(c18RegValue & 0x40000)) {
  73. classCode =
  74.     pci0ReadConfigReg
  75.     (PCI_0CLASS_CODE_AND_REVISION_ID, device);
  76. pci0ArrayPointer->deviceNum = device;
  77. pci0ArrayPointer->venID = (id & 0xffff);
  78. pci0ArrayPointer->deviceID =
  79.     ((id & 0xffff0000) >> 16);
  80. DBG("nrr: venID %x devID %xn",
  81.     pci0ArrayPointer->venID,
  82.     pci0ArrayPointer->deviceID);
  83. DBG("rr: device found %xn",
  84.     pci0ArrayPointer->deviceNum);
  85. /* BAR0 parameters */
  86. memBaseAddress = pci0ReadConfigReg(BAR0, device);
  87. pci0ArrayPointer->bar0Type = memBaseAddress & 1;
  88. pci0ArrayPointer->bar0Base =
  89.     memBaseAddress & 0xfffff000;
  90. pci0WriteConfigReg(BAR0, device, 0xffffffff);
  91. memSize = pci0ReadConfigReg(BAR0, device);
  92. if (memSize == 0) { /* case of an empty BAR */
  93. pci0ArrayPointer->bar0Size = 0;
  94. } else {
  95. if (pci0ArrayPointer->bar0Type == 0) /* memory space */
  96. memSize =
  97.     ~(memSize & 0xfffffff0) + 1;
  98. else /* IO space */
  99. memSize =
  100.     ~(memSize & 0xfffffffc) + 1;
  101. pci0ArrayPointer->bar0Size = memSize;
  102. }
  103. DBG("rr: device BAR0 size %xn", memSize);
  104. DBG("rr: device BAR0 address %xn",
  105.     memBaseAddress);
  106. pci0WriteConfigReg(BAR0, device, memBaseAddress);
  107. /* BAR1 parameters */
  108. memBaseAddress = pci0ReadConfigReg(BAR1, device);
  109. pci0ArrayPointer->bar1Type = memBaseAddress & 1;
  110. pci0ArrayPointer->bar1Base =
  111.     memBaseAddress & 0xfffff000;
  112. pci0WriteConfigReg(BAR1, device, 0xffffffff);
  113. memSize = pci0ReadConfigReg(BAR1, device);
  114. if (memSize == 0) { /* case of an empty BAR */
  115. pci0ArrayPointer->bar1Size = 0;
  116. } else {
  117. if (pci0ArrayPointer->bar1Type == 0) /* memory space */
  118. memSize =
  119.     ~(memSize & 0xfffffff0) + 1;
  120. else /* IO space */
  121. memSize =
  122.     ~(memSize & 0xfffffffc) + 1;
  123. pci0ArrayPointer->bar1Size = memSize;
  124. }
  125. DBG("rr: device BAR1 size %xn", memSize);
  126. DBG("rr: device BAR1 address %xn",
  127.     memBaseAddress);
  128. pci0WriteConfigReg(BAR1, device, memBaseAddress);
  129. /* BAR2 parameters */
  130. memBaseAddress = pci0ReadConfigReg(BAR2, device);
  131. pci0ArrayPointer->bar2Type = memBaseAddress & 1;
  132. pci0ArrayPointer->bar2Base =
  133.     memBaseAddress & 0xfffff000;
  134. pci0WriteConfigReg(BAR2, device, 0xffffffff);
  135. memSize = pci0ReadConfigReg(BAR2, device);
  136. if (memSize == 0) { /* case of an empty BAR */
  137. pci0ArrayPointer->bar2Size = 0;
  138. } else {
  139. if (pci0ArrayPointer->bar2Type == 0) /* memory space */
  140. memSize =
  141.     ~(memSize & 0xfffffff0) + 1;
  142. else /* IO space */
  143. memSize =
  144.     ~(memSize & 0xfffffffc) + 1;
  145. pci0ArrayPointer->bar2Size = memSize;
  146. }
  147. DBG("rr: device BAR2 size %xn", memSize);
  148. DBG("rr: device BAR2 address %xn",
  149.     memBaseAddress);
  150. pci0WriteConfigReg(BAR2, device, memBaseAddress);
  151. /* BAR3 parameters */
  152. memBaseAddress = pci0ReadConfigReg(BAR3, device);
  153. pci0ArrayPointer->bar3Type = memBaseAddress & 1;
  154. pci0ArrayPointer->bar3Base =
  155.     memBaseAddress & 0xfffff000;
  156. pci0WriteConfigReg(BAR3, device, 0xffffffff);
  157. memSize = pci0ReadConfigReg(BAR3, device);
  158. if (memSize == 0) { /* case of an empty BAR */
  159. pci0ArrayPointer->bar3Size = 0;
  160. } else {
  161. if (pci0ArrayPointer->bar3Type == 0) /* memory space */
  162. memSize =
  163.     ~(memSize & 0xfffffff0) + 1;
  164. else /* IO space */
  165. memSize =
  166.     ~(memSize & 0xfffffffc) + 1;
  167. pci0ArrayPointer->bar3Size = memSize;
  168. }
  169. DBG("rr: device BAR3 size %xn", memSize);
  170. DBG("rr: device BAR3 address %xn",
  171.     memBaseAddress);
  172. pci0WriteConfigReg(BAR3, device, memBaseAddress);
  173. /* BAR4 parameters */
  174. memBaseAddress = pci0ReadConfigReg(BAR4, device);
  175. pci0ArrayPointer->bar4Type = memBaseAddress & 1;
  176. pci0ArrayPointer->bar4Base =
  177.     memBaseAddress & 0xfffff000;
  178. pci0WriteConfigReg(BAR4, device, 0xffffffff);
  179. memSize = pci0ReadConfigReg(BAR4, device);
  180. if (memSize == 0) { /* case of an empty BAR */
  181. pci0ArrayPointer->bar4Size = 0;
  182. } else {
  183. if (pci0ArrayPointer->bar4Type == 0) /* memory space */
  184. memSize =
  185.     ~(memSize & 0xfffffff0) + 1;
  186. else /* IO space */
  187. memSize =
  188.     ~(memSize & 0xfffffffc) + 1;
  189. pci0ArrayPointer->bar4Size = memSize;
  190. }
  191. DBG("rr: device BAR4 size %xn", memSize);
  192. DBG("rr: device BAR4 address %xn",
  193.     memBaseAddress);
  194. pci0WriteConfigReg(BAR4, device, memBaseAddress);
  195. /* BAR5 parameters */
  196. memBaseAddress = pci0ReadConfigReg(BAR5, device);
  197. pci0ArrayPointer->bar5Type = memBaseAddress & 1;
  198. pci0ArrayPointer->bar5Base =
  199.     memBaseAddress & 0xfffff000;
  200. pci0WriteConfigReg(BAR5, device, 0xffffffff);
  201. memSize = pci0ReadConfigReg(BAR5, device);
  202. if (memSize == 0) { /* case of an empty BAR */
  203. pci0ArrayPointer->bar5Size = 0;
  204. } else {
  205. if (pci0ArrayPointer->bar5Type == 1) /* memory space */
  206. memSize =
  207.     ~(memSize & 0xfffffff0) + 1;
  208. else /* IO space */
  209. memSize =
  210.     ~(memSize & 0xfffffffc) + 1;
  211. pci0ArrayPointer->bar5Size = memSize;
  212. }
  213. DBG("rr: device BAR5 size %xn", memSize);
  214. DBG("rr: device BAR5 address %xn",
  215.     memBaseAddress);
  216. pci0WriteConfigReg(BAR5, device, memBaseAddress);
  217. /* End of BARs Detection. */
  219. classCode = ((classCode & 0xff000000) >> 24);
  220. switch (classCode) {
  221. case 0x0:
  222. strcpy(pci0ArrayPointer->type,
  223.        "Old generation device");
  224. break;
  225. case 0x1:
  226. strcpy(pci0ArrayPointer->type,
  227.        "Mass storage controller");
  228. break;
  229. case 0x2:
  230. strcpy(pci0ArrayPointer->type,
  231.        "Network controller");
  232. break;
  233. case 0x3:
  234. strcpy(pci0ArrayPointer->type,
  235.        "Display controller");
  236. break;
  237. case 0x4:
  238. strcpy(pci0ArrayPointer->type,
  239.        "Multimedia device");
  240. break;
  241. case 0x5:
  242. strcpy(pci0ArrayPointer->type,
  243.        "Memory controller");
  244. break;
  245. case 0x6:
  246. strcpy(pci0ArrayPointer->type,
  247.        "Bridge Device");
  248. break;
  249. case 0x7:
  250. strcpy(pci0ArrayPointer->type,
  251.        "Simple Communication controllers");
  252. break;
  253. case 0x8:
  254. strcpy(pci0ArrayPointer->type,
  255.        "Base system peripherals");
  256. break;
  257. case 0x9:
  258. strcpy(pci0ArrayPointer->type,
  259.        "Input Devices");
  260. break;
  261. case 0xa:
  262. strcpy(pci0ArrayPointer->type,
  263.        "Docking stations");
  264. break;
  265. case 0xb:
  266. strcpy(pci0ArrayPointer->type,
  267.        "Processors");
  268. break;
  269. case 0xc:
  270. strcpy(pci0ArrayPointer->type,
  271.        "Serial bus controllers");
  272. break;
  273. case 0xd:
  274. strcpy(pci0ArrayPointer->type,
  275.        "Wireless controllers");
  276. break;
  277. case 0xe:
  278. strcpy(pci0ArrayPointer->type,
  279.        "Intelligent I/O controllers");
  280. break;
  281. case 0xf:
  282. strcpy(pci0ArrayPointer->type,
  283.        "Satellite communication controllers");
  284. break;
  285. case 0x10:
  286. strcpy(pci0ArrayPointer->type,
  287.        "Encryption/Decryption controllers");
  288. break;
  289. case 0x11:
  290. strcpy(pci0ArrayPointer->type,
  291.        "Data acquisition and signal processing controllers");
  292. break;
  293. default:
  294. break;
  296. }
  297. arrayCounter++; /* point to the next element in the Array. */
  298. if (arrayCounter == numberOfElment)
  299. return; /* When the Array is fully used, return. */
  300. /* Else, points to next free Element. */
  301. pci0ArrayPointer = &pci0Detect[arrayCounter];
  302. }
  303. }
  304. pci0ArrayPointer->deviceNum = 0; /* 0 => End of List */
  305. }
  308. /********************************************************************
  309. * pci1ScanDevices   - This function scan PCI1 bus, if found any device on
  310. *                     this bus it interrogate the Device for the information
  311. *                     it can discover.
  312. *                     The fields with all information are the following:
  313. *    char            type[20];
  314. *    unsigned int    deviceNum;
  315. *    unsigned int    venID;
  316. *    unsigned int    deviceID;
  317. *    unsigned int    bar0Base;
  318. *    unsigned int    bar0Size;
  319. *    unsigned int    bar1Base;
  320. *    unsigned int    bar1Size;
  321. *    unsigned int    bar2Base;
  322. *    unsigned int    bar2Size;
  323. *    unsigned int    bar3Base;
  324. *    unsigned int    bar3Size;
  325. *    unsigned int    bar4Base;
  326. *    unsigned int    bar4Size;
  327. *    unsigned int    bar5Base;
  328. *    unsigned int    bar5Size;
  329. *
  330. * Inputs:   Pointer to an array of STRUCT PCI1_DEVICE.
  331. * Output:   None.
  332. *********************************************************************/
  334. void pci1ScanDevices(PCI_DEVICE * pci1Detect, unsigned int numberOfElment)
  335. {
  336. PCI_DEVICE *pci1ArrayPointer = pci1Detect;
  337. unsigned int id; /* PCI Configuration register 0x0. */
  338. unsigned int device; /* device`s Counter. */
  339. unsigned int classCode; /* PCI Configuration register 0x8 */
  340. unsigned int arrayCounter = 0;
  341. unsigned int memBaseAddress;
  342. unsigned int memSize;
  343. unsigned int c98RegValue;
  345. PCI1_MASTER_ENABLE(SELF);
  346. /* According to PCI REV 2.1 MAX agents on the bus are -21- */
  347. for (device = 1; device < 22; device++) {
  348. id = pci1ReadConfigReg(PCI_0DEVICE_AND_VENDOR_ID, device);
  349. GT_REG_READ(HIGH_INTERRUPT_CAUSE_REGISTER, &c98RegValue);
  350. /* Clearing bit 18 of in the High Cause Register 0xc98 */
  351. GT_REG_WRITE(HIGH_INTERRUPT_CAUSE_REGISTER,
  352.      c98RegValue & 0xfffbffff);
  353. if ((id != 0xffffffff) && !(c98RegValue & 0x40000)) {
  354. classCode =
  355.     pci1ReadConfigReg
  356.     (PCI_0CLASS_CODE_AND_REVISION_ID, device);
  357. pci1ArrayPointer->deviceNum = device;
  358. pci1ArrayPointer->venID = (id & 0xffff);
  359. pci1ArrayPointer->deviceID =
  360.     ((id & 0xffff0000) >> 16);
  362. /* BAR0 parameters */
  363. memBaseAddress = pci1ReadConfigReg(BAR0, device);
  364. pci1ArrayPointer->bar0Type = memBaseAddress & 1;
  365. pci1ArrayPointer->bar0Base =
  366.     memBaseAddress & 0xfffff000;
  367. pci1WriteConfigReg(BAR0, device, 0xffffffff);
  368. memSize = pci1ReadConfigReg(BAR0, device);
  369. if (memSize == 0) { /* case of an empty BAR */
  370. pci1ArrayPointer->bar0Size = 0;
  371. } else {
  372. if (pci1ArrayPointer->bar0Type == 0) /* memory space */
  373. memSize =
  374.     ~(memSize & 0xfffffff0) + 1;
  375. else /* IO space */
  376. memSize =
  377.     ~(memSize & 0xfffffffc) + 1;
  378. pci1ArrayPointer->bar0Size = memSize;
  379. }
  380. pci1WriteConfigReg(BAR0, device, memBaseAddress);
  381. /* BAR1 parameters */
  382. memBaseAddress = pci1ReadConfigReg(BAR1, device);
  383. pci1ArrayPointer->bar1Type = memBaseAddress & 1;
  384. pci1ArrayPointer->bar1Base =
  385.     memBaseAddress & 0xfffff000;
  386. pci1WriteConfigReg(BAR1, device, 0xffffffff);
  387. memSize = pci1ReadConfigReg(BAR1, device);
  388. if (memSize == 0) { /* case of an empty BAR */
  389. pci1ArrayPointer->bar1Size = 0;
  390. } else {
  391. if (pci1ArrayPointer->bar1Type == 0) /* memory space */
  392. memSize =
  393.     ~(memSize & 0xfffffff0) + 1;
  394. else /* IO space */
  395. memSize =
  396.     ~(memSize & 0xfffffffc) + 1;
  397. pci1ArrayPointer->bar1Size = memSize;
  398. }
  399. pci1WriteConfigReg(BAR1, device, memBaseAddress);
  400. /* BAR2 parameters */
  401. memBaseAddress = pci1ReadConfigReg(BAR2, device);
  402. pci1ArrayPointer->bar2Type = memBaseAddress & 1;
  403. pci1ArrayPointer->bar2Base =
  404.     memBaseAddress & 0xfffff000;
  405. pci1WriteConfigReg(BAR2, device, 0xffffffff);
  406. memSize = pci1ReadConfigReg(BAR2, device);
  407. if (memSize == 0) { /* case of an empty BAR */
  408. pci1ArrayPointer->bar2Size = 0;
  409. } else {
  410. if (pci1ArrayPointer->bar2Type == 0) /* memory space */
  411. memSize =
  412.     ~(memSize & 0xfffffff0) + 1;
  413. else /* IO space */
  414. memSize =
  415.     ~(memSize & 0xfffffffc) + 1;
  416. pci1ArrayPointer->bar2Size = memSize;
  417. }
  418. pci1WriteConfigReg(BAR2, device, memBaseAddress);
  419. /* BAR3 parameters */
  420. memBaseAddress = pci1ReadConfigReg(BAR3, device);
  421. pci1ArrayPointer->bar3Type = memBaseAddress & 1;
  422. pci1ArrayPointer->bar3Base =
  423.     memBaseAddress & 0xfffff000;
  424. pci1WriteConfigReg(BAR3, device, 0xffffffff);
  425. memSize = pci1ReadConfigReg(BAR3, device);
  426. if (memSize == 0) { /* case of an empty BAR */
  427. pci1ArrayPointer->bar3Size = 0;
  428. } else {
  429. if (pci1ArrayPointer->bar3Type == 0) /* memory space */
  430. memSize =
  431.     ~(memSize & 0xfffffff0) + 1;
  432. else /* IO space */
  433. memSize =
  434.     ~(memSize & 0xfffffffc) + 1;
  435. pci1ArrayPointer->bar3Size = memSize;
  436. }
  437. pci1WriteConfigReg(BAR3, device, memBaseAddress);
  438. /* BAR4 parameters */
  439. memBaseAddress = pci1ReadConfigReg(BAR4, device);
  440. pci1ArrayPointer->bar4Type = memBaseAddress & 1;
  441. pci1ArrayPointer->bar4Base =
  442.     memBaseAddress & 0xfffff000;
  443. pci1WriteConfigReg(BAR4, device, 0xffffffff);
  444. memSize = pci1ReadConfigReg(BAR4, device);
  445. if (memSize == 0) { /* case of an empty BAR */
  446. pci1ArrayPointer->bar4Size = 0;
  447. } else {
  448. if (pci1ArrayPointer->bar4Type == 0) /* memory space */
  449. memSize =
  450.     ~(memSize & 0xfffffff0) + 1;
  451. else /* IO space */
  452. memSize =
  453.     ~(memSize & 0xfffffffc) + 1;
  454. pci1ArrayPointer->bar4Size = memSize;
  455. }
  456. pci1WriteConfigReg(BAR4, device, memBaseAddress);
  457. /* BAR5 parameters */
  458. memBaseAddress = pci1ReadConfigReg(BAR5, device);
  459. pci1ArrayPointer->bar5Type = memBaseAddress & 1;
  460. pci1ArrayPointer->bar5Base =
  461.     memBaseAddress & 0xfffff000;
  462. pci1WriteConfigReg(BAR5, device, 0xffffffff);
  463. memSize = pci1ReadConfigReg(BAR5, device);
  464. if (memSize == 0) { /* case of an empty BAR */
  465. pci1ArrayPointer->bar5Size = 0;
  466. } else {
  467. if (pci1ArrayPointer->bar5Type == 0) /* memory space */
  468. memSize =
  469.     ~(memSize & 0xfffffff0) + 1;
  470. else /* IO space */
  471. memSize =
  472.     ~(memSize & 0xfffffffc) + 1;
  473. pci1ArrayPointer->bar5Size = memSize;
  474. }
  475. pci1WriteConfigReg(BAR5, device, memBaseAddress);
  476. /* End of BARs Detection. */
  478. classCode = ((classCode & 0xff000000) >> 24);
  479. switch (classCode) {
  480. case 0x0:
  481. strcpy(pci1ArrayPointer->type,
  482.        "Old generation device");
  483. break;
  484. case 0x1:
  485. strcpy(pci1ArrayPointer->type,
  486.        "Mass storage controller");
  487. break;
  488. case 0x2:
  489. strcpy(pci1ArrayPointer->type,
  490.        "Network controller");
  491. break;
  492. case 0x3:
  493. strcpy(pci1ArrayPointer->type,
  494.        "Display controller");
  495. break;
  496. case 0x4:
  497. strcpy(pci1ArrayPointer->type,
  498.        "Multimedia device");
  499. break;
  500. case 0x5:
  501. strcpy(pci1ArrayPointer->type,
  502.        "Memory controller");
  503. break;
  504. case 0x6:
  505. strcpy(pci1ArrayPointer->type,
  506.        "Bridge Device");
  507. break;
  508. case 0x7:
  509. strcpy(pci1ArrayPointer->type,
  510.        "Simple Communication controllers");
  511. break;
  512. case 0x8:
  513. strcpy(pci1ArrayPointer->type,
  514.        "Base system peripherals");
  515. break;
  516. case 0x9:
  517. strcpy(pci1ArrayPointer->type,
  518.        "Input Devices");
  519. break;
  520. case 0xa:
  521. strcpy(pci1ArrayPointer->type,
  522.        "Docking stations");
  523. break;
  524. case 0xb:
  525. strcpy(pci1ArrayPointer->type,
  526.        "Processors");
  527. break;
  528. case 0xc:
  529. strcpy(pci1ArrayPointer->type,
  530.        "Serial bus controllers");
  531. break;
  532. case 0xd:
  533. strcpy(pci1ArrayPointer->type,
  534.        "Wireless controllers");
  535. break;
  536. case 0xe:
  537. strcpy(pci1ArrayPointer->type,
  538.        "Intelligent I/O controllers");
  539. break;
  540. case 0xf:
  541. strcpy(pci1ArrayPointer->type,
  542.        "Satellite communication controllers");
  543. break;
  544. case 0x10:
  545. strcpy(pci1ArrayPointer->type,
  546.        "Encryption/Decryption controllers");
  547. break;
  548. case 0x11:
  549. strcpy(pci1ArrayPointer->type,
  550.        "Data acquisition and signal processing controllers");
  551. break;
  552. }
  553. arrayCounter++; /* point to the next element in the Array. */
  554. if (arrayCounter == numberOfElment)
  555. return; /* When the Array is fully used, return. */
  556. /* Else, points to next free Element. */
  557. pci1ArrayPointer = &pci1Detect[arrayCounter];
  558. }
  559. }
  560. pci1ArrayPointer->deviceNum = 0; /* 0 => End of List */
  561. }
  563. /********************************************************************
  564. * pci0WriteConfigReg - Write to a PCI configuration register
  565. *                    - Make sure the GT is configured as a master before
  566. *                      writingto another device on the PCI.
  567. *                    - The function takes care of Big/Little endian conversion.
  568. * Inputs:   unsigned int regOffset: The register offset as it apears in the GT spec
  569. *                   (or any other PCI device spec)
  570. *           pciDevNum: The device number needs to be addressed.
  571. *
  572. *  Configuration Address 0xCF8:
  573. *
  574. *       31 30    24 23  16 15  11 10     8 7      2  0     <=bit Number
  575. *  |congif|Reserved|  Bus |Device|Function|Register|00|
  576. *  |Enable|        |Number|Number| Number | Number |  |    <=field Name
  577. *
  578. *********************************************************************/
  580. void pci0WriteConfigReg(unsigned int regOffset, unsigned int pciDevNum,
  581. unsigned int data)
  582. {
  583. unsigned int DataForRegCf8;
  584. unsigned int functionNum;
  586. functionNum = regOffset & 0x00000700;
  587. pciDevNum = pciDevNum << 11;
  588. regOffset = regOffset & 0x0fffffff;
  589. DataForRegCf8 = (regOffset | pciDevNum | functionNum) | BIT31;
  590. GT_REG_WRITE(PCI_0CONFIGURATION_ADDRESS, DataForRegCf8);
  591. if (pciDevNum == SELF) { /* This board */
  592. GT_REG_WRITE(PCI_0CONFIGURATION_DATA_VIRTUAL_REGISTER,
  593.      data);
  594. } else { /* configuration Transaction over the pci. */
  596. /* The PCI is working in LE Mode So it swap the Data. */
  597. GT_REG_WRITE(PCI_0CONFIGURATION_DATA_VIRTUAL_REGISTER,
  598.      WORDSWAP(data));
  599. }
  600. }
  602. /********************************************************************
  603. * pci1WriteConfigReg - Write to a PCI configuration register
  604. *                   - Make sure the GT is configured as a master before writing
  605. *                     to another device on the PCI.
  606. *                   - The function takes care of Big/Little endian conversion.
  607. * Inputs:   unsigned int regOffset: The register offset as it apears in the
  608. *           GT spec (or any other PCI device spec)
  609. *           pciDevNum: The device number needs to be addressed.
  610. *
  611. *  Configuration Address 0xCF8:
  612. *
  613. *       31 30    24 23  16 15  11 10     8 7      2  0     <=bit Number
  614. *  |congif|Reserved|  Bus |Device|Function|Register|00|
  615. *  |Enable|        |Number|Number| Number | Number |  |    <=field Name
  616. *
  617. *********************************************************************/
  619. void pci1WriteConfigReg(unsigned int regOffset, unsigned int pciDevNum,
  620. unsigned int data)
  621. {
  622. unsigned int DataForRegCf8;
  623. unsigned int functionNum;
  625. functionNum = regOffset & 0x00000700;
  626. pciDevNum = pciDevNum << 11;
  627. regOffset = regOffset & 0x0fffffff;
  628. if (pciDevNum == SELF) { /* This board */
  629. /* when configurating our own PCI 1 L-unit the access is through
  630.    the PCI 0 interface with reg number = reg number + 0x80 */
  631. DataForRegCf8 =
  632.     (regOffset | pciDevNum | functionNum | 0x80) | BIT31;
  633. GT_REG_WRITE(PCI_0CONFIGURATION_ADDRESS, DataForRegCf8);
  634. } else {
  635. DataForRegCf8 =
  636.     (regOffset | pciDevNum | functionNum) | BIT31;
  637. GT_REG_WRITE(PCI_1CONFIGURATION_ADDRESS, DataForRegCf8);
  638. }
  639. if (pciDevNum == SELF) { /* This board */
  640. GT_REG_WRITE(PCI_0CONFIGURATION_DATA_VIRTUAL_REGISTER,
  641.      data);
  642. } else {
  643. GT_REG_WRITE(PCI_1CONFIGURATION_DATA_VIRTUAL_REGISTER,
  644.      WORDSWAP(data));
  645. }
  646. }
  648. /********************************************************************
  649. * pci0ReadConfigReg  - Read from a PCI0 configuration register
  650. *                    - Make sure the GT is configured as a master before
  651. *                      reading from another device on the PCI.
  652. *                   - The function takes care of Big/Little endian conversion.
  653. * INPUTS:   regOffset: The register offset as it apears in the GT spec (or PCI
  654. *                        spec)
  655. *           pciDevNum: The device number needs to be addressed.
  656. * RETURNS: data , if the data == 0xffffffff check the master abort bit in the
  657. *                 cause register to make sure the data is valid
  658. *
  659. *  Configuration Address 0xCF8:
  660. *
  661. *       31 30    24 23  16 15  11 10     8 7      2  0     <=bit Number
  662. *  |congif|Reserved|  Bus |Device|Function|Register|00|
  663. *  |Enable|        |Number|Number| Number | Number |  |    <=field Name
  664. *
  665. *********************************************************************/
  667. unsigned int pci0ReadConfigReg(unsigned int regOffset,
  668.        unsigned int pciDevNum)
  669. {
  670. unsigned int DataForRegCf8;
  671. unsigned int data;
  672. unsigned int functionNum;
  674. functionNum = regOffset & 0x00000700;
  675. pciDevNum = pciDevNum << 11;
  676. regOffset = regOffset & 0x0fffffff;
  677. DataForRegCf8 = (regOffset | pciDevNum | functionNum) | BIT31;
  678. GT_REG_WRITE(PCI_0CONFIGURATION_ADDRESS, DataForRegCf8);
  679. if (pciDevNum == SELF) { /* This board */
  680. GT_REG_READ(PCI_0CONFIGURATION_DATA_VIRTUAL_REGISTER,
  681.     &data);
  682. return data;
  683. } else { /* The PCI is working in LE Mode So it swap the Data. */
  685. GT_REG_READ(PCI_0CONFIGURATION_DATA_VIRTUAL_REGISTER,
  686.     &data);
  687. return WORDSWAP(data);
  688. }
  689. }
  691. /********************************************************************
  692. * pci1ReadConfigReg  - Read from a PCI1 configuration register
  693. *                    - Make sure the GT is configured as a master before
  694. *                      reading from another device on the PCI.
  695. *                   - The function takes care of Big/Little endian conversion.
  696. * INPUTS:   regOffset: The register offset as it apears in the GT spec (or PCI
  697. *                        spec)
  698. *           pciDevNum: The device number needs to be addressed.
  699. * RETURNS: data , if the data == 0xffffffff check the master abort bit in the
  700. *                 cause register to make sure the data is valid
  701. *
  702. *  Configuration Address 0xCF8:
  703. *
  704. *       31 30    24 23  16 15  11 10     8 7      2  0     <=bit Number
  705. *  |congif|Reserved|  Bus |Device|Function|Register|00|
  706. *  |Enable|        |Number|Number| Number | Number |  |    <=field Name
  707. *
  708. *********************************************************************/
  710. unsigned int pci1ReadConfigReg(unsigned int regOffset,
  711.        unsigned int pciDevNum)
  712. {
  713. unsigned int DataForRegCf8;
  714. unsigned int data;
  715. unsigned int functionNum;
  717. functionNum = regOffset & 0x00000700;
  718. pciDevNum = pciDevNum << 11;
  719. regOffset = regOffset & 0x0fffffff;
  720. if (pciDevNum == SELF) { /* This board */
  721. /* when configurating our own PCI 1 L-unit the access is through
  722.    the PCI 0 interface with reg number = reg number + 0x80 */
  723. DataForRegCf8 =
  724.     (regOffset | pciDevNum | functionNum | 0x80) | BIT31;
  725. GT_REG_WRITE(PCI_0CONFIGURATION_ADDRESS, DataForRegCf8);
  726. } else {
  727. DataForRegCf8 =
  728.     (regOffset | pciDevNum | functionNum) | BIT31;
  729. GT_REG_WRITE(PCI_1CONFIGURATION_ADDRESS, DataForRegCf8);
  730. }
  731. if (pciDevNum == SELF) { /* This board */
  732. GT_REG_READ(PCI_0CONFIGURATION_DATA_VIRTUAL_REGISTER,
  733.     &data);
  734. return data;
  735. } else {
  736. GT_REG_READ(PCI_1CONFIGURATION_DATA_VIRTUAL_REGISTER,
  737.     &data);
  738. return WORDSWAP(data);
  739. }
  740. }
  742. /********************************************************************
  743. * pci0MapIOspace - Maps PCI0 IO space for the master.
  744. * Inputs: base and length of pci0Io
  745. *********************************************************************/
  747. void pci0MapIOspace(unsigned int pci0IoBase, unsigned int pci0IoLength)
  748. {
  749. unsigned int pci0IoTop =
  750.     (unsigned int) (pci0IoBase + pci0IoLength);
  752. if (pci0IoLength == 0)
  753. pci0IoTop++;
  755. pci0IoBase = (unsigned int) (pci0IoBase >> 21);
  756. pci0IoTop = (unsigned int) (((pci0IoTop - 1) & 0x0fffffff) >> 21);
  757. GT_REG_WRITE(PCI_0I_O_LOW_DECODE_ADDRESS, pci0IoBase);
  758. GT_REG_WRITE(PCI_0I_O_HIGH_DECODE_ADDRESS, pci0IoTop);
  759. }
  761. /********************************************************************
  762. * pci1MapIOspace - Maps PCI1 IO space for the master.
  763. * Inputs: base and length of pci1Io
  764. *********************************************************************/
  766. void pci1MapIOspace(unsigned int pci1IoBase, unsigned int pci1IoLength)
  767. {
  768. unsigned int pci1IoTop =
  769.     (unsigned int) (pci1IoBase + pci1IoLength);
  771. if (pci1IoLength == 0)
  772. pci1IoTop++;
  774. pci1IoBase = (unsigned int) (pci1IoBase >> 21);
  775. pci1IoTop = (unsigned int) (((pci1IoTop - 1) & 0x0fffffff) >> 21);
  776. GT_REG_WRITE(PCI_1I_O_LOW_DECODE_ADDRESS, pci1IoBase);
  777. GT_REG_WRITE(PCI_1I_O_HIGH_DECODE_ADDRESS, pci1IoTop);
  778. }
  780. /********************************************************************
  781. * pci0MapMemory0space - Maps PCI0 memory0 space for the master.
  782. * Inputs: base and length of pci0Mem0
  783. *********************************************************************/
  786. void pci0MapMemory0space(unsigned int pci0Mem0Base,
  787.  unsigned int pci0Mem0Length)
  788. {
  789. unsigned int pci0Mem0Top = pci0Mem0Base + pci0Mem0Length;
  791. if (pci0Mem0Length == 0)
  792. pci0Mem0Top++;
  794. pci0Mem0Base = pci0Mem0Base >> 21;
  795. pci0Mem0Top = ((pci0Mem0Top - 1) & 0x0fffffff) >> 21;
  796. GT_REG_WRITE(PCI_0MEMORY0_LOW_DECODE_ADDRESS, pci0Mem0Base);
  797. GT_REG_WRITE(PCI_0MEMORY0_HIGH_DECODE_ADDRESS, pci0Mem0Top);
  798. }
  800. /********************************************************************
  801. * pci1MapMemory0space - Maps PCI1 memory0 space for the master.
  802. * Inputs: base and length of pci1Mem0
  803. *********************************************************************/
  805. void pci1MapMemory0space(unsigned int pci1Mem0Base,
  806.  unsigned int pci1Mem0Length)
  807. {
  808. unsigned int pci1Mem0Top = pci1Mem0Base + pci1Mem0Length;
  810. if (pci1Mem0Length == 0)
  811. pci1Mem0Top++;
  813. pci1Mem0Base = pci1Mem0Base >> 21;
  814. pci1Mem0Top = ((pci1Mem0Top - 1) & 0x0fffffff) >> 21;
  815. GT_REG_WRITE(PCI_1MEMORY0_LOW_DECODE_ADDRESS, pci1Mem0Base);
  816. GT_REG_WRITE(PCI_1MEMORY0_HIGH_DECODE_ADDRESS, pci1Mem0Top);
  817. }
  819. /********************************************************************
  820. * pci0MapMemory1space - Maps PCI0 memory1 space for the master.
  821. * Inputs: base and length of pci0Mem1
  822. *********************************************************************/
  824. void pci0MapMemory1space(unsigned int pci0Mem1Base,
  825.  unsigned int pci0Mem1Length)
  826. {
  827. unsigned int pci0Mem1Top = pci0Mem1Base + pci0Mem1Length;
  829. if (pci0Mem1Length == 0)
  830. pci0Mem1Top++;
  832. pci0Mem1Base = pci0Mem1Base >> 21;
  833. pci0Mem1Top = ((pci0Mem1Top - 1) & 0x0fffffff) >> 21;
  834. GT_REG_WRITE(PCI_0MEMORY1_LOW_DECODE_ADDRESS, pci0Mem1Base);
  835. GT_REG_WRITE(PCI_0MEMORY1_HIGH_DECODE_ADDRESS, pci0Mem1Top);
  836. #ifndef PROM
  837. DBG(KERN_INFO "pci0Mem1Base %xn", pci0Mem1Base);
  838. DBG(KERN_INFO "pci0Mem1Top %xn", pci0Mem1Top);
  839. GT_REG_READ(PCI_0MEMORY0_ADDRESS_REMAP, &pci0Mem1Base);
  840. DBG(KERN_INFO "Mem 0/0 remap %xn", pci0Mem1Base);
  841. GT_REG_READ(PCI_0MEMORY1_ADDRESS_REMAP, &pci0Mem1Base);
  842. DBG(KERN_INFO "Mem 0/1 remap %xn", pci0Mem1Base);
  843. GT_REG_WRITE(PCI_0MEMORY1_ADDRESS_REMAP, 0x500);
  844. GT_REG_READ(PCI_0MEMORY1_ADDRESS_REMAP, &pci0Mem1Base);
  845. DBG(KERN_INFO "Mem 0/1 remapped %xn", pci0Mem1Base);
  846. #endif
  847. }
  849. /********************************************************************
  850. * pci1MapMemory1space - Maps PCI1 memory1 space for the master.
  851. * Inputs: base and length of pci1Mem1
  852. *********************************************************************/
  854. void pci1MapMemory1space(unsigned int pci1Mem1Base,
  855.  unsigned int pci1Mem1Length)
  856. {
  857. unsigned int pci1Mem1Top = pci1Mem1Base + pci1Mem1Length;
  859. if (pci1Mem1Length == 0)
  860. pci1Mem1Top++;
  862. pci1Mem1Base = pci1Mem1Base >> 21;
  863. pci1Mem1Top = ((pci1Mem1Top - 1) & 0x0fffffff) >> 21;
  864. GT_REG_WRITE(PCI_1MEMORY1_LOW_DECODE_ADDRESS, pci1Mem1Base);
  865. GT_REG_WRITE(PCI_1MEMORY1_HIGH_DECODE_ADDRESS, pci1Mem1Top);
  866. }
  868. /********************************************************************
  869. * pci0GetIOspaceBase - Return PCI0 IO Base Address.
  870. * Inputs: N/A
  871. * Returns: PCI0 IO Base Address.
  872. *********************************************************************/
  874. unsigned int pci0GetIOspaceBase()
  875. {
  876. unsigned int base;
  877. GT_REG_READ(PCI_0I_O_LOW_DECODE_ADDRESS, &base);
  878. base = base << 21;
  879. return base;
  880. }
  882. /********************************************************************
  883. * pci0GetIOspaceSize - Return PCI0 IO Bar Size.
  884. * Inputs: N/A
  885. * Returns: PCI0 IO Bar Size.
  886. *********************************************************************/
  888. unsigned int pci0GetIOspaceSize()
  889. {
  890. unsigned int top, base, size;
  891. GT_REG_READ(PCI_0I_O_LOW_DECODE_ADDRESS, &base);
  892. base = base << 21;
  893. GT_REG_READ(PCI_0I_O_HIGH_DECODE_ADDRESS, &top);
  894. top = (top << 21);
  895. size = ((top - base) & 0xfffffff);
  896. size = size | 0x1fffff;
  897. return (size + 1);
  898. }
  900. /********************************************************************
  901. * pci0GetMemory0Base - Return PCI0 Memory 0 Base Address.
  902. * Inputs: N/A
  903. * Returns: PCI0 Memory 0 Base Address.
  904. *********************************************************************/
  906. unsigned int pci0GetMemory0Base()
  907. {
  908. unsigned int base;
  909. GT_REG_READ(PCI_0MEMORY0_LOW_DECODE_ADDRESS, &base);
  910. base = base << 21;
  911. return base;
  912. }
  914. /********************************************************************
  915. * pci0GetMemory0Size - Return PCI0 Memory 0 Bar Size.
  916. * Inputs: N/A
  917. * Returns: PCI0 Memory 0 Bar Size.
  918. *********************************************************************/
  920. unsigned int pci0GetMemory0Size()
  921. {
  922. unsigned int top, base, size;
  923. GT_REG_READ(PCI_0MEMORY0_LOW_DECODE_ADDRESS, &base);
  924. base = base << 21;
  925. GT_REG_READ(PCI_0MEMORY0_HIGH_DECODE_ADDRESS, &top);
  926. top = (top << 21);
  927. size = ((top - base) & 0xfffffff);
  928. size = size | 0x1fffff;
  929. return (size + 1);
  930. }
  932. /********************************************************************
  933. * pci0GetMemory1Base - Return PCI0 Memory 1 Base Address.
  934. * Inputs: N/A
  935. * Returns: PCI0 Memory 1 Base Address.
  936. *********************************************************************/
  938. unsigned int pci0GetMemory1Base()
  939. {
  940. unsigned int base;
  941. GT_REG_READ(PCI_0MEMORY1_LOW_DECODE_ADDRESS, &base);
  942. base = base << 21;
  943. return base;
  944. }
  946. /********************************************************************
  947. * pci0GetMemory1Size - Return PCI0 Memory 1 Bar Size.
  948. * Inputs: N/A
  949. * Returns: PCI0 Memory 1 Bar Size.
  950. *********************************************************************/
  952. unsigned int pci0GetMemory1Size()
  953. {
  954. unsigned int top, base, size;
  955. GT_REG_READ(PCI_0MEMORY1_LOW_DECODE_ADDRESS, &base);
  956. base = base << 21;
  957. GT_REG_READ(PCI_0MEMORY1_HIGH_DECODE_ADDRESS, &top);
  958. top = (top << 21);
  959. size = ((top - base) & 0xfffffff);
  960. size = size | 0x1fffff;
  961. return (size + 1);
  962. }
  964. /********************************************************************
  965. * pci1GetIOspaceBase - Return PCI1 IO Base Address.
  966. * Inputs: N/A
  967. * Returns: PCI1 IO Base Address.
  968. *********************************************************************/
  970. unsigned int pci1GetIOspaceBase()
  971. {
  972. unsigned int base;
  973. GT_REG_READ(PCI_1I_O_LOW_DECODE_ADDRESS, &base);
  974. base = base << 21;
  975. return base;
  976. }
  978. /********************************************************************
  979. * pci1GetIOspaceSize - Return PCI1 IO Bar Size.
  980. * Inputs: N/A
  981. * Returns: PCI1 IO Bar Size.
  982. *********************************************************************/
  984. unsigned int pci1GetIOspaceSize()
  985. {
  986. unsigned int top, base, size;
  987. GT_REG_READ(PCI_1I_O_LOW_DECODE_ADDRESS, &base);
  988. base = base << 21;
  989. GT_REG_READ(PCI_1I_O_HIGH_DECODE_ADDRESS, &top);
  990. top = (top << 21);
  991. size = ((top - base) & 0xfffffff);
  992. size = size | 0x1fffff;
  993. return (size + 1);
  994. }
  996. /********************************************************************
  997. * pci1GetMemory0Base - Return PCI1 Memory 0 Base Address.
  998. * Inputs: N/A
  999. * Returns: PCI1 Memory 0 Base Address.
  1000. *********************************************************************/
  1002. unsigned int pci1GetMemory0Base()
  1003. {
  1004. unsigned int base;
  1005. GT_REG_READ(PCI_1MEMORY0_LOW_DECODE_ADDRESS, &base);
  1006. base = base << 21;
  1007. return base;
  1008. }
  1010. /********************************************************************
  1011. * pci1GetMemory0Size - Return PCI1 Memory 0 Bar Size.
  1012. * Inputs: N/A
  1013. * Returns: PCI1 Memory 0 Bar Size.
  1014. *********************************************************************/
  1016. unsigned int pci1GetMemory0Size()
  1017. {
  1018. unsigned int top, base, size;
  1019. GT_REG_READ(PCI_1MEMORY1_LOW_DECODE_ADDRESS, &base);
  1020. base = base << 21;
  1021. GT_REG_READ(PCI_1MEMORY1_HIGH_DECODE_ADDRESS, &top);
  1022. top = (top << 21);
  1023. size = ((top - base) & 0xfffffff);
  1024. size = size | 0x1fffff;
  1025. return (size + 1);
  1026. }
  1028. /********************************************************************
  1029. * pci1GetMemory1Base - Return PCI1 Memory 1 Base Address.
  1030. * Inputs: N/A
  1031. * Returns: PCI1 Memory 1 Base Address.
  1032. *********************************************************************/
  1034. unsigned int pci1GetMemory1Base()
  1035. {
  1036. unsigned int base;
  1037. GT_REG_READ(PCI_1MEMORY1_LOW_DECODE_ADDRESS, &base);
  1038. base = base << 21;
  1039. return base;
  1040. }
  1042. /********************************************************************
  1043. * pci1GetMemory1Size - Return PCI1 Memory 1 Bar Size.
  1044. * Inputs: N/A
  1045. * Returns: PCI1 Memory 1 Bar Size.
  1046. *********************************************************************/
  1048. unsigned int pci1GetMemory1Size()
  1049. {
  1050. unsigned int top, base, size;
  1051. GT_REG_READ(PCI_1MEMORY1_LOW_DECODE_ADDRESS, &base);
  1052. base = base << 21;
  1053. GT_REG_READ(PCI_1MEMORY1_HIGH_DECODE_ADDRESS, &top);
  1054. top = (top << 21);
  1055. size = ((top - base) & 0xfffffff);
  1056. size = size | 0x1fffff;
  1057. return (size + 1);
  1058. }
  1060. /********************************************************************
  1061. * pci0MapInternalRegSpace - Maps the internal registers memory space for the
  1062. *                           slave.
  1063. *                           Stays the same for all GT devices Disco include
  1064. * Inputs: base of pci0 internal register
  1065. *********************************************************************/
  1067. void pci0MapInternalRegSpace(unsigned int pci0InternalBase)
  1068. {
  1069. pci0InternalBase = pci0InternalBase & 0xfffff000;
  1070. pci0InternalBase =
  1071.     pci0InternalBase |
  1072.     (pci0ReadConfigReg
  1073.      (PCI_0INTERNAL_REGISTERS_MEMORY_MAPPED_BASE_ADDRESS,
  1074.       SELF) & 0x00000fff);
  1075. pci0WriteConfigReg
  1076.     (PCI_0INTERNAL_REGISTERS_MEMORY_MAPPED_BASE_ADDRESS, SELF,
  1077.      pci0InternalBase);
  1078. }
  1080. /********************************************************************
  1081. * pci1MapInternalRegSpace - Maps the internal registers memory space for the
  1082. *                           slave.
  1083. *                           Stays the same for all GT devices Disco include
  1084. * Inputs: base of pci1 internal register
  1085. *********************************************************************/
  1087. void pci1MapInternalRegSpace(unsigned int pci1InternalBase)
  1088. {
  1089. pci1InternalBase = pci1InternalBase & 0xfffff000;
  1090. pci1InternalBase =
  1091.     pci1InternalBase |
  1092.     (pci1ReadConfigReg
  1093.      (PCI_0INTERNAL_REGISTERS_MEMORY_MAPPED_BASE_ADDRESS,
  1094.       SELF) & 0x00000fff);
  1095. pci1WriteConfigReg
  1096.     (PCI_0INTERNAL_REGISTERS_MEMORY_MAPPED_BASE_ADDRESS, SELF,
  1097.      pci1InternalBase);
  1098. }
  1100. /********************************************************************
  1101. * pci0MapInternalRegIOSpace - Maps the internal registers IO space for the
  1102. *                             slave.
  1103. *                             Stays the same for all GT devices Disco include
  1104. * Inputs: base of pci0 internal io register
  1105. *********************************************************************/
  1107. void pci0MapInternalRegIOSpace(unsigned int pci0InternalBase)
  1108. {
  1109. pci0InternalBase = pci0InternalBase & 0xfffff000;
  1110. pci0InternalBase =
  1111.     pci0InternalBase |
  1112.     (pci0ReadConfigReg
  1113.      (PCI_0INTERNAL_REGISTERS_I_OMAPPED_BASE_ADDRESS,
  1114.       0) & 0x00000fff);
  1115. pci0WriteConfigReg(PCI_0INTERNAL_REGISTERS_I_OMAPPED_BASE_ADDRESS,
  1116.    SELF, pci0InternalBase);
  1117. }
  1119. /********************************************************************
  1120. * pci0MapInternalRegIOSpace - Maps the internal registers IO space for the
  1121. *                             slave.
  1122. *                             Stays the same for all GT devices Disco include
  1123. * Inputs: base of pci1 internal io register
  1124. *********************************************************************/
  1126. void pci1MapInternalRegIOSpace(unsigned int pci1InternalBase)
  1127. {
  1128. pci1InternalBase = pci1InternalBase & 0xfffff000;
  1129. pci1InternalBase =
  1130.     pci1InternalBase |
  1131.     (pci1ReadConfigReg
  1132.      (PCI_0INTERNAL_REGISTERS_I_OMAPPED_BASE_ADDRESS,
  1133.       SELF) & 0x00000fff);
  1134. pci1WriteConfigReg(PCI_0INTERNAL_REGISTERS_I_OMAPPED_BASE_ADDRESS,
  1135.    SELF, pci1InternalBase);
  1136. }
  1138. /********************************************************************
  1139. * pci0MapMemoryBanks0_1 - Maps PCI0 memory banks 0 and 1 for the slave.
  1140. *                         for Discovery we need two function: SCS0 & SCS1
  1141. *                         (instead of SCS[1:0])
  1142. * Inputs: base and size of pci0 dram
  1143. *********************************************************************/
  1146. void pci0MapMemoryBanks0_1(unsigned int pci0Dram0_1Base,
  1147.    unsigned int pci0Dram0_1Size)
  1148. {
  1149. pci0Dram0_1Base = pci0Dram0_1Base & 0xfffff000;
  1150. pci0Dram0_1Base =
  1151.     pci0Dram0_1Base |
  1152.     (pci0ReadConfigReg(PCI_0SCS_1_0_BASE_ADDRESS, SELF) &
  1153.      0x00000fff);
  1154. pci0WriteConfigReg(PCI_0SCS_1_0_BASE_ADDRESS, SELF,
  1155.    pci0Dram0_1Base);
  1156. /* swapped Bar */
  1157. pci0WriteConfigReg(PCI_0SWAPPED_SCS_1_0_BASE_ADDRESS, SELF,
  1158.    pci0Dram0_1Base);
  1159. if (pci0Dram0_1Size == 0)
  1160. pci0Dram0_1Size++;
  1161. GT_REG_WRITE(PCI_0SCS_1_0_BANK_SIZE, pci0Dram0_1Size - 1);
  1162. }
  1164. /********************************************************************
  1165. * pci1MapMemoryBanks0_1 - Maps PCI1 memory banks 0 and 1 for the slave.
  1166. *                         for Discovery we need two function: SCS0 & SCS1
  1167. *                         (instead of SCS[1:0])
  1168. * Inputs: base and size of pci1 dram
  1169. *********************************************************************/
  1171. void pci1MapMemoryBanks0_1(unsigned int pci1Dram0_1Base,
  1172.    unsigned int pci1Dram0_1Size)
  1173. {
  1174. pci1Dram0_1Base = pci1Dram0_1Base & 0xfffff000;
  1175. pci1Dram0_1Base =
  1176.     pci1Dram0_1Base |
  1177.     (pci1ReadConfigReg(PCI_0SCS_1_0_BASE_ADDRESS, SELF) &
  1178.      0x00000fff);
  1179. pci1WriteConfigReg(PCI_0SCS_1_0_BASE_ADDRESS, SELF,
  1180.    pci1Dram0_1Base);
  1181. /* swapped Bar */
  1182. pci1WriteConfigReg(PCI_0SWAPPED_SCS_1_0_BASE_ADDRESS, SELF,
  1183.    pci1Dram0_1Base);
  1184. if (pci1Dram0_1Size == 0)
  1185. pci1Dram0_1Size++;
  1186. GT_REG_WRITE(PCI_1SCS_1_0_BANK_SIZE, pci1Dram0_1Size - 1);
  1187. }
  1189. /********************************************************************
  1190. * pci0MapMemoryBanks2_3 - Maps PCI0 memory banks 2 and 3 for the slave.
  1191. *                         for Discovery we need two function: SCS2 & SCS3
  1192. *                         (instead of SCS[3:2])
  1193. * Inputs: base and size of pci0 dram
  1194. *********************************************************************/
  1196. void pci0MapMemoryBanks2_3(unsigned int pci0Dram2_3Base,
  1197.    unsigned int pci0Dram2_3Size)
  1198. {
  1199. pci0Dram2_3Base = pci0Dram2_3Base & 0xfffff000;
  1200. pci0Dram2_3Base =
  1201.     pci0Dram2_3Base |
  1202.     (pci0ReadConfigReg(PCI_0SCS_3_2_BASE_ADDRESS, SELF) &
  1203.      0x00000fff);
  1204. pci0WriteConfigReg(PCI_0SCS_3_2_BASE_ADDRESS, SELF,
  1205.    pci0Dram2_3Base);
  1206. /* swapped Bar */
  1207. pci0WriteConfigReg(PCI_0SWAPPED_SCS_3_2_BASE_ADDRESS, SELF,
  1208.    pci0Dram2_3Base);
  1209. if (pci0Dram2_3Size == 0)
  1210. pci0Dram2_3Size++;
  1211. GT_REG_WRITE(PCI_0SCS_3_2_BANK_SIZE, pci0Dram2_3Size - 1);
  1212. }
  1214. /********************************************************************
  1215. * pci1MapMemoryBanks2_3 - Maps PCI1 memory banks 2 and 3 for the slave.
  1216. *                         for Discovery we need two function: SCS2 & SCS3
  1217. *                         (instead of SCS[3:2])
  1218. * Inputs: base and size of pci1 dram
  1219. *********************************************************************/
  1221. void pci1MapMemoryBanks2_3(unsigned int pci1Dram2_3Base,
  1222.    unsigned int pci1Dram2_3Size)
  1223. {
  1224. pci1Dram2_3Base = pci1Dram2_3Base & 0xfffff000;
  1225. pci1Dram2_3Base =
  1226.     pci1Dram2_3Base |
  1227.     (pci1ReadConfigReg(PCI_0SCS_3_2_BASE_ADDRESS, SELF) &
  1228.      0x00000fff);
  1229. pci1WriteConfigReg(PCI_0SCS_3_2_BASE_ADDRESS, SELF,
  1230.    pci1Dram2_3Base);
  1231. /* swapped Bar */
  1232. pci1WriteConfigReg(PCI_0SWAPPED_SCS_3_2_BASE_ADDRESS, SELF,
  1233.    pci1Dram2_3Base);
  1234. if (pci1Dram2_3Size == 0)
  1235. pci1Dram2_3Size++;
  1236. GT_REG_WRITE(PCI_1SCS_3_2_BANK_SIZE, pci1Dram2_3Size - 1);
  1237. }
  1239. /********************************************************************
  1240. * pci0MapDevices0_1and2MemorySpace - Maps PCI0 devices 0,1 and 2 memory spaces
  1241. *                                    for the slave.
  1242. *                                    For the Discovery there are 3 separate
  1243. *                                    fucnction's
  1244. * Inputs: base and lengthof pci0 devises012
  1245. *********************************************************************/
  1248. void pci0MapDevices0_1and2MemorySpace(unsigned int pci0Dev012Base,
  1249.       unsigned int pci0Dev012Length)
  1250. {
  1251. pci0Dev012Base = pci0Dev012Base & 0xfffff000;
  1252. pci0Dev012Base =
  1253.     pci0Dev012Base |
  1254.     (pci0ReadConfigReg(PCI_0CS_2_0_BASE_ADDRESS, SELF) &
  1255.      0x00000fff);
  1256. pci0WriteConfigReg(PCI_0CS_2_0_BASE_ADDRESS, SELF, pci0Dev012Base);
  1257. if (pci0Dev012Length == 0)
  1258. pci0Dev012Length++;
  1259. GT_REG_WRITE(PCI_0CS_2_0_BANK_SIZE, pci0Dev012Length - 1);
  1260. }
  1262. /********************************************************************
  1263. * pci1MapDevices0_1and2MemorySpace - Maps PCI1 devices 0,1 and 2 memory spaces
  1264. *                                    for the slave.
  1265. *                                    For the Discovery there are 3 separate
  1266. *                                    fucnction's
  1267. * Inputs: base and lengthof pci1 devises012
  1268. *********************************************************************/
  1270. void pci1MapDevices0_1and2MemorySpace(unsigned int pci1Dev012Base,
  1271.       unsigned int pci1Dev012Length)
  1272. {
  1273. pci1Dev012Base = pci1Dev012Base & 0xfffff000;
  1274. pci1Dev012Base =
  1275.     pci1Dev012Base |
  1276.     (pci1ReadConfigReg(PCI_0CS_2_0_BASE_ADDRESS, SELF) &
  1277.      0x00000fff);
  1278. pci1WriteConfigReg(PCI_0CS_2_0_BASE_ADDRESS, SELF, pci1Dev012Base);
  1279. if (pci1Dev012Length == 0)
  1280. pci1Dev012Length++;
  1281. GT_REG_WRITE(PCI_1CS_2_0_BANK_SIZE, pci1Dev012Length - 1);
  1282. }
  1284. /********************************************************************
  1285. * pci0MapDevices3andBootMemorySpace - Maps PCI0 devices 3 and boot memory
  1286. *                                     spaces for the slave.
  1287. *                                     For the Discovery there are 2 separate
  1288. *                                     fucnction's
  1289. * Inputs: base and length of pci0 device3/ boot
  1290. *********************************************************************/
  1292. void pci0MapDevices3andBootMemorySpace(unsigned int pci0Dev3andBootBase,
  1293.        unsigned int pci0Dev3andBootLength)
  1294. {
  1295. pci0Dev3andBootBase = pci0Dev3andBootBase & 0xfffff000;
  1296. pci0Dev3andBootBase =
  1297.     pci0Dev3andBootBase |
  1298.     (pci0ReadConfigReg(PCI_0CS_3_BOOTCS_BASE_ADDRESS, SELF) &
  1299.      0x00000fff);
  1300. pci0WriteConfigReg(PCI_0CS_3_BOOTCS_BASE_ADDRESS, SELF,
  1301.    pci0Dev3andBootBase);
  1302. /* swapped Bar */
  1303. pci0WriteConfigReg(PCI_0SWAPPED_CS_3_BOOTCS_BASE_ADDRESS, SELF,
  1304.    pci0Dev3andBootBase);
  1305. if (pci0Dev3andBootLength == 0)
  1306. pci0Dev3andBootLength++;
  1307. GT_REG_WRITE(PCI_0CS_3_BOOTCS_BANK_SIZE,
  1308.      pci0Dev3andBootLength - 1);
  1309. }
  1311. /********************************************************************
  1312. * pci1MapDevices3andBootMemorySpace - Maps PCI1 devices 3 and boot memory
  1313. *                                     spaces for the slave.
  1314. *                                     For the Discovery there are 2 separate
  1315. *                                     fucnction's
  1316. * Inputs: base and length of pci1 device3/ boot
  1317. *********************************************************************/
  1319. void pci1MapDevices3andBootMemorySpace(unsigned int pci1Dev3andBootBase,
  1320.        unsigned int pci1Dev3andBootLength)
  1321. {
  1322. pci1Dev3andBootBase = pci1Dev3andBootBase & 0xfffff000;
  1323. pci1Dev3andBootBase =
  1324.     pci1Dev3andBootBase |
  1325.     (pci1ReadConfigReg(PCI_0CS_3_BOOTCS_BASE_ADDRESS, SELF) &
  1326.      0x00000fff);
  1327. pci1WriteConfigReg(PCI_0CS_3_BOOTCS_BASE_ADDRESS, SELF,
  1328.    pci1Dev3andBootBase);
  1329. /* swapped Bar */
  1330. pci1WriteConfigReg(PCI_0SWAPPED_CS_3_BOOTCS_BASE_ADDRESS, SELF,
  1331.    pci1Dev3andBootBase);
  1332. if (pci1Dev3andBootLength == 0)
  1333. pci1Dev3andBootLength++;
  1334. GT_REG_WRITE(PCI_1CS_3_BOOTCS_BANK_SIZE,
  1335.      pci1Dev3andBootLength - 1);
  1336. }