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

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

Linux/Unix编程

开发平台：

Unix_Linux

pci_common.c：源码内容
  1. /* $Id: pci_common.c,v 1.27.2.5 2002/03/10 05:21:26 davem Exp $
  2.  * pci_common.c: PCI controller common support.
  3.  *
  4.  * Copyright (C) 1999 David S. Miller (davem@redhat.com)
  5.  */
  7. #include <linux/string.h>
  8. #include <linux/slab.h>
  9. #include <linux/init.h>
  11. #include <asm/pbm.h>
  13. /* Fix self device of BUS and hook it into BUS->self.
  14.  * The pci_scan_bus does not do this for the host bridge.
  15.  */
  16. void __init pci_fixup_host_bridge_self(struct pci_bus *pbus)
  17. {
  18. struct list_head *walk = &pbus->devices;
  20. walk = walk->next;
  21. while (walk != &pbus->devices) {
  22. struct pci_dev *pdev = pci_dev_b(walk);
  24. if (pdev->class >> 8 == PCI_CLASS_BRIDGE_HOST) {
  25. pbus->self = pdev;
  26. return;
  27. }
  29. walk = walk->next;
  30. }
  32. prom_printf("PCI: Critical error, cannot find host bridge PDEV.n");
  33. prom_halt();
  34. }
  36. /* Find the OBP PROM device tree node for a PCI device.
  37.  * Return zero if not found.
  38.  */
  39. static int __init find_device_prom_node(struct pci_pbm_info *pbm,
  40. struct pci_dev *pdev,
  41. int bus_prom_node,
  42. struct linux_prom_pci_registers *pregs,
  43. int *nregs)
  44. {
  45. int node;
  47. /*
  48.  * Return the PBM's PROM node in case we are it's PCI device,
  49.  * as the PBM's reg property is different to standard PCI reg
  50.  * properties. We would delete this device entry otherwise,
  51.  * which confuses XFree86's device probing...
  52.  */
  53. if ((pdev->bus->number == pbm->pci_bus->number) && (pdev->devfn == 0) &&
  54.     (pdev->vendor == PCI_VENDOR_ID_SUN) &&
  55.     (pdev->device == PCI_DEVICE_ID_SUN_PBM ||
  56.      pdev->device == PCI_DEVICE_ID_SUN_SCHIZO ||
  57.      pdev->device == PCI_DEVICE_ID_SUN_SABRE ||
  58.      pdev->device == PCI_DEVICE_ID_SUN_HUMMINGBIRD)) {
  59. *nregs = 0;
  60. return bus_prom_node;
  61. }
  63. node = prom_getchild(bus_prom_node);
  64. while (node != 0) {
  65. int err = prom_getproperty(node, "reg",
  66.    (char *)pregs,
  67.    sizeof(*pregs) * PROMREG_MAX);
  68. if (err == 0 || err == -1)
  69. goto do_next_sibling;
  70. if (((pregs[0].phys_hi >> 8) & 0xff) == pdev->devfn) {
  71. *nregs = err / sizeof(*pregs);
  72. return node;
  73. }
  75. do_next_sibling:
  76. node = prom_getsibling(node);
  77. }
  78. return 0;
  79. }
  81. /* Remove a PCI device from the device trees, then
  82.  * free it up.  Note that this must run before
  83.  * the device's resources are registered because we
  84.  * do not handle unregistering them here.
  85.  */
  86. static void pci_device_delete(struct pci_dev *pdev)
  87. {
  88. list_del(&pdev->global_list);
  89. list_del(&pdev->bus_list);
  91. /* Ok, all references are gone, free it up. */
  92. kfree(pdev);
  93. }
  95. /* Older versions of OBP on PCI systems encode 64-bit MEM
  96.  * space assignments incorrectly, this fixes them up.  We also
  97.  * take the opportunity here to hide other kinds of bogus
  98.  * assignments.
  99.  */
  100. static void __init fixup_obp_assignments(struct pci_dev *pdev,
  101.  struct pcidev_cookie *pcp)
  102. {
  103. int i;
  105. if (pdev->vendor == PCI_VENDOR_ID_AL &&
  106.     (pdev->device == PCI_DEVICE_ID_AL_M7101 ||
  107.      pdev->device == PCI_DEVICE_ID_AL_M1533)) {
  108. int i;
  110. /* Zap all of the normal resources, they are
  111.  * meaningless and generate bogus resource collision
  112.  * messages.  This is OpenBoot's ill-fated attempt to
  113.  * represent the implicit resources that these devices
  114.  * have.
  115.  */
  116. pcp->num_prom_assignments = 0;
  117. for (i = 0; i < 6; i++) {
  118. pdev->resource[i].start =
  119. pdev->resource[i].end =
  120. pdev->resource[i].flags = 0;
  121. }
  122. pdev->resource[PCI_ROM_RESOURCE].start =
  123. pdev->resource[PCI_ROM_RESOURCE].end =
  124. pdev->resource[PCI_ROM_RESOURCE].flags = 0;
  125. return;
  126. }
  128. for (i = 0; i < pcp->num_prom_assignments; i++) {
  129. struct linux_prom_pci_registers *ap;
  130. int space;
  132. ap = &pcp->prom_assignments[i];
  133. space = ap->phys_hi >> 24;
  134. if ((space & 0x3) == 2 &&
  135.     (space & 0x4) != 0) {
  136. ap->phys_hi &= ~(0x7 << 24);
  137. ap->phys_hi |= 0x3 << 24;
  138. }
  139. }
  140. }
  142. /* Fill in the PCI device cookie sysdata for the given
  143.  * PCI device.  This cookie is the means by which one
  144.  * can get to OBP and PCI controller specific information
  145.  * for a PCI device.
  146.  */
  147. static void __init pdev_cookie_fillin(struct pci_pbm_info *pbm,
  148.       struct pci_dev *pdev,
  149.       int bus_prom_node)
  150. {
  151. struct linux_prom_pci_registers pregs[PROMREG_MAX];
  152. struct pcidev_cookie *pcp;
  153. int device_prom_node, nregs, err;
  155. device_prom_node = find_device_prom_node(pbm, pdev, bus_prom_node,
  156.  pregs, &nregs);
  157. if (device_prom_node == 0) {
  158. /* If it is not in the OBP device tree then
  159.  * there must be a damn good reason for it.
  160.  *
  161.  * So what we do is delete the device from the
  162.  * PCI device tree completely.  This scenerio
  163.  * is seen, for example, on CP1500 for the
  164.  * second EBUS/HappyMeal pair if the external
  165.  * connector for it is not present.
  166.  */
  167. pci_device_delete(pdev);
  168. return;
  169. }
  171. pcp = kmalloc(sizeof(*pcp), GFP_ATOMIC);
  172. if (pcp == NULL) {
  173. prom_printf("PCI_COOKIE: Fatal malloc error, aborting...n");
  174. prom_halt();
  175. }
  176. pcp->pbm = pbm;
  177. pcp->prom_node = device_prom_node;
  178. memcpy(pcp->prom_regs, pregs, sizeof(pcp->prom_regs));
  179. pcp->num_prom_regs = nregs;
  180. err = prom_getproperty(device_prom_node, "name",
  181.        pcp->prom_name, sizeof(pcp->prom_name));
  182. if (err > 0)
  183. pcp->prom_name[err] = 0;
  184. else
  185. pcp->prom_name[0] = 0;
  187. err = prom_getproperty(device_prom_node,
  188.        "assigned-addresses",
  189.        (char *)pcp->prom_assignments,
  190.        sizeof(pcp->prom_assignments));
  191. if (err == 0 || err == -1)
  192. pcp->num_prom_assignments = 0;
  193. else
  194. pcp->num_prom_assignments =
  195. (err / sizeof(pcp->prom_assignments[0]));
  197. if (strcmp(pcp->prom_name, "ebus") == 0) {
  198. struct linux_prom_ebus_ranges erng[PROM_PCIRNG_MAX];
  199. int iter;
  201. /* EBUS is special... */
  202. err = prom_getproperty(device_prom_node, "ranges",
  203.        (char *)&erng[0], sizeof(erng));
  204. if (err == 0 || err == -1) {
  205. prom_printf("EBUS: Fatal error, no range propertyn");
  206. prom_halt();
  207. }
  208. err = (err / sizeof(erng[0]));
  209. for(iter = 0; iter < err; iter++) {
  210. struct linux_prom_ebus_ranges *ep = &erng[iter];
  211. struct linux_prom_pci_registers *ap;
  213. ap = &pcp->prom_assignments[iter];
  215. ap->phys_hi = ep->parent_phys_hi;
  216. ap->phys_mid = ep->parent_phys_mid;
  217. ap->phys_lo = ep->parent_phys_lo;
  218. ap->size_hi = 0;
  219. ap->size_lo = ep->size;
  220. }
  221. pcp->num_prom_assignments = err;
  222. }
  224. fixup_obp_assignments(pdev, pcp);
  226. pdev->sysdata = pcp;
  227. }
  229. void __init pci_fill_in_pbm_cookies(struct pci_bus *pbus,
  230.     struct pci_pbm_info *pbm,
  231.     int prom_node)
  232. {
  233. struct list_head *walk = &pbus->devices;
  235. /* This loop is coded like this because the cookie
  236.  * fillin routine can delete devices from the tree.
  237.  */
  238. walk = walk->next;
  239. while (walk != &pbus->devices) {
  240. struct pci_dev *pdev = pci_dev_b(walk);
  241. struct list_head *walk_next = walk->next;
  243. pdev_cookie_fillin(pbm, pdev, prom_node);
  245. walk = walk_next;
  246. }
  248. walk = &pbus->children;
  249. walk = walk->next;
  250. while (walk != &pbus->children) {
  251. struct pci_bus *this_pbus = pci_bus_b(walk);
  252. struct pcidev_cookie *pcp = this_pbus->self->sysdata;
  253. struct list_head *walk_next = walk->next;
  255. pci_fill_in_pbm_cookies(this_pbus, pbm, pcp->prom_node);
  257. walk = walk_next;
  258. }
  259. }
  261. static void __init bad_assignment(struct pci_dev *pdev,
  262.   struct linux_prom_pci_registers *ap,
  263.   struct resource *res,
  264.   int do_prom_halt)
  265. {
  266. prom_printf("PCI: Bogus PROM assignment. BUS[%02x] DEVFN[%x]n",
  267.     pdev->bus->number, pdev->devfn);
  268. if (ap)
  269. prom_printf("PCI: phys[%08x:%08x:%08x] size[%08x:%08x]n",
  270.     ap->phys_hi, ap->phys_mid, ap->phys_lo,
  271.     ap->size_hi, ap->size_lo);
  272. if (res)
  273. prom_printf("PCI: RES[%016lx-->%016lx:(%lx)]n",
  274.     res->start, res->end, res->flags);
  275. prom_printf("Please email this information to davem@redhat.comn");
  276. if (do_prom_halt)
  277. prom_halt();
  278. }
  280. static struct resource *
  281. __init get_root_resource(struct linux_prom_pci_registers *ap,
  282.  struct pci_pbm_info *pbm)
  283. {
  284. int space = (ap->phys_hi >> 24) & 3;
  286. switch (space) {
  287. case 0:
  288. /* Configuration space, silently ignore it. */
  289. return NULL;
  291. case 1:
  292. /* 16-bit IO space */
  293. return &pbm->io_space;
  295. case 2:
  296. /* 32-bit MEM space */
  297. return &pbm->mem_space;
  299. case 3:
  300. /* 64-bit MEM space, these are allocated out of
  301.  * the 32-bit mem_space range for the PBM, ie.
  302.  * we just zero out the upper 32-bits.
  303.  */
  304. return &pbm->mem_space;
  306. default:
  307. printk("PCI: What is resource space %x? "
  308.        "Tell davem@redhat.com about it!n", space);
  309. return NULL;
  310. };
  311. }
  313. static struct resource *
  314. __init get_device_resource(struct linux_prom_pci_registers *ap,
  315.    struct pci_dev *pdev)
  316. {
  317. struct resource *res;
  318. int breg = (ap->phys_hi & 0xff);
  319. int space = (ap->phys_hi >> 24) & 3;
  321. switch (breg) {
  322. case  PCI_ROM_ADDRESS:
  323. /* It had better be MEM space. */
  324. if (space != 2)
  325. bad_assignment(pdev, ap, NULL, 0);
  327. res = &pdev->resource[PCI_ROM_RESOURCE];
  328. break;
  330. case PCI_BASE_ADDRESS_0:
  331. case PCI_BASE_ADDRESS_1:
  332. case PCI_BASE_ADDRESS_2:
  333. case PCI_BASE_ADDRESS_3:
  334. case PCI_BASE_ADDRESS_4:
  335. case PCI_BASE_ADDRESS_5:
  336. res = &pdev->resource[(breg - PCI_BASE_ADDRESS_0) / 4];
  337. break;
  339. default:
  340. bad_assignment(pdev, ap, NULL, 0);
  341. res = NULL;
  342. break;
  343. };
  345. return res;
  346. }
  348. static int __init pdev_resource_collisions_expected(struct pci_dev *pdev)
  349. {
  350. if (pdev->vendor != PCI_VENDOR_ID_SUN)
  351. return 0;
  353. if (pdev->device == PCI_DEVICE_ID_SUN_RIO_EBUS ||
  354.     pdev->device == PCI_DEVICE_ID_SUN_RIO_1394 ||
  355.     pdev->device == PCI_DEVICE_ID_SUN_RIO_USB)
  356. return 1;
  358. return 0;
  359. }
  361. static void __init pdev_record_assignments(struct pci_pbm_info *pbm,
  362.    struct pci_dev *pdev)
  363. {
  364. struct pcidev_cookie *pcp = pdev->sysdata;
  365. int i;
  367. for (i = 0; i < pcp->num_prom_assignments; i++) {
  368. struct linux_prom_pci_registers *ap;
  369. struct resource *root, *res;
  371. /* The format of this property is specified in
  372.  * the PCI Bus Binding to IEEE1275-1994.
  373.  */
  374. ap = &pcp->prom_assignments[i];
  375. root = get_root_resource(ap, pbm);
  376. res = get_device_resource(ap, pdev);
  377. if (root == NULL || res == NULL ||
  378.     res->flags == 0)
  379. continue;
  381. /* Ok we know which resource this PROM assignment is
  382.  * for, sanity check it.
  383.  */
  384. if ((res->start & 0xffffffffUL) != ap->phys_lo)
  385. bad_assignment(pdev, ap, res, 1);
  387. /* If it is a 64-bit MEM space assignment, verify that
  388.  * the resource is too and that the upper 32-bits match.
  389.  */
  390. if (((ap->phys_hi >> 24) & 3) == 3) {
  391. if (((res->flags & IORESOURCE_MEM) == 0) ||
  392.     ((res->flags & PCI_BASE_ADDRESS_MEM_TYPE_MASK)
  393.      != PCI_BASE_ADDRESS_MEM_TYPE_64))
  394. bad_assignment(pdev, ap, res, 1);
  395. if ((res->start >> 32) != ap->phys_mid)
  396. bad_assignment(pdev, ap, res, 1);
  398. /* PBM cannot generate cpu initiated PIOs
  399.  * to the full 64-bit space.  Therefore the
  400.  * upper 32-bits better be zero.  If it is
  401.  * not, just skip it and we will assign it
  402.  * properly ourselves.
  403.  */
  404. if ((res->start >> 32) != 0UL) {
  405. printk(KERN_ERR "PCI: OBP assigns out of range MEM address "
  406.        "%016lx for region %ld on device %sn",
  407.        res->start, (res - &pdev->resource[0]), pdev->name);
  408. continue;
  409. }
  410. }
  412. /* Adjust the resource into the physical address space
  413.  * of this PBM.
  414.  */
  415. pbm->parent->resource_adjust(pdev, res, root);
  417. if (request_resource(root, res) < 0) {
  418. /* OK, there is some conflict.  But this is fine
  419.  * since we'll reassign it in the fixup pass.
  420.  *
  421.  * We notify the user that OBP made an error if it
  422.  * is a case we don't expect.
  423.  */
  424. if (!pdev_resource_collisions_expected(pdev)) {
  425. printk(KERN_ERR "PCI: Address space collision on region %ld "
  426.        "[%016lx:%016lx] of device %sn",
  427.        (res - &pdev->resource[0]),
  428.        res->start, res->end,
  429.        pdev->name);
  430. }
  431. }
  432. }
  433. }
  435. void __init pci_record_assignments(struct pci_pbm_info *pbm,
  436.    struct pci_bus *pbus)
  437. {
  438. struct list_head *walk = &pbus->devices;
  440. for (walk = walk->next; walk != &pbus->devices; walk = walk->next)
  441. pdev_record_assignments(pbm, pci_dev_b(walk));
  443. walk = &pbus->children;
  444. for (walk = walk->next; walk != &pbus->children; walk = walk->next)
  445. pci_record_assignments(pbm, pci_bus_b(walk));
  446. }
  448. /* Return non-zero if PDEV has implicit I/O resources even
  449.  * though it may not have an I/O base address register
  450.  * active.
  451.  */
  452. static int __init has_implicit_io(struct pci_dev *pdev)
  453. {
  454. int class = pdev->class >> 8;
  456. if (class == PCI_CLASS_NOT_DEFINED ||
  457.     class == PCI_CLASS_NOT_DEFINED_VGA ||
  458.     class == PCI_CLASS_STORAGE_IDE ||
  459.     (pdev->class >> 16) == PCI_BASE_CLASS_DISPLAY)
  460. return 1;
  462. return 0;
  463. }
  465. static void __init pdev_assign_unassigned(struct pci_pbm_info *pbm,
  466.   struct pci_dev *pdev)
  467. {
  468. u32 reg;
  469. u16 cmd;
  470. int i, io_seen, mem_seen;
  472. io_seen = mem_seen = 0;
  473. for (i = 0; i < PCI_NUM_RESOURCES; i++) {
  474. struct resource *root, *res;
  475. unsigned long size, min, max, align;
  477. res = &pdev->resource[i];
  479. if (res->flags & IORESOURCE_IO)
  480. io_seen++;
  481. else if (res->flags & IORESOURCE_MEM)
  482. mem_seen++;
  484. /* If it is already assigned or the resource does
  485.  * not exist, there is nothing to do.
  486.  */
  487. if (res->parent != NULL || res->flags == 0UL)
  488. continue;
  490. /* Determine the root we allocate from. */
  491. if (res->flags & IORESOURCE_IO) {
  492. root = &pbm->io_space;
  493. min = root->start + 0x400UL;
  494. max = root->end;
  495. } else {
  496. root = &pbm->mem_space;
  497. min = root->start;
  498. max = min + 0x80000000UL;
  499. }
  501. size = res->end - res->start;
  502. align = size + 1;
  503. if (allocate_resource(root, res, size + 1, min, max, align, NULL, NULL) < 0) {
  504. /* uh oh */
  505. prom_printf("PCI: Failed to allocate resource %d for %sn",
  506.     i, pdev->name);
  507. prom_halt();
  508. }
  510. /* Update PCI config space. */
  511. pbm->parent->base_address_update(pdev, i);
  512. }
  514. /* Special case, disable the ROM.  Several devices
  515.  * act funny (ie. do not respond to memory space writes)
  516.  * when it is left enabled.  A good example are Qlogic,ISP
  517.  * adapters.
  518.  */
  519. pci_read_config_dword(pdev, PCI_ROM_ADDRESS, &reg);
  520. reg &= ~PCI_ROM_ADDRESS_ENABLE;
  521. pci_write_config_dword(pdev, PCI_ROM_ADDRESS, reg);
  523. /* If we saw I/O or MEM resources, enable appropriate
  524.  * bits in PCI command register.
  525.  */
  526. if (io_seen || mem_seen) {
  527. pci_read_config_word(pdev, PCI_COMMAND, &cmd);
  528. if (io_seen || has_implicit_io(pdev))
  529. cmd |= PCI_COMMAND_IO;
  530. if (mem_seen)
  531. cmd |= PCI_COMMAND_MEMORY;
  532. pci_write_config_word(pdev, PCI_COMMAND, cmd);
  533. }
  535. /* If this is a PCI bridge or an IDE controller,
  536.  * enable bus mastering.  In the former case also
  537.  * set the cache line size correctly.
  538.  */
  539. if (((pdev->class >> 8) == PCI_CLASS_BRIDGE_PCI) ||
  540.     (((pdev->class >> 8) == PCI_CLASS_STORAGE_IDE) &&
  541.      ((pdev->class & 0x80) != 0))) {
  542. pci_read_config_word(pdev, PCI_COMMAND, &cmd);
  543. cmd |= PCI_COMMAND_MASTER;
  544. pci_write_config_word(pdev, PCI_COMMAND, cmd);
  546. if ((pdev->class >> 8) == PCI_CLASS_BRIDGE_PCI)
  547. pci_write_config_byte(pdev,
  548.       PCI_CACHE_LINE_SIZE,
  549.       (64 / sizeof(u32)));
  550. }
  551. }
  553. void __init pci_assign_unassigned(struct pci_pbm_info *pbm,
  554.   struct pci_bus *pbus)
  555. {
  556. struct list_head *walk = &pbus->devices;
  558. for (walk = walk->next; walk != &pbus->devices; walk = walk->next)
  559. pdev_assign_unassigned(pbm, pci_dev_b(walk));
  561. walk = &pbus->children;
  562. for (walk = walk->next; walk != &pbus->children; walk = walk->next)
  563. pci_assign_unassigned(pbm, pci_bus_b(walk));
  564. }
  566. static int __init pci_intmap_match(struct pci_dev *pdev, unsigned int *interrupt)
  567. {
  568. struct linux_prom_pci_intmap bridge_local_intmap[PROM_PCIIMAP_MAX], *intmap;
  569. struct linux_prom_pci_intmask bridge_local_intmask, *intmask;
  570. struct pcidev_cookie *dev_pcp = pdev->sysdata;
  571. struct pci_pbm_info *pbm = dev_pcp->pbm;
  572. struct linux_prom_pci_registers *pregs = dev_pcp->prom_regs;
  573. unsigned int hi, mid, lo, irq;
  574. int i, num_intmap, map_slot;
  576. intmap = &pbm->pbm_intmap[0];
  577. intmask = &pbm->pbm_intmask;
  578. num_intmap = pbm->num_pbm_intmap;
  579. map_slot = 0;
  581. /* If we are underneath a PCI bridge, use PROM register
  582.  * property of the parent bridge which is closest to
  583.  * the PBM.
  584.  *
  585.  * However if that parent bridge has interrupt map/mask
  586.  * properties of it's own we use the PROM register property
  587.  * of the next child device on the path to PDEV.
  588.  *
  589.  * In detail the two cases are (note that the 'X' below is the
  590.  * 'next child on the path to PDEV' mentioned above):
  591.  *
  592.  * 1) PBM --> PCI bus lacking int{map,mask} --> X ... PDEV
  593.  *
  594.  *    Here we use regs of 'PCI bus' device.
  595.  *
  596.  * 2) PBM --> PCI bus with int{map,mask} --> X ... PDEV
  597.  *
  598.  *    Here we use regs of 'X'.  Note that X can be PDEV.
  599.  */
  600. if (pdev->bus->number != pbm->pci_first_busno) {
  601. struct pcidev_cookie *bus_pcp, *regs_pcp;
  602. struct pci_dev *bus_dev, *regs_dev;
  603. int plen;
  605. bus_dev = pdev->bus->self;
  606. regs_dev = pdev;
  608. while (bus_dev->bus &&
  609.        bus_dev->bus->number != pbm->pci_first_busno) {
  610. regs_dev = bus_dev;
  611. bus_dev = bus_dev->bus->self;
  612. }
  614. regs_pcp = regs_dev->sysdata;
  615. pregs = regs_pcp->prom_regs;
  617. bus_pcp = bus_dev->sysdata;
  619. /* But if the PCI bridge has it's own interrupt map
  620.  * and mask properties, use that and the regs of the
  621.  * PCI entity at the next level down on the path to the
  622.  * device.
  623.  */
  624. plen = prom_getproperty(bus_pcp->prom_node, "interrupt-map",
  625. (char *) &bridge_local_intmap[0],
  626. sizeof(bridge_local_intmap));
  627. if (plen != -1) {
  628. intmap = &bridge_local_intmap[0];
  629. num_intmap = plen / sizeof(struct linux_prom_pci_intmap);
  630. plen = prom_getproperty(bus_pcp->prom_node,
  631. "interrupt-map-mask",
  632. (char *) &bridge_local_intmask,
  633. sizeof(bridge_local_intmask));
  634. if (plen == -1) {
  635. printk("pci_intmap_match: Warning! Bridge has intmap "
  636.        "but no intmask.n");
  637. printk("pci_intmap_match: Trying to recover.n");
  638. return 0;
  639. }
  641. if (pdev->bus->self != bus_dev)
  642. map_slot = 1;
  643. } else {
  644. pregs = bus_pcp->prom_regs;
  645. map_slot = 1;
  646. }
  647. }
  649. if (map_slot) {
  650. *interrupt = ((*interrupt
  651.        - 1
  652.        + PCI_SLOT(pdev->devfn)) & 0x3) + 1;
  653. }
  655. hi   = pregs->phys_hi & intmask->phys_hi;
  656. mid  = pregs->phys_mid & intmask->phys_mid;
  657. lo   = pregs->phys_lo & intmask->phys_lo;
  658. irq  = *interrupt & intmask->interrupt;
  660. for (i = 0; i < num_intmap; i++) {
  661. if (intmap[i].phys_hi  == hi &&
  662.     intmap[i].phys_mid == mid &&
  663.     intmap[i].phys_lo  == lo &&
  664.     intmap[i].interrupt == irq) {
  665. *interrupt = intmap[i].cinterrupt;
  666. printk("PCI-IRQ: Routing bus[%2x] slot[%2x] map[%d] to INO[%02x]n",
  667.        pdev->bus->number, PCI_SLOT(pdev->devfn),
  668.        map_slot, *interrupt);
  669. return 1;
  670. }
  671. }
  673. /* We will run this code even if pbm->num_pbm_intmap is zero, just so
  674.  * we can apply the slot mapping to the PROM interrupt property value.
  675.  * So do not spit out these warnings in that case.
  676.  */
  677. if (num_intmap != 0) {
  678. /* Print it both to OBP console and kernel one so that if bootup
  679.  * hangs here the user has the information to report.
  680.  */
  681. prom_printf("pci_intmap_match: bus %02x, devfn %02x: ",
  682.     pdev->bus->number, pdev->devfn);
  683. prom_printf("IRQ [%08x.%08x.%08x.%08x] not found in interrupt-mapn",
  684.     pregs->phys_hi, pregs->phys_mid, pregs->phys_lo, *interrupt);
  685. prom_printf("Please email this information to davem@redhat.comn");
  687. printk("pci_intmap_match: bus %02x, devfn %02x: ",
  688.        pdev->bus->number, pdev->devfn);
  689. printk("IRQ [%08x.%08x.%08x.%08x] not found in interrupt-mapn",
  690.        pregs->phys_hi, pregs->phys_mid, pregs->phys_lo, *interrupt);
  691. printk("Please email this information to davem@redhat.comn");
  692. }
  694. return 0;
  695. }
  697. static void __init pdev_fixup_irq(struct pci_dev *pdev)
  698. {
  699. struct pcidev_cookie *pcp = pdev->sysdata;
  700. struct pci_pbm_info *pbm = pcp->pbm;
  701. struct pci_controller_info *p = pbm->parent;
  702. unsigned int portid = p->portid;
  703. unsigned int prom_irq;
  704. int prom_node = pcp->prom_node;
  705. int err;
  707. /* If this is an empty EBUS device, sometimes OBP fails to
  708.  * give it a valid fully specified interrupts property.
  709.  * The EBUS hooked up to SunHME on PCI I/O boards of
  710.  * Ex000 systems is one such case.
  711.  *
  712.  * The interrupt is not important so just ignore it.
  713.  */
  714. if (pdev->vendor == PCI_VENDOR_ID_SUN &&
  715.     pdev->device == PCI_DEVICE_ID_SUN_EBUS &&
  716.     !prom_getchild(prom_node)) {
  717. pdev->irq = 0;
  718. return;
  719. }
  721. err = prom_getproperty(prom_node, "interrupts",
  722.        (char *)&prom_irq, sizeof(prom_irq));
  723. if (err == 0 || err == -1) {
  724. pdev->irq = 0;
  725. return;
  726. }
  728. /* Fully specified already? */
  729. if (((prom_irq & PCI_IRQ_IGN) >> 6) == portid) {
  730. pdev->irq = p->irq_build(pbm, pdev, prom_irq);
  731. goto have_irq;
  732. }
  734. /* An onboard device? (bit 5 set) */
  735. if ((prom_irq & PCI_IRQ_INO) & 0x20) {
  736. pdev->irq = p->irq_build(pbm, pdev, (portid << 6 | prom_irq));
  737. goto have_irq;
  738. }
  740. /* Can we find a matching entry in the interrupt-map? */
  741. if (pci_intmap_match(pdev, &prom_irq)) {
  742. pdev->irq = p->irq_build(pbm, pdev, (portid << 6) | prom_irq);
  743. goto have_irq;
  744. }
  746. /* Ok, we have to do it the hard way. */
  747. {
  748. unsigned int bus, slot, line;
  750. bus = (pbm == &pbm->parent->pbm_B) ? (1 << 4) : 0;
  752. /* If we have a legal interrupt property, use it as
  753.  * the IRQ line.
  754.  */
  755. if (prom_irq > 0 && prom_irq < 5) {
  756. line = ((prom_irq - 1) & 3);
  757. } else {
  758. u8 pci_irq_line;
  760. /* Else just directly consult PCI config space. */
  761. pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pci_irq_line);
  762. line = ((pci_irq_line - 1) & 3);
  763. }
  765. /* Now figure out the slot.
  766.  *
  767.  * Basically, device number zero on the top-level bus is
  768.  * always the PCI host controller.  Slot 0 is then device 1.
  769.  * PBM A supports two external slots (0 and 1), and PBM B
  770.  * supports 4 external slots (0, 1, 2, and 3).  On-board PCI
  771.  * devices are wired to device numbers outside of these
  772.  * ranges. -DaveM
  773.    */
  774. if (pdev->bus->number == pbm->pci_first_busno) {
  775. slot = PCI_SLOT(pdev->devfn) - pbm->pci_first_slot;
  776. } else {
  777. struct pci_dev *bus_dev;
  779. /* Underneath a bridge, use slot number of parent
  780.  * bridge which is closest to the PBM.
  781.  */
  782. bus_dev = pdev->bus->self;
  783. while (bus_dev->bus &&
  784.        bus_dev->bus->number != pbm->pci_first_busno)
  785. bus_dev = bus_dev->bus->self;
  787. slot = PCI_SLOT(bus_dev->devfn) - pbm->pci_first_slot;
  788. }
  789. slot = slot << 2;
  791. pdev->irq = p->irq_build(pbm, pdev,
  792.  ((portid << 6) & PCI_IRQ_IGN) |
  793.  (bus | slot | line));
  794. }
  796. have_irq:
  797. pci_write_config_byte(pdev, PCI_INTERRUPT_LINE,
  798.       pdev->irq & PCI_IRQ_INO);
  799. }
  801. void __init pci_fixup_irq(struct pci_pbm_info *pbm,
  802.   struct pci_bus *pbus)
  803. {
  804. struct list_head *walk = &pbus->devices;
  806. for (walk = walk->next; walk != &pbus->devices; walk = walk->next)
  807. pdev_fixup_irq(pci_dev_b(walk));
  809. walk = &pbus->children;
  810. for (walk = walk->next; walk != &pbus->children; walk = walk->next)
  811. pci_fixup_irq(pbm, pci_bus_b(walk));
  812. }
  814. static void pdev_setup_busmastering(struct pci_dev *pdev, int is_66mhz)
  815. {
  816. u16 cmd;
  817. u8 hdr_type, min_gnt, ltimer;
  819. pci_read_config_word(pdev, PCI_COMMAND, &cmd);
  820. cmd |= PCI_COMMAND_MASTER;
  821. pci_write_config_word(pdev, PCI_COMMAND, cmd);
  823. /* Read it back, if the mastering bit did not
  824.  * get set, the device does not support bus
  825.  * mastering so we have nothing to do here.
  826.  */
  827. pci_read_config_word(pdev, PCI_COMMAND, &cmd);
  828. if ((cmd & PCI_COMMAND_MASTER) == 0)
  829. return;
  831. /* Set correct cache line size, 64-byte on all
  832.  * Sparc64 PCI systems.  Note that the value is
  833.  * measured in 32-bit words.
  834.  */
  835. pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
  836.       64 / sizeof(u32));
  838. pci_read_config_byte(pdev, PCI_HEADER_TYPE, &hdr_type);
  839. hdr_type &= ~0x80;
  840. if (hdr_type != PCI_HEADER_TYPE_NORMAL)
  841. return;
  843. /* If the latency timer is already programmed with a non-zero
  844.  * value, assume whoever set it (OBP or whoever) knows what
  845.  * they are doing.
  846.  */
  847. pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &ltimer);
  848. if (ltimer != 0)
  849. return;
  851. /* XXX Since I'm tipping off the min grant value to
  852.  * XXX choose a suitable latency timer value, I also
  853.  * XXX considered making use of the max latency value
  854.  * XXX as well.  Unfortunately I've seen too many bogusly
  855.  * XXX low settings for it to the point where it lacks
  856.  * XXX any usefulness.  In one case, an ethernet card
  857.  * XXX claimed a min grant of 10 and a max latency of 5.
  858.  * XXX Now, if I had two such cards on the same bus I
  859.  * XXX could not set the desired burst period (calculated
  860.  * XXX from min grant) without violating the max latency
  861.  * XXX bound.  Duh...
  862.  * XXX
  863.  * XXX I blame dumb PC bios implementors for stuff like
  864.  * XXX this, most of them don't even try to do something
  865.  * XXX sensible with latency timer values and just set some
  866.  * XXX default value (usually 32) into every device.
  867.  */
  869. pci_read_config_byte(pdev, PCI_MIN_GNT, &min_gnt);
  871. if (min_gnt == 0) {
  872. /* If no min_gnt setting then use a default
  873.  * value.
  874.  */
  875. if (is_66mhz)
  876. ltimer = 16;
  877. else
  878. ltimer = 32;
  879. } else {
  880. int shift_factor;
  882. if (is_66mhz)
  883. shift_factor = 2;
  884. else
  885. shift_factor = 3;
  887. /* Use a default value when the min_gnt value
  888.  * is erroneously high.
  889.  */
  890. if (((unsigned int) min_gnt << shift_factor) > 512 ||
  891.     ((min_gnt << shift_factor) & 0xff) == 0) {
  892. ltimer = 8 << shift_factor;
  893. } else {
  894. ltimer = min_gnt << shift_factor;
  895. }
  896. }
  898. pci_write_config_byte(pdev, PCI_LATENCY_TIMER, ltimer);
  899. }
  901. void pci_determine_66mhz_disposition(struct pci_pbm_info *pbm,
  902.      struct pci_bus *pbus)
  903. {
  904. struct list_head *walk;
  905. int all_are_66mhz;
  906. u16 status;
  908. if (pbm->is_66mhz_capable == 0) {
  909. all_are_66mhz = 0;
  910. goto out;
  911. }
  913. walk = &pbus->devices;
  914. all_are_66mhz = 1;
  915. for (walk = walk->next; walk != &pbus->devices; walk = walk->next) {
  916. struct pci_dev *pdev = pci_dev_b(walk);
  918. pci_read_config_word(pdev, PCI_STATUS, &status);
  919. if (!(status & PCI_STATUS_66MHZ)) {
  920. all_are_66mhz = 0;
  921. break;
  922. }
  923. }
  924. out:
  925. pbm->all_devs_66mhz = all_are_66mhz;
  927. printk("PCI%d(PBM%c): Bus running at %dMHzn",
  928.        pbm->parent->index,
  929.        (pbm == &pbm->parent->pbm_A) ? 'A' : 'B',
  930.        (all_are_66mhz ? 66 : 33));
  931. }
  933. void pci_setup_busmastering(struct pci_pbm_info *pbm,
  934.     struct pci_bus *pbus)
  935. {
  936. struct list_head *walk = &pbus->devices;
  937. int is_66mhz;
  939. is_66mhz = pbm->is_66mhz_capable && pbm->all_devs_66mhz;
  941. for (walk = walk->next; walk != &pbus->devices; walk = walk->next)
  942. pdev_setup_busmastering(pci_dev_b(walk), is_66mhz);
  944. walk = &pbus->children;
  945. for (walk = walk->next; walk != &pbus->children; walk = walk->next)
  946. pci_setup_busmastering(pbm, pci_bus_b(walk));
  947. }
  949. void pci_register_legacy_regions(struct resource *io_res,
  950.  struct resource *mem_res)
  951. {
  952. struct resource *p;
  954. /* VGA Video RAM. */
  955. p = kmalloc(sizeof(*p), GFP_KERNEL);
  956. if (!p)
  957. return;
  959. memset(p, 0, sizeof(*p));
  960. p->name = "Video RAM area";
  961. p->start = mem_res->start + 0xa0000UL;
  962. p->end = p->start + 0x1ffffUL;
  963. p->flags = IORESOURCE_BUSY;
  964. request_resource(mem_res, p);
  966. p = kmalloc(sizeof(*p), GFP_KERNEL);
  967. if (!p)
  968. return;
  970. memset(p, 0, sizeof(*p));
  971. p->name = "System ROM";
  972. p->start = mem_res->start + 0xf0000UL;
  973. p->end = p->start + 0xffffUL;
  974. p->flags = IORESOURCE_BUSY;
  975. request_resource(mem_res, p);
  977. p = kmalloc(sizeof(*p), GFP_KERNEL);
  978. if (!p)
  979. return;
  981. memset(p, 0, sizeof(*p));
  982. p->name = "Video ROM";
  983. p->start = mem_res->start + 0xc0000UL;
  984. p->end = p->start + 0x7fffUL;
  985. p->flags = IORESOURCE_BUSY;
  986. request_resource(mem_res, p);
  987. }
  989. /* Generic helper routines for PCI error reporting. */
  990. void pci_scan_for_target_abort(struct pci_controller_info *p,
  991.        struct pci_pbm_info *pbm,
  992.        struct pci_bus *pbus)
  993. {
  994. struct list_head *walk = &pbus->devices;
  996. for (walk = walk->next; walk != &pbus->devices; walk = walk->next) {
  997. struct pci_dev *pdev = pci_dev_b(walk);
  998. u16 status, error_bits;
  1000. pci_read_config_word(pdev, PCI_STATUS, &status);
  1001. error_bits =
  1002. (status & (PCI_STATUS_SIG_TARGET_ABORT |
  1003.    PCI_STATUS_REC_TARGET_ABORT));
  1004. if (error_bits) {
  1005. pci_write_config_word(pdev, PCI_STATUS, error_bits);
  1006. printk("PCI%d(PBM%c): Device [%s] saw Target Abort [%016x]n",
  1007.        p->index, ((pbm == &p->pbm_A) ? 'A' : 'B'),
  1008.        pdev->name, status);
  1009. }
  1010. }
  1012. walk = &pbus->children;
  1013. for (walk = walk->next; walk != &pbus->children; walk = walk->next)
  1014. pci_scan_for_target_abort(p, pbm, pci_bus_b(walk));
  1015. }
  1017. void pci_scan_for_master_abort(struct pci_controller_info *p,
  1018.        struct pci_pbm_info *pbm,
  1019.        struct pci_bus *pbus)
  1020. {
  1021. struct list_head *walk = &pbus->devices;
  1023. for (walk = walk->next; walk != &pbus->devices; walk = walk->next) {
  1024. struct pci_dev *pdev = pci_dev_b(walk);
  1025. u16 status, error_bits;
  1027. pci_read_config_word(pdev, PCI_STATUS, &status);
  1028. error_bits =
  1029. (status & (PCI_STATUS_REC_MASTER_ABORT));
  1030. if (error_bits) {
  1031. pci_write_config_word(pdev, PCI_STATUS, error_bits);
  1032. printk("PCI%d(PBM%c): Device [%s] received Master Abort [%016x]n",
  1033.        p->index, ((pbm == &p->pbm_A) ? 'A' : 'B'),
  1034.        pdev->name, status);
  1035. }
  1036. }
  1038. walk = &pbus->children;
  1039. for (walk = walk->next; walk != &pbus->children; walk = walk->next)
  1040. pci_scan_for_master_abort(p, pbm, pci_bus_b(walk));
  1041. }
  1043. void pci_scan_for_parity_error(struct pci_controller_info *p,
  1044.        struct pci_pbm_info *pbm,
  1045.        struct pci_bus *pbus)
  1046. {
  1047. struct list_head *walk = &pbus->devices;
  1049. for (walk = walk->next; walk != &pbus->devices; walk = walk->next) {
  1050. struct pci_dev *pdev = pci_dev_b(walk);
  1051. u16 status, error_bits;
  1053. pci_read_config_word(pdev, PCI_STATUS, &status);
  1054. error_bits =
  1055. (status & (PCI_STATUS_PARITY |
  1056.    PCI_STATUS_DETECTED_PARITY));
  1057. if (error_bits) {
  1058. pci_write_config_word(pdev, PCI_STATUS, error_bits);
  1059. printk("PCI%d(PBM%c): Device [%s] saw Parity Error [%016x]n",
  1060.        p->index, ((pbm == &p->pbm_A) ? 'A' : 'B'),
  1061.        pdev->name, status);
  1062. }
  1063. }
  1065. walk = &pbus->children;
  1066. for (walk = walk->next; walk != &pbus->children; walk = walk->next)
  1067. pci_scan_for_parity_error(p, pbm, pci_bus_b(walk));
  1068. }