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

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

Linux/Unix编程

开发平台：

Unix_Linux

pci.c：源码内容
  1. /*
  2.  * BK Id: %F% %I% %G% %U% %#%
  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/byteorder.h>
  25. #include <asm/irq.h>
  26. #include <asm/uaccess.h>
  28. #undef DEBUG
  30. #ifdef DEBUG
  31. #define DBG(x...) printk(x)
  32. #else
  33. #define DBG(x...)
  34. #endif
  36. unsigned long isa_io_base     = 0;
  37. unsigned long isa_mem_base    = 0;
  38. unsigned long pci_dram_offset = 0;
  40. void pcibios_make_OF_bus_map(void);
  42. static void pcibios_fixup_resources(struct pci_dev* dev);
  43. static void fixup_broken_pcnet32(struct pci_dev* dev);
  44. static void fixup_rev1_53c810(struct pci_dev* dev);
  45. static void fixup_cpc710_pci64(struct pci_dev* dev);
  46. #ifdef CONFIG_ALL_PPC
  47. static void pcibios_fixup_cardbus(struct pci_dev* dev);
  48. static u8* pci_to_OF_bus_map;
  49. #endif
  51. /* By default, we don't re-assign bus numbers. We do this only on
  52.  * some pmacs
  53.  */
  54. int pci_assign_all_busses;
  56. struct pci_controller* hose_head;
  57. struct pci_controller** hose_tail = &hose_head;
  59. static int pci_bus_count;
  61. struct pci_fixup pcibios_fixups[] = {
  62. { PCI_FIXUP_HEADER, PCI_VENDOR_ID_TRIDENT, PCI_ANY_ID, fixup_broken_pcnet32 },
  63. { PCI_FIXUP_HEADER, PCI_VENDOR_ID_NCR, PCI_DEVICE_ID_NCR_53C810, fixup_rev1_53c810 },
  64. { PCI_FIXUP_HEADER, PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CPC710_PCI64, fixup_cpc710_pci64},
  65. { PCI_FIXUP_HEADER, PCI_ANY_ID, PCI_ANY_ID, pcibios_fixup_resources },
  66. #ifdef CONFIG_ALL_PPC
  67. /* We should add per-machine fixup support in xxx_setup.c or xxx_pci.c */
  68. { PCI_FIXUP_FINAL, PCI_VENDOR_ID_TI, PCI_ANY_ID, pcibios_fixup_cardbus }, 
  69. #endif /* CONFIG_ALL_PPC */
  70.   { 0 }
  71. };
  73. static void
  74. fixup_rev1_53c810(struct pci_dev* dev)
  75. {
  76. /* rev 1 ncr53c810 chips don't set the class at all which means
  77.  * they don't get their resources remapped. Fix that here.
  78.  */
  80. if ((dev->class == PCI_CLASS_NOT_DEFINED)) {
  81. printk("NCR 53c810 rev 1 detected, setting PCI class.n");
  82. dev->class = PCI_CLASS_STORAGE_SCSI;
  83. }
  84. }
  86. static void
  87. fixup_broken_pcnet32(struct pci_dev* dev)
  88. {
  89. if ((dev->class>>8 == PCI_CLASS_NETWORK_ETHERNET)) {
  90. dev->vendor = PCI_VENDOR_ID_AMD;
  91. pci_write_config_word(dev, PCI_VENDOR_ID, PCI_VENDOR_ID_AMD);
  92. pci_name_device(dev);
  93. }
  94. }
  96. static void
  97. fixup_cpc710_pci64(struct pci_dev* dev)
  98. {
  99. /* Hide the PCI64 BARs from the kernel as their content doesn't
  100.  * fit well in the resource management
  101.  */
  102. dev->resource[0].start = dev->resource[0].end = 0;
  103. dev->resource[0].flags = 0;
  104. dev->resource[1].start = dev->resource[1].end = 0;
  105. dev->resource[1].flags = 0;
  106. }
  108. void
  109. pcibios_update_resource(struct pci_dev *dev, struct resource *root,
  110.      struct resource *res, int resource)
  111. {
  112. u32 new, check;
  113. int reg;
  114. struct pci_controller* hose = dev->sysdata;
  115. unsigned long io_offset;
  117. new = res->start;
  118. if (hose && res->flags & IORESOURCE_IO) {
  119. io_offset = (unsigned long)hose->io_base_virt - isa_io_base;
  120. new -= io_offset;
  121. }
  122. if (hose && res->flags & IORESOURCE_MEM)
  123. new -= hose->pci_mem_offset;
  124. new |= (res->flags & PCI_REGION_FLAG_MASK);
  125. if (resource < 6) {
  126. reg = PCI_BASE_ADDRESS_0 + 4*resource;
  127. } else if (resource == PCI_ROM_RESOURCE) {
  128. res->flags |= PCI_ROM_ADDRESS_ENABLE;
  129. reg = dev->rom_base_reg;
  130. } else {
  131. /* Somebody might have asked allocation of a non-standard resource */
  132. return;
  133. }
  135. pci_write_config_dword(dev, reg, new);
  136. pci_read_config_dword(dev, reg, &check);
  137. if ((new ^ check) & ((new & PCI_BASE_ADDRESS_SPACE_IO) ? PCI_BASE_ADDRESS_IO_MASK : PCI_BASE_ADDRESS_MEM_MASK)) {
  138. printk(KERN_ERR "PCI: Error while updating region "
  139.        "%s/%d (%08x != %08x)n", dev->slot_name, resource,
  140.        new, check);
  141. }
  142. }
  144. static void
  145. pcibios_fixup_resources(struct pci_dev *dev)
  146. {
  147. struct pci_controller* hose = (struct pci_controller *)dev->sysdata;
  148. int i;
  149. unsigned long offset;
  151. if (!hose) {
  152. printk(KERN_ERR "No hose for PCI dev %s!n", dev->slot_name);
  153. return;
  154. }
  155. for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
  156. struct resource *res = dev->resource + i;
  157. if (!res->start || !res->flags)
  158. continue;
  159. if (res->end == 0xffffffff) {
  160. DBG("PCI:%s Resource %d [%08lx-%08lx] is unassignedn",
  161.     dev->slot_name, i, res->start, res->end);
  162. res->end -= res->start;
  163. res->start = 0;
  164. continue;
  165. }
  166. offset = 0;
  167. if (res->flags & IORESOURCE_MEM) {
  168. offset = hose->pci_mem_offset;
  169. } else if (res->flags & IORESOURCE_IO) {
  170. offset = (unsigned long) hose->io_base_virt
  171. - isa_io_base;
  172. }
  173. if (offset != 0) {
  174. res->start += offset;
  175. res->end += offset;
  176. #ifdef DEBUG
  177. printk("Fixup res %d (%lx) of dev %s: %lx -> %lxn",
  178.        i, res->flags, dev->slot_name,
  179.        res->start - offset, res->start);
  180. #endif
  181. }
  182. }
  184. /* Call machine specific resource fixup */
  185. if (ppc_md.pcibios_fixup_resources)
  186. ppc_md.pcibios_fixup_resources(dev);
  187. }
  189. #ifdef CONFIG_ALL_PPC
  190. static void
  191. pcibios_fixup_cardbus(struct pci_dev* dev)
  192. {
  193. if (_machine != _MACH_Pmac)
  194. return;
  195. /*
  196.  * Fix the interrupt routing on the various cardbus bridges
  197.  * used on powerbooks
  198.  */
  199. if (dev->vendor != PCI_VENDOR_ID_TI)
  200. return;
  201. if (dev->device == PCI_DEVICE_ID_TI_1130 ||
  202.     dev->device == PCI_DEVICE_ID_TI_1131) {
  203. u8 val;
  204.      /* Enable PCI interrupt */
  205. if (pci_read_config_byte(dev, 0x91, &val) == 0)
  206. pci_write_config_byte(dev, 0x91, val | 0x30);
  207. /* Disable ISA interrupt mode */
  208. if (pci_read_config_byte(dev, 0x92, &val) == 0)
  209. pci_write_config_byte(dev, 0x92, val & ~0x06);
  210. }
  211. if (dev->device == PCI_DEVICE_ID_TI_1210 ||
  212.     dev->device == PCI_DEVICE_ID_TI_1211 ||
  213.     dev->device == PCI_DEVICE_ID_TI_1410) {
  214. u8 val;
  215. /* 0x8c == TI122X_IRQMUX, 2 says to route the INTA
  216.    signal out the MFUNC0 pin */
  217. if (pci_read_config_byte(dev, 0x8c, &val) == 0)
  218. pci_write_config_byte(dev, 0x8c, (val & ~0x0f) | 2);
  219. /* Disable ISA interrupt mode */
  220. if (pci_read_config_byte(dev, 0x92, &val) == 0)
  221. pci_write_config_byte(dev, 0x92, val & ~0x06);
  222. }
  223. }
  224. #endif /* CONFIG_ALL_PPC */
  226. /*
  227.  * We need to avoid collisions with `mirrored' VGA ports
  228.  * and other strange ISA hardware, so we always want the
  229.  * addresses to be allocated in the 0x000-0x0ff region
  230.  * modulo 0x400.
  231.  *
  232.  * Why? Because some silly external IO cards only decode
  233.  * the low 10 bits of the IO address. The 0x00-0xff region
  234.  * is reserved for motherboard devices that decode all 16
  235.  * bits, so it's ok to allocate at, say, 0x2800-0x28ff,
  236.  * but we want to try to avoid allocating at 0x2900-0x2bff
  237.  * which might have be mirrored at 0x0100-0x03ff..
  238.  */
  239. void
  240. pcibios_align_resource(void *data, struct resource *res, unsigned long size,
  241.        unsigned long align)
  242. {
  243. struct pci_dev *dev = data;
  245. if (res->flags & IORESOURCE_IO) {
  246. unsigned long start = res->start;
  248. if (size > 0x100) {
  249. printk(KERN_ERR "PCI: I/O Region %s/%d too large"
  250.        " (%ld bytes)n", dev->slot_name,
  251.        dev->resource - res, size);
  252. }
  254. if (start & 0x300) {
  255. start = (start + 0x3ff) & ~0x3ff;
  256. res->start = start;
  257. }
  258. }
  259. }
  262. /*
  263.  *  Handle resources of PCI devices.  If the world were perfect, we could
  264.  *  just allocate all the resource regions and do nothing more.  It isn't.
  265.  *  On the other hand, we cannot just re-allocate all devices, as it would
  266.  *  require us to know lots of host bridge internals.  So we attempt to
  267.  *  keep as much of the original configuration as possible, but tweak it
  268.  *  when it's found to be wrong.
  269.  *
  270.  *  Known BIOS problems we have to work around:
  271.  * - I/O or memory regions not configured
  272.  * - regions configured, but not enabled in the command register
  273.  * - bogus I/O addresses above 64K used
  274.  * - expansion ROMs left enabled (this may sound harmless, but given
  275.  *   the fact the PCI specs explicitly allow address decoders to be
  276.  *   shared between expansion ROMs and other resource regions, it's
  277.  *   at least dangerous)
  278.  *
  279.  *  Our solution:
  280.  * (1) Allocate resources for all buses behind PCI-to-PCI bridges.
  281.  *     This gives us fixed barriers on where we can allocate.
  282.  * (2) Allocate resources for all enabled devices.  If there is
  283.  *     a collision, just mark the resource as unallocated. Also
  284.  *     disable expansion ROMs during this step.
  285.  * (3) Try to allocate resources for disabled devices.  If the
  286.  *     resources were assigned correctly, everything goes well,
  287.  *     if they weren't, they won't disturb allocation of other
  288.  *     resources.
  289.  * (4) Assign new addresses to resources which were either
  290.  *     not configured at all or misconfigured.  If explicitly
  291.  *     requested by the user, configure expansion ROM address
  292.  *     as well.
  293.  */
  295. static void __init
  296. pcibios_allocate_bus_resources(struct list_head *bus_list)
  297. {
  298. struct list_head *ln;
  299. struct pci_bus *bus;
  300. int i;
  301. struct resource *res, *pr;
  303. /* Depth-First Search on bus tree */
  304. for (ln = bus_list->next; ln != bus_list; ln=ln->next) {
  305. bus = pci_bus_b(ln);
  306. for (i = 0; i < 4; ++i) {
  307. if ((res = bus->resource[i]) == NULL || !res->flags)
  308. continue;
  309. if (bus->parent == NULL)
  310. pr = (res->flags & IORESOURCE_IO)?
  311. &ioport_resource: &iomem_resource;
  312. else {
  313. pr = pci_find_parent_resource(bus->self, res);
  314. if (pr == res) {
  315. /* this happens when the generic PCI
  316.  * code (wrongly) decides that this
  317.  * bridge is transparent  -- paulus
  318.  */
  319. continue;
  320. }
  321. }
  323. if (pr && request_resource(pr, res) == 0)
  324. continue;
  325. printk(KERN_ERR "PCI: Cannot allocate resource region "
  326.        "%d of PCI bridge %dn", i, bus->number);
  327. DBG("PCI: resource is %lx..%lx (%lx), parent %pn",
  328.     res->start, res->end, res->flags, pr);
  329. }
  330. pcibios_allocate_bus_resources(&bus->children);
  331. }
  332. }
  334. static inline void alloc_resource(struct pci_dev *dev, int idx)
  335. {
  336. struct resource *pr, *r = &dev->resource[idx];
  338. DBG("PCI:%s: Resource %d: %08lx-%08lx (f=%lx)n",
  339.     dev->slot_name, idx, r->start, r->end, r->flags);
  340. pr = pci_find_parent_resource(dev, r);
  341. if (!pr || request_resource(pr, r) < 0) {
  342. printk(KERN_ERR "PCI: Cannot allocate resource region %d"
  343.        " of device %sn", idx, dev->slot_name);
  344. if (pr)
  345. DBG("PCI:  parent is %p: %08lx-%08lx (f=%lx)n",
  346.     pr, pr->start, pr->end, pr->flags);
  347. /* We'll assign a new address later */
  348. r->end -= r->start;
  349. r->start = 0;
  350. }
  351. }
  353. static void __init
  354. pcibios_allocate_resources(int pass)
  355. {
  356. struct pci_dev *dev;
  357. int idx, disabled;
  358. u16 command;
  359. struct resource *r;
  361. pci_for_each_dev(dev) {
  362. pci_read_config_word(dev, PCI_COMMAND, &command);
  363. for (idx = 0; idx < 6; idx++) {
  364. r = &dev->resource[idx];
  365. if (r->parent) /* Already allocated */
  366. continue;
  367. if (!r->start) /* Not assigned at all */
  368. continue;
  369. if (r->flags & IORESOURCE_IO)
  370. disabled = !(command & PCI_COMMAND_IO);
  371. else
  372. disabled = !(command & PCI_COMMAND_MEMORY);
  373. if (pass == disabled)
  374. alloc_resource(dev, idx);
  375. }
  376. if (pass)
  377. continue;
  378. r = &dev->resource[PCI_ROM_RESOURCE];
  379. if (r->flags & PCI_ROM_ADDRESS_ENABLE) {
  380. /* Turn the ROM off, leave the resource region, but keep it unregistered. */
  381. u32 reg;
  382. DBG("PCI: Switching off ROM of %sn", dev->slot_name);
  383. r->flags &= ~PCI_ROM_ADDRESS_ENABLE;
  384. pci_read_config_dword(dev, dev->rom_base_reg, &reg);
  385. pci_write_config_dword(dev, dev->rom_base_reg,
  386.        reg & ~PCI_ROM_ADDRESS_ENABLE);
  387. }
  388. }
  389. }
  391. static void __init
  392. pcibios_assign_resources(void)
  393. {
  394. struct pci_dev *dev;
  395. int idx;
  396. struct resource *r;
  398. pci_for_each_dev(dev) {
  399. int class = dev->class >> 8;
  401. /* Don't touch classless devices and host bridges */
  402. if (!class || class == PCI_CLASS_BRIDGE_HOST)
  403. continue;
  405. for (idx = 0; idx < 6; idx++) {
  406. r = &dev->resource[idx];
  408. /*
  409.  * We shall assign a new address to this resource,
  410.  * either because the BIOS (sic) forgot to do so
  411.  * or because we have decided the old address was
  412.  * unusable for some reason.
  413.  */
  414. if (!r->start && r->end &&
  415.     (!ppc_md.pcibios_enable_device_hook ||
  416.      !ppc_md.pcibios_enable_device_hook(dev, 1)))
  417. pci_assign_resource(dev, idx);
  418. }
  420. #if 0 /* don't assign ROMs */
  421. r = &dev->resource[PCI_ROM_RESOURCE];
  422. r->end -= r->start;
  423. r->start = 0;
  424. if (r->end)
  425. pci_assign_resource(dev, PCI_ROM_RESOURCE);
  426. #endif
  427. }
  428. }
  431. int
  432. pcibios_enable_resources(struct pci_dev *dev)
  433. {
  434. u16 cmd, old_cmd;
  435. int idx;
  436. struct resource *r;
  438. pci_read_config_word(dev, PCI_COMMAND, &cmd);
  439. old_cmd = cmd;
  440. for(idx=0; idx<6; idx++) {
  441. r = &dev->resource[idx];
  442. if (!r->start && r->end) {
  443. printk(KERN_ERR "PCI: Device %s not available because of resource collisionsn", dev->slot_name);
  444. return -EINVAL;
  445. }
  446. if (r->flags & IORESOURCE_IO)
  447. cmd |= PCI_COMMAND_IO;
  448. if (r->flags & IORESOURCE_MEM)
  449. cmd |= PCI_COMMAND_MEMORY;
  450. }
  451. if (dev->resource[PCI_ROM_RESOURCE].start)
  452. cmd |= PCI_COMMAND_MEMORY;
  453. if (cmd != old_cmd) {
  454. printk("PCI: Enabling device %s (%04x -> %04x)n", dev->slot_name, old_cmd, cmd);
  455. pci_write_config_word(dev, PCI_COMMAND, cmd);
  456. }
  457. return 0;
  458. }
  460. static int next_controller_index;
  462. struct pci_controller * __init
  463. pcibios_alloc_controller(void)
  464. {
  465. struct pci_controller *hose;
  467. hose = (struct pci_controller *)alloc_bootmem(sizeof(*hose));
  468. memset(hose, 0, sizeof(struct pci_controller));
  470. *hose_tail = hose;
  471. hose_tail = &hose->next;
  473. hose->index = next_controller_index++;
  475. return hose;
  476. }
  478. #ifdef CONFIG_ALL_PPC
  479. /*
  480.  * Functions below are used on OpenFirmware machines.
  481.  */
  482. static void __openfirmware
  483. make_one_node_map(struct device_node* node, u8 pci_bus)
  484. {
  485. int *bus_range;
  486. int len;
  488. if (pci_bus >= pci_bus_count)
  489. return;
  490. bus_range = (int *) get_property(node, "bus-range", &len);
  491. if (bus_range == NULL || len < 2 * sizeof(int)) {
  492. printk(KERN_WARNING "Can't get bus-range for %sn",
  493.        node->full_name);
  494. return;
  495. }
  496. pci_to_OF_bus_map[pci_bus] = bus_range[0];
  498. for (node=node->child; node != 0;node = node->sibling) {
  499. struct pci_dev* dev;
  500. unsigned int *class_code, *reg;
  502. class_code = (unsigned int *) get_property(node, "class-code", 0);
  503. if (!class_code || ((*class_code >> 8) != PCI_CLASS_BRIDGE_PCI &&
  504. (*class_code >> 8) != PCI_CLASS_BRIDGE_CARDBUS))
  505. continue;
  506. reg = (unsigned int *)get_property(node, "reg", 0);
  507. if (!reg)
  508. continue;
  509. dev = pci_find_slot(pci_bus, ((reg[0] >> 8) & 0xff));
  510. if (!dev || !dev->subordinate)
  511. continue;
  512. make_one_node_map(node, dev->subordinate->number);
  513. }
  514. }
  516. void __openfirmware
  517. pcibios_make_OF_bus_map(void)
  518. {
  519. int i;
  520. struct pci_controller* hose;
  521. u8* of_prop_map;
  523. pci_to_OF_bus_map = (u8*)kmalloc(pci_bus_count, GFP_KERNEL);
  524. if (!pci_to_OF_bus_map) {
  525. printk(KERN_ERR "Can't allocate OF bus map !n");
  526. return;
  527. }
  529. /* We fill the bus map with invalid values, that helps
  530.  * debugging.
  531.  */
  532. for (i=0; i<pci_bus_count; i++)
  533. pci_to_OF_bus_map[i] = 0xff;
  535. /* For each hose, we begin searching bridges */
  536. for(hose=hose_head; hose; hose=hose->next) {
  537. struct device_node* node;
  538. node = (struct device_node *)hose->arch_data;
  539. if (!node)
  540. continue;
  541. make_one_node_map(node, hose->first_busno);
  542. }
  543. of_prop_map = get_property(find_path_device("/"), "pci-OF-bus-map", 0);
  544. if (of_prop_map)
  545. memcpy(of_prop_map, pci_to_OF_bus_map, pci_bus_count);
  546. #ifdef DEBUG
  547. printk("PCI->OF bus map:n");
  548. for (i=0; i<pci_bus_count; i++) {
  549. if (pci_to_OF_bus_map[i] == 0xff)
  550. continue;
  551. printk("%d -> %dn", i, pci_to_OF_bus_map[i]);
  552. }
  553. #endif
  554. }
  556. typedef int (*pci_OF_scan_iterator)(struct device_node* node, void* data);
  558. static struct device_node* __openfirmware
  559. scan_OF_pci_childs(struct device_node* node, pci_OF_scan_iterator filter, void* data)
  560. {
  561. struct device_node* sub_node;
  563. for (; node != 0;node = node->sibling) {
  564. unsigned int *class_code;
  566. if (filter(node, data))
  567. return node;
  569. /* For PCI<->PCI bridges or CardBus bridges, we go down
  570.  * Note: some OFs create a parent node "multifunc-device" as
  571.  * a fake root for all functions of a multi-function device,
  572.  * we go down them as well.
  573.  */
  574. class_code = (unsigned int *) get_property(node, "class-code", 0);
  575. if ((!class_code || ((*class_code >> 8) != PCI_CLASS_BRIDGE_PCI &&
  576. (*class_code >> 8) != PCI_CLASS_BRIDGE_CARDBUS)) &&
  577. strcmp(node->name, "multifunc-device"))
  578. continue;
  579. sub_node = scan_OF_pci_childs(node->child, filter, data);
  580. if (sub_node)
  581. return sub_node;
  582. }
  583. return NULL;
  584. }
  586. static int
  587. scan_OF_pci_childs_iterator(struct device_node* node, void* data)
  588. {
  589. unsigned int *reg;
  590. u8* fdata = (u8*)data;
  592. reg = (unsigned int *) get_property(node, "reg", 0);
  593. if (reg && ((reg[0] >> 8) & 0xff) == fdata[1]
  594. && ((reg[0] >> 16) & 0xff) == fdata[0])
  595. return 1;
  596. return 0;
  597. }
  599. static struct device_node* __openfirmware
  600. scan_OF_childs_for_device(struct device_node* node, u8 bus, u8 dev_fn)
  601. {
  602. u8 filter_data[2] = {bus, dev_fn};
  604. return scan_OF_pci_childs(node, scan_OF_pci_childs_iterator, filter_data);
  605. }
  607. /* 
  608.  * Scans the OF tree for a device node matching a PCI device
  609.  */
  610. struct device_node*
  611. pci_device_to_OF_node(struct pci_dev *dev)
  612. {
  613. struct pci_controller *hose;
  614. struct device_node *node;
  615. int bus;
  617. if (!have_of)
  618. return NULL;
  620. /* Lookup the hose */
  621. bus = dev->bus->number;
  622. hose = pci_bus_to_hose(bus);
  623. if (!hose)
  624. return NULL;
  626. /* Check it has an OF node associated */
  627. node = (struct device_node *) hose->arch_data;
  628. if (!node)
  629. return NULL;
  631. /* Fixup bus number according to what OF think it is. */
  632. if (pci_to_OF_bus_map)
  633. bus = pci_to_OF_bus_map[bus];
  634. if (bus == 0xff)
  635. return NULL;
  637. /* Now, lookup childs of the hose */
  638. return scan_OF_childs_for_device(node->child, bus, dev->devfn);
  639. }
  641. /* This routine is meant to be used early during boot, when the
  642.  * PCI bus numbers have not yet been assigned, and you need to
  643.  * issue PCI config cycles to an OF device.
  644.  * It could also be used to "fix" RTAS config cycles if you want
  645.  * to set pci_assign_all_busses to 1 and still use RTAS for PCI
  646.  * config cycles.
  647.  */
  648. struct pci_controller*
  649. pci_find_hose_for_OF_device(struct device_node* node)
  650. {
  651. if (!have_of)
  652. return NULL;
  653. while(node) {
  654. struct pci_controller* hose;
  655. for (hose=hose_head;hose;hose=hose->next)
  656. if (hose->arch_data == node)
  657. return hose;
  658. node=node->parent;
  659. }
  660. return NULL;
  661. }
  663. static int __openfirmware
  664. find_OF_pci_device_filter(struct device_node* node, void* data)
  665. {
  666. return ((void *)node == data);
  667. }
  669. /* 
  670.  * Returns the PCI device matching a given OF node
  671.  */
  672. int
  673. pci_device_from_OF_node(struct device_node* node, u8* bus, u8* devfn)
  674. {
  675. unsigned int *reg;
  676. struct pci_controller* hose;
  677. struct pci_dev* dev;
  679. if (!have_of)
  680. return -ENODEV;
  681. /* Make sure it's really a PCI device */
  682. hose = pci_find_hose_for_OF_device(node);
  683. if (!hose || !hose->arch_data)
  684. return -ENODEV;
  685. if (!scan_OF_pci_childs(((struct device_node*)hose->arch_data)->child,
  686. find_OF_pci_device_filter, (void *)node))
  687. return -ENODEV;
  688. reg = (unsigned int *) get_property(node, "reg", 0);
  689. if (!reg)
  690. return -ENODEV;
  691. *bus = (reg[0] >> 16) & 0xff;
  692. *devfn = ((reg[0] >> 8) & 0xff);
  694. /* Ok, here we need some tweak. If we have already renumbered
  695.  * all busses, we can't rely on the OF bus number any more.
  696.  * the pci_to_OF_bus_map is not enough as several PCI busses
  697.  * may match the same OF bus number.
  698.  */
  699. if (!pci_to_OF_bus_map)
  700. return 0;
  701. pci_for_each_dev(dev) {
  702. if (pci_to_OF_bus_map[dev->bus->number] != *bus)
  703. continue;
  704. if (dev->devfn != *devfn)
  705. continue;
  706. *bus = dev->bus->number;
  707. return 0;
  708. }
  709. return -ENODEV;
  710. }
  712. void __init
  713. pci_process_bridge_OF_ranges(struct pci_controller *hose,
  714.    struct device_node *dev, int primary)
  715. {
  716. unsigned int *ranges, *prev;
  717. int rlen = 0;
  718. int memno = 0;
  719. struct resource *res;
  720. int np, na = prom_n_addr_cells(dev);
  721. np = na + 5;
  723. /* First we try to merge ranges to fix a problem with some pmacs
  724.  * that can have more than 3 ranges, fortunately using contiguous
  725.  * addresses -- BenH
  726.  */
  727. ranges = (unsigned int *) get_property(dev, "ranges", &rlen);
  728. prev = NULL;
  729. while ((rlen -= np * sizeof(unsigned int)) >= 0) {
  730. if (prev) {
  731. if (prev[0] == ranges[0] && prev[1] == ranges[1] &&
  732. (prev[2] + prev[na+4]) == ranges[2] &&
  733. (prev[na+2] + prev[na+4]) == ranges[na+2]) {
  734. prev[na+4] += ranges[na+4];
  735. ranges[0] = 0;
  736. ranges += np;
  737. continue;
  738. }
  739. }
  740. prev = ranges;
  741. ranges += np;
  742. }
  744. /*
  745.  * The ranges property is laid out as an array of elements,
  746.  * each of which comprises:
  747.  *   cells 0 - 2: a PCI address
  748.  *   cells 3 or 3+4: a CPU physical address
  749.  * (size depending on dev->n_addr_cells)
  750.  *   cells 4+5 or 5+6: the size of the range
  751.  */
  752. rlen = 0;
  753. hose->io_base_phys = 0;
  754. ranges = (unsigned int *) get_property(dev, "ranges", &rlen);
  755. while ((rlen -= np * sizeof(unsigned int)) >= 0) {
  756. res = NULL;
  757. switch (ranges[0] >> 24) {
  758. case 1: /* I/O space */
  759. if (ranges[2] != 0)
  760. break;
  761. hose->io_base_phys = ranges[na+2];
  762. hose->io_base_virt = ioremap(ranges[na+2], ranges[na+4]);
  763. if (primary)
  764. isa_io_base = (unsigned long) hose->io_base_virt;
  765. res = &hose->io_resource;
  766. res->flags = IORESOURCE_IO;
  767. res->start = ranges[2];
  768. break;
  769. case 2: /* memory space */
  770. memno = 0;
  771. if (ranges[1] == 0 && ranges[2] == 0
  772.     && ranges[na+4] <= (16 << 20)) {
  773. /* 1st 16MB, i.e. ISA memory area */
  774. if (primary)
  775. isa_mem_base = ranges[na+2];
  776. memno = 1;
  777. }
  778. while (memno < 3 && hose->mem_resources[memno].flags)
  779. ++memno;
  780. if (memno == 0)
  781. hose->pci_mem_offset = ranges[na+2] - ranges[2];
  782. if (memno < 3) {
  783. res = &hose->mem_resources[memno];
  784. res->flags = IORESOURCE_MEM;
  785. res->start = ranges[na+2];
  786. }
  787. break;
  788. }
  789. if (res != NULL) {
  790. res->name = dev->full_name;
  791. res->end = res->start + ranges[na+4] - 1;
  792. res->parent = NULL;
  793. res->sibling = NULL;
  794. res->child = NULL;
  795. }
  796. ranges += np;
  797. }
  798. }
  800. /* We create the "pci-OF-bus-map" property now so it appears in the
  801.  * /proc device tree
  802.  */
  803. void __init
  804. pci_create_OF_bus_map(void)
  805. {
  806. struct property* of_prop;
  808. of_prop = (struct property*) alloc_bootmem(sizeof(struct property) + 256);
  809. if (of_prop && find_path_device("/")) {
  810. memset(of_prop, -1, sizeof(struct property) + 256);
  811. of_prop->name = "pci-OF-bus-map";
  812. of_prop->length = 256;
  813. of_prop->value = (unsigned char *)&of_prop[1];
  814. prom_add_property(find_path_device("/"), of_prop);
  815. }
  816. }
  817. #endif /* CONFIG_ALL_PPC */
  819. /*
  820.  * This set of routines checks for PCI<->PCI bridges that have closed
  821.  * IO resources and have child devices. It tries to re-open an IO
  822.  * window on them. 
  823.  * 
  824.  * This is a _temporary_ fix to workaround a problem with Apple's OF
  825.  * closing IO windows on P2P bridges when the OF drivers of cards
  826.  * below this bridge don't claim any IO range (typically ATI or
  827.  * Adaptec).
  828.  * 
  829.  * A more complete fix would be to use drivers/pci/setup-bus.c, which
  830.  * involves a working pcibios_fixup_pbus_ranges(), some more care about
  831.  * ordering when creating the host bus resources, and maybe a few more
  832.  * minor tweaks
  833.  */
  835. /* Initialize bridges with base/limit values we have collected */
  836. static void __init
  837. do_update_p2p_io_resource(struct pci_bus *bus, int enable_vga)
  838. {
  839. struct pci_dev *bridge = bus->self;
  840. struct pci_controller* hose = (struct pci_controller *)bridge->sysdata;
  841. u32 l;
  842. u16 w;
  843. struct resource res;
  845.   res = *(bus->resource[0]);
  847. DBG("Remapping Bus %d, bridge: %sn", bus->number, bridge->name);
  848. res.start -= ((unsigned long) hose->io_base_virt - isa_io_base);
  849. res.end -= ((unsigned long) hose->io_base_virt - isa_io_base);
  850. DBG("  IO window: %08lx-%08lxn", res.start, res.end);
  852. /* Set up the top and bottom of the PCI I/O segment for this bus. */
  853. pci_read_config_dword(bridge, PCI_IO_BASE, &l);
  854. l &= 0xffff000f;
  855. l |= (res.start >> 8) & 0x00f0;
  856. l |= res.end & 0xf000;
  857. pci_write_config_dword(bridge, PCI_IO_BASE, l);
  859. if ((l & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
  860. l = (res.start >> 16) | (res.end & 0xffff0000);
  861. pci_write_config_dword(bridge, PCI_IO_BASE_UPPER16, l);
  862. }
  864. pci_read_config_word(bridge, PCI_COMMAND, &w);
  865. w |= PCI_COMMAND_IO;
  866. pci_write_config_word(bridge, PCI_COMMAND, w);
  868. #if 0 /* Enabling this causes XFree 4.2.0 to hang during PCI probe */
  869. if (enable_vga) {
  870. pci_read_config_word(bridge, PCI_BRIDGE_CONTROL, &w);
  871. w |= PCI_BRIDGE_CTL_VGA;
  872. pci_write_config_word(bridge, PCI_BRIDGE_CONTROL, w);
  873. }
  874. #endif
  875. }
  877. /* This function is pretty basic and actually quite broken for the
  878.  * general case, it's enough for us right now though. It's supposed
  879.  * to tell us if we need to open an IO range at all or not and what
  880.  * size.
  881.  */
  882. static int __init
  883. check_for_io_childs(struct pci_bus *bus, struct resource* res, int *found_vga)
  884. {
  885. struct list_head *ln;
  886. int i;
  887. int rc = 0;
  889. #define push_end(res, size) do { unsigned long __sz = (size) ; 
  890. res->end = ((res->end + __sz) / (__sz + 1)) * (__sz + 1) + __sz; 
  891.     } while (0)
  893. for (ln=bus->devices.next; ln != &bus->devices; ln=ln->next) {
  894. struct pci_dev *dev = pci_dev_b(ln);
  895. u16 class = dev->class >> 8;
  897. if (class == PCI_CLASS_DISPLAY_VGA || class == PCI_CLASS_NOT_DEFINED_VGA)
  898. *found_vga = 1;
  899. if (class >> 8 == PCI_BASE_CLASS_BRIDGE && dev->subordinate)
  900. rc |= check_for_io_childs(dev->subordinate, res, found_vga);
  901. if (class == PCI_CLASS_BRIDGE_CARDBUS)
  902. push_end(res, 0xfff);
  904. for (i=0; i<PCI_NUM_RESOURCES; i++) {
  905. struct resource *r;
  906. unsigned long r_size;
  908. if (dev->class >> 8 == PCI_CLASS_BRIDGE_PCI && i >= PCI_BRIDGE_RESOURCES)
  909. continue;
  910. r = &dev->resource[i];
  911. r_size = r->end - r->start;
  912. if (r_size < 0xfff)
  913. r_size = 0xfff;
  914. if (r->flags & IORESOURCE_IO && (r_size) != 0) {
  915. rc = 1;
  916. push_end(res, r_size);
  917. }
  918. }
  919. }
  921. return rc;
  922. }
  924. /* Here we scan all P2P bridges of a given level that have a closed
  925.  * IO window. Note that the test for the presence of a VGA card should
  926.  * be improved to take into account already configured P2P bridges,
  927.  * currently, we don't see them and might end up configuring 2 bridges
  928.  * with VGA pass through enabled
  929.  */
  930. static void __init
  931. do_fixup_p2p_level(struct pci_bus *bus)
  932. {
  933. struct list_head *ln;
  934. int i;
  935. int has_vga = 0;
  937. for (ln=bus->children.next; ln != &bus->children; ln=ln->next) {
  938. struct pci_bus *b = pci_bus_b(ln);
  939. struct pci_dev *d = b->self;
  940. struct pci_controller* hose = (struct pci_controller *)d->sysdata;
  941. struct resource *res = b->resource[0];
  942. unsigned long max;
  943. int found_vga = 0;
  945. res->end = 0;
  946. res->start = 0x1000;
  948. if (!list_empty(&b->devices) && res && res->flags == 0 && res != bus->resource[0] &&
  949.     (d->class >> 8) == PCI_CLASS_BRIDGE_PCI &&
  950.     check_for_io_childs(b, res, &found_vga)) {
  951. u8 io_base_lo;
  953. printk(KERN_INFO "Fixing up IO bus %sn", b->name);
  955. if (found_vga) {
  956. if (has_vga) {
  957. printk(KERN_WARNING "Skipping VGA, already active on bus segmentn");
  958. found_vga = 0;
  959. } else
  960. has_vga = 1;
  961. }
  962. pci_read_config_byte(d, PCI_IO_BASE, &io_base_lo);
  964. if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32)
  965. max = ((unsigned long) hose->io_base_virt - isa_io_base) + 0xffffffff;
  966. else
  967. max = ((unsigned long) hose->io_base_virt - isa_io_base) + 0xffff;
  969. res->flags = IORESOURCE_IO;
  970. res->name = b->name;
  972. /* Find a resource in the parent where we can allocate */
  973. for (i = 0 ; i < 4; i++) {
  974. struct resource *r = bus->resource[i];
  975. if (!r)
  976. continue;
  977. if ((r->flags & IORESOURCE_IO) == 0)
  978. continue;
  979. DBG("Trying to allocate from %08lx, size %08lx from parent res %d: %08lx -> %08lxn",
  980. res->start, res->end, i, r->start, r->end);
  982. if (allocate_resource(r, res, res->end + 1, res->start, max, res->end + 1, NULL, NULL) < 0) {
  983. DBG("Failed !n");
  984. continue;
  985. }
  986. do_update_p2p_io_resource(b, found_vga);
  987. break;
  988. }
  989. }
  990. do_fixup_p2p_level(b);
  991. }
  992. }
  994. static void
  995. pcibios_fixup_p2p_bridges(void)
  996. {
  997. struct list_head *ln;
  999. for(ln=pci_root_buses.next; ln != &pci_root_buses; ln=ln->next) {
  1000. struct pci_bus *b = pci_bus_b(ln);
  1001. do_fixup_p2p_level(b);
  1002. }
  1003. }
  1005. void __init
  1006. pcibios_init(void)
  1007. {
  1008. struct pci_controller *hose;
  1009. struct pci_bus *bus;
  1010. int next_busno, bus_offset;
  1012. printk(KERN_INFO "PCI: Probing PCI hardwaren");
  1014. /* There is a problem with bus renumbering currently. If
  1015.  * you have 2 sibling pci<->pci bridges, and during PCI
  1016.  * probe, the first one gets assigned a new number equal
  1017.  * to the old number of the second one, you'll end up
  1018.  * probing that branch with 2 bridges racing on the bus
  1019.  * numbers.
  1020.  * I work around this on pmac by adding a large offset
  1021.  * between host bridges, though a better long term solution
  1022.  * will have to be found in the generic code. --BenH
  1023.  */
  1024. #ifdef CONFIG_ALL_PPC
  1025. if (machine_is_compatible("MacRISC"))
  1026. bus_offset = 0x10;
  1027. else
  1028. #endif
  1029. bus_offset = 1;
  1030. /* Scan all of the recorded PCI controllers.  */
  1031. for (next_busno = 0, hose = hose_head; hose; hose = hose->next) {
  1032. if (pci_assign_all_busses)
  1033. hose->first_busno = next_busno;
  1034. hose->last_busno = 0xff;
  1035. bus = pci_scan_bus(hose->first_busno, hose->ops, hose);
  1036. hose->last_busno = bus->subordinate;
  1037. if (pci_assign_all_busses || next_busno <= hose->last_busno)
  1038. next_busno = hose->last_busno + bus_offset;
  1039. }
  1040. pci_bus_count = next_busno;
  1042. /* OpenFirmware based machines need a map of OF bus
  1043.  * numbers vs. kernel bus numbers since we may have to
  1044.  * remap them.
  1045.  */
  1046. if (pci_assign_all_busses && have_of)
  1047. pcibios_make_OF_bus_map();
  1049. /* Do machine dependent PCI interrupt routing */
  1050. if (ppc_md.pci_swizzle && ppc_md.pci_map_irq)
  1051. pci_fixup_irqs(ppc_md.pci_swizzle, ppc_md.pci_map_irq);
  1053. /* Call machine dependant fixup */
  1054. if (ppc_md.pcibios_fixup)
  1055. ppc_md.pcibios_fixup();
  1057. /* Allocate and assign resources */
  1058. pcibios_allocate_bus_resources(&pci_root_buses);
  1059. pcibios_allocate_resources(0);
  1060. pcibios_allocate_resources(1);
  1061. pcibios_fixup_p2p_bridges();
  1062. pcibios_assign_resources();
  1064. /* Call machine dependent post-init code */
  1065. if (ppc_md.pcibios_after_init)
  1066. ppc_md.pcibios_after_init();
  1067. }
  1069. unsigned char __init
  1070. common_swizzle(struct pci_dev *dev, unsigned char *pinp)
  1071. {
  1072. struct pci_controller *hose = dev->sysdata;
  1074. if (dev->bus->number != hose->first_busno) {
  1075. u8 pin = *pinp;
  1076. do {
  1077. pin = bridge_swizzle(pin, PCI_SLOT(dev->devfn));
  1078. /* Move up the chain of bridges. */
  1079. dev = dev->bus->self;
  1080. } while (dev->bus->self);
  1081. *pinp = pin;
  1083. /* The slot is the idsel of the last bridge. */
  1084. }
  1085. return PCI_SLOT(dev->devfn);
  1086. }
  1088. void __init
  1089. pcibios_fixup_pbus_ranges(struct pci_bus * bus, struct pbus_set_ranges_data * ranges)
  1090. {
  1091. ranges->io_start -= bus->resource[0]->start;
  1092. ranges->io_end -= bus->resource[0]->start;
  1093. ranges->mem_start -= bus->resource[1]->start;
  1094. ranges->mem_end -= bus->resource[1]->start;
  1095. }
  1097. unsigned long resource_fixup(struct pci_dev * dev, struct resource * res,
  1098.      unsigned long start, unsigned long size)
  1099. {
  1100. return start;
  1101. }
  1103. void __init pcibios_fixup_bus(struct pci_bus *bus)
  1104. {
  1105. struct pci_controller *hose = (struct pci_controller *) bus->sysdata;
  1106. unsigned long io_offset;
  1107. struct resource *res;
  1108. int i;
  1110. io_offset = (unsigned long)hose->io_base_virt - isa_io_base;
  1111. if (bus->parent == NULL) {
  1112. /* This is a host bridge - fill in its resources */
  1113. hose->bus = bus;
  1115. bus->resource[0] = res = &hose->io_resource;
  1116. if (!res->flags) {
  1117. if (io_offset)
  1118. printk(KERN_ERR "I/O resource not set for host"
  1119.        " bridge %dn", hose->index);
  1120. res->start = 0;
  1121. res->end = IO_SPACE_LIMIT;
  1122. res->flags = IORESOURCE_IO;
  1123. }
  1124. res->start += io_offset;
  1125. res->end += io_offset;
  1127. for (i = 0; i < 3; ++i) {
  1128. res = &hose->mem_resources[i];
  1129. if (!res->flags) {
  1130. if (i > 0)
  1131. continue;
  1132. printk(KERN_ERR "Memory resource not set for "
  1133.        "host bridge %dn", hose->index);
  1134. res->start = hose->pci_mem_offset;
  1135. res->end = ~0U;
  1136. res->flags = IORESOURCE_MEM;
  1137. }
  1138. bus->resource[i+1] = res;
  1139. }
  1140. } else {
  1141. /* This is a subordinate bridge */
  1142. pci_read_bridge_bases(bus);
  1144. for (i = 0; i < 4; ++i) {
  1145. if ((res = bus->resource[i]) == NULL)
  1146. continue;
  1147. if (!res->flags)
  1148. continue;
  1149. if (io_offset && (res->flags & IORESOURCE_IO)) {
  1150. res->start += io_offset;
  1151. res->end += io_offset;
  1152. } else if (hose->pci_mem_offset
  1153.    && (res->flags & IORESOURCE_MEM)) {
  1154. res->start += hose->pci_mem_offset;
  1155. res->end += hose->pci_mem_offset;
  1156. }
  1157. }
  1158. }
  1160. if (ppc_md.pcibios_fixup_bus)
  1161. ppc_md.pcibios_fixup_bus(bus);
  1162. }
  1164. char __init *pcibios_setup(char *str)
  1165. {
  1166. return str;
  1167. }
  1169. /* the next one is stolen from the alpha port... */
  1170. void __init
  1171. pcibios_update_irq(struct pci_dev *dev, int irq)
  1172. {
  1173. pci_write_config_byte(dev, PCI_INTERRUPT_LINE, irq);
  1174. /* XXX FIXME - update OF device tree node interrupt property */
  1175. }
  1177. int pcibios_enable_device(struct pci_dev *dev, int mask)
  1178. {
  1179. u16 cmd, old_cmd;
  1180. int idx;
  1181. struct resource *r;
  1183. if (ppc_md.pcibios_enable_device_hook)
  1184. if (ppc_md.pcibios_enable_device_hook(dev, 0))
  1185. return -EINVAL;
  1187. pci_read_config_word(dev, PCI_COMMAND, &cmd);
  1188. old_cmd = cmd;
  1189. for (idx=0; idx<6; idx++) {
  1190. if(!(mask & (1<<idx)))
  1191. continue;
  1193. r = &dev->resource[idx];
  1194. if (!r->start && r->end) {
  1195. printk(KERN_ERR "PCI: Device %s not available because of resource collisionsn", dev->slot_name);
  1196. return -EINVAL;
  1197. }
  1198. if (r->flags & IORESOURCE_IO)
  1199. cmd |= PCI_COMMAND_IO;
  1200. if (r->flags & IORESOURCE_MEM)
  1201. cmd |= PCI_COMMAND_MEMORY;
  1202. }
  1203. if (cmd != old_cmd) {
  1204. printk("PCI: Enabling device %s (%04x -> %04x)n",
  1205.        dev->slot_name, old_cmd, cmd);
  1206. pci_write_config_word(dev, PCI_COMMAND, cmd);
  1207. }
  1208. return 0;
  1209. }
  1211. struct pci_controller*
  1212. pci_bus_to_hose(int bus)
  1213. {
  1214. struct pci_controller* hose = hose_head;
  1216. for (; hose; hose = hose->next)
  1217. if (bus >= hose->first_busno && bus <= hose->last_busno)
  1218. return hose;
  1219. return NULL;
  1220. }
  1222. void*
  1223. pci_bus_io_base(unsigned int bus)
  1224. {
  1225. struct pci_controller *hose;
  1227. hose = pci_bus_to_hose(bus);
  1228. if (!hose)
  1229. return NULL;
  1230. return hose->io_base_virt;
  1231. }
  1233. unsigned long
  1234. pci_bus_io_base_phys(unsigned int bus)
  1235. {
  1236. struct pci_controller *hose;
  1238. hose = pci_bus_to_hose(bus);
  1239. if (!hose)
  1240. return 0;
  1241. return hose->io_base_phys;
  1242. }
  1244. unsigned long
  1245. pci_bus_mem_base_phys(unsigned int bus)
  1246. {
  1247. struct pci_controller *hose;
  1249. hose = pci_bus_to_hose(bus);
  1250. if (!hose)
  1251. return 0;
  1252. return hose->pci_mem_offset;
  1253. }
  1255. unsigned long
  1256. pci_resource_to_bus(struct pci_dev *pdev, struct resource *res)
  1257. {
  1258. /* Hack alert again ! See comments in chrp_pci.c
  1259.  */
  1260. struct pci_controller* hose =
  1261. (struct pci_controller *)pdev->sysdata;
  1262. if (hose && res->flags & IORESOURCE_MEM)
  1263. return res->start - hose->pci_mem_offset;
  1264. /* We may want to do something with IOs here... */
  1265. return res->start;
  1266. }
  1268. /*
  1269.  * Return the index of the PCI controller for device pdev.
  1270.  */
  1271. int pci_controller_num(struct pci_dev *dev)
  1272. {
  1273. struct pci_controller *hose = (struct pci_controller *) dev->sysdata;
  1275. return hose->index;
  1276. }
  1278. /*
  1279.  * Platform support for /proc/bus/pci/X/Y mmap()s,
  1280.  * modelled on the sparc64 implementation by Dave Miller.
  1281.  *  -- paulus.
  1282.  */
  1284. /*
  1285.  * Adjust vm_pgoff of VMA such that it is the physical page offset
  1286.  * corresponding to the 32-bit pci bus offset for DEV requested by the user.
  1287.  *
  1288.  * Basically, the user finds the base address for his device which he wishes
  1289.  * to mmap.  They read the 32-bit value from the config space base register,
  1290.  * add whatever PAGE_SIZE multiple offset they wish, and feed this into the
  1291.  * offset parameter of mmap on /proc/bus/pci/XXX for that device.
  1292.  *
  1293.  * Returns negative error code on failure, zero on success.
  1294.  */
  1295. static __inline__ int
  1296. __pci_mmap_make_offset(struct pci_dev *dev, struct vm_area_struct *vma,
  1297.        enum pci_mmap_state mmap_state)
  1298. {
  1299. struct pci_controller *hose = (struct pci_controller *) dev->sysdata;
  1300. unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
  1301. unsigned long io_offset = 0;
  1302. int i, res_bit;
  1304. if (hose == 0)
  1305. return -EINVAL; /* should never happen */
  1307. /* If memory, add on the PCI bridge address offset */
  1308. if (mmap_state == pci_mmap_mem) {
  1309. offset += hose->pci_mem_offset;
  1310. res_bit = IORESOURCE_MEM;
  1311. } else {
  1312. io_offset = (unsigned long)hose->io_base_virt - isa_io_base;
  1313. offset += io_offset;
  1314. res_bit = IORESOURCE_IO;
  1315. }
  1317. /*
  1318.  * Check that the offset requested corresponds to one of the
  1319.  * resources of the device.
  1320.  */
  1321. for (i = 0; i <= PCI_ROM_RESOURCE; i++) {
  1322. struct resource *rp = &dev->resource[i];
  1323. int flags = rp->flags;
  1325. /* treat ROM as memory (should be already) */
  1326. if (i == PCI_ROM_RESOURCE)
  1327. flags |= IORESOURCE_MEM;
  1329. /* Active and same type? */
  1330. if ((flags & res_bit) == 0)
  1331. continue;
  1333. /* In the range of this resource? */
  1334. if (offset < (rp->start & PAGE_MASK) || offset > rp->end)
  1335. continue;
  1337. /* found it! construct the final physical address */
  1338. if (mmap_state == pci_mmap_io)
  1339. offset += hose->io_base_phys - io_offset;
  1341. vma->vm_pgoff = offset >> PAGE_SHIFT;
  1342. return 0;
  1343. }
  1345. return -EINVAL;
  1346. }
  1348. /*
  1349.  * Set vm_flags of VMA, as appropriate for this architecture, for a pci device
  1350.  * mapping.
  1351.  */
  1352. static __inline__ void
  1353. __pci_mmap_set_flags(struct pci_dev *dev, struct vm_area_struct *vma,
  1354.      enum pci_mmap_state mmap_state)
  1355. {
  1356. vma->vm_flags |= VM_SHM | VM_LOCKED | VM_IO;
  1357. }
  1359. /*
  1360.  * Set vm_page_prot of VMA, as appropriate for this architecture, for a pci
  1361.  * device mapping.
  1362.  */
  1363. static __inline__ void
  1364. __pci_mmap_set_pgprot(struct pci_dev *dev, struct vm_area_struct *vma,
  1365.       enum pci_mmap_state mmap_state, int write_combine)
  1366. {
  1367. int prot = pgprot_val(vma->vm_page_prot);
  1369. /* XXX would be nice to have a way to ask for write-through */
  1370. prot |= _PAGE_NO_CACHE;
  1371. if (!write_combine)
  1372. prot |= _PAGE_GUARDED;
  1373. vma->vm_page_prot = __pgprot(prot);
  1374. }
  1376. /*
  1377.  * Perform the actual remap of the pages for a PCI device mapping, as
  1378.  * appropriate for this architecture.  The region in the process to map
  1379.  * is described by vm_start and vm_end members of VMA, the base physical
  1380.  * address is found in vm_pgoff.
  1381.  * The pci device structure is provided so that architectures may make mapping
  1382.  * decisions on a per-device or per-bus basis.
  1383.  *
  1384.  * Returns a negative error code on failure, zero on success.
  1385.  */
  1386. int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
  1387. enum pci_mmap_state mmap_state,
  1388. int write_combine)
  1389. {
  1390. int ret;
  1392. ret = __pci_mmap_make_offset(dev, vma, mmap_state);
  1393. if (ret < 0)
  1394. return ret;
  1396. __pci_mmap_set_flags(dev, vma, mmap_state);
  1397. __pci_mmap_set_pgprot(dev, vma, mmap_state, write_combine);
  1399. ret = remap_page_range(vma->vm_start, vma->vm_pgoff << PAGE_SHIFT,
  1400.        vma->vm_end - vma->vm_start, vma->vm_page_prot);
  1402. return ret;
  1403. }
  1405. /* Obsolete functions. Should be removed once the symbios driver
  1406.  * is fixed
  1407.  */
  1408. unsigned long
  1409. phys_to_bus(unsigned long pa)
  1410. {
  1411. struct pci_controller *hose;
  1412. int i;
  1414. for (hose = hose_head; hose; hose = hose->next) {
  1415. for (i = 0; i < 3; ++i) {
  1416. if (pa >= hose->mem_resources[i].start
  1417.     && pa <= hose->mem_resources[i].end) {
  1418. /*
  1419.  * XXX the hose->pci_mem_offset really
  1420.  * only applies to mem_resources[0].
  1421.  * We need a way to store an offset for
  1422.  * the others.  -- paulus
  1423.  */
  1424. if (i == 0)
  1425. pa -= hose->pci_mem_offset;
  1426. return pa;
  1427. }
  1428. }
  1429. }
  1430. /* hmmm, didn't find it */
  1431. return 0;
  1432. }
  1434. unsigned long
  1435. pci_phys_to_bus(unsigned long pa, int busnr)
  1436. {
  1437. struct pci_controller* hose = pci_bus_to_hose(busnr);
  1438. if (!hose)
  1439. return pa;
  1440. return pa - hose->pci_mem_offset;
  1441. }
  1443. unsigned long
  1444. pci_bus_to_phys(unsigned int ba, int busnr)
  1445. {
  1446. struct pci_controller* hose = pci_bus_to_hose(busnr);
  1447. if (!hose)
  1448. return ba;
  1449. return ba + hose->pci_mem_offset;
  1450. }
  1452. /* Provide information on locations of various I/O regions in physical
  1453.  * memory.  Do this on a per-card basis so that we choose the right
  1454.  * root bridge.
  1455.  * Note that the returned IO or memory base is a physical address
  1456.  */
  1458. long
  1459. sys_pciconfig_iobase(long which, unsigned long bus, unsigned long devfn)
  1460. {
  1461. struct pci_controller* hose = pci_bus_to_hose(bus);
  1462. long result = -EOPNOTSUPP;
  1464. if (!hose)
  1465. return -ENODEV;
  1467. switch (which) {
  1468. case IOBASE_BRIDGE_NUMBER:
  1469. return (long)hose->first_busno;
  1470. case IOBASE_MEMORY:
  1471. return (long)hose->pci_mem_offset;
  1472. case IOBASE_IO:
  1473. return (long)hose->io_base_phys;
  1474. case IOBASE_ISA_IO:
  1475. return (long)isa_io_base;
  1476. case IOBASE_ISA_MEM:
  1477. return (long)isa_mem_base;
  1478. }
  1480. return result;
  1481. }
  1483. void __init
  1484. pci_init_resource(struct resource *res, unsigned long start, unsigned long end,
  1485.   int flags, char *name)
  1486. {
  1487. res->start = start;
  1488. res->end = end;
  1489. res->flags = flags;
  1490. res->name = name;
  1491. res->parent = NULL;
  1492. res->sibling = NULL;
  1493. res->child = NULL;
  1494. }
  1496. /*
  1497.  * Null PCI config access functions, for the case when we can't
  1498.  * find a hose.
  1499.  */
  1500. #define NULL_PCI_OP(rw, size, type)
  1501. static int
  1502. null_##rw##_config_##size(struct pci_dev *dev, int offset, type val)
  1503. {
  1504. return PCIBIOS_DEVICE_NOT_FOUND;    
  1505. }
  1507. NULL_PCI_OP(read, byte, u8 *)
  1508. NULL_PCI_OP(read, word, u16 *)
  1509. NULL_PCI_OP(read, dword, u32 *)
  1510. NULL_PCI_OP(write, byte, u8)
  1511. NULL_PCI_OP(write, word, u16)
  1512. NULL_PCI_OP(write, dword, u32)
  1514. static struct pci_ops null_pci_ops =
  1515. {
  1516. null_read_config_byte,
  1517. null_read_config_word,
  1518. null_read_config_dword,
  1519. null_write_config_byte,
  1520. null_write_config_word,
  1521. null_write_config_dword
  1522. };
  1524. /*
  1525.  * These functions are used early on before PCI scanning is done
  1526.  * and all of the pci_dev and pci_bus structures have been created.
  1527.  */
  1528. static struct pci_dev *
  1529. fake_pci_dev(struct pci_controller *hose, int busnr, int devfn)
  1530. {
  1531. static struct pci_dev dev;
  1532. static struct pci_bus bus;
  1534. if (hose == 0) {
  1535. hose = pci_bus_to_hose(busnr);
  1536. if (hose == 0)
  1537. printk(KERN_ERR "Can't find hose for PCI bus %d!n", busnr);
  1538. }
  1539. dev.bus = &bus;
  1540. dev.sysdata = hose;
  1541. dev.devfn = devfn;
  1542. bus.number = busnr;
  1543. bus.ops = hose? hose->ops: &null_pci_ops;
  1544. return &dev;
  1545. }
  1547. #define EARLY_PCI_OP(rw, size, type)
  1548. int early_##rw##_config_##size(struct pci_controller *hose, int bus,
  1549.        int devfn, int offset, type value)
  1550. {
  1551. return pci_##rw##_config_##size(fake_pci_dev(hose, bus, devfn),
  1552. offset, value);
  1553. }
  1555. EARLY_PCI_OP(read, byte, u8 *)
  1556. EARLY_PCI_OP(read, word, u16 *)
  1557. EARLY_PCI_OP(read, dword, u32 *)
  1558. EARLY_PCI_OP(write, byte, u8)
  1559. EARLY_PCI_OP(write, word, u16)
  1560. EARLY_PCI_OP(write, dword, u32)