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

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

Linux/Unix编程

开发平台：

Unix_Linux

pmac_pci.c：源码内容
  1. /*
  2.  * BK Id: %F% %I% %G% %U% %#%
  3.  */
  4. /*
  5.  * Support for PCI bridges found on Power Macintoshes.
  6.  * At present the "bandit" and "chaos" bridges are supported.
  7.  * Fortunately you access configuration space in the same
  8.  * way with either bridge.
  9.  *
  10.  * Copyright (C) 1997 Paul Mackerras (paulus@cs.anu.edu.au)
  11.  *
  12.  * This program is free software; you can redistribute it and/or
  13.  * modify it under the terms of the GNU General Public License
  14.  * as published by the Free Software Foundation; either version
  15.  * 2 of the License, or (at your option) any later version.
  16.  */
  18. #include <linux/kernel.h>
  19. #include <linux/pci.h>
  20. #include <linux/delay.h>
  21. #include <linux/string.h>
  22. #include <linux/init.h>
  23. #include <linux/bootmem.h>
  25. #include <asm/sections.h>
  26. #include <asm/io.h>
  27. #include <asm/prom.h>
  28. #include <asm/pci-bridge.h>
  29. #include <asm/machdep.h>
  30. #include <asm/pmac_feature.h>
  32. #undef DEBUG
  34. static void add_bridges(struct device_node *dev);
  36. /* XXX Could be per-controller, but I don't think we risk anything by
  37.  * assuming we won't have both UniNorth and Bandit */
  38. static int has_uninorth;
  40. /*
  41.  * Magic constants for enabling cache coherency in the bandit/PSX bridge.
  42.  */
  43. #define BANDIT_DEVID_2 8
  44. #define BANDIT_REVID 3
  46. #define BANDIT_DEVNUM 11
  47. #define BANDIT_MAGIC 0x50
  48. #define BANDIT_COHERENT 0x40
  50. static int __init
  51. fixup_one_level_bus_range(struct device_node *node, int higher)
  52. {
  53. for (; node != 0;node = node->sibling) {
  54. int * bus_range;
  55. unsigned int *class_code;
  56. int len;
  58. /* For PCI<->PCI bridges or CardBus bridges, we go down */
  59. class_code = (unsigned int *) get_property(node, "class-code", 0);
  60. if (!class_code || ((*class_code >> 8) != PCI_CLASS_BRIDGE_PCI &&
  61. (*class_code >> 8) != PCI_CLASS_BRIDGE_CARDBUS))
  62. continue;
  63. bus_range = (int *) get_property(node, "bus-range", &len);
  64. if (bus_range != NULL && len > 2 * sizeof(int)) {
  65. if (bus_range[1] > higher)
  66. higher = bus_range[1];
  67. }
  68. higher = fixup_one_level_bus_range(node->child, higher);
  69. }
  70. return higher;
  71. }
  73. /* This routine fixes the "bus-range" property of all bridges in the
  74.  * system since they tend to have their "last" member wrong on macs
  75.  * 
  76.  * Note that the bus numbers manipulated here are OF bus numbers, they
  77.  * are not Linux bus numbers.
  78.  */
  79. static void __init
  80. fixup_bus_range(struct device_node *bridge)
  81. {
  82. int * bus_range;
  83. int len;
  85. /* Lookup the "bus-range" property for the hose */
  86. bus_range = (int *) get_property(bridge, "bus-range", &len);
  87. if (bus_range == NULL || len < 2 * sizeof(int)) {
  88. printk(KERN_WARNING "Can't get bus-range for %sn",
  89.        bridge->full_name);
  90. return;
  91. }
  92. bus_range[1] = fixup_one_level_bus_range(bridge->child, bus_range[1]);
  93. }
  95. /*
  96.  * Apple MacRISC (UniNorth, Bandit, Chaos) PCI controllers.
  97.  * 
  98.  * The "Bandit" version is present in all early PCI PowerMacs,
  99.  * and up to the first ones using Grackle. Some machines may
  100.  * have 2 bandit controllers (2 PCI busses).
  101.  * 
  102.  * "Chaos" is used in some "Bandit"-type machines as a bridge
  103.  * for the separate display bus. It is accessed the same
  104.  * way as bandit, but cannot be probed for devices. It therefore
  105.  * has its own config access functions.
  106.  *
  107.  * The "UniNorth" version is present in all Core99 machines
  108.  * (iBook, G4, new IMacs, and all the recent Apple machines).
  109.  * It contains 3 controllers in one ASIC.
  110.  */
  112. #define MACRISC_CFA0(devfn, off)
  113. ((1 << (unsigned long)PCI_SLOT(dev_fn)) 
  114. | (((unsigned long)PCI_FUNC(dev_fn)) << 8) 
  115. | (((unsigned long)(off)) & 0xFCUL))
  117. #define MACRISC_CFA1(bus, devfn, off)
  118. ((((unsigned long)(bus)) << 16) 
  119. |(((unsigned long)(devfn)) << 8) 
  120. |(((unsigned long)(off)) & 0xFCUL) 
  121. |1UL)
  123. static unsigned int __pmac
  124. macrisc_cfg_access(struct pci_controller* hose, u8 bus, u8 dev_fn, u8 offset)
  125. {
  126. unsigned int caddr;
  128. if (bus == hose->first_busno) {
  129. if (dev_fn < (11 << 3))
  130. return 0;
  131. caddr = MACRISC_CFA0(dev_fn, offset);
  132. } else
  133. caddr = MACRISC_CFA1(bus, dev_fn, offset);
  135. /* Uninorth will return garbage if we don't read back the value ! */
  136. do {
  137. out_le32(hose->cfg_addr, caddr);
  138. } while(in_le32(hose->cfg_addr) != caddr);
  140. offset &= has_uninorth ? 0x07 : 0x03;
  141. return (unsigned int)(hose->cfg_data) + (unsigned int)offset;
  142. }
  144. #define cfg_read(val, addr, type, op, op2)
  145. *val = op((type)(addr))
  146. #define cfg_write(val, addr, type, op, op2)
  147. op((type *)(addr), (val)); (void) op2((type *)(addr))
  149. #define cfg_read_bad(val, size) *val = bad_##size;
  150. #define cfg_write_bad(val, size)
  152. #define bad_byte 0xff
  153. #define bad_word 0xffff
  154. #define bad_dword 0xffffffffU
  156. #define MACRISC_PCI_OP(rw, size, type, op, op2)     
  157. static int __pmac     
  158. macrisc_##rw##_config_##size(struct pci_dev *dev, int off, type val)     
  159. {     
  160. struct pci_controller *hose = dev->sysdata;     
  161. unsigned int addr;     
  162.     
  163. addr = macrisc_cfg_access(hose, dev->bus->number, dev->devfn, off); 
  164. if (!addr) {     
  165. cfg_##rw##_bad(val, size)     
  166. return PCIBIOS_DEVICE_NOT_FOUND;     
  167. }     
  168. cfg_##rw(val, addr, type, op, op2);     
  169. return PCIBIOS_SUCCESSFUL;     
  170. }
  172. MACRISC_PCI_OP(read, byte, u8 *, in_8, x)
  173. MACRISC_PCI_OP(read, word, u16 *, in_le16, x)
  174. MACRISC_PCI_OP(read, dword, u32 *, in_le32, x)
  175. MACRISC_PCI_OP(write, byte, u8, out_8, in_8)
  176. MACRISC_PCI_OP(write, word, u16, out_le16, in_le16)
  177. MACRISC_PCI_OP(write, dword, u32, out_le32, in_le32)
  179. static struct pci_ops macrisc_pci_ops =
  180. {
  181. macrisc_read_config_byte,
  182. macrisc_read_config_word,
  183. macrisc_read_config_dword,
  184. macrisc_write_config_byte,
  185. macrisc_write_config_word,
  186. macrisc_write_config_dword
  187. };
  189. /*
  190.  * Verifiy that a specific (bus, dev_fn) exists on chaos
  191.  */
  192. static int __pmac
  193. chaos_validate_dev(struct pci_dev *dev, int offset)
  194. {
  195. if(pci_device_to_OF_node(dev) == 0)
  196. return PCIBIOS_DEVICE_NOT_FOUND;
  197. if((dev->vendor == 0x106b) && (dev->device == 3) && (offset >= 0x10) &&
  198.     (offset != 0x14) && (offset != 0x18) && (offset <= 0x24)) {
  199. return PCIBIOS_BAD_REGISTER_NUMBER;
  200. }
  201. return PCIBIOS_SUCCESSFUL;
  202. }
  204. #define CHAOS_PCI_OP(rw, size, type)
  205. static int __pmac
  206. chaos_##rw##_config_##size(struct pci_dev *dev, int off, type val)
  207. {
  208. int result = chaos_validate_dev(dev, off);
  209. if(result == PCIBIOS_BAD_REGISTER_NUMBER) {
  210. cfg_##rw##_bad(val, size)
  211. return PCIBIOS_BAD_REGISTER_NUMBER;
  212. }
  213. if(result == PCIBIOS_SUCCESSFUL)
  214. return macrisc_##rw##_config_##size(dev, off, val);
  215. return result;
  216. }
  218. CHAOS_PCI_OP(read, byte, u8 *)
  219. CHAOS_PCI_OP(read, word, u16 *)
  220. CHAOS_PCI_OP(read, dword, u32 *)
  221. CHAOS_PCI_OP(write, byte, u8)
  222. CHAOS_PCI_OP(write, word, u16)
  223. CHAOS_PCI_OP(write, dword, u32) 
  225. static struct pci_ops chaos_pci_ops =
  226. {
  227. chaos_read_config_byte,
  228. chaos_read_config_word,
  229. chaos_read_config_dword,
  230. chaos_write_config_byte,
  231. chaos_write_config_word,
  232. chaos_write_config_dword
  233. };
  236. /*
  237.  * For a bandit bridge, turn on cache coherency if necessary.
  238.  * N.B. we could clean this up using the hose ops directly.
  239.  */
  240. static void __init
  241. init_bandit(struct pci_controller *bp)
  242. {
  243. unsigned int vendev, magic;
  244. int rev;
  246. /* read the word at offset 0 in config space for device 11 */
  247. out_le32(bp->cfg_addr, (1UL << BANDIT_DEVNUM) + PCI_VENDOR_ID);
  248. udelay(2);
  249. vendev = in_le32((volatile unsigned int *)bp->cfg_data);
  250. if (vendev == (PCI_DEVICE_ID_APPLE_BANDIT << 16) + 
  251. PCI_VENDOR_ID_APPLE) {
  252. /* read the revision id */
  253. out_le32(bp->cfg_addr,
  254.  (1UL << BANDIT_DEVNUM) + PCI_REVISION_ID);
  255. udelay(2);
  256. rev = in_8(bp->cfg_data);
  257. if (rev != BANDIT_REVID)
  258. printk(KERN_WARNING
  259.        "Unknown revision %d for banditn", rev);
  260. } else if (vendev != (BANDIT_DEVID_2 << 16) + PCI_VENDOR_ID_APPLE) {
  261. printk(KERN_WARNING "bandit isn't? (%x)n", vendev);
  262. return;
  263. }
  265. /* read the word at offset 0x50 */
  266. out_le32(bp->cfg_addr, (1UL << BANDIT_DEVNUM) + BANDIT_MAGIC);
  267. udelay(2);
  268. magic = in_le32((volatile unsigned int *)bp->cfg_data);
  269. if ((magic & BANDIT_COHERENT) != 0)
  270. return;
  271. magic |= BANDIT_COHERENT;
  272. udelay(2);
  273. out_le32((volatile unsigned int *)bp->cfg_data, magic);
  274. printk(KERN_INFO "Cache coherency enabled for bandit/PSXn");
  275. }
  278. /*
  279.  * Tweak the PCI-PCI bridge chip on the blue & white G3s.
  280.  */
  281. static void __init
  282. init_p2pbridge(void)
  283. {
  284. struct device_node *p2pbridge;
  285. struct pci_controller* hose;
  286. u8 bus, devfn;
  287. u16 val;
  289. /* XXX it would be better here to identify the specific
  290.    PCI-PCI bridge chip we have. */
  291. if ((p2pbridge = find_devices("pci-bridge")) == 0
  292.     || p2pbridge->parent == NULL
  293.     || strcmp(p2pbridge->parent->name, "pci") != 0)
  294. return;
  295. if (pci_device_from_OF_node(p2pbridge, &bus, &devfn) < 0) {
  296. #ifdef DEBUG
  297. printk("Can't find PCI infos for PCI<->PCI bridgen");
  298. #endif
  299. return;
  300. }
  301. /* Warning: At this point, we have not yet renumbered all busses. 
  302.  * So we must use OF walking to find out hose
  303.  */
  304. hose = pci_find_hose_for_OF_device(p2pbridge);
  305. if (!hose) {
  306. #ifdef DEBUG
  307. printk("Can't find hose for PCI<->PCI bridgen");
  308. #endif
  309. return;
  310. }
  311. if (early_read_config_word(hose, bus, devfn,
  312.    PCI_BRIDGE_CONTROL, &val) < 0) {
  313. printk(KERN_ERR "init_p2pbridge: couldn't read bridge controln");
  314. return;
  315. }
  316. val &= ~PCI_BRIDGE_CTL_MASTER_ABORT;
  317. early_write_config_word(hose, bus, devfn, PCI_BRIDGE_CONTROL, val);
  318. }
  320. void __init
  321. pmac_find_bridges(void)
  322. {
  323. add_bridges(find_devices("bandit"));
  324. add_bridges(find_devices("chaos"));
  325. add_bridges(find_devices("pci"));
  326. init_p2pbridge();
  327. }
  329. #define GRACKLE_CFA(b, d, o) (0x80 | ((b) << 8) | ((d) << 16) 
  330.  | (((o) & ~3) << 24))
  332. #define GRACKLE_PICR1_STG 0x00000040
  333. #define GRACKLE_PICR1_LOOPSNOOP 0x00000010
  335. /* N.B. this is called before bridges is initialized, so we can't
  336.    use grackle_pcibios_{read,write}_config_dword. */
  337. static inline void grackle_set_stg(struct pci_controller* bp, int enable)
  338. {
  339. unsigned int val;
  341. out_be32(bp->cfg_addr, GRACKLE_CFA(0, 0, 0xa8));
  342. val = in_le32((volatile unsigned int *)bp->cfg_data);
  343. val = enable? (val | GRACKLE_PICR1_STG) :
  344. (val & ~GRACKLE_PICR1_STG);
  345. out_be32(bp->cfg_addr, GRACKLE_CFA(0, 0, 0xa8));
  346. out_le32((volatile unsigned int *)bp->cfg_data, val);
  347. (void)in_le32((volatile unsigned int *)bp->cfg_data);
  348. }
  350. static inline void grackle_set_loop_snoop(struct pci_controller *bp, int enable)
  351. {
  352. unsigned int val;
  354. out_be32(bp->cfg_addr, GRACKLE_CFA(0, 0, 0xa8));
  355. val = in_le32((volatile unsigned int *)bp->cfg_data);
  356. val = enable? (val | GRACKLE_PICR1_LOOPSNOOP) :
  357. (val & ~GRACKLE_PICR1_LOOPSNOOP);
  358. out_be32(bp->cfg_addr, GRACKLE_CFA(0, 0, 0xa8));
  359. out_le32((volatile unsigned int *)bp->cfg_data, val);
  360. (void)in_le32((volatile unsigned int *)bp->cfg_data);
  361. }
  363. static int __init
  364. setup_uninorth(struct pci_controller* hose, struct reg_property* addr)
  365. {
  366. pci_assign_all_busses = 1;
  367. has_uninorth = 1;
  368. hose->ops = &macrisc_pci_ops;
  369. hose->cfg_addr = ioremap(addr->address + 0x800000, 0x1000);
  370. hose->cfg_data = ioremap(addr->address + 0xc00000, 0x1000);
  371. /* We "know" that the bridge at f2000000 has the PCI slots. */
  372. return addr->address == 0xf2000000;
  373. }
  375. static void __init
  376. setup_bandit(struct pci_controller* hose, struct reg_property* addr)
  377. {
  378. hose->ops = &macrisc_pci_ops;
  379. hose->cfg_addr = (volatile unsigned int *)
  380. ioremap(addr->address + 0x800000, 0x1000);
  381. hose->cfg_data = (volatile unsigned char *)
  382. ioremap(addr->address + 0xc00000, 0x1000);
  383. init_bandit(hose);
  384. }
  386. static void __init
  387. setup_chaos(struct pci_controller* hose, struct reg_property* addr)
  388. {
  389. /* assume a `chaos' bridge */
  390. hose->ops = &chaos_pci_ops;
  391. hose->cfg_addr = (volatile unsigned int *)
  392. ioremap(addr->address + 0x800000, 0x1000);
  393. hose->cfg_data = (volatile unsigned char *)
  394. ioremap(addr->address + 0xc00000, 0x1000);
  395. }
  397. void __init
  398. setup_grackle(struct pci_controller *hose)
  399. {
  400. setup_indirect_pci(hose, 0xfec00000, 0xfee00000);
  401. if (machine_is_compatible("AAPL,PowerBook1998"))
  402. grackle_set_loop_snoop(hose, 1);
  403. #if 0 /* Disabled for now, HW problems ??? */
  404. grackle_set_stg(hose, 1);
  405. #endif
  406. }
  408. /*
  409.  * We assume that if we have a G3 powermac, we have one bridge called
  410.  * "pci" (a MPC106) and no bandit or chaos bridges, and contrariwise,
  411.  * if we have one or more bandit or chaos bridges, we don't have a MPC106.
  412.  */
  413. static void __init
  414. add_bridges(struct device_node *dev)
  415. {
  416. int len;
  417. struct pci_controller *hose;
  418. struct reg_property *addr;
  419. char* disp_name;
  420. int *bus_range;
  421. int first = 1, primary;
  423. for (; dev != NULL; dev = dev->next) {
  424. addr = (struct reg_property *) get_property(dev, "reg", &len);
  425. if (addr == NULL || len < sizeof(*addr)) {
  426. printk(KERN_WARNING "Can't use %s: no addressn",
  427.        dev->full_name);
  428. continue;
  429. }
  430. bus_range = (int *) get_property(dev, "bus-range", &len);
  431. if (bus_range == NULL || len < 2 * sizeof(int)) {
  432. printk(KERN_WARNING "Can't get bus-range for %s, assume bus 0n",
  433.        dev->full_name);
  434. }
  436. hose = pcibios_alloc_controller();
  437. if (!hose)
  438. continue;
  439. hose->arch_data = dev;
  440. hose->first_busno = bus_range ? bus_range[0] : 0;
  441. hose->last_busno = bus_range ? bus_range[1] : 0xff;
  443. disp_name = NULL;
  444. primary = first;
  445. if (device_is_compatible(dev, "uni-north")) {
  446. primary = setup_uninorth(hose, addr);
  447. disp_name = "UniNorth";
  448. } else if (strcmp(dev->name, "pci") == 0) {
  449. /* XXX assume this is a mpc106 (grackle) */
  450. setup_grackle(hose);
  451. disp_name = "Grackle (MPC106)";
  452. } else if (strcmp(dev->name, "bandit") == 0) {
  453. setup_bandit(hose, addr);
  454. disp_name = "Bandit";
  455. } else if (strcmp(dev->name, "chaos") == 0) {
  456. setup_chaos(hose, addr);
  457. disp_name = "Chaos";
  458. primary = 0;
  459. }
  460. printk(KERN_INFO "Found %s PCI host bridge at 0x%08x. Firmware bus number: %d->%dn",
  461. disp_name, addr->address, hose->first_busno, hose->last_busno);
  462. #ifdef DEBUG
  463. printk(" ->Hose at 0x%08lx, cfg_addr=0x%08lx,cfg_data=0x%08lxn",
  464. hose, hose->cfg_addr, hose->cfg_data);
  465. #endif
  467. /* Interpret the "ranges" property */
  468. /* This also maps the I/O region and sets isa_io/mem_base */
  469. pci_process_bridge_OF_ranges(hose, dev, primary);
  471. /* Fixup "bus-range" OF property */
  472. fixup_bus_range(dev);
  474. first &= !primary;
  475. }
  476. }
  478. static void __init
  479. pcibios_fixup_OF_interrupts(void)
  480. {
  481. struct pci_dev* dev;
  483. /*
  484.  * Open Firmware often doesn't initialize the
  485.  * PCI_INTERRUPT_LINE config register properly, so we
  486.  * should find the device node and apply the interrupt
  487.  * obtained from the OF device-tree
  488.  */
  489. pci_for_each_dev(dev) {
  490. struct device_node* node = pci_device_to_OF_node(dev);
  491. /* this is the node, see if it has interrupts */
  492. if (node && node->n_intrs > 0)
  493. dev->irq = node->intrs[0].line;
  494. pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
  495. }
  496. }
  498. void __init
  499. pmac_pcibios_fixup(void)
  500. {
  501. /* Fixup interrupts according to OF tree */
  502. pcibios_fixup_OF_interrupts();
  503. }
  505. int __pmac
  506. pmac_pci_enable_device_hook(struct pci_dev *dev, int initial)
  507. {
  508. struct device_node* node;
  509. int updatecfg = 0;
  510. int uninorth_child;
  512. node = pci_device_to_OF_node(dev);
  514. /* We don't want to enable USB controllers absent from the OF tree
  515.  * (iBook second controller)
  516.  */
  517. if (dev->vendor == PCI_VENDOR_ID_APPLE
  518.     && dev->device == PCI_DEVICE_ID_APPLE_KL_USB && !node)
  519. return -EINVAL;
  521. if (!node)
  522. return 0;
  524. uninorth_child = node->parent &&
  525. device_is_compatible(node->parent, "uni-north");
  527. /* Firewire & GMAC were disabled after PCI probe, the driver is
  528.  * claiming them, we must re-enable them now.
  529.  */
  530. if (uninorth_child && !strcmp(node->name, "firewire") && 
  531.     (device_is_compatible(node, "pci106b,18") || 
  532.      device_is_compatible(node, "pci106b,30") ||
  533.      device_is_compatible(node, "pci11c1,5811"))) {
  534. pmac_call_feature(PMAC_FTR_1394_CABLE_POWER, node, 0, 1);
  535. pmac_call_feature(PMAC_FTR_1394_ENABLE, node, 0, 1);
  536. updatecfg = 1;
  537. }
  538. if (uninorth_child && !strcmp(node->name, "ethernet") && 
  539.     device_is_compatible(node, "gmac")) {
  540. pmac_call_feature(PMAC_FTR_GMAC_ENABLE, node, 0, 1);
  541. updatecfg = 1;
  542. }
  544. if (updatecfg) {
  545. u16 cmd;
  547. /*
  548.  * Make sure PCI is correctly configured
  549.  *
  550.  * We use old pci_bios versions of the function since, by
  551.  * default, gmac is not powered up, and so will be absent
  552.  * from the kernel initial PCI lookup. 
  553.  * 
  554.  * Should be replaced by 2.4 new PCI mecanisms and really
  555.  * regiser the device.
  556.  */
  557. pci_read_config_word(dev, PCI_COMMAND, &cmd);
  558. cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER | PCI_COMMAND_INVALIDATE;
  559.      pci_write_config_word(dev, PCI_COMMAND, cmd);
  560.      pci_write_config_byte(dev, PCI_LATENCY_TIMER, 16);
  561.      pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, 8);
  562. }
  564. return 0;
  565. }
  567. /* We power down some devices after they have been probed. They'll
  568.  * be powered back on later on
  569.  */
  570. void __init
  571. pmac_pcibios_after_init(void)
  572. {
  573. struct device_node* nd;
  575. #ifdef CONFIG_BLK_DEV_IDE
  576. struct pci_dev *dev;
  578. /* OF fails to initialize IDE controllers on macs
  579.  * (and maybe other machines)
  580.  * 
  581.  * Ideally, this should be moved to the IDE layer, but we need
  582.  * to check specifically with Andre Hedrick how to do it cleanly
  583.  * since the common IDE code seem to care about the fact that the
  584.  * BIOS may have disabled a controller.
  585.  * 
  586.  * -- BenH
  587.  */
  588. pci_for_each_dev(dev) {
  589. if ((dev->class >> 16) == PCI_BASE_CLASS_STORAGE)
  590. pci_enable_device(dev);
  591. }
  592. #endif /* CONFIG_BLK_DEV_IDE */
  594. nd = find_devices("firewire");
  595. while (nd) {
  596. if (nd->parent && (device_is_compatible(nd, "pci106b,18") ||
  597.    device_is_compatible(nd, "pci106b,30") ||
  598.    device_is_compatible(nd, "pci11c1,5811"))
  599.     && device_is_compatible(nd->parent, "uni-north")) {
  600. pmac_call_feature(PMAC_FTR_1394_ENABLE, nd, 0, 0);
  601. pmac_call_feature(PMAC_FTR_1394_CABLE_POWER, nd, 0, 0);
  602. }
  603. nd = nd->next;
  604. }
  605. nd = find_devices("ethernet");
  606. while (nd) {
  607. if (nd->parent && device_is_compatible(nd, "gmac")
  608.     && device_is_compatible(nd->parent, "uni-north"))
  609. pmac_call_feature(PMAC_FTR_GMAC_ENABLE, nd, 0, 0);
  610. nd = nd->next;
  611. }
  612. }