Lines Matching refs:de
322 static void de_tx (struct de_private *de);
323 static void de_clean_rings (struct de_private *de);
324 static void de_media_interrupt (struct de_private *de, u32 status);
327 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media);
359 #define dr32(reg) readl(de->regs + (reg))
360 #define dw32(reg,val) writel((val), de->regs + (reg))
363 static void de_rx_err_acct (struct de_private *de, unsigned rx_tail,
366 if (netif_msg_rx_err (de))
369 de->dev->name, rx_tail, status, len);
374 if (netif_msg_rx_err(de))
377 de->dev->name, status);
378 de->net_stats.rx_length_errors++;
382 de->net_stats.rx_errors++; /* end of a packet.*/
383 if (status & 0x0890) de->net_stats.rx_length_errors++;
384 if (status & RxErrCRC) de->net_stats.rx_crc_errors++;
385 if (status & RxErrFIFO) de->net_stats.rx_fifo_errors++;
389 static void de_rx (struct de_private *de)
391 unsigned rx_tail = de->rx_tail;
402 skb = de->rx_skb[rx_tail].skb;
405 status = le32_to_cpu(de->rx_ring[rx_tail].opts1);
410 mapping = de->rx_skb[rx_tail].mapping;
413 de->net_stats.rx_dropped++;
418 de_rx_err_acct(de, rx_tail, status, len);
424 if (unlikely(netif_msg_rx_status(de)))
426 de->dev->name, rx_tail, status, len,
429 buflen = copying_skb ? (len + RX_OFFSET) : de->rx_buf_sz;
432 de->net_stats.rx_dropped++;
439 pci_unmap_single(de->pdev, mapping,
444 de->rx_skb[rx_tail].mapping =
445 pci_map_single(de->pdev, copy_skb->data,
447 de->rx_skb[rx_tail].skb = copy_skb;
449 pci_dma_sync_single_for_cpu(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
453 pci_dma_sync_single_for_device(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
459 skb->protocol = eth_type_trans (skb, de->dev);
461 de->net_stats.rx_packets++;
462 de->net_stats.rx_bytes += skb->len;
463 de->dev->last_rx = jiffies;
469 de->rx_ring[rx_tail].opts1 = cpu_to_le32(DescOwn);
471 de->rx_ring[rx_tail].opts2 =
472 cpu_to_le32(RingEnd | de->rx_buf_sz);
474 de->rx_ring[rx_tail].opts2 = cpu_to_le32(de->rx_buf_sz);
475 de->rx_ring[rx_tail].addr1 = cpu_to_le32(mapping);
480 printk(KERN_WARNING "%s: rx work limit reached\n", de->dev->name);
482 de->rx_tail = rx_tail;
488 struct de_private *de = dev->priv;
495 if (netif_msg_intr(de))
497 dev->name, status, dr32(MacMode), de->rx_tail, de->tx_head, de->tx_tail);
502 de_rx(de);
507 spin_lock(&de->lock);
510 de_tx(de);
513 de_media_interrupt(de, status);
515 spin_unlock(&de->lock);
520 pci_read_config_word(de->pdev, PCI_STATUS, &pci_status);
521 pci_write_config_word(de->pdev, PCI_STATUS, pci_status);
529 static void de_tx (struct de_private *de)
531 unsigned tx_head = de->tx_head;
532 unsigned tx_tail = de->tx_tail;
539 status = le32_to_cpu(de->tx_ring[tx_tail].opts1);
543 skb = de->tx_skb[tx_tail].skb;
549 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
550 sizeof(de->setup_frame), PCI_DMA_TODEVICE);
554 pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
559 if (netif_msg_tx_err(de))
561 de->dev->name, status);
562 de->net_stats.tx_errors++;
564 de->net_stats.tx_window_errors++;
566 de->net_stats.tx_aborted_errors++;
568 de->net_stats.tx_carrier_errors++;
570 de->net_stats.tx_fifo_errors++;
572 de->net_stats.tx_packets++;
573 de->net_stats.tx_bytes += skb->len;
574 if (netif_msg_tx_done(de))
575 printk(KERN_DEBUG "%s: tx done, slot %d\n", de->dev->name, tx_tail);
581 de->tx_skb[tx_tail].skb = NULL;
586 de->tx_tail = tx_tail;
588 if (netif_queue_stopped(de->dev) && (TX_BUFFS_AVAIL(de) > (DE_TX_RING_SIZE / 4)))
589 netif_wake_queue(de->dev);
594 struct de_private *de = dev->priv;
599 spin_lock_irq(&de->lock);
601 tx_free = TX_BUFFS_AVAIL(de);
604 spin_unlock_irq(&de->lock);
609 entry = de->tx_head;
611 txd = &de->tx_ring[entry];
614 mapping = pci_map_single(de->pdev, skb->data, len, PCI_DMA_TODEVICE);
623 de->tx_skb[entry].skb = skb;
624 de->tx_skb[entry].mapping = mapping;
630 de->tx_head = NEXT_TX(entry);
631 if (netif_msg_tx_queued(de))
638 spin_unlock_irq(&de->lock);
649 new frame, not around filling de->setup_frame. This is non-deterministic
657 struct de_private *de = dev->priv;
676 setup_frm = &de->setup_frame[13*6];
688 struct de_private *de = dev->priv;
704 setup_frm = &de->setup_frame[15*6];
716 struct de_private *de = dev->priv;
739 build_setup_frame_hash (de->setup_frame, dev);
741 build_setup_frame_perfect (de->setup_frame, dev);
747 entry = de->tx_head;
751 de->tx_skb[entry].skb = DE_DUMMY_SKB;
753 dummy_txd = &de->tx_ring[entry];
763 de->tx_skb[entry].skb = DE_SETUP_SKB;
764 de->tx_skb[entry].mapping = mapping =
765 pci_map_single (de->pdev, de->setup_frame,
766 sizeof (de->setup_frame), PCI_DMA_TODEVICE);
769 txd = &de->tx_ring[entry];
771 txd->opts2 = cpu_to_le32(SetupFrame | RingEnd | sizeof (de->setup_frame));
773 txd->opts2 = cpu_to_le32(SetupFrame | sizeof (de->setup_frame));
785 de->tx_head = NEXT_TX(entry);
787 BUG_ON(TX_BUFFS_AVAIL(de) < 0);
788 if (TX_BUFFS_AVAIL(de) == 0)
802 struct de_private *de = dev->priv;
804 spin_lock_irqsave (&de->lock, flags);
806 spin_unlock_irqrestore (&de->lock, flags);
809 static inline void de_rx_missed(struct de_private *de, u32 rx_missed)
812 de->net_stats.rx_missed_errors += RxMissedMask;
814 de->net_stats.rx_missed_errors += (rx_missed & RxMissedMask);
817 static void __de_get_stats(struct de_private *de)
821 de_rx_missed(de, tmp);
826 struct de_private *de = dev->priv;
829 spin_lock_irq(&de->lock);
831 __de_get_stats(de);
832 spin_unlock_irq(&de->lock);
834 return &de->net_stats;
837 static inline int de_is_running (struct de_private *de)
842 static void de_stop_rxtx (struct de_private *de)
854 if (!de_is_running(de))
859 printk(KERN_WARNING "%s: timeout expired stopping DMA\n", de->dev->name);
862 static inline void de_start_rxtx (struct de_private *de)
873 static void de_stop_hw (struct de_private *de)
879 de_stop_rxtx(de);
885 de->rx_tail = 0;
886 de->tx_head = de->tx_tail = 0;
889 static void de_link_up(struct de_private *de)
891 if (!netif_carrier_ok(de->dev)) {
892 netif_carrier_on(de->dev);
893 if (netif_msg_link(de))
895 de->dev->name, media_name[de->media_type]);
899 static void de_link_down(struct de_private *de)
901 if (netif_carrier_ok(de->dev)) {
902 netif_carrier_off(de->dev);
903 if (netif_msg_link(de))
904 printk(KERN_INFO "%s: link down\n", de->dev->name);
908 static void de_set_media (struct de_private *de)
910 unsigned media = de->media_type;
913 BUG_ON(de_is_running(de));
915 if (de->de21040)
918 dw32(CSR14, de->media[media].csr14);
919 dw32(CSR15, de->media[media].csr15);
920 dw32(CSR13, de->media[media].csr13);
932 if (netif_msg_link(de)) {
936 de->dev->name, media_name[media],
937 de->dev->name, dr32(MacMode), dr32(SIAStatus),
939 de->dev->name, macmode, de->media[media].csr13,
940 de->media[media].csr14, de->media[media].csr15);
946 static void de_next_media (struct de_private *de, u32 *media,
952 if (de_ok_to_advertise(de, media[i])) {
953 de->media_type = media[i];
961 struct de_private *de = (struct de_private *) data;
962 struct net_device *dev = de->dev;
970 if (de->media_type != DE_MEDIA_AUI && (status & LinkFailStatus))
973 de->media_timer.expires = jiffies + DE_TIMER_LINK;
974 add_timer(&de->media_timer);
976 de_link_up(de);
978 if (netif_msg_timer(de))
980 dev->name, media_name[de->media_type],
985 de_link_down(de);
987 if (de->media_lock)
990 if (de->media_type == DE_MEDIA_AUI) {
992 de_next_media(de, &next_state, 1);
995 de_next_media(de, &next_state, 1);
998 spin_lock_irqsave(&de->lock, flags);
999 de_stop_rxtx(de);
1000 spin_unlock_irqrestore(&de->lock, flags);
1001 de_set_media(de);
1002 de_start_rxtx(de);
1005 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1006 add_timer(&de->media_timer);
1008 if (netif_msg_timer(de))
1010 dev->name, media_name[de->media_type], status);
1013 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media)
1017 if (!(de->media_advertise & ADVERTISED_Autoneg))
1019 if (!(de->media_advertise & (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full)))
1023 if (!(de->media_advertise & ADVERTISED_BNC))
1027 if (!(de->media_advertise & ADVERTISED_AUI))
1031 if (!(de->media_advertise & ADVERTISED_10baseT_Half))
1035 if (!(de->media_advertise & ADVERTISED_10baseT_Full))
1045 struct de_private *de = (struct de_private *) data;
1046 struct net_device *dev = de->dev;
1054 if ((de->media_type == DE_MEDIA_TP_AUTO ||
1055 de->media_type == DE_MEDIA_TP ||
1056 de->media_type == DE_MEDIA_TP_FD) &&
1060 de->media_timer.expires = jiffies + DE_TIMER_LINK;
1061 add_timer(&de->media_timer);
1063 de_link_up(de);
1065 if (netif_msg_timer(de))
1067 dev->name, media_name[de->media_type],
1072 de_link_down(de);
1075 if (de->media_lock)
1083 if (de->media_type == DE_MEDIA_AUI ||
1084 de->media_type == DE_MEDIA_BNC) {
1085 if (de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))
1086 de->media_type = DE_MEDIA_TP_AUTO;
1092 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_BNC) &&
1093 de_ok_to_advertise(de, DE_MEDIA_BNC))
1094 de->media_type = DE_MEDIA_BNC;
1097 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_AUI) &&
1098 de_ok_to_advertise(de, DE_MEDIA_AUI))
1099 de->media_type = DE_MEDIA_AUI;
1111 * media state. If de->media_type is left unchanged, this
1114 if (de->media_type == DE_MEDIA_AUI) {
1116 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1117 } else if (de->media_type == DE_MEDIA_BNC) {
1119 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1122 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1126 spin_lock_irqsave(&de->lock, flags);
1127 de_stop_rxtx(de);
1128 spin_unlock_irqrestore(&de->lock, flags);
1129 de_set_media(de);
1130 de_start_rxtx(de);
1133 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1134 add_timer(&de->media_timer);
1136 if (netif_msg_timer(de))
1138 dev->name, media_name[de->media_type], status);
1141 static void de_media_interrupt (struct de_private *de, u32 status)
1144 de_link_up(de);
1145 mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK);
1151 if (netif_carrier_ok(de->dev)) {
1152 de_link_down(de);
1153 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1157 static int de_reset_mac (struct de_private *de)
1191 static void de_adapter_wake (struct de_private *de)
1195 if (de->de21040)
1198 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1201 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1208 static void de_adapter_sleep (struct de_private *de)
1212 if (de->de21040)
1215 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1217 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1220 static int de_init_hw (struct de_private *de)
1222 struct net_device *dev = de->dev;
1226 de_adapter_wake(de);
1230 rc = de_reset_mac(de);
1234 de_set_media(de); /* reset phy */
1236 dw32(RxRingAddr, de->ring_dma);
1237 dw32(TxRingAddr, de->ring_dma + (sizeof(struct de_desc) * DE_RX_RING_SIZE));
1250 static int de_refill_rx (struct de_private *de)
1257 skb = dev_alloc_skb(de->rx_buf_sz);
1261 skb->dev = de->dev;
1263 de->rx_skb[i].mapping = pci_map_single(de->pdev,
1264 skb->data, de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1265 de->rx_skb[i].skb = skb;
1267 de->rx_ring[i].opts1 = cpu_to_le32(DescOwn);
1269 de->rx_ring[i].opts2 =
1270 cpu_to_le32(RingEnd | de->rx_buf_sz);
1272 de->rx_ring[i].opts2 = cpu_to_le32(de->rx_buf_sz);
1273 de->rx_ring[i].addr1 = cpu_to_le32(de->rx_skb[i].mapping);
1274 de->rx_ring[i].addr2 = 0;
1280 de_clean_rings(de);
1284 static int de_init_rings (struct de_private *de)
1286 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1287 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1289 de->rx_tail = 0;
1290 de->tx_head = de->tx_tail = 0;
1292 return de_refill_rx (de);
1295 static int de_alloc_rings (struct de_private *de)
1297 de->rx_ring = pci_alloc_consistent(de->pdev, DE_RING_BYTES, &de->ring_dma);
1298 if (!de->rx_ring)
1300 de->tx_ring = &de->rx_ring[DE_RX_RING_SIZE];
1301 return de_init_rings(de);
1304 static void de_clean_rings (struct de_private *de)
1308 memset(de->rx_ring, 0, sizeof(struct de_desc) * DE_RX_RING_SIZE);
1309 de->rx_ring[DE_RX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1311 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1312 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1316 if (de->rx_skb[i].skb) {
1317 pci_unmap_single(de->pdev, de->rx_skb[i].mapping,
1318 de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1319 dev_kfree_skb(de->rx_skb[i].skb);
1324 struct sk_buff *skb = de->tx_skb[i].skb;
1327 de->net_stats.tx_dropped++;
1328 pci_unmap_single(de->pdev,
1329 de->tx_skb[i].mapping,
1333 pci_unmap_single(de->pdev,
1334 de->tx_skb[i].mapping,
1335 sizeof(de->setup_frame),
1341 memset(&de->rx_skb, 0, sizeof(struct ring_info) * DE_RX_RING_SIZE);
1342 memset(&de->tx_skb, 0, sizeof(struct ring_info) * DE_TX_RING_SIZE);
1345 static void de_free_rings (struct de_private *de)
1347 de_clean_rings(de);
1348 pci_free_consistent(de->pdev, DE_RING_BYTES, de->rx_ring, de->ring_dma);
1349 de->rx_ring = NULL;
1350 de->tx_ring = NULL;
1355 struct de_private *de = dev->priv;
1358 if (netif_msg_ifup(de))
1361 de->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
1363 rc = de_alloc_rings(de);
1379 rc = de_init_hw(de);
1387 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1394 de_free_rings(de);
1400 struct de_private *de = dev->priv;
1403 if (netif_msg_ifdown(de))
1406 del_timer_sync(&de->media_timer);
1408 spin_lock_irqsave(&de->lock, flags);
1409 de_stop_hw(de);
1412 spin_unlock_irqrestore(&de->lock, flags);
1416 de_free_rings(de);
1417 de_adapter_sleep(de);
1418 pci_disable_device(de->pdev);
1424 struct de_private *de = dev->priv;
1428 de->rx_tail, de->tx_head, de->tx_tail);
1430 del_timer_sync(&de->media_timer);
1433 spin_lock_irq(&de->lock);
1435 de_stop_hw(de);
1439 spin_unlock_irq(&de->lock);
1443 __de_get_stats(de);
1446 de_clean_rings(de);
1448 de_init_rings(de);
1450 de_init_hw(de);
1455 static void __de_get_regs(struct de_private *de, u8 *buf)
1465 de_rx_missed(de, rbuf[8]);
1468 static int __de_get_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1470 ecmd->supported = de->media_supported;
1473 ecmd->advertising = de->media_advertise;
1475 switch (de->media_type) {
1495 if (de->media_lock)
1505 static int __de_set_settings(struct de_private *de, struct ethtool_cmd *ecmd)
1512 if (de->de21040 && ecmd->speed == 2)
1518 if (de->de21040 && ecmd->port == PORT_BNC)
1524 if (ecmd->advertising & ~de->media_supported)
1557 if ((new_media == de->media_type) &&
1558 (media_lock == de->media_lock) &&
1559 (ecmd->advertising == de->media_advertise))
1562 de_link_down(de);
1563 de_stop_rxtx(de);
1565 de->media_type = new_media;
1566 de->media_lock = media_lock;
1567 de->media_advertise = ecmd->advertising;
1568 de_set_media(de);
1575 struct de_private *de = dev->priv;
1579 strcpy (info->bus_info, pci_name(de->pdev));
1590 struct de_private *de = dev->priv;
1593 spin_lock_irq(&de->lock);
1594 rc = __de_get_settings(de, ecmd);
1595 spin_unlock_irq(&de->lock);
1602 struct de_private *de = dev->priv;
1605 spin_lock_irq(&de->lock);
1606 rc = __de_set_settings(de, ecmd);
1607 spin_unlock_irq(&de->lock);
1614 struct de_private *de = dev->priv;
1616 return de->msg_enable;
1621 struct de_private *de = dev->priv;
1623 de->msg_enable = msglvl;
1629 struct de_private *de = dev->priv;
1631 if (!de->ee_data)
1636 memcpy(data, de->ee_data, eeprom->len);
1643 struct de_private *de = dev->priv;
1646 if (de->media_type != DE_MEDIA_TP_AUTO)
1648 if (netif_carrier_ok(de->dev))
1649 de_link_down(de);
1653 if (netif_msg_link(de))
1655 de->dev->name, status, dr32(SIAStatus));
1662 struct de_private *de = dev->priv;
1664 regs->version = (DE_REGS_VER << 2) | de->de21040;
1666 spin_lock_irq(&de->lock);
1667 __de_get_regs(de, data);
1668 spin_unlock_irq(&de->lock);
1686 static void __devinit de21040_get_mac_address (struct de_private *de)
1697 de->dev->dev_addr[i] = value;
1704 static void __devinit de21040_get_media_info(struct de_private *de)
1708 de->media_type = DE_MEDIA_TP;
1709 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full |
1711 de->media_advertise = de->media_supported;
1718 de->media[i].type = i;
1719 de->media[i].csr13 = t21040_csr13[i];
1720 de->media[i].csr14 = t21040_csr14[i];
1721 de->media[i].csr15 = t21040_csr15[i];
1724 de->media[i].type = DE_MEDIA_INVALID;
1766 static void __devinit de21041_get_srom_info (struct de_private *de)
1770 unsigned ee_addr_size = tulip_read_eeprom(de->regs, 0xff, 8) & 0x40000 ? 8 : 6;
1777 le16_to_cpu(tulip_read_eeprom(de->regs, i, ee_addr_size));
1793 de->dev->dev_addr[i] = ee_data[i + sa_offset];
1812 case 0x0001: de->media_type = DE_MEDIA_BNC; break;
1813 case 0x0002: de->media_type = DE_MEDIA_AUI; break;
1814 case 0x0204: de->media_type = DE_MEDIA_TP_FD; break;
1815 default: de->media_type = DE_MEDIA_TP_AUTO; break;
1818 if (netif_msg_probe(de))
1819 printk(KERN_INFO "de%d: SROM leaf offset %u, default media %s\n",
1820 de->board_idx, ofs,
1821 media_name[de->media_type]);
1825 de->media[i].type = DE_MEDIA_INVALID;
1826 de->media[i].csr13 = 0xffff;
1827 de->media[i].csr14 = 0xffff;
1828 de->media[i].csr15 = 0xffff;
1842 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half
1845 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1848 de->media_supported |= SUPPORTED_BNC;
1852 de->media_supported |= SUPPORTED_AUI;
1856 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full
1859 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1865 de->media[idx].type = idx;
1867 if (netif_msg_probe(de))
1868 printk(KERN_INFO "de%d: media block #%u: %s",
1869 de->board_idx, i,
1870 media_name[de->media[idx].type]);
1875 de->media[idx].csr13 = DE_UNALIGNED_16(&ib->csr13);
1876 de->media[idx].csr14 = DE_UNALIGNED_16(&ib->csr14);
1877 de->media[idx].csr15 = DE_UNALIGNED_16(&ib->csr15);
1881 if (netif_msg_probe(de))
1883 de->media[idx].csr13,
1884 de->media[idx].csr14,
1885 de->media[idx].csr15);
1887 } else if (netif_msg_probe(de))
1894 de->media_advertise = de->media_supported;
1899 if (de->media[i].csr13 == 0xffff)
1900 de->media[i].csr13 = t21041_csr13[i];
1901 if (de->media[i].csr14 == 0xffff)
1902 de->media[i].csr14 = t21041_csr14[i];
1903 if (de->media[i].csr15 == 0xffff)
1904 de->media[i].csr15 = t21041_csr15[i];
1907 de->ee_data = kmemdup(&ee_data[0], DE_EEPROM_SIZE, GFP_KERNEL);
1914 de->media[i].type = i;
1915 de->media_supported =
1929 struct de_private *de;
1958 de = dev->priv;
1959 de->de21040 = ent->driver_data == 0 ? 1 : 0;
1960 de->pdev = pdev;
1961 de->dev = dev;
1962 de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug);
1963 de->board_idx = board_idx;
1964 spin_lock_init (&de->lock);
1965 init_timer(&de->media_timer);
1966 if (de->de21040)
1967 de->media_timer.function = de21040_media_timer;
1969 de->media_timer.function = de21041_media_timer;
1970 de->media_timer.data = (unsigned long) de;
2020 de->regs = regs;
2022 de_adapter_wake(de);
2025 rc = de_reset_mac(de);
2035 if (de->de21040) {
2036 de21040_get_mac_address(de);
2037 de21040_get_media_info(de);
2039 de21041_get_srom_info(de);
2052 de->de21040 ? "21040" : "21041",
2065 de_adapter_sleep(de);
2070 kfree(de->ee_data);
2084 struct de_private *de = dev->priv;
2088 kfree(de->ee_data);
2089 iounmap(de->regs);
2101 struct de_private *de = dev->priv;
2105 del_timer_sync(&de->media_timer);
2108 spin_lock_irq(&de->lock);
2110 de_stop_hw(de);
2115 spin_unlock_irq(&de->lock);
2119 __de_get_stats(de);
2122 de_clean_rings(de);
2124 de_adapter_sleep(de);
2136 struct de_private *de = dev->priv;
2149 de_init_hw(de);