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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
pci_ops.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：10k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

pci_ops.c：源码内容
  1. /***********************************************************************
  2.  * Copyright 2001 MontaVista Software Inc.
  3.  * Author: Jun Sun, jsun@mvista.com or jsun@junsun.net
  4.  *
  5.  * arch/mips/ddb5xxx/ddb5477/pci_ops.c
  6.  *     Define the pci_ops for DB5477.
  7.  *
  8.  * Much of the code is derived from the original DDB5074 port by 
  9.  * Geert Uytterhoeven <geert@sonycom.com>
  10.  *
  11.  * This program is free software; you can redistribute  it and/or modify it
  12.  * under  the terms of  the GNU General  Public License as published by the
  13.  * Free Software Foundation;  either version 2 of the  License, or (at your
  14.  * option) any later version.
  15.  ***********************************************************************
  16.  */
  18. /*
  19.  * DDB5477 has two PCI channels, external PCI and IOPIC (internal)
  20.  * Therefore we provide two sets of pci_ops.
  21.  */
  23. #include <linux/config.h>
  24. #include <linux/pci.h>
  25. #include <linux/kernel.h>
  26. #include <linux/types.h>
  28. #include <asm/addrspace.h>
  29. #include <asm/ddb5xxx/debug.h>
  30. #include <asm/ddb5xxx/ddb5xxx.h>
  32. /*
  33.  * config_swap structure records what set of pdar/pmr are used
  34.  * to access pci config space.  It also provides a place hold the
  35.  * original values for future restoring.
  36.  */
  37. struct pci_config_swap {
  38. u32  pdar;
  39. u32 pmr;
  40. u32 config_base;
  41. u32 config_size;
  42. u32 pdar_backup;
  43. u32 pmr_backup;
  44. };
  46. /*
  47.  * On DDB5477, we have two sets of swap registers, for ext PCI and IOPCI.
  48.  */
  49. struct pci_config_swap ext_pci_swap = {
  50. DDB_PCIW0,  
  51. DDB_PCIINIT00,
  52. DDB_PCI0_CONFIG_BASE,
  53. DDB_PCI0_CONFIG_SIZE
  54. };
  55. struct pci_config_swap io_pci_swap = {
  56. DDB_IOPCIW0,  
  57. DDB_PCIINIT01,
  58. DDB_PCI1_CONFIG_BASE,
  59. DDB_PCI1_CONFIG_SIZE
  60. };
  63. /*
  64.  * access config space
  65.  */
  66. static inline u32 ddb_access_config_base(struct pci_config_swap *swap,
  67.  u32 bus,/* 0 means top level bus */
  68.  u32 slot_num)
  69. {
  70. u32 pci_addr = 0;
  71. u32 pciinit_offset = 0;
  72.         u32 virt_addr = swap->config_base;
  73. u32 option;
  75. /* [jsun] hack for testing */
  76. // if (slot_num == 4) slot_num = 0;
  78. /* minimum pdar (window) size is 2MB */
  79. MIPS_ASSERT(swap->config_size >= (2 << 20));
  81. MIPS_ASSERT(slot_num < (1 << 5));
  82. MIPS_ASSERT(bus < (1 << 8));
  84. /* backup registers */
  85. swap->pdar_backup = ddb_in32(swap->pdar);
  86. swap->pmr_backup = ddb_in32(swap->pmr);
  88. /* set the pdar (pci window) register */
  89. ddb_set_pdar(swap->pdar,
  90.      swap->config_base,
  91.      swap->config_size,
  92.      32, /* 32 bit wide */
  93.      0, /* not on local memory bus */
  94.      0); /* not visible from PCI bus (N/A) */
  96. /* 
  97.  * calcuate the absolute pci config addr; 
  98.  * according to the spec, we start scanning from adr:11 (0x800)
  99.  */ 
  100. if (bus == 0) {
  101. /* type 0 config */
  102. pci_addr = 0x800 << slot_num;
  103. } else {
  104. /* type 1 config */
  105. pci_addr = (bus << 16) | (slot_num << 11);
  106. panic("ddb_access_config_base: we don't support type 1 config Yet");
  107. }
  109. /*
  110.  * if pci_addr is less than pci config window size,  we set
  111.  * pciinit_offset to 0 and adjust the virt_address.
  112.  * Otherwise we will try to adjust pciinit_offset.
  113.  */
  114. if (pci_addr < swap->config_size) {
  115. virt_addr = KSEG1ADDR(swap->config_base + pci_addr);
  116. pciinit_offset = 0;
  117. } else {
  118. MIPS_ASSERT( (pci_addr & (swap->config_size - 1)) == 0);
  119. virt_addr = KSEG1ADDR(swap->config_base);
  120. pciinit_offset = pci_addr;
  121. }
  123. /* set the pmr register */
  124. option = DDB_PCI_ACCESS_32;
  125. if (bus != 0) option |= DDB_PCI_CFGTYPE1;
  126. ddb_set_pmr(swap->pmr, DDB_PCICMD_CFG, pciinit_offset, option);
  128. return virt_addr;
  129. }
  131. static inline void ddb_close_config_base(struct pci_config_swap *swap)
  132. {
  133. ddb_out32(swap->pdar, swap->pdar_backup);
  134. ddb_out32(swap->pmr, swap->pmr_backup);
  135. }
  137. static int read_config_dword(struct pci_config_swap *swap,
  138.      struct pci_dev *dev,
  139.      u32 where,
  140.      u32 *val)
  141. {
  142. u32 bus, slot_num, func_num;
  143. u32 base;
  145. MIPS_ASSERT((where & 3) == 0);
  146. MIPS_ASSERT(where < (1 << 8));
  148. /* check if the bus is top-level */
  149. if (dev->bus->parent != NULL) {
  150. bus = dev->bus->number;
  151. MIPS_ASSERT(bus != 0);
  152. } else {
  153. bus = 0;
  154. }
  156. slot_num = PCI_SLOT(dev->devfn);
  157. func_num = PCI_FUNC(dev->devfn);
  158. base = ddb_access_config_base(swap, bus, slot_num);
  159. *val = *(volatile u32*) (base + (func_num << 8) + where);
  160. ddb_close_config_base(swap);
  161. return PCIBIOS_SUCCESSFUL;
  162. }
  164. static int read_config_word(struct pci_config_swap *swap,
  165.     struct pci_dev *dev,
  166.     u32 where,
  167.     u16 *val)
  168. {
  169.         int status;
  170.         u32 result;
  172. MIPS_ASSERT((where & 1) == 0);
  174.         status = read_config_dword(swap, dev, where & ~3, &result);
  175.         if (where & 2) result >>= 16;
  176.         *val = result & 0xffff;
  177.         return status;
  178. }
  180. static int read_config_byte(struct pci_config_swap *swap,
  181.     struct pci_dev *dev,
  182.     u32 where,
  183.     u8 *val)
  184. {
  185.         int status;
  186.         u32 result;
  188.         status = read_config_dword(swap, dev, where & ~3, &result);
  189.         if (where & 1) result >>= 8;
  190.         if (where & 2) result >>= 16;
  191.         *val = result & 0xff;
  192.         return status;
  193. }
  195. static int write_config_dword(struct pci_config_swap *swap,
  196.       struct pci_dev *dev,
  197.       u32 where,
  198.       u32 val)
  199. {
  200. u32 bus, slot_num, func_num;
  201. u32 base;
  203. MIPS_ASSERT((where & 3) == 0);
  204. MIPS_ASSERT(where < (1 << 8));
  206. /* check if the bus is top-level */
  207. if (dev->bus->parent != NULL) {
  208. bus = dev->bus->number;
  209. MIPS_ASSERT(bus != 0);
  210. } else {
  211. bus = 0;
  212. }
  214. slot_num = PCI_SLOT(dev->devfn);
  215. func_num = PCI_FUNC(dev->devfn);
  216. base = ddb_access_config_base(swap, bus, slot_num);
  217. *(volatile u32*) (base + (func_num << 8) + where) = val; 
  218. ddb_close_config_base(swap);
  219. return PCIBIOS_SUCCESSFUL;
  220. }
  222. static int write_config_word(struct pci_config_swap *swap,
  223.      struct pci_dev *dev,
  224.      u32 where,
  225.      u16 val)
  226. {
  227. int status, shift=0;
  228. u32 result;
  230. MIPS_ASSERT((where & 1) == 0);
  232. status = read_config_dword(swap, dev, where & ~3, &result);
  233. if (status != PCIBIOS_SUCCESSFUL) return status;
  235.         if (where & 2)
  236.                 shift += 16;
  237.         result &= ~(0xffff << shift);
  238.         result |= val << shift;
  239.         return write_config_dword(swap, dev, where & ~3, result);
  240. }
  242. static int write_config_byte(struct pci_config_swap *swap,
  243.      struct pci_dev *dev,
  244.      u32 where,
  245.      u8 val)
  246. {
  247. int status, shift=0;
  248. u32 result;
  250. status = read_config_dword(swap, dev, where & ~3, &result);
  251. if (status != PCIBIOS_SUCCESSFUL) return status;
  253.         if (where & 2)
  254.                 shift += 16;
  255.         if (where & 1)
  256.                 shift += 8;
  257.         result &= ~(0xff << shift);
  258.         result |= val << shift;
  259.         return write_config_dword(swap, dev, where & ~3, result);
  260. }
  262. #define MAKE_PCI_OPS(prefix, rw, unitname, unittype, pciswap) 
  263. static int prefix##_##rw##_config_##unitname(struct pci_dev *dev, int where, unittype val) 
  264. { 
  265.      return rw##_config_##unitname(pciswap, 
  266.                                    dev, 
  267.                                    where, 
  268.                                    val); 
  269. }
  271. MAKE_PCI_OPS(extpci, read, byte, u8 *, &ext_pci_swap)
  272. MAKE_PCI_OPS(extpci, read, word, u16 *, &ext_pci_swap)
  273. MAKE_PCI_OPS(extpci, read, dword, u32 *, &ext_pci_swap)
  275. MAKE_PCI_OPS(iopci, read, byte, u8 *, &io_pci_swap)
  276. MAKE_PCI_OPS(iopci, read, word, u16 *, &io_pci_swap)
  277. MAKE_PCI_OPS(iopci, read, dword, u32 *, &io_pci_swap)
  279. MAKE_PCI_OPS(extpci, write, byte, u8, &ext_pci_swap)
  280. MAKE_PCI_OPS(extpci, write, word, u16, &ext_pci_swap)
  281. MAKE_PCI_OPS(extpci, write, dword, u32, &ext_pci_swap)
  283. MAKE_PCI_OPS(iopci, write, byte, u8, &io_pci_swap)
  284. MAKE_PCI_OPS(iopci, write, word, u16, &io_pci_swap)
  285. MAKE_PCI_OPS(iopci, write, dword, u32, &io_pci_swap)
  287. struct pci_ops ddb5477_ext_pci_ops ={
  288. extpci_read_config_byte,
  289. extpci_read_config_word,
  290. extpci_read_config_dword,
  291. extpci_write_config_byte,
  292. extpci_write_config_word,
  293. extpci_write_config_dword
  294. };
  297. struct pci_ops ddb5477_io_pci_ops ={
  298. iopci_read_config_byte,
  299. iopci_read_config_word,
  300. iopci_read_config_dword,
  301. iopci_write_config_byte,
  302. iopci_write_config_word,
  303. iopci_write_config_dword
  304. };
  306. #if defined(CONFIG_LL_DEBUG)
  307. void jsun_scan_pci_bus(void)
  308. {
  309. struct pci_bus bus;
  310. struct pci_dev dev;
  311. unsigned int devfn;
  312. int j;
  314. bus.parent = NULL; /* we scan the top level only */
  315. dev.bus = &bus;
  316. dev.sysdata = NULL;
  318. /* scan ext pci bus and io pci bus*/
  319. for (j=0; j< 2; j++) {
  320. if (j ==  0) {
  321. printk("scan ddb5477 external PCI bus:n");
  322. bus.ops = &ddb5477_ext_pci_ops;
  323. } else {
  324. printk("scan ddb5477 IO PCI bus:n");
  325. bus.ops = &ddb5477_io_pci_ops;
  326. }
  328. for (devfn = 0; devfn < 0x100; devfn += 8) {
  329. u32 temp;
  330. u16 temp16;
  331. u8 temp8;
  332. int i;
  334. dev.devfn = devfn;
  335. MIPS_VERIFY(pci_read_config_dword(&dev, 0, &temp),
  336.     == PCIBIOS_SUCCESSFUL);
  337. if (temp == 0xffffffff) continue;
  339. printk("slot %d: (addr %d) n", devfn/8, 11+devfn/8);
  341. /* verify read word and byte */
  342. MIPS_VERIFY(pci_read_config_word(&dev, 2, &temp16),
  343.     == PCIBIOS_SUCCESSFUL);
  344. MIPS_ASSERT(temp16 == (temp >> 16));
  345. MIPS_VERIFY(pci_read_config_byte(&dev, 3, &temp8),
  346.     == PCIBIOS_SUCCESSFUL);
  347. MIPS_ASSERT(temp8 == (temp >> 24));
  348. MIPS_VERIFY(pci_read_config_byte(&dev, 1, &temp8),
  349.     == PCIBIOS_SUCCESSFUL);
  350. MIPS_ASSERT(temp8 == ((temp >> 8) & 0xff));
  352. for (i=0; i < 16; i++) {
  353. MIPS_VERIFY(pci_read_config_dword(&dev, i*4, &temp),
  354.     == PCIBIOS_SUCCESSFUL);
  355. printk("t%08X", temp);
  356. if ((i%4) == 3) printk("n");
  357. }
  358. }
  359. }
  360. }
  363. static void jsun_hardcode_pci_resources_eepro(void)
  364. {
  365. struct pci_bus bus;
  366. struct pci_dev dev;
  367. u32 temp;
  369. bus.parent = NULL; /* we scan the top level only */
  370. bus.ops = &ddb5477_ext_pci_ops;
  371. dev.bus = &bus;
  372. dev.sysdata = NULL;
  374. /* for slot 5 (ext pci 1) eepro card */
  375. dev.devfn = 5*8;
  376. pci_read_config_dword(&dev, 0, &temp);
  377. MIPS_ASSERT(temp == 0x12298086);
  379. pci_write_config_dword(&dev, PCI_BASE_ADDRESS_0, DDB_PCI0_MEM_BASE);
  380. pci_write_config_dword(&dev, PCI_BASE_ADDRESS_1, 0);
  381. pci_write_config_dword(&dev, PCI_BASE_ADDRESS_2, DDB_PCI0_MEM_BASE+0x100000);
  382. pci_write_config_dword(&dev, PCI_INTERRUPT_LINE, 17);
  383. }
  385. static void jsun_hardcode_pci_resources_onboard_tulip(void)
  386. {
  387. struct pci_bus bus;
  388. struct pci_dev dev;
  389. u32 temp;
  391. bus.parent = NULL; /* we scan the top level only */
  392. bus.ops = &ddb5477_ext_pci_ops;
  393. dev.bus = &bus;
  394. dev.sysdata = NULL;
  396. /* for slot 4 on board ether chip */
  397. dev.devfn = 4*8;
  398. pci_read_config_dword(&dev, 0, &temp);
  399. MIPS_ASSERT(temp == 0x00191011);
  401. pci_write_config_dword(&dev, PCI_BASE_ADDRESS_0, 0x1000);
  402. pci_write_config_dword(&dev, PCI_BASE_ADDRESS_1, DDB_PCI0_MEM_BASE);
  403. pci_write_config_dword(&dev, PCI_INTERRUPT_LINE, 16);
  404. }
  406. static void jsun_hardcode_pci_resources(void)
  407. {
  408. jsun_hardcode_pci_resources_onboard_tulip();
  409. }
  411. void jsun_assign_pci_resource(void)
  412. {
  413. jsun_hardcode_pci_resources();
  414. }
  416. #endif