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

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

嵌入式Linux

开发平台：

Unix_Linux

pci_common.c：源码内容
  1. /* $Id: pci_common.c,v 1.27.2.2 2002/02/01 00:56:44 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;
  576. if (pbm->num_pbm_intmap == 0)
  577. return 0;
  579. intmap = &pbm->pbm_intmap[0];
  580. intmask = &pbm->pbm_intmask;
  581. num_intmap = pbm->num_pbm_intmap;
  583. /* If we are underneath a PCI bridge, use PROM register
  584.  * property of the parent bridge which is closest to
  585.  * the PBM.
  586.  */
  587. if (pdev->bus->number != pbm->pci_first_busno) {
  588. struct pcidev_cookie *bus_pcp;
  589. struct pci_dev *pwalk;
  590. int offset, plen;
  592. pwalk = pdev->bus->self;
  593. while (pwalk->bus &&
  594.        pwalk->bus->number != pbm->pci_first_busno)
  595. pwalk = pwalk->bus->self;
  597. bus_pcp = pwalk->sysdata;
  599. /* But if the PCI bridge has it's own interrupt map
  600.  * and mask properties, use that and the device regs.
  601.  */
  602. plen = prom_getproperty(bus_pcp->prom_node, "interrupt-map",
  603. (char *) &bridge_local_intmap[0],
  604. sizeof(bridge_local_intmap));
  605. if (plen != -1) {
  606. intmap = &bridge_local_intmap[0];
  607. num_intmap = plen / sizeof(struct linux_prom_pci_intmap);
  608. plen = prom_getproperty(bus_pcp->prom_node, "interrupt-map-mask",
  609. (char *) &bridge_local_intmask,
  610. sizeof(bridge_local_intmask));
  611. if (plen == -1) {
  612. prom_printf("pbm_intmap_match: Bridge has intmap but "
  613.     "no intmask.n");
  614. prom_halt();
  615. }
  616. goto check_intmap;
  617. }
  619. pregs = bus_pcp->prom_regs;
  621. offset = prom_getint(dev_pcp->prom_node,
  622.      "fcode-rom-offset");
  624. /* Did PROM know better and assign an interrupt other
  625.  * than #INTA to the device? - We test here for presence of
  626.  * FCODE on the card, in this case we assume PROM has set
  627.  * correct 'interrupts' property, unless it is quadhme.
  628.  */
  629. if (offset == -1 ||
  630.     !strcmp(dev_pcp->prom_name, "SUNW,qfe") ||
  631.     !strcmp(dev_pcp->prom_name, "qfe")) {
  632. /*
  633.  * No, use low slot number bits of child as IRQ line.
  634.  */
  635. *interrupt = ((*interrupt - 1 + PCI_SLOT(pdev->devfn)) & 3) + 1;
  636. }
  637. }
  639. check_intmap:
  640. hi   = pregs->phys_hi & intmask->phys_hi;
  641. mid  = pregs->phys_mid & intmask->phys_mid;
  642. lo   = pregs->phys_lo & intmask->phys_lo;
  643. irq  = *interrupt & intmask->interrupt;
  645. for (i = 0; i < num_intmap; i++) {
  646. if (intmap[i].phys_hi  == hi &&
  647.     intmap[i].phys_mid == mid &&
  648.     intmap[i].phys_lo  == lo &&
  649.     intmap[i].interrupt == irq) {
  650. *interrupt = intmap[i].cinterrupt;
  651. return 1;
  652. }
  653. }
  655. prom_printf("pbm_intmap_match: bus %02x, devfn %02x: ",
  656.     pdev->bus->number, pdev->devfn);
  657. prom_printf("IRQ [%08x.%08x.%08x.%08x] not found in interrupt-mapn",
  658.     pregs->phys_hi, pregs->phys_mid, pregs->phys_lo, *interrupt);
  659. prom_printf("Please email this information to davem@redhat.comn");
  660. prom_halt();
  661. }
  663. static void __init pdev_fixup_irq(struct pci_dev *pdev)
  664. {
  665. struct pcidev_cookie *pcp = pdev->sysdata;
  666. struct pci_pbm_info *pbm = pcp->pbm;
  667. struct pci_controller_info *p = pbm->parent;
  668. unsigned int portid = p->portid;
  669. unsigned int prom_irq;
  670. int prom_node = pcp->prom_node;
  671. int err;
  673. /* If this is an empty EBUS device, sometimes OBP fails to
  674.  * give it a valid fully specified interrupts property.
  675.  * The EBUS hooked up to SunHME on PCI I/O boards of
  676.  * Ex000 systems is one such case.
  677.  *
  678.  * The interrupt is not important so just ignore it.
  679.  */
  680. if (pdev->vendor == PCI_VENDOR_ID_SUN &&
  681.     pdev->device == PCI_DEVICE_ID_SUN_EBUS &&
  682.     !prom_getchild(prom_node)) {
  683. pdev->irq = 0;
  684. return;
  685. }
  687. err = prom_getproperty(prom_node, "interrupts",
  688.        (char *)&prom_irq, sizeof(prom_irq));
  689. if (err == 0 || err == -1) {
  690. pdev->irq = 0;
  691. return;
  692. }
  694. /* Fully specified already? */
  695. if (((prom_irq & PCI_IRQ_IGN) >> 6) == portid) {
  696. pdev->irq = p->irq_build(pbm, pdev, prom_irq);
  697. goto have_irq;
  698. }
  700. /* An onboard device? (bit 5 set) */
  701. if ((prom_irq & PCI_IRQ_INO) & 0x20) {
  702. pdev->irq = p->irq_build(pbm, pdev, (portid << 6 | prom_irq));
  703. goto have_irq;
  704. }
  706. /* Can we find a matching entry in the interrupt-map? */
  707. if (pci_intmap_match(pdev, &prom_irq)) {
  708. pdev->irq = p->irq_build(pbm, pdev, (portid << 6) | prom_irq);
  709. goto have_irq;
  710. }
  712. /* Ok, we have to do it the hard way. */
  713. {
  714. unsigned int bus, slot, line;
  716. bus = (pbm == &pbm->parent->pbm_B) ? (1 << 4) : 0;
  718. /* If we have a legal interrupt property, use it as
  719.  * the IRQ line.
  720.  */
  721. if (prom_irq > 0 && prom_irq < 5) {
  722. line = ((prom_irq - 1) & 3);
  723. } else {
  724. u8 pci_irq_line;
  726. /* Else just directly consult PCI config space. */
  727. pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pci_irq_line);
  728. line = ((pci_irq_line - 1) & 3);
  729. }
  731. /* Now figure out the slot.
  732.  *
  733.  * Basically, device number zero on the top-level bus is
  734.  * always the PCI host controller.  Slot 0 is then device 1.
  735.  * PBM A supports two external slots (0 and 1), and PBM B
  736.  * supports 4 external slots (0, 1, 2, and 3).  On-board PCI
  737.  * devices are wired to device numbers outside of these
  738.  * ranges. -DaveM
  739.    */
  740. if (pdev->bus->number == pbm->pci_first_busno) {
  741. slot = (pdev->devfn >> 3) - pbm->pci_first_slot;
  742. } else {
  743. /* Underneath a bridge, use slot number of parent
  744.  * bridge.
  745.  */
  746. slot = (pdev->bus->self->devfn >> 3) - pbm->pci_first_slot;
  747. }
  748. slot = slot << 2;
  750. pdev->irq = p->irq_build(pbm, pdev,
  751.  ((portid << 6) & PCI_IRQ_IGN) |
  752.  (bus | slot | line));
  753. }
  755. have_irq:
  756. pci_write_config_byte(pdev, PCI_INTERRUPT_LINE,
  757.       pdev->irq & PCI_IRQ_INO);
  758. }
  760. void __init pci_fixup_irq(struct pci_pbm_info *pbm,
  761.   struct pci_bus *pbus)
  762. {
  763. struct list_head *walk = &pbus->devices;
  765. for (walk = walk->next; walk != &pbus->devices; walk = walk->next)
  766. pdev_fixup_irq(pci_dev_b(walk));
  768. walk = &pbus->children;
  769. for (walk = walk->next; walk != &pbus->children; walk = walk->next)
  770. pci_fixup_irq(pbm, pci_bus_b(walk));
  771. }
  773. static void pdev_setup_busmastering(struct pci_dev *pdev, int is_66mhz)
  774. {
  775. u16 cmd;
  776. u8 hdr_type, min_gnt, ltimer;
  778. pci_read_config_word(pdev, PCI_COMMAND, &cmd);
  779. cmd |= PCI_COMMAND_MASTER;
  780. pci_write_config_word(pdev, PCI_COMMAND, cmd);
  782. /* Read it back, if the mastering bit did not
  783.  * get set, the device does not support bus
  784.  * mastering so we have nothing to do here.
  785.  */
  786. pci_read_config_word(pdev, PCI_COMMAND, &cmd);
  787. if ((cmd & PCI_COMMAND_MASTER) == 0)
  788. return;
  790. /* Set correct cache line size, 64-byte on all
  791.  * Sparc64 PCI systems.  Note that the value is
  792.  * measured in 32-bit words.
  793.  */
  794. pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
  795.       64 / sizeof(u32));
  797. pci_read_config_byte(pdev, PCI_HEADER_TYPE, &hdr_type);
  798. hdr_type &= ~0x80;
  799. if (hdr_type != PCI_HEADER_TYPE_NORMAL)
  800. return;
  802. /* If the latency timer is already programmed with a non-zero
  803.  * value, assume whoever set it (OBP or whoever) knows what
  804.  * they are doing.
  805.  */
  806. pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &ltimer);
  807. if (ltimer != 0)
  808. return;
  810. /* XXX Since I'm tipping off the min grant value to
  811.  * XXX choose a suitable latency timer value, I also
  812.  * XXX considered making use of the max latency value
  813.  * XXX as well.  Unfortunately I've seen too many bogusly
  814.  * XXX low settings for it to the point where it lacks
  815.  * XXX any usefulness.  In one case, an ethernet card
  816.  * XXX claimed a min grant of 10 and a max latency of 5.
  817.  * XXX Now, if I had two such cards on the same bus I
  818.  * XXX could not set the desired burst period (calculated
  819.  * XXX from min grant) without violating the max latency
  820.  * XXX bound.  Duh...
  821.  * XXX
  822.  * XXX I blame dumb PC bios implementors for stuff like
  823.  * XXX this, most of them don't even try to do something
  824.  * XXX sensible with latency timer values and just set some
  825.  * XXX default value (usually 32) into every device.
  826.  */
  828. pci_read_config_byte(pdev, PCI_MIN_GNT, &min_gnt);
  830. if (min_gnt == 0) {
  831. /* If no min_gnt setting then use a default
  832.  * value.
  833.  */
  834. if (is_66mhz)
  835. ltimer = 16;
  836. else
  837. ltimer = 32;
  838. } else {
  839. int shift_factor;
  841. if (is_66mhz)
  842. shift_factor = 2;
  843. else
  844. shift_factor = 3;
  846. /* Use a default value when the min_gnt value
  847.  * is erroneously high.
  848.  */
  849. if (((unsigned int) min_gnt << shift_factor) > 512 ||
  850.     ((min_gnt << shift_factor) & 0xff) == 0) {
  851. ltimer = 8 << shift_factor;
  852. } else {
  853. ltimer = min_gnt << shift_factor;
  854. }
  855. }
  857. pci_write_config_byte(pdev, PCI_LATENCY_TIMER, ltimer);
  858. }
  860. void pci_determine_66mhz_disposition(struct pci_pbm_info *pbm,
  861.      struct pci_bus *pbus)
  862. {
  863. struct list_head *walk;
  864. int all_are_66mhz;
  865. u16 status;
  867. if (pbm->is_66mhz_capable == 0) {
  868. all_are_66mhz = 0;
  869. goto out;
  870. }
  872. walk = &pbus->devices;
  873. all_are_66mhz = 1;
  874. for (walk = walk->next; walk != &pbus->devices; walk = walk->next) {
  875. struct pci_dev *pdev = pci_dev_b(walk);
  877. pci_read_config_word(pdev, PCI_STATUS, &status);
  878. if (!(status & PCI_STATUS_66MHZ)) {
  879. all_are_66mhz = 0;
  880. break;
  881. }
  882. }
  883. out:
  884. pbm->all_devs_66mhz = all_are_66mhz;
  886. printk("PCI%d(PBM%c): Bus running at %dMHzn",
  887.        pbm->parent->index,
  888.        (pbm == &pbm->parent->pbm_A) ? 'A' : 'B',
  889.        (all_are_66mhz ? 66 : 33));
  890. }
  892. void pci_setup_busmastering(struct pci_pbm_info *pbm,
  893.     struct pci_bus *pbus)
  894. {
  895. struct list_head *walk = &pbus->devices;
  896. int is_66mhz;
  898. is_66mhz = pbm->is_66mhz_capable && pbm->all_devs_66mhz;
  900. for (walk = walk->next; walk != &pbus->devices; walk = walk->next)
  901. pdev_setup_busmastering(pci_dev_b(walk), is_66mhz);
  903. walk = &pbus->children;
  904. for (walk = walk->next; walk != &pbus->children; walk = walk->next)
  905. pci_setup_busmastering(pbm, pci_bus_b(walk));
  906. }
  908. void pci_register_legacy_regions(struct resource *io_res,
  909.  struct resource *mem_res)
  910. {
  911. struct resource *p;
  913. /* VGA Video RAM. */
  914. p = kmalloc(sizeof(*p), GFP_KERNEL);
  915. if (!p)
  916. return;
  918. memset(p, 0, sizeof(*p));
  919. p->name = "Video RAM area";
  920. p->start = mem_res->start + 0xa0000UL;
  921. p->end = p->start + 0x1ffffUL;
  922. p->flags = IORESOURCE_BUSY;
  923. request_resource(mem_res, p);
  925. p = kmalloc(sizeof(*p), GFP_KERNEL);
  926. if (!p)
  927. return;
  929. memset(p, 0, sizeof(*p));
  930. p->name = "System ROM";
  931. p->start = mem_res->start + 0xf0000UL;
  932. p->end = p->start + 0xffffUL;
  933. p->flags = IORESOURCE_BUSY;
  934. request_resource(mem_res, p);
  936. p = kmalloc(sizeof(*p), GFP_KERNEL);
  937. if (!p)
  938. return;
  940. memset(p, 0, sizeof(*p));
  941. p->name = "Video ROM";
  942. p->start = mem_res->start + 0xc0000UL;
  943. p->end = p->start + 0x7fffUL;
  944. p->flags = IORESOURCE_BUSY;
  945. request_resource(mem_res, p);
  946. }
  948. /* Generic helper routines for PCI error reporting. */
  949. void pci_scan_for_target_abort(struct pci_controller_info *p,
  950.        struct pci_pbm_info *pbm,
  951.        struct pci_bus *pbus)
  952. {
  953. struct list_head *walk = &pbus->devices;
  955. for (walk = walk->next; walk != &pbus->devices; walk = walk->next) {
  956. struct pci_dev *pdev = pci_dev_b(walk);
  957. u16 status, error_bits;
  959. pci_read_config_word(pdev, PCI_STATUS, &status);
  960. error_bits =
  961. (status & (PCI_STATUS_SIG_TARGET_ABORT |
  962.    PCI_STATUS_REC_TARGET_ABORT));
  963. if (error_bits) {
  964. pci_write_config_word(pdev, PCI_STATUS, error_bits);
  965. printk("PCI%d(PBM%c): Device [%s] saw Target Abort [%016x]n",
  966.        p->index, ((pbm == &p->pbm_A) ? 'A' : 'B'),
  967.        pdev->name, status);
  968. }
  969. }
  971. walk = &pbus->children;
  972. for (walk = walk->next; walk != &pbus->children; walk = walk->next)
  973. pci_scan_for_target_abort(p, pbm, pci_bus_b(walk));
  974. }
  976. void pci_scan_for_master_abort(struct pci_controller_info *p,
  977.        struct pci_pbm_info *pbm,
  978.        struct pci_bus *pbus)
  979. {
  980. struct list_head *walk = &pbus->devices;
  982. for (walk = walk->next; walk != &pbus->devices; walk = walk->next) {
  983. struct pci_dev *pdev = pci_dev_b(walk);
  984. u16 status, error_bits;
  986. pci_read_config_word(pdev, PCI_STATUS, &status);
  987. error_bits =
  988. (status & (PCI_STATUS_REC_MASTER_ABORT));
  989. if (error_bits) {
  990. pci_write_config_word(pdev, PCI_STATUS, error_bits);
  991. printk("PCI%d(PBM%c): Device [%s] received Master Abort [%016x]n",
  992.        p->index, ((pbm == &p->pbm_A) ? 'A' : 'B'),
  993.        pdev->name, status);
  994. }
  995. }
  997. walk = &pbus->children;
  998. for (walk = walk->next; walk != &pbus->children; walk = walk->next)
  999. pci_scan_for_master_abort(p, pbm, pci_bus_b(walk));
  1000. }
  1002. void pci_scan_for_parity_error(struct pci_controller_info *p,
  1003.        struct pci_pbm_info *pbm,
  1004.        struct pci_bus *pbus)
  1005. {
  1006. struct list_head *walk = &pbus->devices;
  1008. for (walk = walk->next; walk != &pbus->devices; walk = walk->next) {
  1009. struct pci_dev *pdev = pci_dev_b(walk);
  1010. u16 status, error_bits;
  1012. pci_read_config_word(pdev, PCI_STATUS, &status);
  1013. error_bits =
  1014. (status & (PCI_STATUS_PARITY |
  1015.    PCI_STATUS_DETECTED_PARITY));
  1016. if (error_bits) {
  1017. pci_write_config_word(pdev, PCI_STATUS, error_bits);
  1018. printk("PCI%d(PBM%c): Device [%s] saw Parity Error [%016x]n",
  1019.        p->index, ((pbm == &p->pbm_A) ? 'A' : 'B'),
  1020.        pdev->name, status);
  1021. }
  1022. }
  1024. walk = &pbus->children;
  1025. for (walk = walk->next; walk != &pbus->children; walk = walk->next)
  1026. pci_scan_for_parity_error(p, pbm, pci_bus_b(walk));
  1027. }