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

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

Linux/Unix编程

开发平台：

Unix_Linux

pci.c：源码内容
  1. /*
  2.  * Copyright 2002 Momentum Computer
  3.  * Author: Matthew Dharm <mdharm@momenco.com>
  4.  *
  5.  *  This program is free software; you can redistribute  it and/or modify it
  6.  *  under  the terms of  the GNU General  Public License as published by the
  7.  *  Free Software Foundation;  either version 2 of the  License, or (at your
  8.  *  option) any later version.
  9.  *
  10.  *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
  11.  *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
  12.  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
  13.  *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
  14.  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  15.  *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
  16.  *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  17.  *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
  18.  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  19.  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  20.  *
  21.  *  You should have received a copy of the  GNU General Public License along
  22.  *  with this program; if not, write  to the Free Software Foundation, Inc.,
  23.  *  675 Mass Ave, Cambridge, MA 02139, USA.
  24.  */
  25. #include <linux/config.h>
  26. #include <linux/types.h>
  27. #include <linux/pci.h>
  28. #include <linux/kernel.h>
  29. #include <linux/slab.h>
  30. #include <linux/version.h>
  31. #include <asm/pci.h>
  32. #include <asm/io.h>
  33. #include "gt64240.h"
  35. #include <linux/init.h>
  37. #ifdef CONFIG_PCI
  39. #define SELF 0
  40. #define MASTER_ABORT_BIT 0x100
  42. /*
  43.  * These functions and structures provide the BIOS scan and mapping of the PCI
  44.  * devices.
  45.  */
  47. #define MAX_PCI_DEVS 10
  49. void gt64240_board_pcibios_fixup_bus(struct pci_bus* c);
  51. /*  Functions to implement "pci ops"  */
  52. static int galileo_pcibios_read_config_word(struct pci_dev *dev,
  53.     int offset, u16 * val);
  54. static int galileo_pcibios_read_config_byte(struct pci_dev *dev,
  55.     int offset, u8 * val);
  56. static int galileo_pcibios_read_config_dword(struct pci_dev *dev,
  57.      int offset, u32 * val);
  58. static int galileo_pcibios_write_config_byte(struct pci_dev *dev,
  59.      int offset, u8 val);
  60. static int galileo_pcibios_write_config_word(struct pci_dev *dev,
  61.      int offset, u16 val);
  62. static int galileo_pcibios_write_config_dword(struct pci_dev *dev,
  63.       int offset, u32 val);
  64. static void galileo_pcibios_set_master(struct pci_dev *dev);
  66. /*
  67.  *  General-purpose PCI functions.
  68.  */
  71. /*
  72.  * pci_range_ck -
  73.  *
  74.  * Check if the pci device that are trying to access does really exists
  75.  * on the evaluation board.
  76.  *
  77.  * Inputs :
  78.  * bus - bus number (0 for PCI 0 ; 1 for PCI 1)
  79.  * dev - number of device on the specific pci bus
  80.  *
  81.  * Outpus :
  82.  * 0 - if OK , 1 - if failure
  83.  */
  84. static __inline__ int pci_range_ck(unsigned char bus, unsigned char dev)
  85. {
  86. /* Accessing device 31 crashes the GT-64240. */
  87. if (dev < 5)
  88. return 0;
  89. return -1;
  90. }
  92. /*
  93.  * galileo_pcibios_(read/write)_config_(dword/word/byte) -
  94.  *
  95.  * reads/write a dword/word/byte register from the configuration space
  96.  * of a device.
  97.  *
  98.  * Note that bus 0 and bus 1 are local, and we assume all other busses are
  99.  * bridged from bus 1.  This is a safe assumption, since any other
  100.  * configuration will require major modifications to the CP7000G
  101.  *
  102.  * Inputs :
  103.  * bus - bus number
  104.  * dev - device number
  105.  * offset - register offset in the configuration space
  106.  * val - value to be written / read
  107.  *
  108.  * Outputs :
  109.  * PCIBIOS_SUCCESSFUL when operation was succesfull
  110.  * PCIBIOS_DEVICE_NOT_FOUND when the bus or dev is errorneous
  111.  * PCIBIOS_BAD_REGISTER_NUMBER when accessing non aligned
  112.  */
  114. static int galileo_pcibios_read_config_dword(struct pci_dev *device,
  115.       int offset, u32* val)
  116. {
  117. int dev, bus, func;
  118. uint32_t address_reg, data_reg;
  119. uint32_t address;
  121. bus = device->bus->number;
  122. dev = PCI_SLOT(device->devfn);
  123. func = PCI_FUNC(device->devfn);
  125. /* verify the range */
  126. if (pci_range_ck(bus, dev))
  127. return PCIBIOS_DEVICE_NOT_FOUND;
  129. /* select the GT-64240 registers to communicate with the PCI bus */
  130. if (bus == 0) {
  131. address_reg = PCI_0CONFIGURATION_ADDRESS;
  132. data_reg = PCI_0CONFIGURATION_DATA_VIRTUAL_REGISTER;
  133. GT_WRITE(PCI_0ERROR_CAUSE, ~MASTER_ABORT_BIT);
  134. } else {
  135. address_reg = PCI_1CONFIGURATION_ADDRESS;
  136. data_reg = PCI_1CONFIGURATION_DATA_VIRTUAL_REGISTER;
  137. GT_WRITE(PCI_1ERROR_CAUSE, ~MASTER_ABORT_BIT);
  138. if (bus == 1)
  139. bus = 0;
  140. }
  142. address = (bus << 16) | (dev << 11) | (func << 8) |
  143. (offset & 0xfc) | 0x80000000;
  145. /* start the configuration cycle */
  146. GT_WRITE(address_reg, address);
  148. /* read the data */
  149. GT_READ(data_reg, val);
  151. return PCIBIOS_SUCCESSFUL;
  152. }
  155. static int galileo_pcibios_read_config_word(struct pci_dev *device,
  156.      int offset, u16* val)
  157. {
  158. int dev, bus, func;
  159. uint32_t address_reg, data_reg;
  160. uint32_t address;
  162. bus = device->bus->number;
  163. dev = PCI_SLOT(device->devfn);
  164. func = PCI_FUNC(device->devfn);
  166. /* verify the range */
  167. if (pci_range_ck(bus, dev))
  168. return PCIBIOS_DEVICE_NOT_FOUND;
  170. /* select the GT-64240 registers to communicate with the PCI bus */
  171. if (bus == 0) {
  172. address_reg = PCI_0CONFIGURATION_ADDRESS;
  173. data_reg = PCI_0CONFIGURATION_DATA_VIRTUAL_REGISTER;
  174. GT_WRITE(PCI_0ERROR_CAUSE, ~MASTER_ABORT_BIT);
  175. } else {
  176. address_reg = PCI_1CONFIGURATION_ADDRESS;
  177. data_reg = PCI_1CONFIGURATION_DATA_VIRTUAL_REGISTER;
  178. GT_WRITE(PCI_1ERROR_CAUSE, ~MASTER_ABORT_BIT);
  179. if (bus == 1)
  180. bus = 0;
  181. }
  183. address = (bus << 16) | (dev << 11) | (func << 8) |
  184. (offset & 0xfc) | 0x80000000;
  186. /* start the configuration cycle */
  187. GT_WRITE(address_reg, address);
  189. /* read the data */
  190. GT_READ_16(data_reg + (offset & 0x3), val);
  192. return PCIBIOS_SUCCESSFUL;
  193. }
  195. static int galileo_pcibios_read_config_byte(struct pci_dev *device,
  196.      int offset, u8* val)
  197. {
  198. int dev, bus, func;
  199. uint32_t address_reg, data_reg;
  200. uint32_t address;
  202. bus = device->bus->number;
  203. dev = PCI_SLOT(device->devfn);
  204. func = PCI_FUNC(device->devfn);
  206. /* verify the range */
  207. if (pci_range_ck(bus, dev))
  208. return PCIBIOS_DEVICE_NOT_FOUND;
  210. /* select the GT-64240 registers to communicate with the PCI bus */
  211. if (bus == 0) {
  212. address_reg = PCI_0CONFIGURATION_ADDRESS;
  213. data_reg = PCI_0CONFIGURATION_DATA_VIRTUAL_REGISTER;
  214. } else {
  215. address_reg = PCI_1CONFIGURATION_ADDRESS;
  216. data_reg = PCI_1CONFIGURATION_DATA_VIRTUAL_REGISTER;
  217. if (bus == 1)
  218. bus = 0;
  219. }
  221. address = (bus << 16) | (dev << 11) | (func << 8) |
  222. (offset & 0xfc) | 0x80000000;
  224. /* start the configuration cycle */
  225. GT_WRITE(address_reg, address);
  227. /* write the data */
  228. GT_READ_8(data_reg + (offset & 0x3), val);
  230. return PCIBIOS_SUCCESSFUL;
  231. }
  233. static int galileo_pcibios_write_config_dword(struct pci_dev *device,
  234.       int offset, u32 val)
  235. {
  236. int dev, bus, func;
  237. uint32_t address_reg, data_reg;
  238. uint32_t address;
  240. bus = device->bus->number;
  241. dev = PCI_SLOT(device->devfn);
  242. func = PCI_FUNC(device->devfn);
  244. /* verify the range */
  245. if (pci_range_ck(bus, dev))
  246. return PCIBIOS_DEVICE_NOT_FOUND;
  248. /* select the GT-64240 registers to communicate with the PCI bus */
  249. if (bus == 0) {
  250. address_reg = PCI_0CONFIGURATION_ADDRESS;
  251. data_reg = PCI_0CONFIGURATION_DATA_VIRTUAL_REGISTER;
  252. } else {
  253. address_reg = PCI_1CONFIGURATION_ADDRESS;
  254. data_reg = PCI_1CONFIGURATION_DATA_VIRTUAL_REGISTER;
  255. if (bus == 1)
  256. bus = 0;
  257. }
  259. address = (bus << 16) | (dev << 11) | (func << 8) |
  260. (offset & 0xfc) | 0x80000000;
  262. /* start the configuration cycle */
  263. GT_WRITE(address_reg, address);
  265. /* write the data */
  266. GT_WRITE(data_reg, val);
  268. return PCIBIOS_SUCCESSFUL;
  269. }
  272. static int galileo_pcibios_write_config_word(struct pci_dev *device,
  273.      int offset, u16 val)
  274. {
  275. int dev, bus, func;
  276. uint32_t address_reg, data_reg;
  277. uint32_t address;
  279. bus = device->bus->number;
  280. dev = PCI_SLOT(device->devfn);
  281. func = PCI_FUNC(device->devfn);
  283. /* verify the range */
  284. if (pci_range_ck(bus, dev))
  285. return PCIBIOS_DEVICE_NOT_FOUND;
  287. /* select the GT-64240 registers to communicate with the PCI bus */
  288. if (bus == 0) {
  289. address_reg = PCI_0CONFIGURATION_ADDRESS;
  290. data_reg = PCI_0CONFIGURATION_DATA_VIRTUAL_REGISTER;
  291. } else {
  292. address_reg = PCI_1CONFIGURATION_ADDRESS;
  293. data_reg = PCI_1CONFIGURATION_DATA_VIRTUAL_REGISTER;
  294. if (bus == 1)
  295. bus = 0;
  296. }
  298. address = (bus << 16) | (dev << 11) | (func << 8) |
  299. (offset & 0xfc) | 0x80000000;
  301. /* start the configuration cycle */
  302. GT_WRITE(address_reg, address);
  304. /* write the data */
  305. GT_WRITE_16(data_reg + (offset & 0x3), val);
  307. return PCIBIOS_SUCCESSFUL;
  308. }
  310. static int galileo_pcibios_write_config_byte(struct pci_dev *device,
  311.      int offset, u8 val)
  312. {
  313. int dev, bus, func;
  314. uint32_t address_reg, data_reg;
  315. uint32_t address;
  317. bus = device->bus->number;
  318. dev = PCI_SLOT(device->devfn);
  319. func = PCI_FUNC(device->devfn);
  321. /* verify the range */
  322. if (pci_range_ck(bus, dev))
  323. return PCIBIOS_DEVICE_NOT_FOUND;
  325. /* select the GT-64240 registers to communicate with the PCI bus */
  326. if (bus == 0) {
  327. address_reg = PCI_0CONFIGURATION_ADDRESS;
  328. data_reg = PCI_0CONFIGURATION_DATA_VIRTUAL_REGISTER;
  329. } else {
  330. address_reg = PCI_1CONFIGURATION_ADDRESS;
  331. data_reg = PCI_1CONFIGURATION_DATA_VIRTUAL_REGISTER;
  332. if (bus == 1)
  333. bus = 0;
  334. }
  336. address = (bus << 16) | (dev << 11) | (func << 8) |
  337. (offset & 0xfc) | 0x80000000;
  339. /* start the configuration cycle */
  340. GT_WRITE(address_reg, address);
  342. /* write the data */
  343. GT_WRITE_8(data_reg + (offset & 0x3), val);
  345. return PCIBIOS_SUCCESSFUL;
  346. }
  348. static void galileo_pcibios_set_master(struct pci_dev *dev)
  349. {
  350. u16 cmd;
  352. galileo_pcibios_read_config_word(dev, PCI_COMMAND, &cmd);
  353. cmd |= PCI_COMMAND_MASTER;
  354. galileo_pcibios_write_config_word(dev, PCI_COMMAND, cmd);
  355. }
  357. /*  Externally-expected functions.  Do not change function names  */
  359. int pcibios_enable_resources(struct pci_dev *dev)
  360. {
  361. u16 cmd, old_cmd;
  362. u8 tmp1;
  363. int idx;
  364. struct resource *r;
  366. galileo_pcibios_read_config_word(dev, PCI_COMMAND, &cmd);
  367. old_cmd = cmd;
  368. for (idx = 0; idx < 6; idx++) {
  369. r = &dev->resource[idx];
  370. if (!r->start && r->end) {
  371. printk(KERN_ERR
  372.        "PCI: Device %s not available because of "
  373.        "resource collisionsn", dev->slot_name);
  374. return -EINVAL;
  375. }
  376. if (r->flags & IORESOURCE_IO)
  377. cmd |= PCI_COMMAND_IO;
  378. if (r->flags & IORESOURCE_MEM)
  379. cmd |= PCI_COMMAND_MEMORY;
  380. }
  381. if (cmd != old_cmd) {
  382. galileo_pcibios_write_config_word(dev, PCI_COMMAND, cmd);
  383. }
  385. /*
  386.  * Let's fix up the latency timer and cache line size here.  Cache
  387.  * line size = 32 bytes / sizeof dword (4) = 8.
  388.  * Latency timer must be > 8.  32 is random but appears to work.
  389.  */
  390. galileo_pcibios_read_config_byte(dev, PCI_CACHE_LINE_SIZE, &tmp1);
  391. if (tmp1 != 8) {
  392. printk(KERN_WARNING "PCI setting cache line size to 8 from "
  393.        "%dn", tmp1);
  394. galileo_pcibios_write_config_byte(dev, PCI_CACHE_LINE_SIZE,
  395.   8);
  396. }
  397. galileo_pcibios_read_config_byte(dev, PCI_LATENCY_TIMER, &tmp1);
  398. if (tmp1 < 32) {
  399. printk(KERN_WARNING "PCI setting latency timer to 32 from %dn",
  400.        tmp1);
  401. galileo_pcibios_write_config_byte(dev, PCI_LATENCY_TIMER,
  402.   32);
  403. }
  405. return 0;
  406. }
  408. int pcibios_enable_device(struct pci_dev *dev)
  409. {
  410. return pcibios_enable_resources(dev);
  411. }
  413. void pcibios_update_resource(struct pci_dev *dev, struct resource *root,
  414.      struct resource *res, int resource)
  415. {
  416. u32 new, check;
  417. int reg;
  419. return;
  421. #if 0
  422. new = res->start | (res->flags & PCI_REGION_FLAG_MASK);
  423. if (resource < 6) {
  424. reg = PCI_BASE_ADDRESS_0 + 4 * resource;
  425. } else if (resource == PCI_ROM_RESOURCE) {
  426. res->flags |= PCI_ROM_ADDRESS_ENABLE;
  427. reg = dev->rom_base_reg;
  428. } else {
  429. /*
  430.  * Somebody might have asked allocation of a non-standard
  431.  * resource
  432.  */
  433. return;
  434. }
  436. pci_write_config_dword(dev, reg, new);
  437. pci_read_config_dword(dev, reg, &check);
  438. if ((new ^ check) &
  439.     ((new & PCI_BASE_ADDRESS_SPACE_IO) ? PCI_BASE_ADDRESS_IO_MASK :
  440.      PCI_BASE_ADDRESS_MEM_MASK)) {
  441. printk(KERN_ERR "PCI: Error while updating region "
  442.        "%s/%d (%08x != %08x)n", dev->slot_name, resource,
  443.        new, check);
  444. }
  445. #endif
  446. }
  448. void pcibios_align_resource(void *data, struct resource *res,
  449.     unsigned long size, unsigned long align)
  450. {
  451. struct pci_dev *dev = data;
  453. if (res->flags & IORESOURCE_IO) {
  454. unsigned long start = res->start;
  456. /* We need to avoid collisions with `mirrored' VGA ports
  457.    and other strange ISA hardware, so we always want the
  458.    addresses kilobyte aligned.  */
  459. if (size > 0x100) {
  460. printk(KERN_ERR "PCI: I/O Region %s/%d too large"
  461.        " (%ld bytes)n", dev->slot_name,
  462.         dev->resource - res, size);
  463. }
  465. start = (start + 1024 - 1) & ~(1024 - 1);
  466. res->start = start;
  467. }
  468. }
  470. struct pci_ops galileo_pci_ops = {
  471. galileo_pcibios_read_config_byte,
  472. galileo_pcibios_read_config_word,
  473. galileo_pcibios_read_config_dword,
  474. galileo_pcibios_write_config_byte,
  475. galileo_pcibios_write_config_word,
  476. galileo_pcibios_write_config_dword
  477. };
  479. struct pci_fixup pcibios_fixups[] = {
  480. {0}
  481. };
  483. void __init pcibios_fixup_bus(struct pci_bus *c)
  484. {
  485. gt64240_board_pcibios_fixup_bus(c);
  486. }
  489. /********************************************************************
  490. * pci0P2PConfig - This function set the PCI_0 P2P configurate.
  491. *                 For more information on the P2P read PCI spec.
  492. *
  493. * Inputs:  unsigned int SecondBusLow - Secondery PCI interface Bus Range Lower
  494. *                                      Boundry.
  495. *          unsigned int SecondBusHigh - Secondry PCI interface Bus Range upper
  496. *                                      Boundry.
  497. *          unsigned int busNum - The CPI bus number to which the PCI interface
  498. *                                      is connected.
  499. *          unsigned int devNum - The PCI interface's device number.
  500. *
  501. * Returns:  true.
  502. */
  503. void pci0P2PConfig(unsigned int SecondBusLow,unsigned int SecondBusHigh,
  504.                    unsigned int busNum,unsigned int devNum)
  505. {
  506. uint32_t regData;
  508. regData = (SecondBusLow & 0xff) | ((SecondBusHigh & 0xff) << 8) |
  509. ((busNum & 0xff) << 16) | ((devNum & 0x1f) << 24);
  510. GT_WRITE(PCI_0P2P_CONFIGURATION, regData);
  511. }
  513. /********************************************************************
  514. * pci1P2PConfig - This function set the PCI_1 P2P configurate.
  515. *                 For more information on the P2P read PCI spec.
  516. *
  517. * Inputs:  unsigned int SecondBusLow - Secondery PCI interface Bus Range Lower
  518. *               Boundry.
  519. *          unsigned int SecondBusHigh - Secondry PCI interface Bus Range upper
  520. *               Boundry.
  521. *          unsigned int busNum - The CPI bus number to which the PCI interface
  522. *               is connected.
  523. *          unsigned int devNum - The PCI interface's device number.
  524. *
  525. * Returns:  true.
  526. */
  527. void pci1P2PConfig(unsigned int SecondBusLow,unsigned int SecondBusHigh,
  528.                    unsigned int busNum,unsigned int devNum)
  529. {
  530. uint32_t regData;
  532. regData = (SecondBusLow & 0xff) | ((SecondBusHigh & 0xff) << 8) |
  533. ((busNum & 0xff) << 16) | ((devNum & 0x1f) << 24);
  534. GT_WRITE(PCI_1P2P_CONFIGURATION, regData);
  535. }
  537. #define PCI0_STATUS_COMMAND_REG                 0x4
  538. #define PCI1_STATUS_COMMAND_REG                 0x84
  540. void __init pcibios_init(void)
  541. {
  542. /* Reset PCI I/O and PCI MEM values */
  543. ioport_resource.start = 0xe0000000;
  544. ioport_resource.end   = 0xe0000000 + 0x20000000 - 1;
  545. iomem_resource.start  = 0xc0000000;
  546. iomem_resource.end    = 0xc0000000 + 0x20000000 - 1;
  548. pci_scan_bus(0, &galileo_pci_ops, NULL);
  549. pci_scan_bus(1, &galileo_pci_ops, NULL);
  550. }
  552. /*
  553.  * for parsing "pci=" kernel boot arguments.
  554.  */
  555. char *pcibios_setup(char *str)
  556. {
  557.         printk(KERN_INFO "rr: pcibios_setupn");
  558.         /* Nothing to do for now.  */
  560.         return str;
  561. }
  563. unsigned __init int pcibios_assign_all_busses(void)
  564. {
  565. return 1;
  566. }
  568. #endif /* CONFIG_PCI */