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

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

嵌入式Linux

开发平台：

Unix_Linux

media.c：源码内容
  1. /*
  2. drivers/net/tulip/media.c
  4. Maintained by Jeff Garzik <jgarzik@mandrakesoft.com>
  5. Copyright 2000,2001  The Linux Kernel Team
  6. Written/copyright 1994-2001 by Donald Becker.
  8. This software may be used and distributed according to the terms
  9. of the GNU General Public License, incorporated herein by reference.
  11. Please refer to Documentation/DocBook/tulip.{pdf,ps,html}
  12. for more information on this driver, or visit the project
  13. Web page at http://sourceforge.net/projects/tulip/
  15. */
  17. #include <linux/kernel.h>
  18. #include <linux/mii.h>
  19. #include <linux/init.h>
  20. #include <linux/delay.h>
  21. #include "tulip.h"
  24. /* This is a mysterious value that can be written to CSR11 in the 21040 (only)
  25.    to support a pre-NWay full-duplex signaling mechanism using short frames.
  26.    No one knows what it should be, but if left at its default value some
  27.    10base2(!) packets trigger a full-duplex-request interrupt. */
  28. #define FULL_DUPLEX_MAGIC 0x6969
  30. /* The maximum data clock rate is 2.5 Mhz.  The minimum timing is usually
  31.    met by back-to-back PCI I/O cycles, but we insert a delay to avoid
  32.    "overclocking" issues or future 66Mhz PCI. */
  33. #define mdio_delay() inl(mdio_addr)
  35. /* Read and write the MII registers using software-generated serial
  36.    MDIO protocol.  It is just different enough from the EEPROM protocol
  37.    to not share code.  The maxium data clock rate is 2.5 Mhz. */
  38. #define MDIO_SHIFT_CLK 0x10000
  39. #define MDIO_DATA_WRITE0 0x00000
  40. #define MDIO_DATA_WRITE1 0x20000
  41. #define MDIO_ENB 0x00000 /* Ignore the 0x02000 databook setting. */
  42. #define MDIO_ENB_IN 0x40000
  43. #define MDIO_DATA_READ 0x80000
  45. static const unsigned char comet_miireg2offset[32] = {
  46. 0xB4, 0xB8, 0xBC, 0xC0,  0xC4, 0xC8, 0xCC, 0,  0,0,0,0,  0,0,0,0,
  47. 0,0xD0,0,0,  0,0,0,0,  0,0,0,0, 0, 0xD4, 0xD8, 0xDC, };
  50. /* MII transceiver control section.
  51.    Read and write the MII registers using software-generated serial
  52.    MDIO protocol.  See the MII specifications or DP83840A data sheet
  53.    for details. */
  55. int tulip_mdio_read(struct net_device *dev, int phy_id, int location)
  56. {
  57. struct tulip_private *tp = (struct tulip_private *)dev->priv;
  58. int i;
  59. int read_cmd = (0xf6 << 10) | ((phy_id & 0x1f) << 5) | location;
  60. int retval = 0;
  61. long ioaddr = dev->base_addr;
  62. long mdio_addr = ioaddr + CSR9;
  63. unsigned long flags;
  65. if (location & ~0x1f)
  66. return 0xffff;
  68. if (tp->chip_id == COMET  &&  phy_id == 30) {
  69. if (comet_miireg2offset[location])
  70. return inl(ioaddr + comet_miireg2offset[location]);
  71. return 0xffff;
  72. }
  74. spin_lock_irqsave(&tp->mii_lock, flags);
  75. if (tp->chip_id == LC82C168) {
  76. int i = 1000;
  77. outl(0x60020000 + (phy_id<<23) + (location<<18), ioaddr + 0xA0);
  78. inl(ioaddr + 0xA0);
  79. inl(ioaddr + 0xA0);
  80. while (--i > 0) {
  81. barrier();
  82. if ( ! ((retval = inl(ioaddr + 0xA0)) & 0x80000000))
  83. break;
  84. }
  85. spin_unlock_irqrestore(&tp->mii_lock, flags);
  86. return retval & 0xffff;
  87. }
  89. /* Establish sync by sending at least 32 logic ones. */
  90. for (i = 32; i >= 0; i--) {
  91. outl(MDIO_ENB | MDIO_DATA_WRITE1, mdio_addr);
  92. mdio_delay();
  93. outl(MDIO_ENB | MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
  94. mdio_delay();
  95. }
  96. /* Shift the read command bits out. */
  97. for (i = 15; i >= 0; i--) {
  98. int dataval = (read_cmd & (1 << i)) ? MDIO_DATA_WRITE1 : 0;
  100. outl(MDIO_ENB | dataval, mdio_addr);
  101. mdio_delay();
  102. outl(MDIO_ENB | dataval | MDIO_SHIFT_CLK, mdio_addr);
  103. mdio_delay();
  104. }
  105. /* Read the two transition, 16 data, and wire-idle bits. */
  106. for (i = 19; i > 0; i--) {
  107. outl(MDIO_ENB_IN, mdio_addr);
  108. mdio_delay();
  109. retval = (retval << 1) | ((inl(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
  110. outl(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
  111. mdio_delay();
  112. }
  114. spin_unlock_irqrestore(&tp->mii_lock, flags);
  115. return (retval>>1) & 0xffff;
  116. }
  118. void tulip_mdio_write(struct net_device *dev, int phy_id, int location, int val)
  119. {
  120. struct tulip_private *tp = (struct tulip_private *)dev->priv;
  121. int i;
  122. int cmd = (0x5002 << 16) | ((phy_id & 0x1f) << 23) | (location<<18) | (val & 0xffff);
  123. long ioaddr = dev->base_addr;
  124. long mdio_addr = ioaddr + CSR9;
  125. unsigned long flags;
  127. if (location & ~0x1f)
  128. return;
  130. if (tp->chip_id == COMET && phy_id == 30) {
  131. if (comet_miireg2offset[location])
  132. outl(val, ioaddr + comet_miireg2offset[location]);
  133. return;
  134. }
  136. spin_lock_irqsave(&tp->mii_lock, flags);
  137. if (tp->chip_id == LC82C168) {
  138. int i = 1000;
  139. outl(cmd, ioaddr + 0xA0);
  140. do {
  141. barrier();
  142. if ( ! (inl(ioaddr + 0xA0) & 0x80000000))
  143. break;
  144. } while (--i > 0);
  145. spin_unlock_irqrestore(&tp->mii_lock, flags);
  146. return;
  147. }
  149. /* Establish sync by sending 32 logic ones. */
  150. for (i = 32; i >= 0; i--) {
  151. outl(MDIO_ENB | MDIO_DATA_WRITE1, mdio_addr);
  152. mdio_delay();
  153. outl(MDIO_ENB | MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
  154. mdio_delay();
  155. }
  156. /* Shift the command bits out. */
  157. for (i = 31; i >= 0; i--) {
  158. int dataval = (cmd & (1 << i)) ? MDIO_DATA_WRITE1 : 0;
  159. outl(MDIO_ENB | dataval, mdio_addr);
  160. mdio_delay();
  161. outl(MDIO_ENB | dataval | MDIO_SHIFT_CLK, mdio_addr);
  162. mdio_delay();
  163. }
  164. /* Clear out extra bits. */
  165. for (i = 2; i > 0; i--) {
  166. outl(MDIO_ENB_IN, mdio_addr);
  167. mdio_delay();
  168. outl(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
  169. mdio_delay();
  170. }
  172. spin_unlock_irqrestore(&tp->mii_lock, flags);
  173. }
  176. /* Set up the transceiver control registers for the selected media type. */
  177. void tulip_select_media(struct net_device *dev, int startup)
  178. {
  179. long ioaddr = dev->base_addr;
  180. struct tulip_private *tp = (struct tulip_private *)dev->priv;
  181. struct mediatable *mtable = tp->mtable;
  182. u32 new_csr6;
  183. int i;
  185. if (mtable) {
  186. struct medialeaf *mleaf = &mtable->mleaf[tp->cur_index];
  187. unsigned char *p = mleaf->leafdata;
  188. switch (mleaf->type) {
  189. case 0: /* 21140 non-MII xcvr. */
  190. if (tulip_debug > 1)
  191. printk(KERN_DEBUG "%s: Using a 21140 non-MII transceiver"
  192.    " with control setting %2.2x.n",
  193.    dev->name, p[1]);
  194. dev->if_port = p[0];
  195. if (startup)
  196. outl(mtable->csr12dir | 0x100, ioaddr + CSR12);
  197. outl(p[1], ioaddr + CSR12);
  198. new_csr6 = 0x02000000 | ((p[2] & 0x71) << 18);
  199. break;
  200. case 2: case 4: {
  201. u16 setup[5];
  202. u32 csr13val, csr14val, csr15dir, csr15val;
  203. for (i = 0; i < 5; i++)
  204. setup[i] = get_u16(&p[i*2 + 1]);
  206. dev->if_port = p[0] & MEDIA_MASK;
  207. if (tulip_media_cap[dev->if_port] & MediaAlwaysFD)
  208. tp->full_duplex = 1;
  210. if (startup && mtable->has_reset) {
  211. struct medialeaf *rleaf = &mtable->mleaf[mtable->has_reset];
  212. unsigned char *rst = rleaf->leafdata;
  213. if (tulip_debug > 1)
  214. printk(KERN_DEBUG "%s: Resetting the transceiver.n",
  215.    dev->name);
  216. for (i = 0; i < rst[0]; i++)
  217. outl(get_u16(rst + 1 + (i<<1)) << 16, ioaddr + CSR15);
  218. }
  219. if (tulip_debug > 1)
  220. printk(KERN_DEBUG "%s: 21143 non-MII %s transceiver control "
  221.    "%4.4x/%4.4x.n",
  222.    dev->name, medianame[dev->if_port], setup[0], setup[1]);
  223. if (p[0] & 0x40) { /* SIA (CSR13-15) setup values are provided. */
  224. csr13val = setup[0];
  225. csr14val = setup[1];
  226. csr15dir = (setup[3]<<16) | setup[2];
  227. csr15val = (setup[4]<<16) | setup[2];
  228. outl(0, ioaddr + CSR13);
  229. outl(csr14val, ioaddr + CSR14);
  230. outl(csr15dir, ioaddr + CSR15); /* Direction */
  231. outl(csr15val, ioaddr + CSR15); /* Data */
  232. outl(csr13val, ioaddr + CSR13);
  233. } else {
  234. csr13val = 1;
  235. csr14val = 0;
  236. csr15dir = (setup[0]<<16) | 0x0008;
  237. csr15val = (setup[1]<<16) | 0x0008;
  238. if (dev->if_port <= 4)
  239. csr14val = t21142_csr14[dev->if_port];
  240. if (startup) {
  241. outl(0, ioaddr + CSR13);
  242. outl(csr14val, ioaddr + CSR14);
  243. }
  244. outl(csr15dir, ioaddr + CSR15); /* Direction */
  245. outl(csr15val, ioaddr + CSR15); /* Data */
  246. if (startup) outl(csr13val, ioaddr + CSR13);
  247. }
  248. if (tulip_debug > 1)
  249. printk(KERN_DEBUG "%s:  Setting CSR15 to %8.8x/%8.8x.n",
  250.    dev->name, csr15dir, csr15val);
  251. if (mleaf->type == 4)
  252. new_csr6 = 0x82020000 | ((setup[2] & 0x71) << 18);
  253. else
  254. new_csr6 = 0x82420000;
  255. break;
  256. }
  257. case 1: case 3: {
  258. int phy_num = p[0];
  259. int init_length = p[1];
  260. u16 *misc_info, tmp_info;
  262. dev->if_port = 11;
  263. new_csr6 = 0x020E0000;
  264. if (mleaf->type == 3) { /* 21142 */
  265. u16 *init_sequence = (u16*)(p+2);
  266. u16 *reset_sequence = &((u16*)(p+3))[init_length];
  267. int reset_length = p[2 + init_length*2];
  268. misc_info = reset_sequence + reset_length;
  269. if (startup)
  270. for (i = 0; i < reset_length; i++)
  271. outl(get_u16(&reset_sequence[i]) << 16, ioaddr + CSR15);
  272. for (i = 0; i < init_length; i++)
  273. outl(get_u16(&init_sequence[i]) << 16, ioaddr + CSR15);
  274. } else {
  275. u8 *init_sequence = p + 2;
  276. u8 *reset_sequence = p + 3 + init_length;
  277. int reset_length = p[2 + init_length];
  278. misc_info = (u16*)(reset_sequence + reset_length);
  279. if (startup) {
  280. outl(mtable->csr12dir | 0x100, ioaddr + CSR12);
  281. for (i = 0; i < reset_length; i++)
  282. outl(reset_sequence[i], ioaddr + CSR12);
  283. }
  284. for (i = 0; i < init_length; i++)
  285. outl(init_sequence[i], ioaddr + CSR12);
  286. }
  287. tmp_info = get_u16(&misc_info[1]);
  288. if (tmp_info)
  289. tp->advertising[phy_num] = tmp_info | 1;
  290. if (tmp_info && startup < 2) {
  291. if (tp->mii_advertise == 0)
  292. tp->mii_advertise = tp->advertising[phy_num];
  293. if (tulip_debug > 1)
  294. printk(KERN_DEBUG "%s:  Advertising %4.4x on MII %d.n",
  295.        dev->name, tp->mii_advertise, tp->phys[phy_num]);
  296. tulip_mdio_write(dev, tp->phys[phy_num], 4, tp->mii_advertise);
  297. }
  298. break;
  299. }
  300. case 5: case 6: {
  301. u16 setup[5];
  303. new_csr6 = 0; /* FIXME */
  305. for (i = 0; i < 5; i++)
  306. setup[i] = get_u16(&p[i*2 + 1]);
  308. if (startup && mtable->has_reset) {
  309. struct medialeaf *rleaf = &mtable->mleaf[mtable->has_reset];
  310. unsigned char *rst = rleaf->leafdata;
  311. if (tulip_debug > 1)
  312. printk(KERN_DEBUG "%s: Resetting the transceiver.n",
  313.    dev->name);
  314. for (i = 0; i < rst[0]; i++)
  315. outl(get_u16(rst + 1 + (i<<1)) << 16, ioaddr + CSR15);
  316. }
  318. break;
  319. }
  320. default:
  321. printk(KERN_DEBUG "%s:  Invalid media table selection %d.n",
  322.    dev->name, mleaf->type);
  323. new_csr6 = 0x020E0000;
  324. }
  325. if (tulip_debug > 1)
  326. printk(KERN_DEBUG "%s: Using media type %s, CSR12 is %2.2x.n",
  327.    dev->name, medianame[dev->if_port],
  328.    inl(ioaddr + CSR12) & 0xff);
  329. } else if (tp->chip_id == DC21041) {
  330. int port = dev->if_port <= 4 ? dev->if_port : 0;
  331. if (tulip_debug > 1)
  332. printk(KERN_DEBUG "%s: 21041 using media %s, CSR12 is %4.4x.n",
  333.    dev->name, medianame[port == 3 ? 12: port],
  334.    inl(ioaddr + CSR12));
  335. outl(0x00000000, ioaddr + CSR13); /* Reset the serial interface */
  336. outl(t21041_csr14[port], ioaddr + CSR14);
  337. outl(t21041_csr15[port], ioaddr + CSR15);
  338. outl(t21041_csr13[port], ioaddr + CSR13);
  339. new_csr6 = 0x80020000;
  340. } else if (tp->chip_id == LC82C168) {
  341. if (startup && ! tp->medialock)
  342. dev->if_port = tp->mii_cnt ? 11 : 0;
  343. if (tulip_debug > 1)
  344. printk(KERN_DEBUG "%s: PNIC PHY status is %3.3x, media %s.n",
  345.    dev->name, inl(ioaddr + 0xB8), medianame[dev->if_port]);
  346. if (tp->mii_cnt) {
  347. new_csr6 = 0x810C0000;
  348. outl(0x0001, ioaddr + CSR15);
  349. outl(0x0201B07A, ioaddr + 0xB8);
  350. } else if (startup) {
  351. /* Start with 10mbps to do autonegotiation. */
  352. outl(0x32, ioaddr + CSR12);
  353. new_csr6 = 0x00420000;
  354. outl(0x0001B078, ioaddr + 0xB8);
  355. outl(0x0201B078, ioaddr + 0xB8);
  356. } else if (dev->if_port == 3  ||  dev->if_port == 5) {
  357. outl(0x33, ioaddr + CSR12);
  358. new_csr6 = 0x01860000;
  359. /* Trigger autonegotiation. */
  360. outl(startup ? 0x0201F868 : 0x0001F868, ioaddr + 0xB8);
  361. } else {
  362. outl(0x32, ioaddr + CSR12);
  363. new_csr6 = 0x00420000;
  364. outl(0x1F078, ioaddr + 0xB8);
  365. }
  366. } else if (tp->chip_id == DC21040) { /* 21040 */
  367. /* Turn on the xcvr interface. */
  368. int csr12 = inl(ioaddr + CSR12);
  369. if (tulip_debug > 1)
  370. printk(KERN_DEBUG "%s: 21040 media type is %s, CSR12 is %2.2x.n",
  371.    dev->name, medianame[dev->if_port], csr12);
  372. if (tulip_media_cap[dev->if_port] & MediaAlwaysFD)
  373. tp->full_duplex = 1;
  374. new_csr6 = 0x20000;
  375. /* Set the full duplux match frame. */
  376. outl(FULL_DUPLEX_MAGIC, ioaddr + CSR11);
  377. outl(0x00000000, ioaddr + CSR13); /* Reset the serial interface */
  378. if (t21040_csr13[dev->if_port] & 8) {
  379. outl(0x0705, ioaddr + CSR14);
  380. outl(0x0006, ioaddr + CSR15);
  381. } else {
  382. outl(0xffff, ioaddr + CSR14);
  383. outl(0x0000, ioaddr + CSR15);
  384. }
  385. outl(0x8f01 | t21040_csr13[dev->if_port], ioaddr + CSR13);
  386. } else { /* Unknown chip type with no media table. */
  387. if (tp->default_port == 0)
  388. dev->if_port = tp->mii_cnt ? 11 : 3;
  389. if (tulip_media_cap[dev->if_port] & MediaIsMII) {
  390. new_csr6 = 0x020E0000;
  391. } else if (tulip_media_cap[dev->if_port] & MediaIsFx) {
  392. new_csr6 = 0x028600000;
  393. } else
  394. new_csr6 = 0x038600000;
  395. if (tulip_debug > 1)
  396. printk(KERN_DEBUG "%s: No media description table, assuming "
  397.    "%s transceiver, CSR12 %2.2x.n",
  398.    dev->name, medianame[dev->if_port],
  399.    inl(ioaddr + CSR12));
  400. }
  402. tp->csr6 = new_csr6 | (tp->csr6 & 0xfdff) | (tp->full_duplex ? 0x0200 : 0);
  403. return;
  404. }
  406. /*
  407.   Check the MII negotiated duplex and change the CSR6 setting if
  408.   required.
  409.   Return 0 if everything is OK.
  410.   Return < 0 if the transceiver is missing or has no link beat.
  411.   */
  412. int tulip_check_duplex(struct net_device *dev)
  413. {
  414. struct tulip_private *tp = dev->priv;
  415. unsigned int bmsr, lpa, negotiated, new_csr6;
  417. bmsr = tulip_mdio_read(dev, tp->phys[0], MII_BMSR);
  418. lpa = tulip_mdio_read(dev, tp->phys[0], MII_LPA);
  419. if (tulip_debug > 1)
  420. printk(KERN_INFO "%s: MII status %4.4x, Link partner report "
  421.    "%4.4x.n", dev->name, bmsr, lpa);
  422. if (bmsr == 0xffff)
  423. return -2;
  424. if ((bmsr & BMSR_LSTATUS) == 0) {
  425. int new_bmsr = tulip_mdio_read(dev, tp->phys[0], MII_BMSR);
  426. if ((new_bmsr & BMSR_LSTATUS) == 0) {
  427. if (tulip_debug  > 1)
  428. printk(KERN_INFO "%s: No link beat on the MII interface,"
  429.    " status %4.4x.n", dev->name, new_bmsr);
  430. return -1;
  431. }
  432. }
  433. negotiated = lpa & tp->advertising[0];
  434. tp->full_duplex = mii_duplex(tp->full_duplex_lock, negotiated);
  436. new_csr6 = tp->csr6;
  438. if (negotiated & LPA_100) new_csr6 &= ~TxThreshold;
  439. else   new_csr6 |= TxThreshold;
  440. if (tp->full_duplex) new_csr6 |= FullDuplex;
  441. else      new_csr6 &= ~FullDuplex;
  443. if (new_csr6 != tp->csr6) {
  444. tp->csr6 = new_csr6;
  445. tulip_restart_rxtx(tp);
  447. if (tulip_debug > 0)
  448. printk(KERN_INFO "%s: Setting %s-duplex based on MII"
  449.    "#%d link partner capability of %4.4x.n",
  450.    dev->name, tp->full_duplex ? "full" : "half",
  451.    tp->phys[0], lpa);
  452. return 1;
  453. }
  455. return 0;
  456. }
  458. void __devinit tulip_find_mii (struct net_device *dev, int board_idx)
  459. {
  460. struct tulip_private *tp = dev->priv;
  461. int phyn, phy_idx = 0;
  462. int mii_reg0;
  463. int mii_advert;
  464. unsigned int to_advert, new_bmcr, ane_switch;
  466. /* Find the connected MII xcvrs.
  467.    Doing this in open() would allow detecting external xcvrs later,
  468.    but takes much time. */
  469. for (phyn = 1; phyn <= 32 && phy_idx < sizeof (tp->phys); phyn++) {
  470. int phy = phyn & 0x1f;
  471. int mii_status = tulip_mdio_read (dev, phy, MII_BMSR);
  472. if ((mii_status & 0x8301) == 0x8001 ||
  473.     ((mii_status & BMSR_100BASE4) == 0
  474.      && (mii_status & 0x7800) != 0)) {
  475. /* preserve Becker logic, gain indentation level */
  476. } else {
  477. continue;
  478. }
  480. mii_reg0 = tulip_mdio_read (dev, phy, MII_BMCR);
  481. mii_advert = tulip_mdio_read (dev, phy, MII_ADVERTISE);
  482. ane_switch = 0;
  484. /* if not advertising at all, gen an
  485.  * advertising value from the capability
  486.  * bits in BMSR
  487.  */
  488. if ((mii_advert & ADVERTISE_ALL) == 0) {
  489. unsigned int tmpadv = tulip_mdio_read (dev, phy, MII_BMSR);
  490. mii_advert = ((tmpadv >> 6) & 0x3e0) | 1;
  491. }
  493. if (tp->mii_advertise) {
  494. tp->advertising[phy_idx] =
  495. to_advert = tp->mii_advertise;
  496. } else if (tp->advertising[phy_idx]) {
  497. to_advert = tp->advertising[phy_idx];
  498. } else {
  499. tp->advertising[phy_idx] =
  500. tp->mii_advertise =
  501. to_advert = mii_advert;
  502. }
  504. tp->phys[phy_idx++] = phy;
  506. printk (KERN_INFO "tulip%d:  MII transceiver #%d "
  507. "config %4.4x status %4.4x advertising %4.4x.n",
  508. board_idx, phy, mii_reg0, mii_status, mii_advert);
  510. /* Fixup for DLink with miswired PHY. */
  511. if (mii_advert != to_advert) {
  512. printk (KERN_DEBUG "tulip%d:  Advertising %4.4x on PHY %d,"
  513. " previously advertising %4.4x.n",
  514. board_idx, to_advert, phy, mii_advert);
  515. tulip_mdio_write (dev, phy, 4, to_advert);
  516. }
  518. /* Enable autonegotiation: some boards default to off. */
  519. if (tp->default_port == 0) {
  520. new_bmcr = mii_reg0 | BMCR_ANENABLE;
  521. if (new_bmcr != mii_reg0) {
  522. new_bmcr |= BMCR_ANRESTART;
  523. ane_switch = 1;
  524. }
  525. }
  526. /* ...or disable nway, if forcing media */
  527. else {
  528. new_bmcr = mii_reg0 & ~BMCR_ANENABLE;
  529. if (new_bmcr != mii_reg0)
  530. ane_switch = 1;
  531. }
  533. /* clear out bits we never want at this point */
  534. new_bmcr &= ~(BMCR_CTST | BMCR_FULLDPLX | BMCR_ISOLATE |
  535.       BMCR_PDOWN | BMCR_SPEED100 | BMCR_LOOPBACK |
  536.       BMCR_RESET);
  538. if (tp->full_duplex)
  539. new_bmcr |= BMCR_FULLDPLX;
  540. if (tulip_media_cap[tp->default_port] & MediaIs100)
  541. new_bmcr |= BMCR_SPEED100;
  543. if (new_bmcr != mii_reg0) {
  544. /* some phys need the ANE switch to
  545.  * happen before forced media settings
  546.  * will "take."  However, we write the
  547.  * same value twice in order not to
  548.  * confuse the sane phys.
  549.  */
  550. if (ane_switch) {
  551. tulip_mdio_write (dev, phy, MII_BMCR, new_bmcr);
  552. udelay (10);
  553. }
  554. tulip_mdio_write (dev, phy, MII_BMCR, new_bmcr);
  555. }
  556. }
  557. tp->mii_cnt = phy_idx;
  558. if (tp->mtable && tp->mtable->has_mii && phy_idx == 0) {
  559. printk (KERN_INFO "tulip%d: ***WARNING***: No MII transceiver found!n",
  560. board_idx);
  561. tp->phys[0] = 1;
  562. }
  563. }