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

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

嵌入式Linux

开发平台：

Unix_Linux

pci.c：源码内容
  1. /*
  2.  * BK Id: SCCS/s.pci.c 1.40 01/25/02 15:15:24 benh
  3.  */
  4. /*
  5.  * Common pmac/prep/chrp pci routines. -- Cort
  6.  */
  8. #include <linux/config.h>
  9. #include <linux/kernel.h>
  10. #include <linux/pci.h>
  11. #include <linux/delay.h>
  12. #include <linux/string.h>
  13. #include <linux/init.h>
  14. #include <linux/capability.h>
  15. #include <linux/sched.h>
  16. #include <linux/errno.h>
  17. #include <linux/bootmem.h>
  19. #include <asm/processor.h>
  20. #include <asm/io.h>
  21. #include <asm/prom.h>
  22. #include <asm/sections.h>
  23. #include <asm/pci-bridge.h>
  24. #include <asm/residual.h>
  25. #include <asm/byteorder.h>
  26. #include <asm/irq.h>
  27. #include <asm/gg2.h>
  28. #include <asm/uaccess.h>
  30. #include "pci.h"
  32. #define DEBUG
  34. #ifdef DEBUG
  35. #define DBG(x...) printk(x)
  36. #else
  37. #define DBG(x...)
  38. #endif
  40. unsigned long isa_io_base     = 0;
  41. unsigned long isa_mem_base    = 0;
  42. unsigned long pci_dram_offset = 0;
  44. void pcibios_make_OF_bus_map(void);
  46. static void pcibios_fixup_resources(struct pci_dev* dev);
  47. static void fixup_broken_pcnet32(struct pci_dev* dev);
  48. static void fixup_rev1_53c810(struct pci_dev* dev);
  49. #ifdef CONFIG_ALL_PPC
  50. static void pcibios_fixup_cardbus(struct pci_dev* dev);
  51. static u8* pci_to_OF_bus_map;
  52. #endif
  54. /* By default, we don't re-assign bus numbers. We do this only on
  55.  * some pmacs
  56.  */
  57. int pci_assign_all_busses;
  59. struct pci_controller* hose_head;
  60. struct pci_controller** hose_tail = &hose_head;
  62. static int pci_bus_count;
  64. struct pci_fixup pcibios_fixups[] = {
  65. { PCI_FIXUP_HEADER, PCI_VENDOR_ID_TRIDENT, PCI_ANY_ID, fixup_broken_pcnet32 },
  66. { PCI_FIXUP_HEADER, PCI_VENDOR_ID_NCR, PCI_DEVICE_ID_NCR_53C810, fixup_rev1_53c810 },
  67. { PCI_FIXUP_HEADER, PCI_ANY_ID, PCI_ANY_ID, pcibios_fixup_resources },
  68. #ifdef CONFIG_ALL_PPC
  69. /* We should add per-machine fixup support in xxx_setup.c or xxx_pci.c */
  70. { PCI_FIXUP_FINAL, PCI_VENDOR_ID_TI, PCI_ANY_ID, pcibios_fixup_cardbus }, 
  71. #endif /* CONFIG_ALL_PPC */
  72.   { 0 }
  73. };
  75. static void
  76. fixup_rev1_53c810(struct pci_dev* dev)
  77. {
  78. /* rev 1 ncr53c810 chips don't set the class at all which means
  79.  * they don't get their resources remapped. Fix that here.
  80.  */
  82. if ((dev->class == PCI_CLASS_NOT_DEFINED)) {
  83. printk("NCR 53c810 rev 1 detected, setting PCI class.n");
  84. dev->class = PCI_CLASS_STORAGE_SCSI;
  85. }
  86. }
  88. static void
  89. fixup_broken_pcnet32(struct pci_dev* dev)
  90. {
  91. if ((dev->class>>8 == PCI_CLASS_NETWORK_ETHERNET)) {
  92. dev->vendor = PCI_VENDOR_ID_AMD;
  93. pci_write_config_word(dev, PCI_VENDOR_ID, PCI_VENDOR_ID_AMD);
  94. pci_name_device(dev);
  95. }
  96. }
  98. void
  99. pcibios_update_resource(struct pci_dev *dev, struct resource *root,
  100.      struct resource *res, int resource)
  101. {
  102. u32 new, check;
  103. int reg;
  104. struct pci_controller* hose = dev->sysdata;
  105. unsigned long io_offset;
  107. new = res->start;
  108. if (hose && res->flags & IORESOURCE_IO) {
  109. io_offset = (unsigned long)hose->io_base_virt - isa_io_base;
  110. new -= io_offset;
  111. }
  112. if (hose && res->flags & IORESOURCE_MEM)
  113. new -= hose->pci_mem_offset;
  114. new |= (res->flags & PCI_REGION_FLAG_MASK);
  115. if (resource < 6) {
  116. reg = PCI_BASE_ADDRESS_0 + 4*resource;
  117. } else if (resource == PCI_ROM_RESOURCE) {
  118. res->flags |= PCI_ROM_ADDRESS_ENABLE;
  119. reg = dev->rom_base_reg;
  120. } else {
  121. /* Somebody might have asked allocation of a non-standard resource */
  122. return;
  123. }
  125. pci_write_config_dword(dev, reg, new);
  126. pci_read_config_dword(dev, reg, &check);
  127. if ((new ^ check) & ((new & PCI_BASE_ADDRESS_SPACE_IO) ? PCI_BASE_ADDRESS_IO_MASK : PCI_BASE_ADDRESS_MEM_MASK)) {
  128. printk(KERN_ERR "PCI: Error while updating region "
  129.        "%s/%d (%08x != %08x)n", dev->slot_name, resource,
  130.        new, check);
  131. }
  132. }
  134. static void
  135. pcibios_fixup_resources(struct pci_dev *dev)
  136. {
  137. struct pci_controller* hose = (struct pci_controller *)dev->sysdata;
  138. int i;
  139. unsigned long offset;
  141. if (!hose) {
  142. printk(KERN_ERR "No hose for PCI dev %s!n", dev->slot_name);
  143. return;
  144. }
  145. for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
  146. struct resource *res = dev->resource + i;
  147. if (!res->start || !res->flags)
  148. continue;
  149. if (res->end == 0xffffffff) {
  150. DBG("PCI:%s Resource %d [%08lx-%08lx] is unassignedn",
  151.     dev->slot_name, i, res->start, res->end);
  152. res->end -= res->start;
  153. res->start = 0;
  154. continue;
  155. }
  156. offset = 0;
  157. if (res->flags & IORESOURCE_MEM) {
  158. offset = hose->pci_mem_offset;
  159. } else if (res->flags & IORESOURCE_IO) {
  160. offset = (unsigned long) hose->io_base_virt
  161. - isa_io_base;
  162. }
  163. if (offset != 0) {
  164. res->start += offset;
  165. res->end += offset;
  166. #ifdef DEBUG
  167. printk("Fixup res %d (%lx) of dev %s: %lx -> %lxn",
  168.        i, res->flags, dev->slot_name,
  169.        res->start - offset, res->start);
  170. #endif
  171. }
  172. }
  173. }
  175. #ifdef CONFIG_ALL_PPC
  176. static void
  177. pcibios_fixup_cardbus(struct pci_dev* dev)
  178. {
  179. if (_machine != _MACH_Pmac)
  180. return;
  181. /*
  182.  * Fix the interrupt routing on the TI1211 chip on the 1999
  183.  * G3 powerbook, which doesn't get initialized properly by OF.
  184.  * Same problem with the 1410 of the new titanium pbook which
  185.  * has the same register.
  186.  */
  187. if (dev->vendor == PCI_VENDOR_ID_TI
  188.     && (dev->device == PCI_DEVICE_ID_TI_1211 ||
  189.         dev->device == PCI_DEVICE_ID_TI_1410)) {
  190. u8 val;
  191. /* 0x8c == TI122X_IRQMUX, 2 says to route the INTA
  192.    signal out the MFUNC0 pin */
  193. if (pci_read_config_byte(dev, 0x8c, &val) == 0)
  194. pci_write_config_byte(dev, 0x8c, (val & ~0x0f) | 2);
  195. /* Disable ISA interrupt mode */
  196. if (pci_read_config_byte(dev, 0x92, &val) == 0)
  197. pci_write_config_byte(dev, 0x92, val & ~0x06);
  198. }
  199. }
  200. #endif /* CONFIG_ALL_PPC */
  202. /*
  203.  * We need to avoid collisions with `mirrored' VGA ports
  204.  * and other strange ISA hardware, so we always want the
  205.  * addresses to be allocated in the 0x000-0x0ff region
  206.  * modulo 0x400.
  207.  *
  208.  * Why? Because some silly external IO cards only decode
  209.  * the low 10 bits of the IO address. The 0x00-0xff region
  210.  * is reserved for motherboard devices that decode all 16
  211.  * bits, so it's ok to allocate at, say, 0x2800-0x28ff,
  212.  * but we want to try to avoid allocating at 0x2900-0x2bff
  213.  * which might have be mirrored at 0x0100-0x03ff..
  214.  */
  215. void
  216. pcibios_align_resource(void *data, struct resource *res, unsigned long size)
  217. {
  218. struct pci_dev *dev = data;
  220. if (res->flags & IORESOURCE_IO) {
  221. unsigned long start = res->start;
  223. if (size > 0x100) {
  224. printk(KERN_ERR "PCI: I/O Region %s/%d too large"
  225.        " (%ld bytes)n", dev->slot_name,
  226.        dev->resource - res, size);
  227. }
  229. if (start & 0x300) {
  230. start = (start + 0x3ff) & ~0x3ff;
  231. res->start = start;
  232. }
  233. }
  234. }
  237. /*
  238.  *  Handle resources of PCI devices.  If the world were perfect, we could
  239.  *  just allocate all the resource regions and do nothing more.  It isn't.
  240.  *  On the other hand, we cannot just re-allocate all devices, as it would
  241.  *  require us to know lots of host bridge internals.  So we attempt to
  242.  *  keep as much of the original configuration as possible, but tweak it
  243.  *  when it's found to be wrong.
  244.  *
  245.  *  Known BIOS problems we have to work around:
  246.  * - I/O or memory regions not configured
  247.  * - regions configured, but not enabled in the command register
  248.  * - bogus I/O addresses above 64K used
  249.  * - expansion ROMs left enabled (this may sound harmless, but given
  250.  *   the fact the PCI specs explicitly allow address decoders to be
  251.  *   shared between expansion ROMs and other resource regions, it's
  252.  *   at least dangerous)
  253.  *
  254.  *  Our solution:
  255.  * (1) Allocate resources for all buses behind PCI-to-PCI bridges.
  256.  *     This gives us fixed barriers on where we can allocate.
  257.  * (2) Allocate resources for all enabled devices.  If there is
  258.  *     a collision, just mark the resource as unallocated. Also
  259.  *     disable expansion ROMs during this step.
  260.  * (3) Try to allocate resources for disabled devices.  If the
  261.  *     resources were assigned correctly, everything goes well,
  262.  *     if they weren't, they won't disturb allocation of other
  263.  *     resources.
  264.  * (4) Assign new addresses to resources which were either
  265.  *     not configured at all or misconfigured.  If explicitly
  266.  *     requested by the user, configure expansion ROM address
  267.  *     as well.
  268.  */
  270. static void __init
  271. pcibios_allocate_bus_resources(struct list_head *bus_list)
  272. {
  273. struct list_head *ln;
  274. struct pci_bus *bus;
  275. int i;
  276. struct resource *res, *pr;
  278. /* Depth-First Search on bus tree */
  279. for (ln = bus_list->next; ln != bus_list; ln=ln->next) {
  280. bus = pci_bus_b(ln);
  281. for (i = 0; i < 4; ++i) {
  282. if ((res = bus->resource[i]) == NULL || !res->flags)
  283. continue;
  284. if (bus->parent == NULL)
  285. pr = (res->flags & IORESOURCE_IO)?
  286. &ioport_resource: &iomem_resource;
  287. else {
  288. pr = pci_find_parent_resource(bus->self, res);
  289. if (pr == res) {
  290. /* this happens when the generic PCI
  291.  * code (wrongly) decides that this
  292.  * bridge is transparent  -- paulus
  293.  */
  294. continue;
  295. }
  296. }
  298. if (pr && request_resource(pr, res) == 0)
  299. continue;
  300. printk(KERN_ERR "PCI: Cannot allocate resource region "
  301.        "%d of PCI bridge %dn", i, bus->number);
  302. DBG("PCI: resource is %lx..%lx (%lx), parent %pn",
  303.     res->start, res->end, res->flags, pr);
  304. }
  305. pcibios_allocate_bus_resources(&bus->children);
  306. }
  307. }
  309. static inline void alloc_resource(struct pci_dev *dev, int idx)
  310. {
  311. struct resource *pr, *r = &dev->resource[idx];
  313. DBG("PCI:%s: Resource %d: %08lx-%08lx (f=%lx)n",
  314.     dev->slot_name, idx, r->start, r->end, r->flags);
  315. pr = pci_find_parent_resource(dev, r);
  316. if (!pr || request_resource(pr, r) < 0) {
  317. printk(KERN_ERR "PCI: Cannot allocate resource region %d"
  318.        " of device %sn", idx, dev->slot_name);
  319. if (pr)
  320. DBG("PCI:  parent is %p: %08lx-%08lx (f=%lx)n",
  321.     pr, pr->start, pr->end, pr->flags);
  322. /* We'll assign a new address later */
  323. r->end -= r->start;
  324. r->start = 0;
  325. }
  326. }
  328. static void __init
  329. pcibios_allocate_resources(int pass)
  330. {
  331. struct pci_dev *dev;
  332. int idx, disabled;
  333. u16 command;
  334. struct resource *r;
  336. pci_for_each_dev(dev) {
  337. pci_read_config_word(dev, PCI_COMMAND, &command);
  338. for (idx = 0; idx < 6; idx++) {
  339. r = &dev->resource[idx];
  340. if (r->parent) /* Already allocated */
  341. continue;
  342. if (!r->start) /* Not assigned at all */
  343. continue;
  344. if (r->flags & IORESOURCE_IO)
  345. disabled = !(command & PCI_COMMAND_IO);
  346. else
  347. disabled = !(command & PCI_COMMAND_MEMORY);
  348. if (pass == disabled)
  349. alloc_resource(dev, idx);
  350. }
  351. if (pass)
  352. continue;
  353. r = &dev->resource[PCI_ROM_RESOURCE];
  354. if (r->flags & PCI_ROM_ADDRESS_ENABLE) {
  355. /* Turn the ROM off, leave the resource region, but keep it unregistered. */
  356. u32 reg;
  357. DBG("PCI: Switching off ROM of %sn", dev->slot_name);
  358. r->flags &= ~PCI_ROM_ADDRESS_ENABLE;
  359. pci_read_config_dword(dev, dev->rom_base_reg, &reg);
  360. pci_write_config_dword(dev, dev->rom_base_reg,
  361.        reg & ~PCI_ROM_ADDRESS_ENABLE);
  362. }
  363. }
  364. }
  366. static void __init
  367. pcibios_assign_resources(void)
  368. {
  369. struct pci_dev *dev;
  370. int idx;
  371. struct resource *r;
  373. pci_for_each_dev(dev) {
  374. int class = dev->class >> 8;
  376. /* Don't touch classless devices and host bridges */
  377. if (!class || class == PCI_CLASS_BRIDGE_HOST)
  378. continue;
  380. for (idx = 0; idx < 6; idx++) {
  381. r = &dev->resource[idx];
  383. /*
  384.  * We shall assign a new address to this resource,
  385.  * either because the BIOS (sic) forgot to do so
  386.  * or because we have decided the old address was
  387.  * unusable for some reason.
  388.  */
  389. if (!r->start && r->end &&
  390.     (!ppc_md.pcibios_enable_device_hook ||
  391.      !ppc_md.pcibios_enable_device_hook(dev, 1)))
  392. pci_assign_resource(dev, idx);
  393. }
  395. #if 0 /* don't assign ROMs */
  396. r = &dev->resource[PCI_ROM_RESOURCE];
  397. r->end -= r->start;
  398. r->start = 0;
  399. if (r->end)
  400. pci_assign_resource(dev, PCI_ROM_RESOURCE);
  401. #endif
  402. }
  403. }
  406. int
  407. pcibios_enable_resources(struct pci_dev *dev)
  408. {
  409. u16 cmd, old_cmd;
  410. int idx;
  411. struct resource *r;
  413. pci_read_config_word(dev, PCI_COMMAND, &cmd);
  414. old_cmd = cmd;
  415. for(idx=0; idx<6; idx++) {
  416. r = &dev->resource[idx];
  417. if (!r->start && r->end) {
  418. printk(KERN_ERR "PCI: Device %s not available because of resource collisionsn", dev->slot_name);
  419. return -EINVAL;
  420. }
  421. if (r->flags & IORESOURCE_IO)
  422. cmd |= PCI_COMMAND_IO;
  423. if (r->flags & IORESOURCE_MEM)
  424. cmd |= PCI_COMMAND_MEMORY;
  425. }
  426. if (dev->resource[PCI_ROM_RESOURCE].start)
  427. cmd |= PCI_COMMAND_MEMORY;
  428. if (cmd != old_cmd) {
  429. printk("PCI: Enabling device %s (%04x -> %04x)n", dev->slot_name, old_cmd, cmd);
  430. pci_write_config_word(dev, PCI_COMMAND, cmd);
  431. }
  432. return 0;
  433. }
  435. static int next_controller_index;
  437. struct pci_controller * __init
  438. pcibios_alloc_controller(void)
  439. {
  440. struct pci_controller *hose;
  442. hose = (struct pci_controller *)alloc_bootmem(sizeof(*hose));
  443. memset(hose, 0, sizeof(struct pci_controller));
  445. *hose_tail = hose;
  446. hose_tail = &hose->next;
  448. hose->index = next_controller_index++;
  450. return hose;
  451. }
  453. #ifdef CONFIG_ALL_PPC
  454. /*
  455.  * Functions below are used on OpenFirmware machines.
  456.  */
  457. static void __openfirmware
  458. make_one_node_map(struct device_node* node, u8 pci_bus)
  459. {
  460. int *bus_range;
  461. int len;
  463. if (pci_bus >= pci_bus_count)
  464. return;
  465. bus_range = (int *) get_property(node, "bus-range", &len);
  466. if (bus_range == NULL || len < 2 * sizeof(int)) {
  467. printk(KERN_WARNING "Can't get bus-range for %sn",
  468.        node->full_name);
  469. return;
  470. }
  471. pci_to_OF_bus_map[pci_bus] = bus_range[0];
  473. for (node=node->child; node != 0;node = node->sibling) {
  474. struct pci_dev* dev;
  475. unsigned int *class_code, *reg;
  477. class_code = (unsigned int *) get_property(node, "class-code", 0);
  478. if (!class_code || ((*class_code >> 8) != PCI_CLASS_BRIDGE_PCI &&
  479. (*class_code >> 8) != PCI_CLASS_BRIDGE_CARDBUS))
  480. continue;
  481. reg = (unsigned int *)get_property(node, "reg", 0);
  482. if (!reg)
  483. continue;
  484. dev = pci_find_slot(pci_bus, ((reg[0] >> 8) & 0xff));
  485. if (!dev || !dev->subordinate)
  486. continue;
  487. make_one_node_map(node, dev->subordinate->number);
  488. }
  489. }
  491. void __openfirmware
  492. pcibios_make_OF_bus_map(void)
  493. {
  494. int i;
  495. struct pci_controller* hose;
  496. u8* of_prop_map;
  498. pci_to_OF_bus_map = (u8*)kmalloc(pci_bus_count, GFP_KERNEL);
  499. if (!pci_to_OF_bus_map) {
  500. printk(KERN_ERR "Can't allocate OF bus map !n");
  501. return;
  502. }
  504. /* We fill the bus map with invalid values, that helps
  505.  * debugging.
  506.  */
  507. for (i=0; i<pci_bus_count; i++)
  508. pci_to_OF_bus_map[i] = 0xff;
  510. /* For each hose, we begin searching bridges */
  511. for(hose=hose_head; hose; hose=hose->next) {
  512. struct device_node* node;
  513. node = (struct device_node *)hose->arch_data;
  514. if (!node)
  515. continue;
  516. make_one_node_map(node, hose->first_busno);
  517. }
  518. of_prop_map = get_property(find_path_device("/"), "pci-OF-bus-map", 0);
  519. if (of_prop_map)
  520. memcpy(of_prop_map, pci_to_OF_bus_map, pci_bus_count);
  521. #ifdef DEBUG
  522. printk("PCI->OF bus map:n");
  523. for (i=0; i<pci_bus_count; i++) {
  524. if (pci_to_OF_bus_map[i] == 0xff)
  525. continue;
  526. printk("%d -> %dn", i, pci_to_OF_bus_map[i]);
  527. }
  528. #endif
  529. }
  531. typedef int (*pci_OF_scan_iterator)(struct device_node* node, void* data);
  533. static struct device_node* __openfirmware
  534. scan_OF_pci_childs(struct device_node* node, pci_OF_scan_iterator filter, void* data)
  535. {
  536. struct device_node* sub_node;
  538. for (; node != 0;node = node->sibling) {
  539. unsigned int *class_code;
  541. if (filter(node, data))
  542. return node;
  544. /* For PCI<->PCI bridges or CardBus bridges, we go down
  545.  * Note: some OFs create a parent node "multifunc-device" as
  546.  * a fake root for all functions of a multi-function device,
  547.  * we go down them as well.
  548.  */
  549. class_code = (unsigned int *) get_property(node, "class-code", 0);
  550. if ((!class_code || ((*class_code >> 8) != PCI_CLASS_BRIDGE_PCI &&
  551. (*class_code >> 8) != PCI_CLASS_BRIDGE_CARDBUS)) &&
  552. strcmp(node->name, "multifunc-device"))
  553. continue;
  554. sub_node = scan_OF_pci_childs(node->child, filter, data);
  555. if (sub_node)
  556. return sub_node;
  557. }
  558. return NULL;
  559. }
  561. static int
  562. scan_OF_pci_childs_iterator(struct device_node* node, void* data)
  563. {
  564. unsigned int *reg;
  565. u8* fdata = (u8*)data;
  567. reg = (unsigned int *) get_property(node, "reg", 0);
  568. if (reg && ((reg[0] >> 8) & 0xff) == fdata[1]
  569. && ((reg[0] >> 16) & 0xff) == fdata[0])
  570. return 1;
  571. return 0;
  572. }
  574. static struct device_node* __openfirmware
  575. scan_OF_childs_for_device(struct device_node* node, u8 bus, u8 dev_fn)
  576. {
  577. u8 filter_data[2] = {bus, dev_fn};
  579. return scan_OF_pci_childs(node, scan_OF_pci_childs_iterator, filter_data);
  580. }
  582. /* 
  583.  * Scans the OF tree for a device node matching a PCI device
  584.  */
  585. struct device_node*
  586. pci_device_to_OF_node(struct pci_dev *dev)
  587. {
  588. struct pci_controller *hose;
  589. struct device_node *node;
  590. int bus;
  592. if (!have_of)
  593. return NULL;
  595. /* Lookup the hose */
  596. bus = dev->bus->number;
  597. hose = pci_bus_to_hose(bus);
  598. if (!hose)
  599. return NULL;
  601. /* Check it has an OF node associated */
  602. node = (struct device_node *) hose->arch_data;
  603. if (!node)
  604. return NULL;
  606. /* Fixup bus number according to what OF think it is. */
  607. if (pci_to_OF_bus_map)
  608. bus = pci_to_OF_bus_map[bus];
  609. if (bus == 0xff)
  610. return NULL;
  612. /* Now, lookup childs of the hose */
  613. return scan_OF_childs_for_device(node->child, bus, dev->devfn);
  614. }
  616. /* This routine is meant to be used early during boot, when the
  617.  * PCI bus numbers have not yet been assigned, and you need to
  618.  * issue PCI config cycles to an OF device.
  619.  * It could also be used to "fix" RTAS config cycles if you want
  620.  * to set pci_assign_all_busses to 1 and still use RTAS for PCI
  621.  * config cycles.
  622.  */
  623. struct pci_controller*
  624. pci_find_hose_for_OF_device(struct device_node* node)
  625. {
  626. if (!have_of)
  627. return NULL;
  628. while(node) {
  629. struct pci_controller* hose;
  630. for (hose=hose_head;hose;hose=hose->next)
  631. if (hose->arch_data == node)
  632. return hose;
  633. node=node->parent;
  634. }
  635. return NULL;
  636. }
  638. static int __openfirmware
  639. find_OF_pci_device_filter(struct device_node* node, void* data)
  640. {
  641. return ((void *)node == data);
  642. }
  644. /* 
  645.  * Returns the PCI device matching a given OF node
  646.  */
  647. int
  648. pci_device_from_OF_node(struct device_node* node, u8* bus, u8* devfn)
  649. {
  650. unsigned int *reg;
  651. struct pci_controller* hose;
  652. struct pci_dev* dev;
  654. if (!have_of)
  655. return -ENODEV;
  656. /* Make sure it's really a PCI device */
  657. hose = pci_find_hose_for_OF_device(node);
  658. if (!hose || !hose->arch_data)
  659. return -ENODEV;
  660. if (!scan_OF_pci_childs(((struct device_node*)hose->arch_data)->child,
  661. find_OF_pci_device_filter, (void *)node))
  662. return -ENODEV;
  663. reg = (unsigned int *) get_property(node, "reg", 0);
  664. if (!reg)
  665. return -ENODEV;
  666. *bus = (reg[0] >> 16) & 0xff;
  667. *devfn = ((reg[0] >> 8) & 0xff);
  669. /* Ok, here we need some tweak. If we have already renumbered
  670.  * all busses, we can't rely on the OF bus number any more.
  671.  * the pci_to_OF_bus_map is not enough as several PCI busses
  672.  * may match the same OF bus number.
  673.  */
  674. if (!pci_to_OF_bus_map)
  675. return 0;
  676. pci_for_each_dev(dev) {
  677. if (pci_to_OF_bus_map[dev->bus->number] != *bus)
  678. continue;
  679. if (dev->devfn != *devfn)
  680. continue;
  681. *bus = dev->bus->number;
  682. return 0;
  683. }
  684. return -ENODEV;
  685. }
  687. void __init
  688. pci_process_bridge_OF_ranges(struct pci_controller *hose,
  689.    struct device_node *dev, int primary)
  690. {
  691. unsigned int *ranges, *prev;
  692. int rlen = 0;
  693. int memno = 0;
  694. struct resource *res;
  695. int np, na = prom_n_addr_cells(dev);
  696. np = na + 5;
  698. /* First we try to merge ranges to fix a problem with some pmacs
  699.  * that can have more than 3 ranges, fortunately using contiguous
  700.  * addresses -- BenH
  701.  */
  702. ranges = (unsigned int *) get_property(dev, "ranges", &rlen);
  703. prev = NULL;
  704. while ((rlen -= np * sizeof(unsigned int)) >= 0) {
  705. if (prev) {
  706. if (prev[0] == ranges[0] && prev[1] == ranges[1] &&
  707. (prev[2] + prev[na+4]) == ranges[2] &&
  708. (prev[na+2] + prev[na+4]) == ranges[na+2]) {
  709. prev[na+4] += ranges[na+4];
  710. ranges[0] = 0;
  711. ranges += np;
  712. continue;
  713. }
  714. }
  715. prev = ranges;
  716. ranges += np;
  717. }
  719. /*
  720.  * The ranges property is laid out as an array of elements,
  721.  * each of which comprises:
  722.  *   cells 0 - 2: a PCI address
  723.  *   cells 3 or 3+4: a CPU physical address
  724.  * (size depending on dev->n_addr_cells)
  725.  *   cells 4+5 or 5+6: the size of the range
  726.  */
  727. rlen = 0;
  728. hose->io_base_phys = 0;
  729. ranges = (unsigned int *) get_property(dev, "ranges", &rlen);
  730. while ((rlen -= np * sizeof(unsigned int)) >= 0) {
  731. res = NULL;
  732. switch (ranges[0] >> 24) {
  733. case 1: /* I/O space */
  734. if (ranges[2] != 0)
  735. break;
  736. hose->io_base_phys = ranges[na+2];
  737. hose->io_base_virt = ioremap(ranges[na+2], ranges[na+4]);
  738. if (primary)
  739. isa_io_base = (unsigned long) hose->io_base_virt;
  740. res = &hose->io_resource;
  741. res->flags = IORESOURCE_IO;
  742. res->start = ranges[2];
  743. break;
  744. case 2: /* memory space */
  745. memno = 0;
  746. if (ranges[1] == 0 && ranges[2] == 0
  747.     && ranges[na+4] <= (16 << 20)) {
  748. /* 1st 16MB, i.e. ISA memory area */
  749. if (primary)
  750. isa_mem_base = ranges[na+2];
  751. memno = 1;
  752. }
  753. while (memno < 3 && hose->mem_resources[memno].flags)
  754. ++memno;
  755. if (memno == 0)
  756. hose->pci_mem_offset = ranges[na+2] - ranges[2];
  757. if (memno < 3) {
  758. res = &hose->mem_resources[memno];
  759. res->flags = IORESOURCE_MEM;
  760. res->start = ranges[na+2];
  761. }
  762. break;
  763. }
  764. if (res != NULL) {
  765. res->name = dev->full_name;
  766. res->end = res->start + ranges[na+4] - 1;
  767. res->parent = NULL;
  768. res->sibling = NULL;
  769. res->child = NULL;
  770. }
  771. ranges += np;
  772. }
  773. }
  774. #endif /* CONFIG_ALL_PPC */
  776. void __init
  777. pcibios_init(void)
  778. {
  779. struct pci_controller *hose;
  780. struct pci_bus *bus;
  781. int next_busno;
  783. printk(KERN_INFO "PCI: Probing PCI hardwaren");
  785. /* Scan all of the recorded PCI controllers.  */
  786. for (next_busno = 0, hose = hose_head; hose; hose = hose->next) {
  787. if (pci_assign_all_busses)
  788. hose->first_busno = next_busno;
  789. hose->last_busno = 0xff;
  790. bus = pci_scan_bus(hose->first_busno, hose->ops, hose);
  791. hose->last_busno = bus->subordinate;
  792. if (pci_assign_all_busses || next_busno <= hose->last_busno)
  793. next_busno = hose->last_busno+1;
  794. }
  795. pci_bus_count = next_busno;
  797. /* OpenFirmware based machines need a map of OF bus
  798.  * numbers vs. kernel bus numbers since we may have to
  799.  * remap them.
  800.  */
  801. if (pci_assign_all_busses && have_of)
  802. pcibios_make_OF_bus_map();
  804. /* Call machine dependant fixup */
  805. if (ppc_md.pcibios_fixup)
  806. ppc_md.pcibios_fixup();
  808. /* Allocate and assign resources */
  809. pcibios_allocate_bus_resources(&pci_root_buses);
  810. pcibios_allocate_resources(0);
  811. pcibios_allocate_resources(1);
  812. pcibios_assign_resources();
  814. /* Call machine dependent post-init code */
  815. if (ppc_md.pcibios_after_init)
  816. ppc_md.pcibios_after_init();
  817. }
  819. int __init
  820. pcibios_assign_all_busses(void)
  821. {
  822. return pci_assign_all_busses;
  823. }
  825. void __init
  826. pcibios_fixup_pbus_ranges(struct pci_bus * bus, struct pbus_set_ranges_data * ranges)
  827. {
  828. ranges->io_start -= bus->resource[0]->start;
  829. ranges->io_end -= bus->resource[0]->start;
  830. ranges->mem_start -= bus->resource[1]->start;
  831. ranges->mem_end -= bus->resource[1]->start;
  832. }
  834. unsigned long resource_fixup(struct pci_dev * dev, struct resource * res,
  835.      unsigned long start, unsigned long size)
  836. {
  837. return start;
  838. }
  840. void __init pcibios_fixup_bus(struct pci_bus *bus)
  841. {
  842. struct pci_controller *hose = (struct pci_controller *) bus->sysdata;
  843. unsigned long io_offset;
  844. struct resource *res;
  845. int i;
  847. io_offset = (unsigned long)hose->io_base_virt - isa_io_base;
  848. if (bus->parent == NULL) {
  849. /* This is a host bridge - fill in its resources */
  850. hose->bus = bus;
  852. bus->resource[0] = res = &hose->io_resource;
  853. if (!res->flags) {
  854. if (io_offset)
  855. printk(KERN_ERR "I/O resource not set for host"
  856.        " bridge %dn", hose->index);
  857. res->start = 0;
  858. res->end = IO_SPACE_LIMIT;
  859. res->flags = IORESOURCE_IO;
  860. }
  861. res->start += io_offset;
  862. res->end += io_offset;
  864. for (i = 0; i < 3; ++i) {
  865. res = &hose->mem_resources[i];
  866. if (!res->flags) {
  867. if (i > 0)
  868. continue;
  869. printk(KERN_ERR "Memory resource not set for "
  870.        "host bridge %dn", hose->index);
  871. res->start = hose->pci_mem_offset;
  872. res->end = ~0U;
  873. res->flags = IORESOURCE_MEM;
  874. }
  875. bus->resource[i+1] = res;
  876. }
  877. } else {
  878. /* This is a subordinate bridge */
  879. pci_read_bridge_bases(bus);
  881. for (i = 0; i < 4; ++i) {
  882. if ((res = bus->resource[i]) == NULL)
  883. continue;
  884. if (!res->flags)
  885. continue;
  886. if (io_offset && (res->flags & IORESOURCE_IO)) {
  887. res->start += io_offset;
  888. res->end += io_offset;
  889. } else if (hose->pci_mem_offset
  890.    && (res->flags & IORESOURCE_MEM)) {
  891. res->start += hose->pci_mem_offset;
  892. res->end += hose->pci_mem_offset;
  893. }
  894. }
  895. }
  897. if (ppc_md.pcibios_fixup_bus)
  898. ppc_md.pcibios_fixup_bus(bus);
  899. }
  901. char __init *pcibios_setup(char *str)
  902. {
  903. return str;
  904. }
  906. /* the next one is stolen from the alpha port... */
  907. void __init
  908. pcibios_update_irq(struct pci_dev *dev, int irq)
  909. {
  910. pci_write_config_byte(dev, PCI_INTERRUPT_LINE, irq);
  911. /* XXX FIXME - update OF device tree node interrupt property */
  912. }
  914. int pcibios_enable_device(struct pci_dev *dev)
  915. {
  916. u16 cmd, old_cmd;
  917. int idx;
  918. struct resource *r;
  920. if (ppc_md.pcibios_enable_device_hook)
  921. if (ppc_md.pcibios_enable_device_hook(dev, 0))
  922. return -EINVAL;
  924. pci_read_config_word(dev, PCI_COMMAND, &cmd);
  925. old_cmd = cmd;
  926. for (idx=0; idx<6; idx++) {
  927. r = &dev->resource[idx];
  928. if (!r->start && r->end) {
  929. printk(KERN_ERR "PCI: Device %s not available because of resource collisionsn", dev->slot_name);
  930. return -EINVAL;
  931. }
  932. if (r->flags & IORESOURCE_IO)
  933. cmd |= PCI_COMMAND_IO;
  934. if (r->flags & IORESOURCE_MEM)
  935. cmd |= PCI_COMMAND_MEMORY;
  936. }
  937. if (cmd != old_cmd) {
  938. printk("PCI: Enabling device %s (%04x -> %04x)n",
  939.        dev->slot_name, old_cmd, cmd);
  940. pci_write_config_word(dev, PCI_COMMAND, cmd);
  941. }
  942. return 0;
  943. }
  945. struct pci_controller*
  946. pci_bus_to_hose(int bus)
  947. {
  948. struct pci_controller* hose = hose_head;
  950. for (; hose; hose = hose->next)
  951. if (bus >= hose->first_busno && bus <= hose->last_busno)
  952. return hose;
  953. return NULL;
  954. }
  956. void*
  957. pci_bus_io_base(unsigned int bus)
  958. {
  959. struct pci_controller *hose;
  961. hose = pci_bus_to_hose(bus);
  962. if (!hose)
  963. return NULL;
  964. return hose->io_base_virt;
  965. }
  967. unsigned long
  968. pci_bus_io_base_phys(unsigned int bus)
  969. {
  970. struct pci_controller *hose;
  972. hose = pci_bus_to_hose(bus);
  973. if (!hose)
  974. return 0;
  975. return hose->io_base_phys;
  976. }
  978. unsigned long
  979. pci_bus_mem_base_phys(unsigned int bus)
  980. {
  981. struct pci_controller *hose;
  983. hose = pci_bus_to_hose(bus);
  984. if (!hose)
  985. return 0;
  986. return hose->pci_mem_offset;
  987. }
  989. unsigned long
  990. pci_resource_to_bus(struct pci_dev *pdev, struct resource *res)
  991. {
  992. /* Hack alert again ! See comments in chrp_pci.c
  993.  */
  994. struct pci_controller* hose =
  995. (struct pci_controller *)pdev->sysdata;
  996. if (hose && res->flags & IORESOURCE_MEM)
  997. return res->start - hose->pci_mem_offset;
  998. /* We may want to do something with IOs here... */
  999. return res->start;
  1000. }
  1002. /*
  1003.  * Return the index of the PCI controller for device pdev.
  1004.  */
  1005. int pci_controller_num(struct pci_dev *dev)
  1006. {
  1007. struct pci_controller *hose = (struct pci_controller *) dev->sysdata;
  1009. return hose->index;
  1010. }
  1012. /*
  1013.  * Platform support for /proc/bus/pci/X/Y mmap()s,
  1014.  * modelled on the sparc64 implementation by Dave Miller.
  1015.  *  -- paulus.
  1016.  */
  1018. /*
  1019.  * Adjust vm_pgoff of VMA such that it is the physical page offset
  1020.  * corresponding to the 32-bit pci bus offset for DEV requested by the user.
  1021.  *
  1022.  * Basically, the user finds the base address for his device which he wishes
  1023.  * to mmap.  They read the 32-bit value from the config space base register,
  1024.  * add whatever PAGE_SIZE multiple offset they wish, and feed this into the
  1025.  * offset parameter of mmap on /proc/bus/pci/XXX for that device.
  1026.  *
  1027.  * Returns negative error code on failure, zero on success.
  1028.  */
  1029. static __inline__ int
  1030. __pci_mmap_make_offset(struct pci_dev *dev, struct vm_area_struct *vma,
  1031.        enum pci_mmap_state mmap_state)
  1032. {
  1033. struct pci_controller *hose = (struct pci_controller *) dev->sysdata;
  1034. unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
  1035. unsigned long io_offset = 0;
  1036. int i, res_bit;
  1038. if (hose == 0)
  1039. return -EINVAL; /* should never happen */
  1041. /* If memory, add on the PCI bridge address offset */
  1042. if (mmap_state == pci_mmap_mem) {
  1043. offset += hose->pci_mem_offset;
  1044. res_bit = IORESOURCE_MEM;
  1045. } else {
  1046. io_offset = (unsigned long)hose->io_base_virt - isa_io_base;
  1047. offset += io_offset;
  1048. res_bit = IORESOURCE_IO;
  1049. }
  1051. /*
  1052.  * Check that the offset requested corresponds to one of the
  1053.  * resources of the device.
  1054.  */
  1055. for (i = 0; i <= PCI_ROM_RESOURCE; i++) {
  1056. struct resource *rp = &dev->resource[i];
  1057. int flags = rp->flags;
  1059. /* treat ROM as memory (should be already) */
  1060. if (i == PCI_ROM_RESOURCE)
  1061. flags |= IORESOURCE_MEM;
  1063. /* Active and same type? */
  1064. if ((flags & res_bit) == 0)
  1065. continue;
  1067. /* In the range of this resource? */
  1068. if (offset < (rp->start & PAGE_MASK) || offset > rp->end)
  1069. continue;
  1071. /* found it! construct the final physical address */
  1072. if (mmap_state == pci_mmap_io)
  1073. offset += hose->io_base_phys - io_offset;
  1075. vma->vm_pgoff = offset >> PAGE_SHIFT;
  1076. return 0;
  1077. }
  1079. return -EINVAL;
  1080. }
  1082. /*
  1083.  * Set vm_flags of VMA, as appropriate for this architecture, for a pci device
  1084.  * mapping.
  1085.  */
  1086. static __inline__ void
  1087. __pci_mmap_set_flags(struct pci_dev *dev, struct vm_area_struct *vma,
  1088.      enum pci_mmap_state mmap_state)
  1089. {
  1090. vma->vm_flags |= VM_SHM | VM_LOCKED | VM_IO;
  1091. }
  1093. /*
  1094.  * Set vm_page_prot of VMA, as appropriate for this architecture, for a pci
  1095.  * device mapping.
  1096.  */
  1097. static __inline__ void
  1098. __pci_mmap_set_pgprot(struct pci_dev *dev, struct vm_area_struct *vma,
  1099.       enum pci_mmap_state mmap_state, int write_combine)
  1100. {
  1101. int prot = pgprot_val(vma->vm_page_prot);
  1103. /* XXX would be nice to have a way to ask for write-through */
  1104. prot |= _PAGE_NO_CACHE;
  1105. if (!write_combine)
  1106. prot |= _PAGE_GUARDED;
  1107. vma->vm_page_prot = __pgprot(prot);
  1108. }
  1110. /*
  1111.  * Perform the actual remap of the pages for a PCI device mapping, as
  1112.  * appropriate for this architecture.  The region in the process to map
  1113.  * is described by vm_start and vm_end members of VMA, the base physical
  1114.  * address is found in vm_pgoff.
  1115.  * The pci device structure is provided so that architectures may make mapping
  1116.  * decisions on a per-device or per-bus basis.
  1117.  *
  1118.  * Returns a negative error code on failure, zero on success.
  1119.  */
  1120. int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
  1121. enum pci_mmap_state mmap_state,
  1122. int write_combine)
  1123. {
  1124. int ret;
  1126. ret = __pci_mmap_make_offset(dev, vma, mmap_state);
  1127. if (ret < 0)
  1128. return ret;
  1130. __pci_mmap_set_flags(dev, vma, mmap_state);
  1131. __pci_mmap_set_pgprot(dev, vma, mmap_state, write_combine);
  1133. ret = remap_page_range(vma->vm_start, vma->vm_pgoff << PAGE_SHIFT,
  1134.        vma->vm_end - vma->vm_start, vma->vm_page_prot);
  1136. return ret;
  1137. }
  1139. /* Obsolete functions. Should be removed once the symbios driver
  1140.  * is fixed
  1141.  */
  1142. unsigned long
  1143. phys_to_bus(unsigned long pa)
  1144. {
  1145. struct pci_controller *hose;
  1146. int i;
  1148. for (hose = hose_head; hose; hose = hose->next) {
  1149. for (i = 0; i < 3; ++i) {
  1150. if (pa >= hose->mem_resources[i].start
  1151.     && pa <= hose->mem_resources[i].end) {
  1152. /*
  1153.  * XXX the hose->pci_mem_offset really
  1154.  * only applies to mem_resources[0].
  1155.  * We need a way to store an offset for
  1156.  * the others.  -- paulus
  1157.  */
  1158. if (i == 0)
  1159. pa -= hose->pci_mem_offset;
  1160. return pa;
  1161. }
  1162. }
  1163. }
  1164. /* hmmm, didn't find it */
  1165. return 0;
  1166. }
  1168. unsigned long
  1169. pci_phys_to_bus(unsigned long pa, int busnr)
  1170. {
  1171. struct pci_controller* hose = pci_bus_to_hose(busnr);
  1172. if (!hose)
  1173. return pa;
  1174. return pa - hose->pci_mem_offset;
  1175. }
  1177. unsigned long
  1178. pci_bus_to_phys(unsigned int ba, int busnr)
  1179. {
  1180. struct pci_controller* hose = pci_bus_to_hose(busnr);
  1181. if (!hose)
  1182. return ba;
  1183. return ba + hose->pci_mem_offset;
  1184. }
  1186. /* Provide information on locations of various I/O regions in physical
  1187.  * memory.  Do this on a per-card basis so that we choose the right
  1188.  * root bridge.
  1189.  * Note that the returned IO or memory base is a physical address
  1190.  */
  1192. long
  1193. sys_pciconfig_iobase(long which, unsigned long bus, unsigned long devfn)
  1194. {
  1195. struct pci_controller* hose = pci_bus_to_hose(bus);
  1196. long result = -EOPNOTSUPP;
  1198. if (!hose)
  1199. return -ENODEV;
  1201. switch (which) {
  1202. case IOBASE_BRIDGE_NUMBER:
  1203. return (long)hose->first_busno;
  1204. case IOBASE_MEMORY:
  1205. return (long)hose->pci_mem_offset;
  1206. case IOBASE_IO:
  1207. return (long)hose->io_base_phys;
  1208. case IOBASE_ISA_IO:
  1209. return (long)isa_io_base;
  1210. case IOBASE_ISA_MEM:
  1211. return (long)isa_mem_base;
  1212. }
  1214. return result;
  1215. }
  1217. /*
  1218.  * Null PCI config access functions, for the case when we can't
  1219.  * find a hose.
  1220.  */
  1221. #define NULL_PCI_OP(rw, size, type)
  1222. static int
  1223. null_##rw##_config_##size(struct pci_dev *dev, int offset, type val)
  1224. {
  1225. return PCIBIOS_DEVICE_NOT_FOUND;    
  1226. }
  1228. NULL_PCI_OP(read, byte, u8 *)
  1229. NULL_PCI_OP(read, word, u16 *)
  1230. NULL_PCI_OP(read, dword, u32 *)
  1231. NULL_PCI_OP(write, byte, u8)
  1232. NULL_PCI_OP(write, word, u16)
  1233. NULL_PCI_OP(write, dword, u32)
  1235. static struct pci_ops null_pci_ops =
  1236. {
  1237. null_read_config_byte,
  1238. null_read_config_word,
  1239. null_read_config_dword,
  1240. null_write_config_byte,
  1241. null_write_config_word,
  1242. null_write_config_dword
  1243. };
  1245. /*
  1246.  * These functions are used early on before PCI scanning is done
  1247.  * and all of the pci_dev and pci_bus structures have been created.
  1248.  */
  1249. static struct pci_dev *
  1250. fake_pci_dev(struct pci_controller *hose, int busnr, int devfn)
  1251. {
  1252. static struct pci_dev dev;
  1253. static struct pci_bus bus;
  1255. if (hose == 0) {
  1256. hose = pci_bus_to_hose(busnr);
  1257. if (hose == 0)
  1258. printk(KERN_ERR "Can't find hose for PCI bus %d!n", busnr);
  1259. }
  1260. dev.bus = &bus;
  1261. dev.sysdata = hose;
  1262. dev.devfn = devfn;
  1263. bus.number = busnr;
  1264. bus.ops = hose? hose->ops: &null_pci_ops;
  1265. return &dev;
  1266. }
  1268. #define EARLY_PCI_OP(rw, size, type)
  1269. int early_##rw##_config_##size(struct pci_controller *hose, int bus,
  1270.        int devfn, int offset, type value)
  1271. {
  1272. return pci_##rw##_config_##size(fake_pci_dev(hose, bus, devfn),
  1273. offset, value);
  1274. }
  1276. EARLY_PCI_OP(read, byte, u8 *)
  1277. EARLY_PCI_OP(read, word, u16 *)
  1278. EARLY_PCI_OP(read, dword, u32 *)
  1279. EARLY_PCI_OP(write, byte, u8)
  1280. EARLY_PCI_OP(write, word, u16)
  1281. EARLY_PCI_OP(write, dword, u32)