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

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

嵌入式Linux

开发平台：

Unix_Linux

pci.c：源码内容
  1. /*
  2.  *  arch/mips/ddb5476/pci.c -- NEC DDB Vrc-5074 PCI access routines
  3.  *
  4.  *  Copyright (C) 2000 Geert Uytterhoeven <geert@sonycom.com>
  5.  *                     Albert Dorofeev <albert@sonycom.com>
  6.  *                     Sony Software Development Center Europe (SDCE), Brussels
  7.  */
  8. #include <linux/init.h>
  9. #include <linux/kernel.h>
  10. #include <linux/pci.h>
  11. #include <linux/types.h>
  12. #include <linux/sched.h>
  13. #include <linux/ioport.h>
  15. #include <asm-mips/nile4.h>
  17. static u32 nile4_pre_pci_access0(int slot_num)
  18. {
  19. u32 pci_addr = 0;
  20. u32 virt_addr = NILE4_PCI_CFG_BASE;
  22. /* work around the bug for Vrc5476 */
  23. if (slot_num == 13)
  24. return NILE4_BASE + NILE4_PCI_BASE;
  26. /* Set window 1 address 08000000 - 32 bit - 128 MB (PCI config space) */
  27. nile4_set_pdar(NILE4_PCIW1, PHYSADDR(virt_addr), 0x08000000, 32, 0,
  28.        0);
  30. // [jsun] we start scanning from addr:10, 
  31. // with 128M we can go up to addr:26 (slot 16)
  32. if (slot_num <= 16) {
  33. virt_addr += 0x00000400 << slot_num;
  34. } else {
  35. /* for high slot, we have to set higher PCI base addr */
  36. pci_addr = 0x00000400 << slot_num;
  37. }
  38. nile4_set_pmr(NILE4_PCIINIT1, NILE4_PCICMD_CFG, pci_addr);
  39. return virt_addr;
  40. }
  42. static void nile4_post_pci_access0(void)
  43. {
  44. /*
  45.  * Set window 1 back to address 08000000 - 32 bit - 128 MB
  46.  * (PCI IO space)
  47.  */
  48. nile4_set_pdar(NILE4_PCIW1, PHYSADDR(NILE4_PCI_MEM_BASE),
  49.        0x08000000, 32, 1, 1);
  50. // nile4_set_pmr(NILE4_PCIINIT1, NILE4_PCICMD_MEM, 0);
  51. nile4_set_pmr(NILE4_PCIINIT1, NILE4_PCICMD_MEM, 0x08000000);
  52. }
  55. static int nile4_pci_read_config_dword(struct pci_dev *dev,
  56.        int where, u32 * val)
  57. {
  58. int slot_num, func_num;
  59. u32 base;
  60. u32 addr;
  62. /*
  63.  *  Do we need to generate type 1 configure transaction?
  64.  */
  65. if (dev->bus->number) {
  66. /* FIXME - not working yet */
  67. return PCIBIOS_FUNC_NOT_SUPPORTED;
  69. /*
  70.  * the largest type 1 configuration addr is 16M, < 256M
  71.  * config space
  72.  */
  73. slot_num = 0;
  74. addr =
  75.     (dev->bus->number << 16) | (dev->devfn <
  76. 8) | where | 1;
  77. } else {
  78. slot_num = PCI_SLOT(dev->devfn);
  79. func_num = PCI_FUNC(dev->devfn);
  80. addr = (func_num << 8) + where;
  81. }
  83. base = nile4_pre_pci_access0(slot_num);
  84. *val = *(volatile u32 *) (base + addr);
  85. nile4_post_pci_access0();
  86. return PCIBIOS_SUCCESSFUL;
  87. }
  89. static int nile4_pci_write_config_dword(struct pci_dev *dev, int where,
  90. u32 val)
  91. {
  92. int slot_num, func_num;
  93. u32 base;
  94. u32 addr;
  96. /*
  97.  *  Do we need to generate type 1 configure transaction?
  98.  */
  99. if (dev->bus->number) {
  100. /* FIXME - not working yet */
  101. return PCIBIOS_FUNC_NOT_SUPPORTED;
  103. /* the largest type 1 configuration addr is 16M, < 256M config space */
  104. slot_num = 0;
  105. addr =
  106.     (dev->bus->number << 16) | (dev->devfn <
  107. 8) | where | 1;
  108. } else {
  109. slot_num = PCI_SLOT(dev->devfn);
  110. func_num = PCI_FUNC(dev->devfn);
  111. addr = (func_num << 8) + where;
  112. }
  114. base = nile4_pre_pci_access0(slot_num);
  115. *(volatile u32 *) (base + addr) = val;
  116. nile4_post_pci_access0();
  117. return PCIBIOS_SUCCESSFUL;
  118. }
  120. static int nile4_pci_read_config_word(struct pci_dev *dev, int where,
  121.       u16 * val)
  122. {
  123. int status;
  124. u32 result;
  126. status = nile4_pci_read_config_dword(dev, where & ~3, &result);
  127. if (status != PCIBIOS_SUCCESSFUL)
  128. return status;
  129. if (where & 2)
  130. result >>= 16;
  131. *val = result & 0xffff;
  132. return PCIBIOS_SUCCESSFUL;
  133. }
  135. static int nile4_pci_read_config_byte(struct pci_dev *dev, int where,
  136.       u8 * val)
  137. {
  138. int status;
  139. u32 result;
  141. status = nile4_pci_read_config_dword(dev, where & ~3, &result);
  142. if (status != PCIBIOS_SUCCESSFUL)
  143. return status;
  144. if (where & 1)
  145. result >>= 8;
  146. if (where & 2)
  147. result >>= 16;
  148. *val = result & 0xff;
  149. return PCIBIOS_SUCCESSFUL;
  150. }
  152. static int nile4_pci_write_config_word(struct pci_dev *dev, int where,
  153.        u16 val)
  154. {
  155. int status, shift = 0;
  156. u32 result;
  158. status = nile4_pci_read_config_dword(dev, where & ~3, &result);
  159. if (status != PCIBIOS_SUCCESSFUL)
  160. return status;
  161. if (where & 2)
  162. shift += 16;
  163. result &= ~(0xffff << shift);
  164. result |= val << shift;
  165. return nile4_pci_write_config_dword(dev, where & ~3, result);
  166. }
  168. static int nile4_pci_write_config_byte(struct pci_dev *dev, int where,
  169.        u8 val)
  170. {
  171. int status, shift = 0;
  172. u32 result;
  174. status = nile4_pci_read_config_dword(dev, where & ~3, &result);
  175. if (status != PCIBIOS_SUCCESSFUL)
  176. return status;
  177. if (where & 2)
  178. shift += 16;
  179. if (where & 1)
  180. shift += 8;
  181. result &= ~(0xff << shift);
  182. result |= val << shift;
  183. return nile4_pci_write_config_dword(dev, where & ~3, result);
  184. }
  186. struct pci_ops nile4_pci_ops = {
  187. nile4_pci_read_config_byte,
  188. nile4_pci_read_config_word,
  189. nile4_pci_read_config_dword,
  190. nile4_pci_write_config_byte,
  191. nile4_pci_write_config_word,
  192. nile4_pci_write_config_dword
  193. };
  195. struct {
  196. struct resource ram;
  197. struct resource flash;
  198. struct resource isa_io;
  199. struct resource pci_io;
  200. struct resource isa_mem;
  201. struct resource pci_mem;
  202. struct resource nile4;
  203. struct resource boot;
  204. } ddb5476_resources = {
  205. // { "RAM", 0x00000000, 0x03ffffff, IORESOURCE_MEM | PCI_BASE_ADDRESS_MEM_TYPE_64 },
  206. {
  207. "RAM", 0x00000000, 0x03ffffff, IORESOURCE_MEM}, {
  208. "Flash ROM", 0x04000000, 0x043fffff}, {
  209. "Nile4 ISA I/O", 0x06000000, 0x060fffff}, {
  210. "Nile4 PCI I/O", 0x06100000, 0x07ffffff}, {
  211. "Nile4 ISA mem", 0x08000000, 0x08ffffff, IORESOURCE_MEM}, {
  212. "Nile4 PCI mem", 0x09000000, 0x0fffffff, IORESOURCE_MEM},
  213.     // { "Nile4 ctrl", 0x1fa00000, 0x1fbfffff, IORESOURCE_MEM | PCI_BASE_ADDRESS_MEM_TYPE_64 },
  214. {
  215. "Nile4 ctrl", 0x1fa00000, 0x1fbfffff, IORESOURCE_MEM}, {
  216. "Boot ROM", 0x1fc00000, 0x1fffffff}
  217. };
  219. struct resource M5229_resources[5] = {
  220. {"M5229 BAR0", 0x1f0, 0x1f3, IORESOURCE_IO},
  221. {"M5229 BAR1", 0x3f4, 0x3f7, IORESOURCE_IO},
  222. {"M5229 BAR2", 0x170, 0x173, IORESOURCE_IO},
  223. {"M5229 BAR3", 0x374, 0x377, IORESOURCE_IO},
  224. {"M5229 BAR4", 0xf000, 0xf00f, IORESOURCE_IO}
  225. };
  227. static void __init ddb5476_pci_fixup(void)
  228. {
  229. struct pci_dev *dev;
  231. pci_for_each_dev(dev) {
  232. if (dev->vendor == PCI_VENDOR_ID_NEC &&
  233.     dev->device == PCI_DEVICE_ID_NEC_VRC5476) {
  234. /*
  235.  * The first 64-bit PCI base register should point to
  236.  * the Nile4 control registers. Unfortunately this
  237.  * isn't the case, so we fix it ourselves. This allows
  238.  * the serial driver to find the UART.
  239.  */
  240. dev->resource[0] = ddb5476_resources.nile4;
  241. request_resource(&iomem_resource,
  242.  &dev->resource[0]);
  243. /*
  244.  * The second 64-bit PCI base register points to the
  245.  * first memory bank. Unfortunately the address is
  246.  * wrong, so we fix it (again).
  247.  */
  249. /* [jsun] We cannot request the resource anymore,
  250.  * because kernel/setup.c has already reserved "System 
  251.  * RAM" resource at the same spot.  
  252.  * The fundamental problem here is that PCI host 
  253.  * controller should not put system RAM mapping in BAR
  254.  * and make subject to PCI resource assignement.
  255.  * Current fix is a total hack.  We set parent to 1 so
  256.                          * so that PCI resource assignement code is fooled to 
  257.                          * think the resource is assigned, and will not attempt
  258.                          * to mess with it.
  259.  */
  260. dev->resource[2] = ddb5476_resources.ram;
  261. if (request_resource(&iomem_resource,
  262.                      &dev->resource[2]) ) {
  263. dev->resource[2].parent = 0x1;
  264.                         }
  266. } else if (dev->vendor == PCI_VENDOR_ID_AL
  267.    && dev->device == PCI_DEVICE_ID_AL_M7101) {
  268. /*
  269.  * It's nice to have the LEDs on the GPIO pins
  270.  * available for debugging
  271.  */
  272. extern struct pci_dev *pci_pmu;
  273. u8 t8;
  275. pci_pmu = dev; /* for LEDs D2 and D3 */
  276. /* Program the lines for LEDs D2 and D3 to output */
  277. nile4_pci_read_config_byte(dev, 0x7d, &t8);
  278. t8 |= 0xc0;
  279. nile4_pci_write_config_byte(dev, 0x7d, t8);
  280. /* Turn LEDs D2 and D3 off */
  281. nile4_pci_read_config_byte(dev, 0x7e, &t8);
  282. t8 |= 0xc0;
  283. nile4_pci_write_config_byte(dev, 0x7e, t8);
  284. } else if (dev->vendor == PCI_VENDOR_ID_AL &&
  285.    dev->device == 0x5229) {
  286. int i;
  287. for (i = 0; i < 5; i++) {
  288. dev->resource[i] = M5229_resources[i];
  289. request_resource(&ioport_resource,
  290.  &dev->resource[i]);
  291. }
  292. }
  293. }
  294. }
  296. static void __init pcibios_fixup_irqs(void)
  297. {
  298. struct pci_dev *dev;
  299. int slot_num;
  301. pci_for_each_dev(dev) {
  302. slot_num = PCI_SLOT(dev->devfn);
  303. switch (slot_num) {
  304. case 3: /* re-programmed to USB */
  305. dev->irq = 9; /* hard-coded; see irq.c */
  306. break;
  307. case 4: /* re-programmed to PMU */
  308. dev->irq = 10; /* hard-coded; see irq.c */
  309. break;
  310. case 6: /* on-board pci-pci bridge */
  311. dev->irq = 0xff;
  312. break;
  313. case 7: /* on-board ether */
  314. dev->irq = nile4_to_irq(NILE4_INT_INTB);
  315. break;
  316. case 8: /* ISA-PCI bridge  */
  317. dev->irq = nile4_to_irq(NILE4_INT_INTC);
  318. break;
  319. case 9: /* ext slot #3 */
  320. dev->irq = nile4_to_irq(NILE4_INT_INTD);
  321. break;
  322. case 10: /* ext slot #4 */
  323. dev->irq = nile4_to_irq(NILE4_INT_INTA);
  324. break;
  325. case 13: /* Vrc5476 */
  326. dev->irq = 0xff;
  327. break;
  328. case 14: /* HD controller, M5229 */
  329. dev->irq = 14;
  330. break;
  331. default:
  332. printk
  333.     ("JSUN : in pcibios_fixup_irqs - unkown slot %dn",
  334.      slot_num);
  335. panic
  336.     ("JSUN : in pcibios_fixup_irqs - unkown slot.n");
  337. }
  338. }
  339. }
  341. void __init pcibios_init(void)
  342. {
  343. printk("PCI: Emulate bios initialization n");
  344. /* [jsun] we need to set BAR0 so that SDRAM 0 appears at 0x0 in PCI */
  345. *(long *) (NILE4_BASE + NILE4_BAR0) = 0x8;
  347. printk("PCI: Probing PCI hardwaren");
  348. ioport_resource.end = 0x1ffffff; /*  32 MB */
  349. iomem_resource.end = 0x1fffffff; /* 512 MB */
  351. /* `ram' and `nile4' are requested through the Nile4 pci_dev */
  352. request_resource(&iomem_resource, &ddb5476_resources.flash);
  353. request_resource(&iomem_resource, &ddb5476_resources.isa_io);
  354. request_resource(&iomem_resource, &ddb5476_resources.pci_io);
  355. request_resource(&iomem_resource, &ddb5476_resources.isa_mem);
  356. request_resource(&iomem_resource, &ddb5476_resources.pci_mem);
  357. request_resource(&iomem_resource, &ddb5476_resources.boot);
  359. pci_scan_bus(0, &nile4_pci_ops, NULL);
  360. ddb5476_pci_fixup();
  361. pci_assign_unassigned_resources();
  362. pcibios_fixup_irqs();
  363. }
  365. void __init pcibios_fixup_bus(struct pci_bus *bus)
  366. {
  367. /* [jsun] we don't know how to fix sub-buses yet */
  368. if (bus->number == 0) {
  369. bus->resource[1] = &ddb5476_resources.pci_mem;
  370. }
  371. }
  373. char *pcibios_setup(char *str)
  374. {
  375. return str;
  376. }
  378. void __init pcibios_update_irq(struct pci_dev *dev, int irq)
  379. {
  380. pci_write_config_byte(dev, PCI_INTERRUPT_LINE, irq);
  381. }
  383. void __init pcibios_fixup_pbus_ranges(struct pci_bus *bus,
  384.       struct pbus_set_ranges_data *ranges)
  385. {
  386. /*
  387.  * our caller figure out range by going through the dev structures.  
  388.  * I guess this is the place to fix things up if the bus is using a 
  389.  * different view of the addressing space.
  390.  */
  392. #if 0 /*  original DDB5074 code */
  393.    if (bus->number == 0) {
  394.    ranges->io_start -= bus->resource[0]->start;
  395.    ranges->io_end -= bus->resource[0]->start;
  396.    ranges->mem_start -= bus->resource[1]->start;
  397.    ranges->mem_end -= bus->resource[1]->start;
  398.    }
  399. #endif
  400. }
  402. int pcibios_enable_resources(struct pci_dev *dev)
  403. {
  404. u16 cmd, old_cmd;
  405. int idx;
  406. struct resource *r;
  408. /*
  409.  *  Don't touch the Nile 4
  410.  */
  411. if (dev->vendor == PCI_VENDOR_ID_NEC &&
  412.     dev->device == PCI_DEVICE_ID_NEC_VRC5476) return 0;
  414. pci_read_config_word(dev, PCI_COMMAND, &cmd);
  415. old_cmd = cmd;
  416. for (idx = 0; idx < 6; idx++) {
  417. r = &dev->resource[idx];
  418. if (!r->start && r->end) {
  419. printk(KERN_ERR "PCI: Device %s not available because "
  420.        "of resource collisionsn", dev->slot_name);
  421. return -EINVAL;
  422. }
  423. if (r->flags & IORESOURCE_IO)
  424. cmd |= PCI_COMMAND_IO;
  425. if (r->flags & IORESOURCE_MEM)
  426. cmd |= PCI_COMMAND_MEMORY;
  427. }
  428. if (cmd != old_cmd) {
  429. printk("PCI: Enabling device %s (%04x -> %04x)n",
  430.        dev->slot_name, old_cmd, cmd);
  431. pci_write_config_word(dev, PCI_COMMAND, cmd);
  432. }
  433. return 0;
  434. }
  436. int pcibios_enable_device(struct pci_dev *dev)
  437. {
  438. return pcibios_enable_resources(dev);
  439. }
  441. void pcibios_update_resource(struct pci_dev *dev, struct resource *root,
  442.      struct resource *res, int resource)
  443. {
  444. u32 new, check;
  445. int reg;
  447. new = res->start | (res->flags & PCI_REGION_FLAG_MASK);
  448. if (resource < 6) {
  449. reg = PCI_BASE_ADDRESS_0 + 4 * resource;
  450. } else if (resource == PCI_ROM_RESOURCE) {
  451. res->flags |= PCI_ROM_ADDRESS_ENABLE;
  452. reg = dev->rom_base_reg;
  453. } else {
  454. /*
  455.  * Somebody might have asked allocation of a non-standard
  456.  * resource
  457.  */
  458. return;
  459. }
  461. pci_write_config_dword(dev, reg, new);
  462. pci_read_config_dword(dev, reg, &check);
  463. if ((new ^ check) &
  464.     ((new & PCI_BASE_ADDRESS_SPACE_IO) ? PCI_BASE_ADDRESS_IO_MASK :
  465.      PCI_BASE_ADDRESS_MEM_MASK)) {
  466. printk(KERN_ERR "PCI: Error while updating region "
  467.        "%s/%d (%08x != %08x)n", dev->slot_name, resource,
  468.        new, check);
  469. }
  470. }
  472. void pcibios_align_resource(void *data, struct resource *res,
  473.     unsigned long size)
  474. {
  475. struct pci_dev *dev = data;
  477. if (res->flags & IORESOURCE_IO) {
  478. unsigned long start = res->start;
  480. /* We need to avoid collisions with `mirrored' VGA ports
  481.    and other strange ISA hardware, so we always want the
  482.    addresses kilobyte aligned.  */
  483. if (size > 0x100) {
  484. printk(KERN_ERR "PCI: I/O Region %s/%d too large"
  485.        " (%ld bytes)n", dev->slot_name,
  486.        dev->resource - res, size);
  487. }
  489. start = (start + 1024 - 1) & ~(1024 - 1);
  490. res->start = start;
  491. }
  492. }
  494. unsigned __init int pcibios_assign_all_busses(void)
  495. {
  496. return 1;
  497. }
  499. struct pci_fixup pcibios_fixups[] = { {0} };