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

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

Linux/Unix编程

开发平台：

Unix_Linux

de4x5.c：源码内容
  1. ** When autonegotiation is working, the ANS part searches the SROM for
  2. ** the highest common speed (TP) link that both can run and if that can
  3. ** be full duplex. That infoblock is executed and then the link speed set.
  4. **
  5. ** Only _10Mb and _100Mb are tested here.
  6. */
  7. static int
  8. dc2114x_autoconf(struct net_device *dev)
  9. {
  10.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  11.     u_long iobase = dev->base_addr;
  12.     s32 cr, anlpa, ana, cap, irqs, irq_mask, imr, omr, slnk, sr, sts;
  13.     int next_tick = DE4X5_AUTOSENSE_MS;
  15.     switch (lp->media) {
  16.     case INIT:
  17.         if (lp->timeout < 0) {
  18.     DISABLE_IRQs;
  19.     lp->tx_enable = FALSE;
  20.     lp->linkOK = 0;
  21.             lp->timeout = -1;
  22.     de4x5_save_skbs(dev);            /* Save non transmitted skb's */
  23.     if (lp->params.autosense & ~AUTO) {
  24. srom_map_media(dev);         /* Fixed media requested      */
  25. if (lp->media != lp->params.autosense) {
  26.     lp->tcount++;
  27.     lp->media = INIT;
  28.     return next_tick;
  29. }
  30. lp->media = INIT;
  31.     }
  32. }
  33. if ((next_tick = de4x5_reset_phy(dev)) < 0) {
  34.     next_tick &= ~TIMER_CB;
  35. } else {
  36.     if (lp->autosense == _100Mb) {
  37. lp->media = _100Mb;
  38.     } else if (lp->autosense == _10Mb) {
  39. lp->media = _10Mb;
  40.     } else if (lp->autosense == TP) {
  41. lp->media = TP;
  42.     } else if (lp->autosense == BNC) {
  43. lp->media = BNC;
  44.     } else if (lp->autosense == AUI) {
  45. lp->media = AUI;
  46.     } else {
  47. lp->media = SPD_DET;
  48. if ((lp->infoblock_media == ANS) && 
  49.                     ((sr=is_anc_capable(dev)) & MII_SR_ANC)) {
  50.     ana = (((sr >> 6) & MII_ANA_TAF) | MII_ANA_CSMA);
  51.     ana &= (lp->fdx ? ~0 : ~MII_ANA_FDAM);
  52.     mii_wr(ana, MII_ANA, lp->phy[lp->active].addr, DE4X5_MII);
  53.     lp->media = ANS;
  54. }
  55.     }
  56.     lp->local_state = 0;
  57.     next_tick = dc2114x_autoconf(dev);
  58.         }
  59. break;
  61.     case ANS:
  62. switch (lp->local_state) {
  63. case 0:
  64.     if (lp->timeout < 0) {
  65. mii_wr(MII_CR_ASSE | MII_CR_RAN, MII_CR, lp->phy[lp->active].addr, DE4X5_MII);
  66.     }
  67.     cr = test_mii_reg(dev, MII_CR, MII_CR_RAN, FALSE, 500);
  68.     if (cr < 0) {
  69. next_tick = cr & ~TIMER_CB;
  70.     } else {
  71. if (cr) {
  72.     lp->local_state = 0;
  73.     lp->media = SPD_DET;
  74. } else {
  75.     lp->local_state++;
  76. }
  77. next_tick = dc2114x_autoconf(dev);
  78.     }
  79.     break;
  80.     
  81. case 1:
  82.     if ((sr=test_mii_reg(dev, MII_SR, MII_SR_ASSC, TRUE, 2000)) < 0) {
  83. next_tick = sr & ~TIMER_CB;
  84.     } else {
  85. lp->media = SPD_DET;
  86. lp->local_state = 0;
  87. if (sr) {                         /* Success! */
  88.     lp->tmp = MII_SR_ASSC;
  89.     anlpa = mii_rd(MII_ANLPA, lp->phy[lp->active].addr, DE4X5_MII);
  90.     ana = mii_rd(MII_ANA, lp->phy[lp->active].addr, DE4X5_MII);
  91.     if (!(anlpa & MII_ANLPA_RF) && 
  92.  (cap = anlpa & MII_ANLPA_TAF & ana)) {
  93. if (cap & MII_ANA_100M) {
  94.     lp->fdx = ((ana & anlpa & MII_ANA_FDAM & MII_ANA_100M) ? TRUE : FALSE);
  95.     lp->media = _100Mb;
  96. } else if (cap & MII_ANA_10M) {
  97.     lp->fdx = ((ana & anlpa & MII_ANA_FDAM & MII_ANA_10M) ? TRUE : FALSE);
  98.     lp->media = _10Mb;
  99. }
  100.     }
  101. }                       /* Auto Negotiation failed to finish */
  102. next_tick = dc2114x_autoconf(dev);
  103.     }                           /* Auto Negotiation failed to start  */
  104.     break;
  105. }
  106. break;
  108.     case AUI:
  109. if (!lp->tx_enable) {
  110.     if (lp->timeout < 0) {
  111. omr = inl(DE4X5_OMR);   /* Set up half duplex for AUI        */
  112. outl(omr & ~OMR_FDX, DE4X5_OMR);
  113.     }
  114.     irqs = 0;
  115.     irq_mask = 0;
  116.     sts = test_media(dev,irqs, irq_mask, 0, 0, 0, 1000);
  117.     if (sts < 0) {
  118. next_tick = sts & ~TIMER_CB;
  119.     } else {
  120. if (!(inl(DE4X5_SISR) & SISR_SRA) && (lp->autosense == AUTO)) {
  121.     lp->media = BNC;
  122.     next_tick = dc2114x_autoconf(dev);
  123. } else {
  124.     lp->local_state = 1;
  125.     de4x5_init_connection(dev);
  126. }
  127.     }
  128. } else if (!lp->linkOK && (lp->autosense == AUTO)) {
  129.     lp->media = AUI_SUSPECT;
  130.     next_tick = 3000;
  131. }
  132. break;
  134.     case AUI_SUSPECT:
  135. next_tick = de4x5_suspect_state(dev, 1000, AUI, ping_media, dc2114x_autoconf);
  136. break;
  138.     case BNC:
  139. switch (lp->local_state) {
  140. case 0:
  141.     if (lp->timeout < 0) {
  142. omr = inl(DE4X5_OMR);          /* Set up half duplex for BNC */
  143. outl(omr & ~OMR_FDX, DE4X5_OMR);
  144.     }
  145.     irqs = 0;
  146.     irq_mask = 0;
  147.     sts = test_media(dev,irqs, irq_mask, 0, 0, 0, 1000);
  148.     if (sts < 0) {
  149. next_tick = sts & ~TIMER_CB;
  150.     } else {
  151. lp->local_state++;             /* Ensure media connected */
  152. next_tick = dc2114x_autoconf(dev);
  153.     }
  154.     break;
  155.     
  156. case 1:
  157.     if (!lp->tx_enable) {
  158. if ((sts = ping_media(dev, 3000)) < 0) {
  159.     next_tick = sts & ~TIMER_CB;
  160. } else {
  161.     if (sts) {
  162. lp->local_state = 0;
  163. lp->tcount++;
  164. lp->media = INIT;
  165.     } else {
  166. de4x5_init_connection(dev);
  167.     }
  168. }
  169.     } else if (!lp->linkOK && (lp->autosense == AUTO)) {
  170. lp->media = BNC_SUSPECT;
  171. next_tick = 3000;
  172.     }
  173.     break;
  174. }
  175. break;
  177.     case BNC_SUSPECT:
  178. next_tick = de4x5_suspect_state(dev, 1000, BNC, ping_media, dc2114x_autoconf);
  179. break;
  181.     case SPD_DET:                              /* Choose 10Mb/s or 100Mb/s */
  182.   if (srom_map_media(dev) < 0) {
  183.       lp->tcount++;
  184.       lp->media = INIT;
  185.       return next_tick;
  186.   }
  187.   if (lp->media == _100Mb) {
  188.       if ((slnk = test_for_100Mb(dev, 6500)) < 0) {
  189.   lp->media = SPD_DET;
  190.   return  (slnk & ~TIMER_CB);
  191.       }
  192.   } else {
  193.       if (wait_for_link(dev) < 0) {
  194.   lp->media = SPD_DET;
  195.   return PDET_LINK_WAIT;
  196.       }
  197.   }
  198.   if (lp->media == ANS) {           /* Do MII parallel detection */
  199.       if (is_spd_100(dev)) {
  200.   lp->media = _100Mb;
  201.       } else {
  202.   lp->media = _10Mb;
  203.       }
  204.       next_tick = dc2114x_autoconf(dev);
  205.   } else if (((lp->media == _100Mb) && is_100_up(dev)) ||
  206.      (((lp->media == _10Mb) || (lp->media == TP) ||
  207.        (lp->media == BNC)   || (lp->media == AUI)) && 
  208.       is_10_up(dev))) {
  209.       next_tick = dc2114x_autoconf(dev);
  210.   } else {
  211.       lp->tcount++;
  212.       lp->media = INIT;
  213.   }
  214.   break;
  216.     case _10Mb:
  217.         next_tick = 3000;
  218. if (!lp->tx_enable) {
  219.     SET_10Mb;
  220.     de4x5_init_connection(dev);
  221. } else {
  222.     if (!lp->linkOK && (lp->autosense == AUTO)) {
  223. if (!is_10_up(dev) || (!lp->useSROM && is_spd_100(dev))) {
  224.     lp->media = INIT;
  225.     lp->tcount++;
  226.     next_tick = DE4X5_AUTOSENSE_MS;
  227. }
  228.     }
  229. }
  230. break;
  232.     case _100Mb:
  233.         next_tick = 3000;
  234. if (!lp->tx_enable) {
  235.     SET_100Mb;
  236.     de4x5_init_connection(dev);
  237. } else {
  238.     if (!lp->linkOK && (lp->autosense == AUTO)) {
  239. if (!is_100_up(dev) || (!lp->useSROM && !is_spd_100(dev))) {
  240.     lp->media = INIT;
  241.     lp->tcount++;
  242.     next_tick = DE4X5_AUTOSENSE_MS;
  243. }
  244.     }
  245. }
  246. break;
  248.     default:
  249. lp->tcount++;
  250. printk("Huh?: media:%02xn", lp->media);
  251. lp->media = INIT;
  252. break;
  253.     }
  254.     
  255.     return next_tick;
  256. }
  258. static int
  259. srom_autoconf(struct net_device *dev)
  260. {
  261.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  263.     return lp->infoleaf_fn(dev);
  264. }
  266. /*
  267. ** This mapping keeps the original media codes and FDX flag unchanged.
  268. ** While it isn't strictly necessary, it helps me for the moment...
  269. ** The early return avoids a media state / SROM media space clash.
  270. */
  271. static int
  272. srom_map_media(struct net_device *dev)
  273. {
  274.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  276.     lp->fdx = 0;
  277.     if (lp->infoblock_media == lp->media) 
  278.       return 0;
  280.     switch(lp->infoblock_media) {
  281.       case SROM_10BASETF:
  282. if (!lp->params.fdx) return -1;
  283. lp->fdx = TRUE;
  284.       case SROM_10BASET:
  285. if (lp->params.fdx && !lp->fdx) return -1;
  286. if ((lp->chipset == DC21140) || ((lp->chipset & ~0x00ff) == DC2114x)) {
  287.     lp->media = _10Mb;
  288. } else {
  289.     lp->media = TP;
  290. }
  291. break;
  293.       case SROM_10BASE2:
  294. lp->media = BNC;
  295. break;
  297.       case SROM_10BASE5:
  298. lp->media = AUI;
  299. break;
  301.       case SROM_100BASETF:
  302.         if (!lp->params.fdx) return -1;
  303. lp->fdx = TRUE;
  304.       case SROM_100BASET:
  305. if (lp->params.fdx && !lp->fdx) return -1;
  306. lp->media = _100Mb;
  307. break;
  309.       case SROM_100BASET4:
  310. lp->media = _100Mb;
  311. break;
  313.       case SROM_100BASEFF:
  314. if (!lp->params.fdx) return -1;
  315. lp->fdx = TRUE;
  316.       case SROM_100BASEF: 
  317. if (lp->params.fdx && !lp->fdx) return -1;
  318. lp->media = _100Mb;
  319. break;
  321.       case ANS:
  322. lp->media = ANS;
  323. lp->fdx = lp->params.fdx;
  324. break;
  326.       default: 
  327. printk("%s: Bad media code [%d] detected in SROM!n", dev->name, 
  328.                                                   lp->infoblock_media);
  329. return -1;
  330. break;
  331.     }
  333.     return 0;
  334. }
  336. static void
  337. de4x5_init_connection(struct net_device *dev)
  338. {
  339.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  340.     u_long iobase = dev->base_addr;
  341.     u_long flags = 0;
  343.     if (lp->media != lp->c_media) {
  344.         de4x5_dbg_media(dev);
  345. lp->c_media = lp->media;          /* Stop scrolling media messages */
  346.     }
  348.     spin_lock_irqsave(&lp->lock, flags);
  349.     de4x5_rst_desc_ring(dev);
  350.     de4x5_setup_intr(dev);
  351.     lp->tx_enable = YES;
  352.     spin_unlock_irqrestore(&lp->lock, flags);
  353.     outl(POLL_DEMAND, DE4X5_TPD);
  355.     netif_wake_queue(dev);
  357.     return;
  358. }
  360. /*
  361. ** General PHY reset function. Some MII devices don't reset correctly
  362. ** since their MII address pins can float at voltages that are dependent
  363. ** on the signal pin use. Do a double reset to ensure a reset.
  364. */
  365. static int
  366. de4x5_reset_phy(struct net_device *dev)
  367. {
  368.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  369.     u_long iobase = dev->base_addr;
  370.     int next_tick = 0;
  372.     if ((lp->useSROM) || (lp->phy[lp->active].id)) {
  373. if (lp->timeout < 0) {
  374.     if (lp->useSROM) {
  375. if (lp->phy[lp->active].rst) {
  376.     srom_exec(dev, lp->phy[lp->active].rst);
  377.     srom_exec(dev, lp->phy[lp->active].rst);
  378. } else if (lp->rst) {          /* Type 5 infoblock reset */
  379.     srom_exec(dev, lp->rst);
  380.     srom_exec(dev, lp->rst);
  381. }
  382.     } else {
  383. PHY_HARD_RESET;
  384.     }
  385.     if (lp->useMII) {
  386.         mii_wr(MII_CR_RST, MII_CR, lp->phy[lp->active].addr, DE4X5_MII);
  387.             }
  388.         }
  389. if (lp->useMII) {
  390.     next_tick = test_mii_reg(dev, MII_CR, MII_CR_RST, FALSE, 500);
  391. }
  392.     } else if (lp->chipset == DC21140) {
  393. PHY_HARD_RESET;
  394.     }
  396.     return next_tick;
  397. }
  399. static int
  400. test_media(struct net_device *dev, s32 irqs, s32 irq_mask, s32 csr13, s32 csr14, s32 csr15, s32 msec)
  401. {
  402.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  403.     u_long iobase = dev->base_addr;
  404.     s32 sts, csr12;
  405.     
  406.     if (lp->timeout < 0) {
  407. lp->timeout = msec/100;
  408. if (!lp->useSROM) {      /* Already done if by SROM, else dc2104[01] */
  409.     reset_init_sia(dev, csr13, csr14, csr15);
  410. }
  412. /* set up the interrupt mask */
  413. outl(irq_mask, DE4X5_IMR);
  415. /* clear all pending interrupts */
  416. sts = inl(DE4X5_STS);
  417. outl(sts, DE4X5_STS);
  419. /* clear csr12 NRA and SRA bits */
  420. if ((lp->chipset == DC21041) || lp->useSROM) {
  421.     csr12 = inl(DE4X5_SISR);
  422.     outl(csr12, DE4X5_SISR);
  423. }
  424.     }
  425.     
  426.     sts = inl(DE4X5_STS) & ~TIMER_CB;
  427.     
  428.     if (!(sts & irqs) && --lp->timeout) {
  429. sts = 100 | TIMER_CB;
  430.     } else {
  431. lp->timeout = -1;
  432.     }
  433.     
  434.     return sts;
  435. }
  437. static int
  438. test_tp(struct net_device *dev, s32 msec)
  439. {
  440.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  441.     u_long iobase = dev->base_addr;
  442.     int sisr;
  443.     
  444.     if (lp->timeout < 0) {
  445. lp->timeout = msec/100;
  446.     }
  447.     
  448.     sisr = (inl(DE4X5_SISR) & ~TIMER_CB) & (SISR_LKF | SISR_NCR);
  450.     if (sisr && --lp->timeout) {
  451. sisr = 100 | TIMER_CB;
  452.     } else {
  453. lp->timeout = -1;
  454.     }
  455.     
  456.     return sisr;
  457. }
  459. /*
  460. ** Samples the 100Mb Link State Signal. The sample interval is important
  461. ** because too fast a rate can give erroneous results and confuse the
  462. ** speed sense algorithm.
  463. */
  464. #define SAMPLE_INTERVAL 500  /* ms */
  465. #define SAMPLE_DELAY    2000 /* ms */
  466. static int
  467. test_for_100Mb(struct net_device *dev, int msec)
  468. {
  469.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  470.     int gep = 0, ret = ((lp->chipset & ~0x00ff)==DC2114x? -1 :GEP_SLNK);
  472.     if (lp->timeout < 0) {
  473. if ((msec/SAMPLE_INTERVAL) <= 0) return 0;
  474. if (msec > SAMPLE_DELAY) {
  475.     lp->timeout = (msec - SAMPLE_DELAY)/SAMPLE_INTERVAL;
  476.     gep = SAMPLE_DELAY | TIMER_CB;
  477.     return gep;
  478. } else {
  479.     lp->timeout = msec/SAMPLE_INTERVAL;
  480. }
  481.     }
  482.     
  483.     if (lp->phy[lp->active].id || lp->useSROM) {
  484. gep = is_100_up(dev) | is_spd_100(dev);
  485.     } else {
  486. gep = (~gep_rd(dev) & (GEP_SLNK | GEP_LNP));
  487.     }
  488.     if (!(gep & ret) && --lp->timeout) {
  489. gep = SAMPLE_INTERVAL | TIMER_CB;
  490.     } else {
  491. lp->timeout = -1;
  492.     }
  493.     
  494.     return gep;
  495. }
  497. static int
  498. wait_for_link(struct net_device *dev)
  499. {
  500.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  502.     if (lp->timeout < 0) {
  503. lp->timeout = 1;
  504.     }
  505.     
  506.     if (lp->timeout--) {
  507. return TIMER_CB;
  508.     } else {
  509. lp->timeout = -1;
  510.     }
  511.     
  512.     return 0;
  513. }
  515. /*
  516. **
  517. **
  518. */
  519. static int
  520. test_mii_reg(struct net_device *dev, int reg, int mask, int pol, long msec)
  521. {
  522.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  523.     int test;
  524.     u_long iobase = dev->base_addr;
  525.     
  526.     if (lp->timeout < 0) {
  527. lp->timeout = msec/100;
  528.     }
  529.     
  530.     if (pol) pol = ~0;
  531.     reg = mii_rd((u_char)reg, lp->phy[lp->active].addr, DE4X5_MII) & mask;
  532.     test = (reg ^ pol) & mask;
  533.     
  534.     if (test && --lp->timeout) {
  535. reg = 100 | TIMER_CB;
  536.     } else {
  537. lp->timeout = -1;
  538.     }
  539.     
  540.     return reg;
  541. }
  543. static int
  544. is_spd_100(struct net_device *dev)
  545. {
  546.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  547.     u_long iobase = dev->base_addr;
  548.     int spd;
  549.     
  550.     if (lp->useMII) {
  551. spd = mii_rd(lp->phy[lp->active].spd.reg, lp->phy[lp->active].addr, DE4X5_MII);
  552. spd = ~(spd ^ lp->phy[lp->active].spd.value);
  553. spd &= lp->phy[lp->active].spd.mask;
  554.     } else if (!lp->useSROM) {                      /* de500-xa */
  555. spd = ((~gep_rd(dev)) & GEP_SLNK);
  556.     } else {
  557. if ((lp->ibn == 2) || !lp->asBitValid)
  558.     return ((lp->chipset == DC21143)?(~inl(DE4X5_SISR)&SISR_LS100):0);
  560. spd = (lp->asBitValid & (lp->asPolarity ^ (gep_rd(dev) & lp->asBit))) |
  561.           (lp->linkOK & ~lp->asBitValid);
  562.     }
  563.     
  564.     return spd;
  565. }
  567. static int
  568. is_100_up(struct net_device *dev)
  569. {
  570.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  571.     u_long iobase = dev->base_addr;
  572.     
  573.     if (lp->useMII) {
  574. /* Double read for sticky bits & temporary drops */
  575. mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII);
  576. return (mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII) & MII_SR_LKS);
  577.     } else if (!lp->useSROM) {                       /* de500-xa */
  578. return ((~gep_rd(dev)) & GEP_SLNK);
  579.     } else {
  580. if ((lp->ibn == 2) || !lp->asBitValid)
  581.     return ((lp->chipset == DC21143)?(~inl(DE4X5_SISR)&SISR_LS100):0);
  583.         return ((lp->asBitValid&(lp->asPolarity^(gep_rd(dev)&lp->asBit))) |
  584. (lp->linkOK & ~lp->asBitValid));
  585.     }
  586. }
  588. static int
  589. is_10_up(struct net_device *dev)
  590. {
  591.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  592.     u_long iobase = dev->base_addr;
  593.     
  594.     if (lp->useMII) {
  595. /* Double read for sticky bits & temporary drops */
  596. mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII);
  597. return (mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII) & MII_SR_LKS);
  598.     } else if (!lp->useSROM) {                       /* de500-xa */
  599. return ((~gep_rd(dev)) & GEP_LNP);
  600.     } else {
  601. if ((lp->ibn == 2) || !lp->asBitValid)
  602.     return (((lp->chipset & ~0x00ff) == DC2114x) ?
  603.     (~inl(DE4X5_SISR)&SISR_LS10):
  604.     0);
  606. return ((lp->asBitValid&(lp->asPolarity^(gep_rd(dev)&lp->asBit))) |
  607. (lp->linkOK & ~lp->asBitValid));
  608.     }
  609. }
  611. static int
  612. is_anc_capable(struct net_device *dev)
  613. {
  614.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  615.     u_long iobase = dev->base_addr;
  616.     
  617.     if (lp->phy[lp->active].id && (!lp->useSROM || lp->useMII)) {
  618. return (mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII));
  619.     } else if ((lp->chipset & ~0x00ff) == DC2114x) {
  620. return (inl(DE4X5_SISR) & SISR_LPN) >> 12;
  621.     } else {
  622. return 0;
  623.     }
  624. }
  626. /*
  627. ** Send a packet onto the media and watch for send errors that indicate the
  628. ** media is bad or unconnected.
  629. */
  630. static int
  631. ping_media(struct net_device *dev, int msec)
  632. {
  633.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  634.     u_long iobase = dev->base_addr;
  635.     int sisr;
  636.     
  637.     if (lp->timeout < 0) {
  638. lp->timeout = msec/100;
  640. lp->tmp = lp->tx_new;                /* Remember the ring position */
  641. load_packet(dev, lp->frame, TD_LS | TD_FS | sizeof(lp->frame), (struct sk_buff *)1);
  642. lp->tx_new = (++lp->tx_new) % lp->txRingSize;
  643. outl(POLL_DEMAND, DE4X5_TPD);
  644.     }
  645.     
  646.     sisr = inl(DE4X5_SISR);
  648.     if ((!(sisr & SISR_NCR)) && 
  649. ((s32)le32_to_cpu(lp->tx_ring[lp->tmp].status) < 0) && 
  650.  (--lp->timeout)) {
  651. sisr = 100 | TIMER_CB;
  652.     } else {
  653. if ((!(sisr & SISR_NCR)) && 
  654.     !(le32_to_cpu(lp->tx_ring[lp->tmp].status) & (T_OWN | TD_ES)) &&
  655.     lp->timeout) {
  656.     sisr = 0;
  657. } else {
  658.     sisr = 1;
  659. }
  660. lp->timeout = -1;
  661.     }
  662.     
  663.     return sisr;
  664. }
  666. /*
  667. ** This function does 2 things: on Intels it kmalloc's another buffer to
  668. ** replace the one about to be passed up. On Alpha's it kmallocs a buffer
  669. ** into which the packet is copied.
  670. */
  671. static struct sk_buff *
  672. de4x5_alloc_rx_buff(struct net_device *dev, int index, int len)
  673. {
  674.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  675.     struct sk_buff *p;
  677. #if !defined(__alpha__) && !defined(__powerpc__) && !defined(__sparc_v9__) && !defined(DE4X5_DO_MEMCPY)
  678.     struct sk_buff *ret;
  679.     u_long i=0, tmp;
  681.     p = dev_alloc_skb(IEEE802_3_SZ + DE4X5_ALIGN + 2);
  682.     if (!p) return NULL;
  684.     p->dev = dev;
  685.     tmp = virt_to_bus(p->data);
  686.     i = ((tmp + DE4X5_ALIGN) & ~DE4X5_ALIGN) - tmp;
  687.     skb_reserve(p, i);
  688.     lp->rx_ring[index].buf = cpu_to_le32(tmp + i);
  690.     ret = lp->rx_skb[index];
  691.     lp->rx_skb[index] = p;
  693.     if ((u_long) ret > 1) {
  694. skb_put(ret, len);
  695.     }
  697.     return ret;
  699. #else
  700.     if (lp->state != OPEN) return (struct sk_buff *)1; /* Fake out the open */
  702.     p = dev_alloc_skb(len + 2);
  703.     if (!p) return NULL;
  705.     p->dev = dev;
  706.     skb_reserve(p, 2);                                /* Align */
  707.     if (index < lp->rx_old) {                          /* Wrapped buffer */
  708. short tlen = (lp->rxRingSize - lp->rx_old) * RX_BUFF_SZ;
  709. memcpy(skb_put(p,tlen),lp->rx_bufs + lp->rx_old * RX_BUFF_SZ,tlen);
  710. memcpy(skb_put(p,len-tlen),lp->rx_bufs,len-tlen);
  711.     } else {                                           /* Linear buffer */
  712. memcpy(skb_put(p,len),lp->rx_bufs + lp->rx_old * RX_BUFF_SZ,len);
  713.     }
  714.     
  715.     return p;
  716. #endif
  717. }
  719. static void
  720. de4x5_free_rx_buffs(struct net_device *dev)
  721. {
  722.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  723.     int i;
  725.     for (i=0; i<lp->rxRingSize; i++) {
  726. if ((u_long) lp->rx_skb[i] > 1) {
  727.     dev_kfree_skb(lp->rx_skb[i]);
  728. }
  729. lp->rx_ring[i].status = 0;
  730. lp->rx_skb[i] = (struct sk_buff *)1;    /* Dummy entry */
  731.     }
  733.     return;
  734. }
  736. static void
  737. de4x5_free_tx_buffs(struct net_device *dev)
  738. {
  739.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  740.     int i;
  742.     for (i=0; i<lp->txRingSize; i++) {
  743. if (lp->tx_skb[i])
  744.     de4x5_free_tx_buff(lp, i);
  745. lp->tx_ring[i].status = 0;
  746.     }
  748.     /* Unload the locally queued packets */
  749.     while (lp->cache.skb) {
  750. dev_kfree_skb(de4x5_get_cache(dev));
  751.     }
  753.     return;
  754. }
  756. /*
  757. ** When a user pulls a connection, the DECchip can end up in a
  758. ** 'running - waiting for end of transmission' state. This means that we
  759. ** have to perform a chip soft reset to ensure that we can synchronize
  760. ** the hardware and software and make any media probes using a loopback
  761. ** packet meaningful.
  762. */
  763. static void
  764. de4x5_save_skbs(struct net_device *dev)
  765. {
  766.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  767.     u_long iobase = dev->base_addr;
  768.     s32 omr;
  770.     if (!lp->cache.save_cnt) {
  771. STOP_DE4X5;
  772. de4x5_tx(dev);                          /* Flush any sent skb's */
  773. de4x5_free_tx_buffs(dev);
  774. de4x5_cache_state(dev, DE4X5_SAVE_STATE);
  775. de4x5_sw_reset(dev);
  776. de4x5_cache_state(dev, DE4X5_RESTORE_STATE);
  777. lp->cache.save_cnt++;
  778. START_DE4X5;
  779.     }
  781.     return;
  782. }
  784. static void
  785. de4x5_rst_desc_ring(struct net_device *dev)
  786. {
  787.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  788.     u_long iobase = dev->base_addr;
  789.     int i;
  790.     s32 omr;
  792.     if (lp->cache.save_cnt) {
  793. STOP_DE4X5;
  794. outl(lp->dma_rings, DE4X5_RRBA);
  795. outl(lp->dma_rings + NUM_RX_DESC * sizeof(struct de4x5_desc),
  796.      DE4X5_TRBA);
  797.     
  798. lp->rx_new = lp->rx_old = 0;
  799. lp->tx_new = lp->tx_old = 0;
  800.     
  801. for (i = 0; i < lp->rxRingSize; i++) {
  802.     lp->rx_ring[i].status = cpu_to_le32(R_OWN);
  803. }
  804.     
  805. for (i = 0; i < lp->txRingSize; i++) {
  806.     lp->tx_ring[i].status = cpu_to_le32(0);
  807. }
  808.     
  809. barrier();
  810. lp->cache.save_cnt--;
  811. START_DE4X5;
  812.     }
  813.         
  814.     return;
  815. }
  817. static void
  818. de4x5_cache_state(struct net_device *dev, int flag)
  819. {
  820.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  821.     u_long iobase = dev->base_addr;
  823.     switch(flag) {
  824.       case DE4X5_SAVE_STATE:
  825. lp->cache.csr0 = inl(DE4X5_BMR);
  826. lp->cache.csr6 = (inl(DE4X5_OMR) & ~(OMR_ST | OMR_SR));
  827. lp->cache.csr7 = inl(DE4X5_IMR);
  828. break;
  830.       case DE4X5_RESTORE_STATE:
  831. outl(lp->cache.csr0, DE4X5_BMR);
  832. outl(lp->cache.csr6, DE4X5_OMR);
  833. outl(lp->cache.csr7, DE4X5_IMR);
  834. if (lp->chipset == DC21140) {
  835.     gep_wr(lp->cache.gepc, dev);
  836.     gep_wr(lp->cache.gep, dev);
  837. } else {
  838.     reset_init_sia(dev, lp->cache.csr13, lp->cache.csr14, 
  839.                                       lp->cache.csr15);
  840. }
  841. break;
  842.     }
  844.     return;
  845. }
  847. static void
  848. de4x5_put_cache(struct net_device *dev, struct sk_buff *skb)
  849. {
  850.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  851.     struct sk_buff *p;
  853.     if (lp->cache.skb) {
  854. for (p=lp->cache.skb; p->next; p=p->next);
  855. p->next = skb;
  856.     } else {
  857. lp->cache.skb = skb;
  858.     }
  859.     skb->next = NULL;
  861.     return;
  862. }
  864. static void
  865. de4x5_putb_cache(struct net_device *dev, struct sk_buff *skb)
  866. {
  867.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  868.     struct sk_buff *p = lp->cache.skb;
  870.     lp->cache.skb = skb;
  871.     skb->next = p;
  873.     return;
  874. }
  876. static struct sk_buff *
  877. de4x5_get_cache(struct net_device *dev)
  878. {
  879.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  880.     struct sk_buff *p = lp->cache.skb;
  882.     if (p) {
  883. lp->cache.skb = p->next;
  884. p->next = NULL;
  885.     }
  887.     return p;
  888. }
  890. /*
  891. ** Check the Auto Negotiation State. Return OK when a link pass interrupt
  892. ** is received and the auto-negotiation status is NWAY OK.
  893. */
  894. static int
  895. test_ans(struct net_device *dev, s32 irqs, s32 irq_mask, s32 msec)
  896. {
  897.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  898.     u_long iobase = dev->base_addr;
  899.     s32 sts, ans;
  900.     
  901.     if (lp->timeout < 0) {
  902. lp->timeout = msec/100;
  903. outl(irq_mask, DE4X5_IMR);
  905. /* clear all pending interrupts */
  906. sts = inl(DE4X5_STS);
  907. outl(sts, DE4X5_STS);
  908.     }
  909.     
  910.     ans = inl(DE4X5_SISR) & SISR_ANS;
  911.     sts = inl(DE4X5_STS) & ~TIMER_CB;
  912.     
  913.     if (!(sts & irqs) && (ans ^ ANS_NWOK) && --lp->timeout) {
  914. sts = 100 | TIMER_CB;
  915.     } else {
  916. lp->timeout = -1;
  917.     }
  918.     
  919.     return sts;
  920. }
  922. static void
  923. de4x5_setup_intr(struct net_device *dev)
  924. {
  925.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  926.     u_long iobase = dev->base_addr;
  927.     s32 imr, sts;
  928.     
  929.     if (inl(DE4X5_OMR) & OMR_SR) {   /* Only unmask if TX/RX is enabled */
  930. imr = 0;
  931. UNMASK_IRQs;
  932. sts = inl(DE4X5_STS);        /* Reset any pending (stale) interrupts */
  933. outl(sts, DE4X5_STS);
  934. ENABLE_IRQs;
  935.     }
  936.     
  937.     return;
  938. }
  940. /*
  941. **
  942. */
  943. static void
  944. reset_init_sia(struct net_device *dev, s32 csr13, s32 csr14, s32 csr15)
  945. {
  946.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  947.     u_long iobase = dev->base_addr;
  949.     RESET_SIA;
  950.     if (lp->useSROM) {
  951. if (lp->ibn == 3) {
  952.     srom_exec(dev, lp->phy[lp->active].rst);
  953.     srom_exec(dev, lp->phy[lp->active].gep);
  954.     outl(1, DE4X5_SICR);
  955.     return;
  956. } else {
  957.     csr15 = lp->cache.csr15;
  958.     csr14 = lp->cache.csr14;
  959.     csr13 = lp->cache.csr13;
  960.     outl(csr15 | lp->cache.gepc, DE4X5_SIGR);
  961.     outl(csr15 | lp->cache.gep, DE4X5_SIGR);
  962. }
  963.     } else {
  964. outl(csr15, DE4X5_SIGR);
  965.     }
  966.     outl(csr14, DE4X5_STRR);
  967.     outl(csr13, DE4X5_SICR);
  969.     mdelay(10);
  971.     return;
  972. }
  974. /*
  975. ** Create a loopback ethernet packet
  976. */
  977. static void
  978. create_packet(struct net_device *dev, char *frame, int len)
  979. {
  980.     int i;
  981.     char *buf = frame;
  982.     
  983.     for (i=0; i<ETH_ALEN; i++) {             /* Use this source address */
  984. *buf++ = dev->dev_addr[i];
  985.     }
  986.     for (i=0; i<ETH_ALEN; i++) {             /* Use this destination address */
  987. *buf++ = dev->dev_addr[i];
  988.     }
  989.     
  990.     *buf++ = 0;                              /* Packet length (2 bytes) */
  991.     *buf++ = 1;
  992.     
  993.     return;
  994. }
  996. /*
  997. ** Look for a particular board name in the EISA configuration space
  998. */
  999. static int
  1000. EISA_signature(char *name, s32 eisa_id)
  1001. {
  1002.     static c_char *signatures[] = DE4X5_SIGNATURE;
  1003.     char ManCode[DE4X5_STRLEN];
  1004.     union {
  1005. s32 ID;
  1006. char Id[4];
  1007.     } Eisa;
  1008.     int i, status = 0, siglen = sizeof(signatures)/sizeof(c_char *);
  1009.     
  1010.     *name = '';
  1011.     Eisa.ID = inl(eisa_id);
  1012.     
  1013.     ManCode[0]=(((Eisa.Id[0]>>2)&0x1f)+0x40);
  1014.     ManCode[1]=(((Eisa.Id[1]&0xe0)>>5)+((Eisa.Id[0]&0x03)<<3)+0x40);
  1015.     ManCode[2]=(((Eisa.Id[2]>>4)&0x0f)+0x30);
  1016.     ManCode[3]=((Eisa.Id[2]&0x0f)+0x30);
  1017.     ManCode[4]=(((Eisa.Id[3]>>4)&0x0f)+0x30);
  1018.     ManCode[5]='';
  1019.     
  1020.     for (i=0;i<siglen;i++) {
  1021. if (strstr(ManCode, signatures[i]) != NULL) {
  1022.     strcpy(name,ManCode);
  1023.     status = 1;
  1024.     break;
  1025. }
  1026.     }
  1027.     
  1028.     return status;                         /* return the device name string */
  1029. }
  1031. /*
  1032. ** Look for a particular board name in the PCI configuration space
  1033. */
  1034. static int
  1035. PCI_signature(char *name, struct de4x5_bus_type *lp)
  1036. {
  1037.     static c_char *de4x5_signatures[] = DE4X5_SIGNATURE;
  1038.     int i, status = 0, siglen = sizeof(de4x5_signatures)/sizeof(c_char *);
  1039.     
  1040.     if (lp->chipset == DC21040) {
  1041. strcpy(name, "DE434/5");
  1042. return status;
  1043.     } else {                           /* Search for a DEC name in the SROM */
  1044. int i = *((char *)&lp->srom + 19) * 3;
  1045. strncpy(name, (char *)&lp->srom + 26 + i, 8);
  1046.     }
  1047.     name[8] = '';
  1048.     for (i=0; i<siglen; i++) {
  1049. if (strstr(name,de4x5_signatures[i])!=NULL) break;
  1050.     }
  1051.     if (i == siglen) {
  1052. if (dec_only) {
  1053.     *name = '';
  1054. } else {                        /* Use chip name to avoid confusion */
  1055.     strcpy(name, (((lp->chipset == DC21040) ? "DC21040" :
  1056.    ((lp->chipset == DC21041) ? "DC21041" :
  1057.     ((lp->chipset == DC21140) ? "DC21140" :
  1058.      ((lp->chipset == DC21142) ? "DC21142" :
  1059.       ((lp->chipset == DC21143) ? "DC21143" : "UNKNOWN"
  1060.      )))))));
  1061. }
  1062. if (lp->chipset != DC21041) {
  1063.     useSROM = TRUE;             /* card is not recognisably DEC */
  1064. }
  1065.     } else if ((lp->chipset & ~0x00ff) == DC2114x) {
  1066. useSROM = TRUE;
  1067.     }
  1068.     
  1069.     return status;
  1070. }
  1072. /*
  1073. ** Set up the Ethernet PROM counter to the start of the Ethernet address on
  1074. ** the DC21040, else  read the SROM for the other chips.
  1075. ** The SROM may not be present in a multi-MAC card, so first read the
  1076. ** MAC address and check for a bad address. If there is a bad one then exit
  1077. ** immediately with the prior srom contents intact (the h/w address will
  1078. ** be fixed up later).
  1079. */
  1080. static void
  1081. DevicePresent(u_long aprom_addr)
  1082. {
  1083.     int i, j=0;
  1084.     struct de4x5_bus_type *lp = &bus;
  1085.     
  1086.     if (lp->chipset == DC21040) {
  1087. if (lp->bus == EISA) {
  1088.     enet_addr_rst(aprom_addr); /* Reset Ethernet Address ROM Pointer */
  1089. } else {
  1090.     outl(0, aprom_addr);       /* Reset Ethernet Address ROM Pointer */
  1091. }
  1092.     } else {                           /* Read new srom */
  1093. u_short tmp, *p = (short *)((char *)&lp->srom + SROM_HWADD);
  1094. for (i=0; i<(ETH_ALEN>>1); i++) {
  1095.     tmp = srom_rd(aprom_addr, (SROM_HWADD>>1) + i);
  1096.     *p = le16_to_cpu(tmp);
  1097.     j += *p++;
  1098. }
  1099. if ((j == 0) || (j == 0x2fffd)) {
  1100.     return;
  1101. }
  1103. p=(short *)&lp->srom;
  1104. for (i=0; i<(sizeof(struct de4x5_srom)>>1); i++) {
  1105.     tmp = srom_rd(aprom_addr, i);
  1106.     *p++ = le16_to_cpu(tmp);
  1107. }
  1108. de4x5_dbg_srom((struct de4x5_srom *)&lp->srom);
  1109.     }
  1110.     
  1111.     return;
  1112. }
  1114. /*
  1115. ** Since the write on the Enet PROM register doesn't seem to reset the PROM
  1116. ** pointer correctly (at least on my DE425 EISA card), this routine should do
  1117. ** it...from depca.c.
  1118. */
  1119. static void
  1120. enet_addr_rst(u_long aprom_addr)
  1121. {
  1122.     union {
  1123. struct {
  1124.     u32 a;
  1125.     u32 b;
  1126. } llsig;
  1127. char Sig[sizeof(u32) << 1];
  1128.     } dev;
  1129.     short sigLength=0;
  1130.     s8 data;
  1131.     int i, j;
  1132.     
  1133.     dev.llsig.a = ETH_PROM_SIG;
  1134.     dev.llsig.b = ETH_PROM_SIG;
  1135.     sigLength = sizeof(u32) << 1;
  1136.     
  1137.     for (i=0,j=0;j<sigLength && i<PROBE_LENGTH+sigLength-1;i++) {
  1138. data = inb(aprom_addr);
  1139. if (dev.Sig[j] == data) {    /* track signature */
  1140.     j++;
  1141. } else {                     /* lost signature; begin search again */
  1142.     if (data == dev.Sig[0]) {  /* rare case.... */
  1143. j=1;
  1144.     } else {
  1145. j=0;
  1146.     }
  1147. }
  1148.     }
  1149.     
  1150.     return;
  1151. }
  1153. /*
  1154. ** For the bad status case and no SROM, then add one to the previous
  1155. ** address. However, need to add one backwards in case we have 0xff
  1156. ** as one or more of the bytes. Only the last 3 bytes should be checked
  1157. ** as the first three are invariant - assigned to an organisation.
  1158. */
  1159. static int
  1160. get_hw_addr(struct net_device *dev)
  1161. {
  1162.     u_long iobase = dev->base_addr;
  1163.     int broken, i, k, tmp, status = 0;
  1164.     u_short j,chksum;
  1165.     struct de4x5_bus_type *lp = &bus;
  1167.     broken = de4x5_bad_srom(lp);
  1169.     for (i=0,k=0,j=0;j<3;j++) {
  1170. k <<= 1;
  1171. if (k > 0xffff) k-=0xffff;
  1173. if (lp->bus == PCI) {
  1174.     if (lp->chipset == DC21040) {
  1175. while ((tmp = inl(DE4X5_APROM)) < 0);
  1176. k += (u_char) tmp;
  1177. dev->dev_addr[i++] = (u_char) tmp;
  1178. while ((tmp = inl(DE4X5_APROM)) < 0);
  1179. k += (u_short) (tmp << 8);
  1180. dev->dev_addr[i++] = (u_char) tmp;
  1181.     } else if (!broken) {
  1182. dev->dev_addr[i] = (u_char) lp->srom.ieee_addr[i]; i++;
  1183. dev->dev_addr[i] = (u_char) lp->srom.ieee_addr[i]; i++;
  1184.     } else if ((broken == SMC) || (broken == ACCTON)) {
  1185. dev->dev_addr[i] = *((u_char *)&lp->srom + i); i++;
  1186. dev->dev_addr[i] = *((u_char *)&lp->srom + i); i++;
  1187.     }
  1188. } else {
  1189.     k += (u_char) (tmp = inb(EISA_APROM));
  1190.     dev->dev_addr[i++] = (u_char) tmp;
  1191.     k += (u_short) ((tmp = inb(EISA_APROM)) << 8);
  1192.     dev->dev_addr[i++] = (u_char) tmp;
  1193. }
  1195. if (k > 0xffff) k-=0xffff;
  1196.     }
  1197.     if (k == 0xffff) k=0;
  1198.     
  1199.     if (lp->bus == PCI) {
  1200. if (lp->chipset == DC21040) {
  1201.     while ((tmp = inl(DE4X5_APROM)) < 0);
  1202.     chksum = (u_char) tmp;
  1203.     while ((tmp = inl(DE4X5_APROM)) < 0);
  1204.     chksum |= (u_short) (tmp << 8);
  1205.     if ((k != chksum) && (dec_only)) status = -1;
  1206. }
  1207.     } else {
  1208. chksum = (u_char) inb(EISA_APROM);
  1209. chksum |= (u_short) (inb(EISA_APROM) << 8);
  1210. if ((k != chksum) && (dec_only)) status = -1;
  1211.     }
  1213.     /* If possible, try to fix a broken card - SMC only so far */
  1214.     srom_repair(dev, broken);
  1216. #ifdef CONFIG_PPC
  1217.     /* 
  1218.     ** If the address starts with 00 a0, we have to bit-reverse
  1219.     ** each byte of the address.
  1220.     */
  1221.     if ( (ppc_md.ppc_machine & _MACH_Pmac) &&
  1222.  (dev->dev_addr[0] == 0) &&
  1223.  (dev->dev_addr[1] == 0xa0) )
  1224.     {
  1225.     for (i = 0; i < ETH_ALEN; ++i)
  1226.     {
  1227.     int x = dev->dev_addr[i];
  1228.     x = ((x & 0xf) << 4) + ((x & 0xf0) >> 4);
  1229.     x = ((x & 0x33) << 2) + ((x & 0xcc) >> 2);
  1230.     dev->dev_addr[i] = ((x & 0x55) << 1) + ((x & 0xaa) >> 1);
  1231.     }
  1232.     }
  1233. #endif /* CONFIG_PPC */
  1235.     /* Test for a bad enet address */
  1236.     status = test_bad_enet(dev, status);
  1238.     return status;
  1239. }
  1241. /*
  1242. ** Test for enet addresses in the first 32 bytes. The built-in strncmp
  1243. ** didn't seem to work here...?
  1244. */
  1245. static int
  1246. de4x5_bad_srom(struct de4x5_bus_type *lp)
  1247. {
  1248.     int i, status = 0;
  1250.     for (i=0; i<sizeof(enet_det)/ETH_ALEN; i++) {
  1251. if (!de4x5_strncmp((char *)&lp->srom, (char *)&enet_det[i], 3) &&
  1252.     !de4x5_strncmp((char *)&lp->srom+0x10, (char *)&enet_det[i], 3)) {
  1253.     if (i == 0) {
  1254. status = SMC;
  1255.     } else if (i == 1) {
  1256. status = ACCTON;
  1257.     }
  1258.     break;
  1259. }
  1260.     }
  1262.     return status;
  1263. }
  1265. static int
  1266. de4x5_strncmp(char *a, char *b, int n)
  1267. {
  1268.     int ret=0;
  1270.     for (;n && !ret;n--) {
  1271. ret = *a++ - *b++;
  1272.     }
  1274.     return ret;
  1275. }
  1277. static void
  1278. srom_repair(struct net_device *dev, int card)
  1279. {
  1280.     struct de4x5_bus_type *lp = &bus;
  1282.     switch(card) {
  1283.       case SMC:
  1284. memset((char *)&bus.srom, 0, sizeof(struct de4x5_srom));
  1285. memcpy(lp->srom.ieee_addr, (char *)dev->dev_addr, ETH_ALEN);
  1286. memcpy(lp->srom.info, (char *)&srom_repair_info[SMC-1], 100);
  1287. useSROM = TRUE;
  1288. break;
  1289.     }
  1291.     return;
  1292. }
  1294. /*
  1295. ** Assume that the irq's do not follow the PCI spec - this is seems
  1296. ** to be true so far (2 for 2).
  1297. */
  1298. static int
  1299. test_bad_enet(struct net_device *dev, int status)
  1300. {
  1301.     struct de4x5_bus_type *lp = &bus;
  1302.     int i, tmp;
  1304.     for (tmp=0,i=0; i<ETH_ALEN; i++) tmp += (u_char)dev->dev_addr[i];
  1305.     if ((tmp == 0) || (tmp == 0x5fa)) {
  1306. if ((lp->chipset == last.chipset) && 
  1307.     (lp->bus_num == last.bus) && (lp->bus_num > 0)) {
  1308.     for (i=0; i<ETH_ALEN; i++) dev->dev_addr[i] = last.addr[i];
  1309.     for (i=ETH_ALEN-1; i>2; --i) {
  1310. dev->dev_addr[i] += 1;
  1311. if (dev->dev_addr[i] != 0) break;
  1312.     }
  1313.     for (i=0; i<ETH_ALEN; i++) last.addr[i] = dev->dev_addr[i];
  1314.     if (!an_exception(lp)) {
  1315. dev->irq = last.irq;
  1316.     }
  1318.     status = 0;
  1319. }
  1320.     } else if (!status) {
  1321. last.chipset = lp->chipset;
  1322. last.bus = lp->bus_num;
  1323. last.irq = dev->irq;
  1324. for (i=0; i<ETH_ALEN; i++) last.addr[i] = dev->dev_addr[i];
  1325.     }
  1327.     return status;
  1328. }
  1330. /*
  1331. ** List of board exceptions with correctly wired IRQs
  1332. */
  1333. static int
  1334. an_exception(struct de4x5_bus_type *lp)
  1335. {
  1336.     if ((*(u_short *)lp->srom.sub_vendor_id == 0x00c0) && 
  1337. (*(u_short *)lp->srom.sub_system_id == 0x95e0)) {
  1338. return -1;
  1339.     }
  1341.     return 0;
  1342. }
  1344. /*
  1345. ** SROM Read
  1346. */
  1347. static short
  1348. srom_rd(u_long addr, u_char offset)
  1349. {
  1350.     sendto_srom(SROM_RD | SROM_SR, addr);
  1351.     
  1352.     srom_latch(SROM_RD | SROM_SR | DT_CS, addr);
  1353.     srom_command(SROM_RD | SROM_SR | DT_IN | DT_CS, addr);
  1354.     srom_address(SROM_RD | SROM_SR | DT_CS, addr, offset);
  1355.     
  1356.     return srom_data(SROM_RD | SROM_SR | DT_CS, addr);
  1357. }
  1359. static void
  1360. srom_latch(u_int command, u_long addr)
  1361. {
  1362.     sendto_srom(command, addr);
  1363.     sendto_srom(command | DT_CLK, addr);
  1364.     sendto_srom(command, addr);
  1365.     
  1366.     return;
  1367. }
  1369. static void
  1370. srom_command(u_int command, u_long addr)
  1371. {
  1372.     srom_latch(command, addr);
  1373.     srom_latch(command, addr);
  1374.     srom_latch((command & 0x0000ff00) | DT_CS, addr);
  1375.     
  1376.     return;
  1377. }
  1379. static void
  1380. srom_address(u_int command, u_long addr, u_char offset)
  1381. {
  1382.     int i, a;
  1383.     
  1384.     a = offset << 2;
  1385.     for (i=0; i<6; i++, a <<= 1) {
  1386. srom_latch(command | ((a & 0x80) ? DT_IN : 0), addr);
  1387.     }
  1388.     udelay(1);
  1389.     
  1390.     i = (getfrom_srom(addr) >> 3) & 0x01;
  1391.     
  1392.     return;
  1393. }
  1395. static short
  1396. srom_data(u_int command, u_long addr)
  1397. {
  1398.     int i;
  1399.     short word = 0;
  1400.     s32 tmp;
  1401.     
  1402.     for (i=0; i<16; i++) {
  1403. sendto_srom(command  | DT_CLK, addr);
  1404. tmp = getfrom_srom(addr);
  1405. sendto_srom(command, addr);
  1407. word = (word << 1) | ((tmp >> 3) & 0x01);
  1408.     }
  1409.     
  1410.     sendto_srom(command & 0x0000ff00, addr);
  1411.     
  1412.     return word;
  1413. }
  1415. /*
  1416. static void
  1417. srom_busy(u_int command, u_long addr)
  1418. {
  1419.    sendto_srom((command & 0x0000ff00) | DT_CS, addr);
  1420.    
  1421.    while (!((getfrom_srom(addr) >> 3) & 0x01)) {
  1422.        mdelay(1);
  1423.    }
  1424.    
  1425.    sendto_srom(command & 0x0000ff00, addr);
  1426.    
  1427.    return;
  1428. }
  1429. */
  1431. static void
  1432. sendto_srom(u_int command, u_long addr)
  1433. {
  1434.     outl(command, addr);
  1435.     udelay(1);
  1436.     
  1437.     return;
  1438. }
  1440. static int
  1441. getfrom_srom(u_long addr)
  1442. {
  1443.     s32 tmp;
  1444.     
  1445.     tmp = inl(addr);
  1446.     udelay(1);
  1447.     
  1448.     return tmp;
  1449. }
  1451. static int
  1452. srom_infoleaf_info(struct net_device *dev)
  1453. {
  1454.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  1455.     int i, count;
  1456.     u_char *p;
  1458.     /* Find the infoleaf decoder function that matches this chipset */
  1459.     for (i=0; i<INFOLEAF_SIZE; i++) {
  1460. if (lp->chipset == infoleaf_array[i].chipset) break;
  1461.     }
  1462.     if (i == INFOLEAF_SIZE) {
  1463. lp->useSROM = FALSE;
  1464. printk("%s: Cannot find correct chipset for SROM decoding!n", 
  1465.                                                           dev->name);
  1466. return -ENXIO;
  1467.     }
  1469.     lp->infoleaf_fn = infoleaf_array[i].fn;
  1471.     /* Find the information offset that this function should use */
  1472.     count = *((u_char *)&lp->srom + 19);
  1473.     p  = (u_char *)&lp->srom + 26;
  1475.     if (count > 1) {
  1476. for (i=count; i; --i, p+=3) {
  1477.     if (lp->device == *p) break;
  1478. }
  1479. if (i == 0) {
  1480.     lp->useSROM = FALSE;
  1481.     printk("%s: Cannot find correct PCI device [%d] for SROM decoding!n", 
  1482.                                                dev->name, lp->device);
  1483.     return -ENXIO;
  1484. }
  1485.     }
  1487.     lp->infoleaf_offset = TWIDDLE(p+1);
  1489.     return 0;
  1490. }
  1492. /*
  1493. ** This routine loads any type 1 or 3 MII info into the mii device
  1494. ** struct and executes any type 5 code to reset PHY devices for this
  1495. ** controller.
  1496. ** The info for the MII devices will be valid since the index used
  1497. ** will follow the discovery process from MII address 1-31 then 0.
  1498. */
  1499. static void
  1500. srom_init(struct net_device *dev)
  1501. {
  1502.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  1503.     u_char *p = (u_char *)&lp->srom + lp->infoleaf_offset;
  1504.     u_char count;
  1506.     p+=2;
  1507.     if (lp->chipset == DC21140) {
  1508. lp->cache.gepc = (*p++ | GEP_CTRL);
  1509. gep_wr(lp->cache.gepc, dev);
  1510.     }
  1512.     /* Block count */
  1513.     count = *p++;
  1515.     /* Jump the infoblocks to find types */
  1516.     for (;count; --count) {
  1517. if (*p < 128) {
  1518.     p += COMPACT_LEN;
  1519. } else if (*(p+1) == 5) {
  1520.     type5_infoblock(dev, 1, p);
  1521.     p += ((*p & BLOCK_LEN) + 1);
  1522. } else if (*(p+1) == 4) {
  1523.     p += ((*p & BLOCK_LEN) + 1);
  1524. } else if (*(p+1) == 3) {
  1525.     type3_infoblock(dev, 1, p);
  1526.     p += ((*p & BLOCK_LEN) + 1);
  1527. } else if (*(p+1) == 2) {
  1528.     p += ((*p & BLOCK_LEN) + 1);
  1529. } else if (*(p+1) == 1) {
  1530.     type1_infoblock(dev, 1, p);
  1531.     p += ((*p & BLOCK_LEN) + 1);
  1532. } else {
  1533.     p += ((*p & BLOCK_LEN) + 1);
  1534. }
  1535.     }
  1537.     return;
  1538. }
  1540. /*
  1541. ** A generic routine that writes GEP control, data and reset information
  1542. ** to the GEP register (21140) or csr15 GEP portion (2114[23]).
  1543. */
  1544. static void
  1545. srom_exec(struct net_device *dev, u_char *p)
  1546. {
  1547.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  1548.     u_long iobase = dev->base_addr;
  1549.     u_char count = (p ? *p++ : 0);
  1550.     u_short *w = (u_short *)p;
  1552.     if (((lp->ibn != 1) && (lp->ibn != 3) && (lp->ibn != 5)) || !count) return;
  1554.     if (lp->chipset != DC21140) RESET_SIA;
  1555.  
  1556.     while (count--) {
  1557. gep_wr(((lp->chipset==DC21140) && (lp->ibn!=5) ? 
  1558.                                    *p++ : TWIDDLE(w++)), dev);
  1559. mdelay(2);                          /* 2ms per action */
  1560.     }
  1562.     if (lp->chipset != DC21140) {
  1563. outl(lp->cache.csr14, DE4X5_STRR);
  1564. outl(lp->cache.csr13, DE4X5_SICR);
  1565.     }
  1567.     return;
  1568. }
  1570. /*
  1571. ** Basically this function is a NOP since it will never be called,
  1572. ** unless I implement the DC21041 SROM functions. There's no need
  1573. ** since the existing code will be satisfactory for all boards.
  1574. */
  1575. static int 
  1576. dc21041_infoleaf(struct net_device *dev)
  1577. {
  1578.     return DE4X5_AUTOSENSE_MS;
  1579. }
  1581. static int 
  1582. dc21140_infoleaf(struct net_device *dev)
  1583. {
  1584.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  1585.     u_char count = 0;
  1586.     u_char *p = (u_char *)&lp->srom + lp->infoleaf_offset;
  1587.     int next_tick = DE4X5_AUTOSENSE_MS;
  1589.     /* Read the connection type */
  1590.     p+=2;
  1592.     /* GEP control */
  1593.     lp->cache.gepc = (*p++ | GEP_CTRL);
  1595.     /* Block count */
  1596.     count = *p++;
  1598.     /* Recursively figure out the info blocks */
  1599.     if (*p < 128) {
  1600. next_tick = dc_infoblock[COMPACT](dev, count, p);
  1601.     } else {
  1602. next_tick = dc_infoblock[*(p+1)](dev, count, p);
  1603.     }
  1605.     if (lp->tcount == count) {
  1606. lp->media = NC;
  1607.         if (lp->media != lp->c_media) {
  1608.     de4x5_dbg_media(dev);
  1609.     lp->c_media = lp->media;
  1610. }
  1611. lp->media = INIT;
  1612. lp->tcount = 0;
  1613. lp->tx_enable = FALSE;
  1614.     }
  1616.     return next_tick & ~TIMER_CB;
  1617. }
  1619. static int 
  1620. dc21142_infoleaf(struct net_device *dev)
  1621. {
  1622.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  1623.     u_char count = 0;
  1624.     u_char *p = (u_char *)&lp->srom + lp->infoleaf_offset;
  1625.     int next_tick = DE4X5_AUTOSENSE_MS;
  1627.     /* Read the connection type */
  1628.     p+=2;
  1630.     /* Block count */
  1631.     count = *p++;
  1633.     /* Recursively figure out the info blocks */
  1634.     if (*p < 128) {
  1635. next_tick = dc_infoblock[COMPACT](dev, count, p);
  1636.     } else {
  1637. next_tick = dc_infoblock[*(p+1)](dev, count, p);
  1638.     }
  1640.     if (lp->tcount == count) {
  1641. lp->media = NC;
  1642.         if (lp->media != lp->c_media) {
  1643.     de4x5_dbg_media(dev);
  1644.     lp->c_media = lp->media;
  1645. }
  1646. lp->media = INIT;
  1647. lp->tcount = 0;
  1648. lp->tx_enable = FALSE;
  1649.     }
  1651.     return next_tick & ~TIMER_CB;
  1652. }
  1654. static int 
  1655. dc21143_infoleaf(struct net_device *dev)
  1656. {
  1657.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  1658.     u_char count = 0;
  1659.     u_char *p = (u_char *)&lp->srom + lp->infoleaf_offset;
  1660.     int next_tick = DE4X5_AUTOSENSE_MS;
  1662.     /* Read the connection type */
  1663.     p+=2;
  1665.     /* Block count */
  1666.     count = *p++;
  1668.     /* Recursively figure out the info blocks */
  1669.     if (*p < 128) {
  1670. next_tick = dc_infoblock[COMPACT](dev, count, p);
  1671.     } else {
  1672. next_tick = dc_infoblock[*(p+1)](dev, count, p);
  1673.     }
  1674.     if (lp->tcount == count) {
  1675. lp->media = NC;
  1676.         if (lp->media != lp->c_media) {
  1677.     de4x5_dbg_media(dev);
  1678.     lp->c_media = lp->media;
  1679. }
  1680. lp->media = INIT;
  1681. lp->tcount = 0;
  1682. lp->tx_enable = FALSE;
  1683.     }
  1685.     return next_tick & ~TIMER_CB;
  1686. }
  1688. /*
  1689. ** The compact infoblock is only designed for DC21140[A] chips, so
  1690. ** we'll reuse the dc21140m_autoconf function. Non MII media only.
  1691. */
  1692. static int 
  1693. compact_infoblock(struct net_device *dev, u_char count, u_char *p)
  1694. {
  1695.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  1696.     u_char flags, csr6;
  1698.     /* Recursively figure out the info blocks */
  1699.     if (--count > lp->tcount) {
  1700. if (*(p+COMPACT_LEN) < 128) {
  1701.     return dc_infoblock[COMPACT](dev, count, p+COMPACT_LEN);
  1702. } else {
  1703.     return dc_infoblock[*(p+COMPACT_LEN+1)](dev, count, p+COMPACT_LEN);
  1704. }
  1705.     }
  1707.     if ((lp->media == INIT) && (lp->timeout < 0)) {
  1708.         lp->ibn = COMPACT;
  1709.         lp->active = 0;
  1710. gep_wr(lp->cache.gepc, dev);
  1711. lp->infoblock_media = (*p++) & COMPACT_MC;
  1712. lp->cache.gep = *p++;
  1713. csr6 = *p++;
  1714. flags = *p++;
  1716. lp->asBitValid = (flags & 0x80) ? 0 : -1;
  1717. lp->defMedium = (flags & 0x40) ? -1 : 0;
  1718. lp->asBit = 1 << ((csr6 >> 1) & 0x07);
  1719. lp->asPolarity = ((csr6 & 0x80) ? -1 : 0) & lp->asBit;
  1720. lp->infoblock_csr6 = OMR_DEF | ((csr6 & 0x71) << 18);
  1721. lp->useMII = FALSE;
  1723. de4x5_switch_mac_port(dev);
  1724.     }
  1726.     return dc21140m_autoconf(dev);
  1727. }
  1729. /*
  1730. ** This block describes non MII media for the DC21140[A] only.
  1731. */
  1732. static int 
  1733. type0_infoblock(struct net_device *dev, u_char count, u_char *p)
  1734. {
  1735.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  1736.     u_char flags, csr6, len = (*p & BLOCK_LEN)+1;
  1738.     /* Recursively figure out the info blocks */
  1739.     if (--count > lp->tcount) {
  1740. if (*(p+len) < 128) {
  1741.     return dc_infoblock[COMPACT](dev, count, p+len);
  1742. } else {
  1743.     return dc_infoblock[*(p+len+1)](dev, count, p+len);
  1744. }
  1745.     }
  1747.     if ((lp->media == INIT) && (lp->timeout < 0)) {
  1748.         lp->ibn = 0;
  1749.         lp->active = 0;
  1750.         gep_wr(lp->cache.gepc, dev);
  1751. p+=2;
  1752. lp->infoblock_media = (*p++) & BLOCK0_MC;
  1753. lp->cache.gep = *p++;
  1754. csr6 = *p++;
  1755. flags = *p++;
  1757. lp->asBitValid = (flags & 0x80) ? 0 : -1;
  1758. lp->defMedium = (flags & 0x40) ? -1 : 0;
  1759. lp->asBit = 1 << ((csr6 >> 1) & 0x07);
  1760. lp->asPolarity = ((csr6 & 0x80) ? -1 : 0) & lp->asBit;
  1761. lp->infoblock_csr6 = OMR_DEF | ((csr6 & 0x71) << 18);
  1762. lp->useMII = FALSE;
  1764. de4x5_switch_mac_port(dev);
  1765.     }
  1767.     return dc21140m_autoconf(dev);
  1768. }
  1770. /* These functions are under construction! */
  1772. static int 
  1773. type1_infoblock(struct net_device *dev, u_char count, u_char *p)
  1774. {
  1775.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  1776.     u_char len = (*p & BLOCK_LEN)+1;
  1778.     /* Recursively figure out the info blocks */
  1779.     if (--count > lp->tcount) {
  1780. if (*(p+len) < 128) {
  1781.     return dc_infoblock[COMPACT](dev, count, p+len);
  1782. } else {
  1783.     return dc_infoblock[*(p+len+1)](dev, count, p+len);
  1784. }
  1785.     }
  1787.     p += 2;
  1788.     if (lp->state == INITIALISED) {
  1789.         lp->ibn = 1;
  1790. lp->active = *p++;
  1791. lp->phy[lp->active].gep = (*p ? p : 0); p += (*p + 1);
  1792. lp->phy[lp->active].rst = (*p ? p : 0); p += (*p + 1);
  1793. lp->phy[lp->active].mc  = TWIDDLE(p); p += 2;
  1794. lp->phy[lp->active].ana = TWIDDLE(p); p += 2;
  1795. lp->phy[lp->active].fdx = TWIDDLE(p); p += 2;
  1796. lp->phy[lp->active].ttm = TWIDDLE(p);
  1797. return 0;
  1798.     } else if ((lp->media == INIT) && (lp->timeout < 0)) {
  1799.         lp->ibn = 1;
  1800.         lp->active = *p;
  1801. lp->infoblock_csr6 = OMR_MII_100;
  1802. lp->useMII = TRUE;
  1803. lp->infoblock_media = ANS;
  1805. de4x5_switch_mac_port(dev);
  1806.     }
  1808.     return dc21140m_autoconf(dev);
  1809. }
  1811. static int 
  1812. type2_infoblock(struct net_device *dev, u_char count, u_char *p)
  1813. {
  1814.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  1815.     u_char len = (*p & BLOCK_LEN)+1;
  1817.     /* Recursively figure out the info blocks */
  1818.     if (--count > lp->tcount) {
  1819. if (*(p+len) < 128) {
  1820.     return dc_infoblock[COMPACT](dev, count, p+len);
  1821. } else {
  1822.     return dc_infoblock[*(p+len+1)](dev, count, p+len);
  1823. }
  1824.     }
  1826.     if ((lp->media == INIT) && (lp->timeout < 0)) {
  1827.         lp->ibn = 2;
  1828.         lp->active = 0;
  1829. p += 2;
  1830. lp->infoblock_media = (*p) & MEDIA_CODE;
  1832.         if ((*p++) & EXT_FIELD) {
  1833.     lp->cache.csr13 = TWIDDLE(p); p += 2;
  1834.     lp->cache.csr14 = TWIDDLE(p); p += 2;
  1835.     lp->cache.csr15 = TWIDDLE(p); p += 2;
  1836. } else {
  1837.     lp->cache.csr13 = CSR13;
  1838.     lp->cache.csr14 = CSR14;
  1839.     lp->cache.csr15 = CSR15;
  1840. }
  1841.         lp->cache.gepc = ((s32)(TWIDDLE(p)) << 16); p += 2;
  1842.         lp->cache.gep  = ((s32)(TWIDDLE(p)) << 16);
  1843. lp->infoblock_csr6 = OMR_SIA;
  1844. lp->useMII = FALSE;
  1846. de4x5_switch_mac_port(dev);
  1847.     }
  1849.     return dc2114x_autoconf(dev);
  1850. }
  1852. static int 
  1853. type3_infoblock(struct net_device *dev, u_char count, u_char *p)
  1854. {
  1855.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  1856.     u_char len = (*p & BLOCK_LEN)+1;
  1858.     /* Recursively figure out the info blocks */
  1859.     if (--count > lp->tcount) {
  1860. if (*(p+len) < 128) {
  1861.     return dc_infoblock[COMPACT](dev, count, p+len);
  1862. } else {
  1863.     return dc_infoblock[*(p+len+1)](dev, count, p+len);
  1864. }
  1865.     }
  1867.     p += 2;
  1868.     if (lp->state == INITIALISED) {
  1869.         lp->ibn = 3;
  1870.         lp->active = *p++;
  1871. if (MOTO_SROM_BUG) lp->active = 0;
  1872. lp->phy[lp->active].gep = (*p ? p : 0); p += (2 * (*p) + 1);
  1873. lp->phy[lp->active].rst = (*p ? p : 0); p += (2 * (*p) + 1);
  1874. lp->phy[lp->active].mc  = TWIDDLE(p); p += 2;
  1875. lp->phy[lp->active].ana = TWIDDLE(p); p += 2;
  1876. lp->phy[lp->active].fdx = TWIDDLE(p); p += 2;
  1877. lp->phy[lp->active].ttm = TWIDDLE(p); p += 2;
  1878. lp->phy[lp->active].mci = *p;
  1879. return 0;
  1880.     } else if ((lp->media == INIT) && (lp->timeout < 0)) {
  1881.         lp->ibn = 3;
  1882. lp->active = *p;
  1883. if (MOTO_SROM_BUG) lp->active = 0;
  1884. lp->infoblock_csr6 = OMR_MII_100;
  1885. lp->useMII = TRUE;
  1886. lp->infoblock_media = ANS;
  1888. de4x5_switch_mac_port(dev);
  1889.     }
  1891.     return dc2114x_autoconf(dev);
  1892. }
  1894. static int 
  1895. type4_infoblock(struct net_device *dev, u_char count, u_char *p)
  1896. {
  1897.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  1898.     u_char flags, csr6, len = (*p & BLOCK_LEN)+1;
  1900.     /* Recursively figure out the info blocks */
  1901.     if (--count > lp->tcount) {
  1902. if (*(p+len) < 128) {
  1903.     return dc_infoblock[COMPACT](dev, count, p+len);
  1904. } else {
  1905.     return dc_infoblock[*(p+len+1)](dev, count, p+len);
  1906. }
  1907.     }
  1909.     if ((lp->media == INIT) && (lp->timeout < 0)) {
  1910.         lp->ibn = 4;
  1911.         lp->active = 0;
  1912. p+=2;
  1913. lp->infoblock_media = (*p++) & MEDIA_CODE;
  1914.         lp->cache.csr13 = CSR13;              /* Hard coded defaults */
  1915. lp->cache.csr14 = CSR14;
  1916. lp->cache.csr15 = CSR15;
  1917.         lp->cache.gepc = ((s32)(TWIDDLE(p)) << 16); p += 2;
  1918.         lp->cache.gep  = ((s32)(TWIDDLE(p)) << 16); p += 2;
  1919. csr6 = *p++;
  1920. flags = *p++;
  1922. lp->asBitValid = (flags & 0x80) ? 0 : -1;
  1923. lp->defMedium = (flags & 0x40) ? -1 : 0;
  1924. lp->asBit = 1 << ((csr6 >> 1) & 0x07);
  1925. lp->asPolarity = ((csr6 & 0x80) ? -1 : 0) & lp->asBit;
  1926. lp->infoblock_csr6 = OMR_DEF | ((csr6 & 0x71) << 18);
  1927. lp->useMII = FALSE;
  1929. de4x5_switch_mac_port(dev);
  1930.     }
  1932.     return dc2114x_autoconf(dev);
  1933. }
  1935. /*
  1936. ** This block type provides information for resetting external devices
  1937. ** (chips) through the General Purpose Register.
  1938. */
  1939. static int 
  1940. type5_infoblock(struct net_device *dev, u_char count, u_char *p)
  1941. {
  1942.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  1943.     u_char len = (*p & BLOCK_LEN)+1;
  1945.     /* Recursively figure out the info blocks */
  1946.     if (--count > lp->tcount) {
  1947. if (*(p+len) < 128) {
  1948.     return dc_infoblock[COMPACT](dev, count, p+len);
  1949. } else {
  1950.     return dc_infoblock[*(p+len+1)](dev, count, p+len);
  1951. }
  1952.     }
  1954.     /* Must be initializing to run this code */
  1955.     if ((lp->state == INITIALISED) || (lp->media == INIT)) {
  1956. p+=2;
  1957.         lp->rst = p;
  1958.         srom_exec(dev, lp->rst);
  1959.     }
  1961.     return DE4X5_AUTOSENSE_MS;
  1962. }
  1964. /*
  1965. ** MII Read/Write
  1966. */
  1968. static int
  1969. mii_rd(u_char phyreg, u_char phyaddr, u_long ioaddr)
  1970. {
  1971.     mii_wdata(MII_PREAMBLE,  2, ioaddr);   /* Start of 34 bit preamble...    */
  1972.     mii_wdata(MII_PREAMBLE, 32, ioaddr);   /* ...continued                   */
  1973.     mii_wdata(MII_STRD, 4, ioaddr);        /* SFD and Read operation         */
  1974.     mii_address(phyaddr, ioaddr);          /* PHY address to be accessed     */
  1975.     mii_address(phyreg, ioaddr);           /* PHY Register to read           */
  1976.     mii_ta(MII_STRD, ioaddr);              /* Turn around time - 2 MDC       */
  1977.     
  1978.     return mii_rdata(ioaddr);              /* Read data                      */
  1979. }
  1981. static void
  1982. mii_wr(int data, u_char phyreg, u_char phyaddr, u_long ioaddr)
  1983. {
  1984.     mii_wdata(MII_PREAMBLE,  2, ioaddr);   /* Start of 34 bit preamble...    */
  1985.     mii_wdata(MII_PREAMBLE, 32, ioaddr);   /* ...continued                   */
  1986.     mii_wdata(MII_STWR, 4, ioaddr);        /* SFD and Write operation        */
  1987.     mii_address(phyaddr, ioaddr);          /* PHY address to be accessed     */
  1988.     mii_address(phyreg, ioaddr);           /* PHY Register to write          */
  1989.     mii_ta(MII_STWR, ioaddr);              /* Turn around time - 2 MDC       */
  1990.     data = mii_swap(data, 16);             /* Swap data bit ordering         */
  1991.     mii_wdata(data, 16, ioaddr);           /* Write data                     */
  1992.     
  1993.     return;
  1994. }
  1996. static int
  1997. mii_rdata(u_long ioaddr)
  1998. {
  1999.     int i;
  2000.     s32 tmp = 0;
  2001.     
  2002.     for (i=0; i<16; i++) {
  2003. tmp <<= 1;
  2004. tmp |= getfrom_mii(MII_MRD | MII_RD, ioaddr);
  2005.     }
  2006.     
  2007.     return tmp;
  2008. }
  2010. static void
  2011. mii_wdata(int data, int len, u_long ioaddr)
  2012. {
  2013.     int i;
  2014.     
  2015.     for (i=0; i<len; i++) {
  2016. sendto_mii(MII_MWR | MII_WR, data, ioaddr);
  2017. data >>= 1;
  2018.     }
  2019.     
  2020.     return;
  2021. }
  2023. static void
  2024. mii_address(u_char addr, u_long ioaddr)
  2025. {
  2026.     int i;
  2027.     
  2028.     addr = mii_swap(addr, 5);
  2029.     for (i=0; i<5; i++) {
  2030. sendto_mii(MII_MWR | MII_WR, addr, ioaddr);
  2031. addr >>= 1;
  2032.     }
  2033.     
  2034.     return;
  2035. }
  2037. static void
  2038. mii_ta(u_long rw, u_long ioaddr)
  2039. {
  2040.     if (rw == MII_STWR) {
  2041. sendto_mii(MII_MWR | MII_WR, 1, ioaddr);  
  2042. sendto_mii(MII_MWR | MII_WR, 0, ioaddr);  
  2043.     } else {
  2044. getfrom_mii(MII_MRD | MII_RD, ioaddr);        /* Tri-state MDIO */
  2045.     }
  2046.     
  2047.     return;
  2048. }
  2050. static int
  2051. mii_swap(int data, int len)
  2052. {
  2053.     int i, tmp = 0;
  2054.     
  2055.     for (i=0; i<len; i++) {
  2056. tmp <<= 1;
  2057. tmp |= (data & 1);
  2058. data >>= 1;
  2059.     }
  2060.     
  2061.     return tmp;
  2062. }
  2064. static void
  2065. sendto_mii(u32 command, int data, u_long ioaddr)
  2066. {
  2067.     u32 j;
  2068.     
  2069.     j = (data & 1) << 17;
  2070.     outl(command | j, ioaddr);
  2071.     udelay(1);
  2072.     outl(command | MII_MDC | j, ioaddr);
  2073.     udelay(1);
  2074.     
  2075.     return;
  2076. }
  2078. static int
  2079. getfrom_mii(u32 command, u_long ioaddr)
  2080. {
  2081.     outl(command, ioaddr);
  2082.     udelay(1);
  2083.     outl(command | MII_MDC, ioaddr);
  2084.     udelay(1);
  2085.     
  2086.     return ((inl(ioaddr) >> 19) & 1);
  2087. }
  2089. /*
  2090. ** Here's 3 ways to calculate the OUI from the ID registers.
  2091. */
  2092. static int
  2093. mii_get_oui(u_char phyaddr, u_long ioaddr)
  2094. {
  2095. /*
  2096.     union {
  2097. u_short reg;
  2098. u_char breg[2];
  2099.     } a;
  2100.     int i, r2, r3, ret=0;*/
  2101.     int r2, r3;
  2103.     /* Read r2 and r3 */
  2104.     r2 = mii_rd(MII_ID0, phyaddr, ioaddr);
  2105.     r3 = mii_rd(MII_ID1, phyaddr, ioaddr);
  2106.                                                 /* SEEQ and Cypress way * /
  2107.     / * Shuffle r2 and r3 * /
  2108.     a.reg=0;
  2109.     r3 = ((r3>>10)|(r2<<6))&0x0ff;
  2110.     r2 = ((r2>>2)&0x3fff);
  2112.     / * Bit reverse r3 * /
  2113.     for (i=0;i<8;i++) {
  2114. ret<<=1;
  2115. ret |= (r3&1);
  2116. r3>>=1;
  2117.     }
  2119.     / * Bit reverse r2 * /
  2120.     for (i=0;i<16;i++) {
  2121. a.reg<<=1;
  2122. a.reg |= (r2&1);
  2123. r2>>=1;
  2124.     }
  2126.     / * Swap r2 bytes * /
  2127.     i=a.breg[0];
  2128.     a.breg[0]=a.breg[1];
  2129.     a.breg[1]=i;
  2131.     return ((a.reg<<8)|ret); */                 /* SEEQ and Cypress way */
  2132. /*    return ((r2<<6)|(u_int)(r3>>10)); */      /* NATIONAL and BROADCOM way */
  2133.     return r2;                                  /* (I did it) My way */
  2134. }
  2136. /*
  2137. ** The SROM spec forces us to search addresses [1-31 0]. Bummer.
  2138. */
  2139. static int
  2140. mii_get_phy(struct net_device *dev)
  2141. {
  2142.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  2143.     u_long iobase = dev->base_addr;
  2144.     int i, j, k, n, limit=sizeof(phy_info)/sizeof(struct phy_table);
  2145.     int id;
  2146.     
  2147.     lp->active = 0;
  2148.     lp->useMII = TRUE;
  2150.     /* Search the MII address space for possible PHY devices */
  2151.     for (n=0, lp->mii_cnt=0, i=1; !((i==1) && (n==1)); i=(++i)%DE4X5_MAX_MII) {
  2152. lp->phy[lp->active].addr = i;
  2153. if (i==0) n++;                             /* Count cycles */
  2154. while (de4x5_reset_phy(dev)<0) udelay(100);/* Wait for reset */
  2155. id = mii_get_oui(i, DE4X5_MII); 
  2156. if ((id == 0) || (id == 65535)) continue;  /* Valid ID? */
  2157. for (j=0; j<limit; j++) {                  /* Search PHY table */
  2158.     if (id != phy_info[j].id) continue;    /* ID match? */
  2159.     for (k=0; lp->phy[k].id && (k < DE4X5_MAX_PHY); k++);
  2160.     if (k < DE4X5_MAX_PHY) {
  2161. memcpy((char *)&lp->phy[k],
  2162.        (char *)&phy_info[j], sizeof(struct phy_table));
  2163. lp->phy[k].addr = i;
  2164. lp->mii_cnt++;
  2165. lp->active++;
  2166.     } else {
  2167. goto purgatory;                    /* Stop the search */
  2168.     }
  2169.     break;
  2170. }
  2171. if ((j == limit) && (i < DE4X5_MAX_MII)) {
  2172.     for (k=0; lp->phy[k].id && (k < DE4X5_MAX_PHY); k++);
  2173.     lp->phy[k].addr = i;
  2174.     lp->phy[k].id = id;
  2175.     lp->phy[k].spd.reg = GENERIC_REG;      /* ANLPA register         */
  2176.     lp->phy[k].spd.mask = GENERIC_MASK;    /* 100Mb/s technologies   */
  2177.     lp->phy[k].spd.value = GENERIC_VALUE;  /* TX & T4, H/F Duplex    */
  2178.     lp->mii_cnt++;
  2179.     lp->active++;
  2180.     printk("%s: Using generic MII device control. If the board doesn't operate, nplease mail the following dump to the author:n", dev->name);
  2181.     j = de4x5_debug;
  2182.     de4x5_debug |= DEBUG_MII;
  2183.     de4x5_dbg_mii(dev, k);
  2184.     de4x5_debug = j;
  2185.     printk("n");
  2186. }
  2187.     }
  2188.   purgatory:
  2189.     lp->active = 0;
  2190.     if (lp->phy[0].id) {                           /* Reset the PHY devices */
  2191. for (k=0; lp->phy[k].id && (k < DE4X5_MAX_PHY); k++) { /*For each PHY*/
  2192.     mii_wr(MII_CR_RST, MII_CR, lp->phy[k].addr, DE4X5_MII);
  2193.     while (mii_rd(MII_CR, lp->phy[k].addr, DE4X5_MII) & MII_CR_RST);
  2194.     
  2195.     de4x5_dbg_mii(dev, k);
  2196. }
  2197.     }
  2198.     if (!lp->mii_cnt) lp->useMII = FALSE;
  2200.     return lp->mii_cnt;
  2201. }
  2203. static char *
  2204. build_setup_frame(struct net_device *dev, int mode)
  2205. {
  2206.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  2207.     int i;
  2208.     char *pa = lp->setup_frame;
  2209.     
  2210.     /* Initialise the setup frame */
  2211.     if (mode == ALL) {
  2212. memset(lp->setup_frame, 0, SETUP_FRAME_LEN);
  2213.     }
  2214.     
  2215.     if (lp->setup_f == HASH_PERF) {
  2216. for (pa=lp->setup_frame+IMPERF_PA_OFFSET, i=0; i<ETH_ALEN; i++) {
  2217.     *(pa + i) = dev->dev_addr[i];                 /* Host address */
  2218.     if (i & 0x01) pa += 2;
  2219. }
  2220. *(lp->setup_frame + (HASH_TABLE_LEN >> 3) - 3) = 0x80;
  2221.     } else {
  2222. for (i=0; i<ETH_ALEN; i++) { /* Host address */
  2223.     *(pa + (i&1)) = dev->dev_addr[i];
  2224.     if (i & 0x01) pa += 4;
  2225. }
  2226. for (i=0; i<ETH_ALEN; i++) { /* Broadcast address */
  2227.     *(pa + (i&1)) = (char) 0xff;
  2228.     if (i & 0x01) pa += 4;
  2229. }
  2230.     }
  2231.     
  2232.     return pa;                     /* Points to the next entry */
  2233. }
  2235. static void
  2236. enable_ast(struct net_device *dev, u32 time_out)
  2237. {
  2238.     timeout(dev, (void *)&de4x5_ast, (u_long)dev, time_out);
  2239.     
  2240.     return;
  2241. }
  2243. static void
  2244. disable_ast(struct net_device *dev)
  2245. {
  2246.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  2247.     
  2248.     del_timer(&lp->timer);
  2249.     
  2250.     return;
  2251. }
  2253. static long
  2254. de4x5_switch_mac_port(struct net_device *dev)
  2255. {
  2256.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  2257.     u_long iobase = dev->base_addr;
  2258.     s32 omr;
  2260.     STOP_DE4X5;
  2262.     /* Assert the OMR_PS bit in CSR6 */
  2263.     omr = (inl(DE4X5_OMR) & ~(OMR_PS | OMR_HBD | OMR_TTM | OMR_PCS | OMR_SCR |
  2264.                                              OMR_FDX));
  2265.     omr |= lp->infoblock_csr6;
  2266.     if (omr & OMR_PS) omr |= OMR_HBD;
  2267.     outl(omr, DE4X5_OMR);
  2268.     
  2269.     /* Soft Reset */
  2270.     RESET_DE4X5;
  2271.     
  2272.     /* Restore the GEP - especially for COMPACT and Type 0 Infoblocks */
  2273.     if (lp->chipset == DC21140) {
  2274. gep_wr(lp->cache.gepc, dev);
  2275. gep_wr(lp->cache.gep, dev);
  2276.     } else if ((lp->chipset & ~0x0ff) == DC2114x) {
  2277. reset_init_sia(dev, lp->cache.csr13, lp->cache.csr14, lp->cache.csr15);
  2278.     }
  2280.     /* Restore CSR6 */
  2281.     outl(omr, DE4X5_OMR);
  2283.     /* Reset CSR8 */
  2284.     inl(DE4X5_MFC);
  2286.     return omr;
  2287. }
  2289. static void
  2290. gep_wr(s32 data, struct net_device *dev)
  2291. {
  2292.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  2293.     u_long iobase = dev->base_addr;
  2295.     if (lp->chipset == DC21140) {
  2296. outl(data, DE4X5_GEP);
  2297.     } else if ((lp->chipset & ~0x00ff) == DC2114x) {
  2298. outl((data<<16) | lp->cache.csr15, DE4X5_SIGR);
  2299.     }
  2301.     return;
  2302. }
  2304. static int
  2305. gep_rd(struct net_device *dev)
  2306. {
  2307.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  2308.     u_long iobase = dev->base_addr;
  2310.     if (lp->chipset == DC21140) {
  2311. return inl(DE4X5_GEP);
  2312.     } else if ((lp->chipset & ~0x00ff) == DC2114x) {
  2313. return (inl(DE4X5_SIGR) & 0x000fffff);
  2314.     }
  2316.     return 0;
  2317. }
  2319. static void
  2320. timeout(struct net_device *dev, void (*fn)(u_long data), u_long data, u_long msec)
  2321. {
  2322.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  2323.     int dt;
  2324.     
  2325.     /* First, cancel any pending timer events */
  2326.     del_timer(&lp->timer);
  2327.     
  2328.     /* Convert msec to ticks */
  2329.     dt = (msec * HZ) / 1000;
  2330.     if (dt==0) dt=1;
  2331.     
  2332.     /* Set up timer */
  2333.     lp->timer.expires = jiffies + dt;
  2334.     lp->timer.function = fn;
  2335.     lp->timer.data = data;
  2336.     add_timer(&lp->timer);
  2337.     
  2338.     return;
  2339. }
  2341. static void
  2342. yawn(struct net_device *dev, int state)
  2343. {
  2344.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  2345.     u_long iobase = dev->base_addr;
  2347.     if ((lp->chipset == DC21040) || (lp->chipset == DC21140)) return;
  2349.     if(lp->bus == EISA) {
  2350. switch(state) {
  2351.   case WAKEUP:
  2352.     outb(WAKEUP, PCI_CFPM);
  2353.     mdelay(10);
  2354.     break;
  2356.   case SNOOZE:
  2357.     outb(SNOOZE, PCI_CFPM);
  2358.     break;
  2360.   case SLEEP:
  2361.     outl(0, DE4X5_SICR);
  2362.     outb(SLEEP, PCI_CFPM);
  2363.     break;
  2364. }
  2365.     } else {
  2366. switch(state) {
  2367.   case WAKEUP:
  2368.     pcibios_write_config_byte(lp->bus_num, lp->device << 3, 
  2369.       PCI_CFDA_PSM, WAKEUP);
  2370.     mdelay(10);
  2371.     break;
  2373.   case SNOOZE:
  2374.     pcibios_write_config_byte(lp->bus_num, lp->device << 3, 
  2375.       PCI_CFDA_PSM, SNOOZE);
  2376.     break;
  2378.   case SLEEP:
  2379.     outl(0, DE4X5_SICR);
  2380.     pcibios_write_config_byte(lp->bus_num, lp->device << 3, 
  2381.       PCI_CFDA_PSM, SLEEP);
  2382.     break;
  2383. }
  2384.     }
  2386.     return;
  2387. }
  2389. static void
  2390. de4x5_parse_params(struct net_device *dev)
  2391. {
  2392.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  2393.     char *p, *q, t;
  2395.     lp->params.fdx = 0;
  2396.     lp->params.autosense = AUTO;
  2398.     if (args == NULL) return;
  2400.     if ((p = strstr(args, dev->name))) {
  2401. if (!(q = strstr(p+strlen(dev->name), "eth"))) q = p + strlen(p);
  2402. t = *q;
  2403. *q = '';
  2405. #if !defined(__sparc_v9__) && !defined(__powerpc__) && !defined(__alpha__)
  2406. if (strstr(p, "force_eisa") || strstr(p, "FORCE_EISA")) forceEISA = 1;
  2407. #endif
  2408. if (strstr(p, "fdx") || strstr(p, "FDX")) lp->params.fdx = 1;
  2410. if (strstr(p, "autosense") || strstr(p, "AUTOSENSE")) {
  2411.     if (strstr(p, "TP")) {
  2412. lp->params.autosense = TP;
  2413.     } else if (strstr(p, "TP_NW")) {
  2414. lp->params.autosense = TP_NW;
  2415.     } else if (strstr(p, "BNC")) {
  2416. lp->params.autosense = BNC;
  2417.     } else if (strstr(p, "AUI")) {
  2418. lp->params.autosense = AUI;
  2419.     } else if (strstr(p, "BNC_AUI")) {
  2420. lp->params.autosense = BNC;
  2421.     } else if (strstr(p, "10Mb")) {
  2422. lp->params.autosense = _10Mb;
  2423.     } else if (strstr(p, "100Mb")) {
  2424. lp->params.autosense = _100Mb;
  2425.     } else if (strstr(p, "AUTO")) {
  2426. lp->params.autosense = AUTO;
  2427.     }
  2428. }
  2429. *q = t;
  2430.     }
  2432.     return;
  2433. }
  2435. static void
  2436. de4x5_dbg_open(struct net_device *dev)
  2437. {
  2438.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  2439.     int i;
  2440.     
  2441.     if (de4x5_debug & DEBUG_OPEN) {
  2442. printk("%s: de4x5 opening with irq %dn",dev->name,dev->irq);
  2443. printk("tphysical address: ");
  2444. for (i=0;i<6;i++) {
  2445.     printk("%2.2x:",(short)dev->dev_addr[i]);
  2446. }
  2447. printk("n");
  2448. printk("Descriptor head addresses:n");
  2449. printk("t0x%8.8lx  0x%8.8lxn",(u_long)lp->rx_ring,(u_long)lp->tx_ring);
  2450. printk("Descriptor addresses:nRX: ");
  2451. for (i=0;i<lp->rxRingSize-1;i++){
  2452.     if (i < 3) {
  2453. printk("0x%8.8lx  ",(u_long)&lp->rx_ring[i].status);
  2454.     }
  2455. }
  2456. printk("...0x%8.8lxn",(u_long)&lp->rx_ring[i].status);
  2457. printk("TX: ");
  2458. for (i=0;i<lp->txRingSize-1;i++){
  2459.     if (i < 3) {
  2460. printk("0x%8.8lx  ", (u_long)&lp->tx_ring[i].status);
  2461.     }
  2462. }
  2463. printk("...0x%8.8lxn", (u_long)&lp->tx_ring[i].status);
  2464. printk("Descriptor buffers:nRX: ");
  2465. for (i=0;i<lp->rxRingSize-1;i++){
  2466.     if (i < 3) {
  2467. printk("0x%8.8x  ",le32_to_cpu(lp->rx_ring[i].buf));
  2468.     }
  2469. }
  2470. printk("...0x%8.8xn",le32_to_cpu(lp->rx_ring[i].buf));
  2471. printk("TX: ");
  2472. for (i=0;i<lp->txRingSize-1;i++){
  2473.     if (i < 3) {
  2474. printk("0x%8.8x  ", le32_to_cpu(lp->tx_ring[i].buf));
  2475.     }
  2476. }
  2477. printk("...0x%8.8xn", le32_to_cpu(lp->tx_ring[i].buf));
  2478. printk("Ring size: nRX: %dnTX: %dn", 
  2479.        (short)lp->rxRingSize, 
  2480.        (short)lp->txRingSize); 
  2481.     }
  2482.     
  2483.     return;
  2484. }
  2486. static void
  2487. de4x5_dbg_mii(struct net_device *dev, int k)
  2488. {
  2489.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  2490.     u_long iobase = dev->base_addr;
  2491.     
  2492.     if (de4x5_debug & DEBUG_MII) {
  2493. printk("nMII device address: %dn", lp->phy[k].addr);
  2494. printk("MII CR:  %xn",mii_rd(MII_CR,lp->phy[k].addr,DE4X5_MII));
  2495. printk("MII SR:  %xn",mii_rd(MII_SR,lp->phy[k].addr,DE4X5_MII));
  2496. printk("MII ID0: %xn",mii_rd(MII_ID0,lp->phy[k].addr,DE4X5_MII));
  2497. printk("MII ID1: %xn",mii_rd(MII_ID1,lp->phy[k].addr,DE4X5_MII));
  2498. if (lp->phy[k].id != BROADCOM_T4) {
  2499.     printk("MII ANA: %xn",mii_rd(0x04,lp->phy[k].addr,DE4X5_MII));
  2500.     printk("MII ANC: %xn",mii_rd(0x05,lp->phy[k].addr,DE4X5_MII));
  2501. }
  2502. printk("MII 16:  %xn",mii_rd(0x10,lp->phy[k].addr,DE4X5_MII));
  2503. if (lp->phy[k].id != BROADCOM_T4) {
  2504.     printk("MII 17:  %xn",mii_rd(0x11,lp->phy[k].addr,DE4X5_MII));
  2505.     printk("MII 18:  %xn",mii_rd(0x12,lp->phy[k].addr,DE4X5_MII));
  2506. } else {
  2507.     printk("MII 20:  %xn",mii_rd(0x14,lp->phy[k].addr,DE4X5_MII));
  2508. }
  2509.     }
  2510.     
  2511.     return;
  2512. }
  2514. static void
  2515. de4x5_dbg_media(struct net_device *dev)
  2516. {
  2517.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  2518.     
  2519.     if (lp->media != lp->c_media) {
  2520. if (de4x5_debug & DEBUG_MEDIA) {
  2521.     printk("%s: media is %s%sn", dev->name,
  2522.    (lp->media == NC  ? "unconnected, link down or incompatible connection" :
  2523.     (lp->media == TP  ? "TP" :
  2524.      (lp->media == ANS ? "TP/Nway" :
  2525.       (lp->media == BNC ? "BNC" : 
  2526.        (lp->media == AUI ? "AUI" : 
  2527. (lp->media == BNC_AUI ? "BNC/AUI" : 
  2528.  (lp->media == EXT_SIA ? "EXT SIA" : 
  2529.   (lp->media == _100Mb  ? "100Mb/s" :
  2530.    (lp->media == _10Mb   ? "10Mb/s" :
  2531.     "???"
  2532.     ))))))))), (lp->fdx?" full duplex.":"."));
  2533. }
  2534. lp->c_media = lp->media;
  2535.     }
  2536.     
  2537.     return;
  2538. }
  2540. static void
  2541. de4x5_dbg_srom(struct de4x5_srom *p)
  2542. {
  2543.     int i;
  2545.     if (de4x5_debug & DEBUG_SROM) {
  2546. printk("Sub-system Vendor ID: %04xn", *((u_short *)p->sub_vendor_id));
  2547. printk("Sub-system ID:        %04xn", *((u_short *)p->sub_system_id));
  2548. printk("ID Block CRC:         %02xn", (u_char)(p->id_block_crc));
  2549. printk("SROM version:         %02xn", (u_char)(p->version));
  2550. printk("# controllers:         %02xn", (u_char)(p->num_controllers));
  2552. printk("Hardware Address:     ");
  2553. for (i=0;i<ETH_ALEN-1;i++) {
  2554.     printk("%02x:", (u_char)*(p->ieee_addr+i));
  2555. }
  2556. printk("%02xn", (u_char)*(p->ieee_addr+i));
  2557. printk("CRC checksum:         %04xn", (u_short)(p->chksum));
  2558. for (i=0; i<64; i++) {
  2559.     printk("%3d %04xn", i<<1, (u_short)*((u_short *)p+i));
  2560. }
  2561.     }
  2563.     return;
  2564. }
  2566. static void
  2567. de4x5_dbg_rx(struct sk_buff *skb, int len)
  2568. {
  2569.     int i, j;
  2571.     if (de4x5_debug & DEBUG_RX) {
  2572. printk("R: %02x:%02x:%02x:%02x:%02x:%02x <- %02x:%02x:%02x:%02x:%02x:%02x len/SAP:%02x%02x [%d]n",
  2573.        (u_char)skb->data[0],
  2574.        (u_char)skb->data[1],
  2575.        (u_char)skb->data[2],
  2576.        (u_char)skb->data[3],
  2577.        (u_char)skb->data[4],
  2578.        (u_char)skb->data[5],
  2579.        (u_char)skb->data[6],
  2580.        (u_char)skb->data[7],
  2581.        (u_char)skb->data[8],
  2582.        (u_char)skb->data[9],
  2583.        (u_char)skb->data[10],
  2584.        (u_char)skb->data[11],
  2585.        (u_char)skb->data[12],
  2586.        (u_char)skb->data[13],
  2587.        len);
  2588. for (j=0; len>0;j+=16, len-=16) {
  2589.   printk("    %03x: ",j);
  2590.   for (i=0; i<16 && i<len; i++) {
  2591.     printk("%02x ",(u_char)skb->data[i+j]);
  2592.   }
  2593.   printk("n");
  2594. }
  2595.     }
  2597.     return;
  2598. }
  2600. /*
  2601. ** Perform IOCTL call functions here. Some are privileged operations and the
  2602. ** effective uid is checked in those cases. In the normal course of events
  2603. ** this function is only used for my testing.
  2604. */
  2605. static int
  2606. de4x5_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  2607. {
  2608.     struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
  2609.     struct de4x5_ioctl *ioc = (struct de4x5_ioctl *) &rq->ifr_data;
  2610.     u_long iobase = dev->base_addr;
  2611.     int i, j, status = 0;
  2612.     s32 omr;
  2613.     union {
  2614. u8  addr[144];
  2615. u16 sval[72];
  2616. u32 lval[36];
  2617.     } tmp;
  2618.     u_long flags = 0;
  2619.     
  2620.     switch(ioc->cmd) {
  2621.     case DE4X5_GET_HWADDR:           /* Get the hardware address */
  2622. ioc->len = ETH_ALEN;
  2623. for (i=0; i<ETH_ALEN; i++) {
  2624.     tmp.addr[i] = dev->dev_addr[i];
  2625. }
  2626. if (copy_to_user(ioc->data, tmp.addr, ioc->len)) return -EFAULT;
  2627. break;
  2629.     case DE4X5_SET_HWADDR:           /* Set the hardware address */
  2630. if (!capable(CAP_NET_ADMIN)) return -EPERM;
  2631. if (copy_from_user(tmp.addr, ioc->data, ETH_ALEN)) return -EFAULT;
  2632. if (netif_queue_stopped(dev))
  2633. return -EBUSY;
  2634. netif_stop_queue(dev);
  2635. for (i=0; i<ETH_ALEN; i++) {
  2636.     dev->dev_addr[i] = tmp.addr[i];
  2637. }
  2638. build_setup_frame(dev, PHYS_ADDR_ONLY);
  2639. /* Set up the descriptor and give ownership to the card */
  2640. load_packet(dev, lp->setup_frame, TD_IC | PERFECT_F | TD_SET | 
  2641.                                        SETUP_FRAME_LEN, (struct sk_buff *)1);
  2642. lp->tx_new = (++lp->tx_new) % lp->txRingSize;
  2643. outl(POLL_DEMAND, DE4X5_TPD);                /* Start the TX */
  2644. netif_wake_queue(dev);                      /* Unlock the TX ring */
  2645. break;
  2647.     case DE4X5_SET_PROM:             /* Set Promiscuous Mode */
  2648. if (!capable(CAP_NET_ADMIN)) return -EPERM;
  2649. omr = inl(DE4X5_OMR);
  2650. omr |= OMR_PR;
  2651. outl(omr, DE4X5_OMR);
  2652. dev->flags |= IFF_PROMISC;
  2653. break;
  2655.     case DE4X5_CLR_PROM:             /* Clear Promiscuous Mode */
  2656. if (!capable(CAP_NET_ADMIN)) return -EPERM;
  2657. omr = inl(DE4X5_OMR);
  2658. omr &= ~OMR_PR;
  2659. outl(omr, DE4X5_OMR);
  2660. dev->flags &= ~IFF_PROMISC;
  2661. break;
  2663.     case DE4X5_SAY_BOO:              /* Say "Boo!" to the kernel log file */
  2664. if (!capable(CAP_NET_ADMIN)) return -EPERM;
  2665. printk("%s: Boo!n", dev->name);
  2666. break;
  2668.     case DE4X5_MCA_EN:               /* Enable pass all multicast addressing */
  2669. if (!capable(CAP_NET_ADMIN)) return -EPERM;
  2670. omr = inl(DE4X5_OMR);
  2671. omr |= OMR_PM;
  2672. outl(omr, DE4X5_OMR);
  2673. break;
  2675.     case DE4X5_GET_STATS:            /* Get the driver statistics */
  2676.     {
  2677.         struct pkt_stats statbuf;
  2678. ioc->len = sizeof(statbuf);
  2679. spin_lock_irqsave(&lp->lock, flags);
  2680. memcpy(&statbuf, &lp->pktStats, ioc->len);
  2681. spin_unlock_irqrestore(&lp->lock, flags);
  2682. if (copy_to_user(ioc->data, &statbuf, ioc->len)) 
  2683. return -EFAULT; 
  2684. break;
  2685.     }
  2686.     case DE4X5_CLR_STATS:            /* Zero out the driver statistics */
  2687. if (!capable(CAP_NET_ADMIN)) return -EPERM;
  2688. spin_lock_irqsave(&lp->lock, flags);
  2689. memset(&lp->pktStats, 0, sizeof(lp->pktStats));
  2690. spin_unlock_irqrestore(&lp->lock, flags);
  2691. break;
  2693.     case DE4X5_GET_OMR:              /* Get the OMR Register contents */
  2694. tmp.addr[0] = inl(DE4X5_OMR);
  2695. if (copy_to_user(ioc->data, tmp.addr, 1)) return -EFAULT;
  2696. break;
  2698.     case DE4X5_SET_OMR:              /* Set the OMR Register contents */
  2699. if (!capable(CAP_NET_ADMIN)) return -EPERM;
  2700. if (copy_from_user(tmp.addr, ioc->data, 1)) return -EFAULT;
  2701. outl(tmp.addr[0], DE4X5_OMR);
  2702. break;
  2704.     case DE4X5_GET_REG:              /* Get the DE4X5 Registers */
  2705. j = 0;
  2706. tmp.lval[0] = inl(DE4X5_STS); j+=4;
  2707. tmp.lval[1] = inl(DE4X5_BMR); j+=4;
  2708. tmp.lval[2] = inl(DE4X5_IMR); j+=4;
  2709. tmp.lval[3] = inl(DE4X5_OMR); j+=4;
  2710. tmp.lval[4] = inl(DE4X5_SISR); j+=4;
  2711. tmp.lval[5] = inl(DE4X5_SICR); j+=4;
  2712. tmp.lval[6] = inl(DE4X5_STRR); j+=4;
  2713. tmp.lval[7] = inl(DE4X5_SIGR); j+=4;
  2714. ioc->len = j;
  2715. if (copy_to_user(ioc->data, tmp.addr, ioc->len)) return -EFAULT;
  2716. break;
  2718. #define DE4X5_DUMP              0x0f /* Dump the DE4X5 Status */
  2719. /*
  2720.       case DE4X5_DUMP:
  2721. j = 0;
  2722. tmp.addr[j++] = dev->irq;
  2723. for (i=0; i<ETH_ALEN; i++) {
  2724.     tmp.addr[j++] = dev->dev_addr[i];
  2725. }
  2726. tmp.addr[j++] = lp->rxRingSize;
  2727. tmp.lval[j>>2] = (long)lp->rx_ring; j+=4;
  2728. tmp.lval[j>>2] = (long)lp->tx_ring; j+=4;
  2730. for (i=0;i<lp->rxRingSize-1;i++){
  2731.     if (i < 3) {
  2732. tmp.lval[j>>2] = (long)&lp->rx_ring[i].status; j+=4;
  2733.     }
  2734. }
  2735. tmp.lval[j>>2] = (long)&lp->rx_ring[i].status; j+=4;
  2736. for (i=0;i<lp->txRingSize-1;i++){
  2737.     if (i < 3) {
  2738. tmp.lval[j>>2] = (long)&lp->tx_ring[i].status; j+=4;
  2739.     }
  2740. }
  2741. tmp.lval[j>>2] = (long)&lp->tx_ring[i].status; j+=4;
  2743. for (i=0;i<lp->rxRingSize-1;i++){
  2744.     if (i < 3) {
  2745. tmp.lval[j>>2] = (s32)le32_to_cpu(lp->rx_ring[i].buf); j+=4;
  2746.     }
  2747. }
  2748. tmp.lval[j>>2] = (s32)le32_to_cpu(lp->rx_ring[i].buf); j+=4;
  2749. for (i=0;i<lp->txRingSize-1;i++){
  2750.     if (i < 3) {
  2751. tmp.lval[j>>2] = (s32)le32_to_cpu(lp->tx_ring[i].buf); j+=4;
  2752.     }
  2753. }
  2754. tmp.lval[j>>2] = (s32)le32_to_cpu(lp->tx_ring[i].buf); j+=4;
  2756. for (i=0;i<lp->rxRingSize;i++){
  2757.     tmp.lval[j>>2] = le32_to_cpu(lp->rx_ring[i].status); j+=4;
  2758. }
  2759. for (i=0;i<lp->txRingSize;i++){
  2760.     tmp.lval[j>>2] = le32_to_cpu(lp->tx_ring[i].status); j+=4;
  2761. }
  2763. tmp.lval[j>>2] = inl(DE4X5_BMR);  j+=4;
  2764. tmp.lval[j>>2] = inl(DE4X5_TPD);  j+=4;
  2765. tmp.lval[j>>2] = inl(DE4X5_RPD);  j+=4;
  2766. tmp.lval[j>>2] = inl(DE4X5_RRBA); j+=4;
  2767. tmp.lval[j>>2] = inl(DE4X5_TRBA); j+=4;
  2768. tmp.lval[j>>2] = inl(DE4X5_STS);  j+=4;
  2769. tmp.lval[j>>2] = inl(DE4X5_OMR);  j+=4;
  2770. tmp.lval[j>>2] = inl(DE4X5_IMR);  j+=4;
  2771. tmp.lval[j>>2] = lp->chipset; j+=4; 
  2772. if (lp->chipset == DC21140) {
  2773.     tmp.lval[j>>2] = gep_rd(dev);  j+=4;
  2774. } else {
  2775.     tmp.lval[j>>2] = inl(DE4X5_SISR); j+=4;
  2776.     tmp.lval[j>>2] = inl(DE4X5_SICR); j+=4;
  2777.     tmp.lval[j>>2] = inl(DE4X5_STRR); j+=4;
  2778.     tmp.lval[j>>2] = inl(DE4X5_SIGR); j+=4; 
  2779. }
  2780. tmp.lval[j>>2] = lp->phy[lp->active].id; j+=4; 
  2781. if (lp->phy[lp->active].id && (!lp->useSROM || lp->useMII)) {
  2782.     tmp.lval[j>>2] = lp->active; j+=4; 
  2783.     tmp.lval[j>>2]=mii_rd(MII_CR,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
  2784.     tmp.lval[j>>2]=mii_rd(MII_SR,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
  2785.     tmp.lval[j>>2]=mii_rd(MII_ID0,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
  2786.     tmp.lval[j>>2]=mii_rd(MII_ID1,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
  2787.     if (lp->phy[lp->active].id != BROADCOM_T4) {
  2788. tmp.lval[j>>2]=mii_rd(MII_ANA,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
  2789. tmp.lval[j>>2]=mii_rd(MII_ANLPA,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
  2790.     }
  2791.     tmp.lval[j>>2]=mii_rd(0x10,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
  2792.     if (lp->phy[lp->active].id != BROADCOM_T4) {
  2793. tmp.lval[j>>2]=mii_rd(0x11,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
  2794. tmp.lval[j>>2]=mii_rd(0x12,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
  2795.     } else {
  2796. tmp.lval[j>>2]=mii_rd(0x14,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
  2797.     }
  2798. }
  2800. tmp.addr[j++] = lp->txRingSize;
  2801. tmp.addr[j++] = netif_queue_stopped(dev);
  2803. ioc->len = j;
  2804. if (copy_to_user(ioc->data, tmp.addr, ioc->len)) return -EFAULT;
  2805. break;
  2807. */
  2808.     default:
  2809. return -EOPNOTSUPP;
  2810.     }
  2811.     
  2812.     return status;
  2813. }
  2815. #ifdef MODULE
  2816. /*
  2817. ** Note now that module autoprobing is allowed under EISA and PCI. The
  2818. ** IRQ lines will not be auto-detected; instead I'll rely on the BIOSes
  2819. ** to "do the right thing".
  2820. */
  2821. #define LP(a) ((struct de4x5_private *)(a))
  2822. static struct net_device *mdev = NULL;
  2823. static int io=0x0;/* EDIT THIS LINE FOR YOUR CONFIGURATION IF NEEDED        */
  2824. MODULE_PARM(io, "i");
  2825. MODULE_PARM_DESC(io, "de4x5 I/O base address");
  2827. int
  2828. init_module(void)
  2829. {
  2830.     int i, num, status = -EIO;
  2831.     struct net_device *p;
  2833.     num = count_adapters();
  2835.     for (i=0; i<num; i++) {
  2836. if ((p = insert_device(NULL, io, de4x5_probe)) == NULL) 
  2837.     return -ENOMEM;
  2839. if (!mdev) mdev = p;
  2841. if (register_netdev(p) != 0) {
  2842.     struct de4x5_private *lp = (struct de4x5_private *)p->priv;
  2843.     if (lp) {
  2844. release_region(p->base_addr, (lp->bus == PCI ? 
  2845.       DE4X5_PCI_TOTAL_SIZE :
  2846.       DE4X5_EISA_TOTAL_SIZE));
  2847. if (lp->cache.priv) {       /* Private area allocated?   */
  2848.     kfree(lp->cache.priv);  /* Free the private area     */
  2849. }
  2850. if (lp->rx_ring) {
  2851.     pci_free_consistent(lp->pdev, lp->dma_size, lp->rx_ring,
  2852. lp->dma_rings);
  2853. }
  2854.     }
  2855.     kfree(p);
  2856. } else {
  2857.     status = 0;                 /* At least one adapter will work */
  2858.     lastModule = p;
  2859. }
  2860.     }
  2862.     return status;
  2863. }
  2865. void
  2866. cleanup_module(void)
  2867. {
  2868.     while (mdev != NULL) {
  2869. mdev = unlink_modules(mdev);
  2870.     }
  2872.     return;
  2873. }
  2875. static struct net_device *
  2876. unlink_modules(struct net_device *p)
  2877. {
  2878.     struct net_device *next = NULL;
  2880.     if (p->priv) {                          /* Private areas allocated?  */
  2881. struct de4x5_private *lp = (struct de4x5_private *)p->priv;
  2883. next = lp->next_module;
  2884. if (lp->rx_ring) {
  2885. pci_free_consistent(lp->pdev, lp->dma_size, lp->rx_ring,
  2886.     lp->dma_rings);
  2887. }
  2888. release_region(p->base_addr, (lp->bus == PCI ? 
  2889.       DE4X5_PCI_TOTAL_SIZE :
  2890.       DE4X5_EISA_TOTAL_SIZE));
  2891. kfree(lp->cache.priv);              /* Free the private area     */
  2892.     }
  2893.     unregister_netdev(p);
  2894.     kfree(p);                               /* Free the device structure */
  2895.     
  2896.     return next;
  2897. }
  2899. static int
  2900. count_adapters(void)
  2901. {
  2902.     int i, j=0;
  2903.     u_short vendor;
  2904.     u_int class = DE4X5_CLASS_CODE;
  2905.     u_int device;
  2907. #if !defined(__sparc_v9__) && !defined(__powerpc__) && !defined(__alpha__)
  2908.     char name[DE4X5_STRLEN];
  2909.     u_long iobase = 0x1000;
  2911.     for (i=1; i<MAX_EISA_SLOTS; i++, iobase+=EISA_SLOT_INC) {
  2912. if (EISA_signature(name, EISA_ID)) j++;
  2913.     }
  2914. #endif
  2915.     if (!pcibios_present()) return j;
  2917.     for (i=0; (pdev=pci_find_class(class, pdev))!= NULL; i++) {
  2918. vendor = pdev->vendor;
  2919. device = pdev->device << 8;
  2920. if (is_DC21040 || is_DC21041 || is_DC21140 || is_DC2114x) j++;
  2921.     }
  2923.     return j;
  2924. }
  2926. /*
  2927. ** If at end of eth device list and can't use current entry, malloc
  2928. ** one up. If memory could not be allocated, print an error message.
  2929. */
  2930. static struct net_device * __init 
  2931. insert_device(struct net_device *dev, u_long iobase, int (*init)(struct net_device *))
  2932. {
  2933.     struct net_device *new;
  2935.     new = (struct net_device *)kmalloc(sizeof(struct net_device), GFP_KERNEL);
  2936.     if (new == NULL) {
  2937. printk("de4x5.c: Device not initialised, insufficient memoryn");
  2938. return NULL;
  2939.     } else {
  2940. memset((char *)new, 0, sizeof(struct net_device));
  2941. new->base_addr = iobase;       /* assign the io address */
  2942. new->init = init;              /* initialisation routine */
  2943.     }
  2945.     return new;
  2946. }
  2948. #endif /* MODULE */
  2951. /*
  2952.  * Local variables:
  2953.  *
  2954.  * Delete -DMODVERSIONS below if you didn't define this in your kernel
  2955.  *
  2956.  *  compile-command: "gcc -D__KERNEL__ -DMODULE -I/linux/include -Wall -Wstrict-prototypes -fomit-frame-pointer -fno-strength-reduce -malign-loops=2 -malign-jumps=2 -malign-functions=2 -O2 -m486 -DMODVERSIONS -include /linux/include/linux/modversions.h -c de4x5.c"
  2957.  * End:
  2958.  */