Lines Matching refs:de
327 static void de_tx (struct de_private *de);
328 static void de_clean_rings (struct de_private *de);
329 static void de_media_interrupt (struct de_private *de, u32 status);
332 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media);
366 #define dr32(reg) ioread32(de->regs + (reg))
367 #define dw32(reg, val) iowrite32((val), de->regs + (reg))
370 static void de_rx_err_acct (struct de_private *de, unsigned rx_tail,
373 netif_dbg(de, rx_err, de->dev,
380 netif_warn(de, rx_err, de->dev,
383 de->dev->stats.rx_length_errors++;
387 de->dev->stats.rx_errors++; /* end of a packet.*/
388 if (status & 0x0890) de->dev->stats.rx_length_errors++;
389 if (status & RxErrCRC) de->dev->stats.rx_crc_errors++;
390 if (status & RxErrFIFO) de->dev->stats.rx_fifo_errors++;
394 static void de_rx (struct de_private *de)
396 unsigned rx_tail = de->rx_tail;
407 skb = de->rx_skb[rx_tail].skb;
410 status = le32_to_cpu(de->rx_ring[rx_tail].opts1);
418 mapping = de->rx_skb[rx_tail].mapping;
421 de->dev->stats.rx_dropped++;
426 de_rx_err_acct(de, rx_tail, status, len);
432 netif_dbg(de, rx_status, de->dev,
436 buflen = copying_skb ? (len + RX_OFFSET) : de->rx_buf_sz;
437 copy_skb = netdev_alloc_skb(de->dev, buflen);
439 de->dev->stats.rx_dropped++;
446 dma_unmap_single(&de->pdev->dev, mapping, buflen,
451 de->rx_skb[rx_tail].mapping =
452 dma_map_single(&de->pdev->dev, copy_skb->data,
454 de->rx_skb[rx_tail].skb = copy_skb;
456 dma_sync_single_for_cpu(&de->pdev->dev, mapping, len,
461 dma_sync_single_for_device(&de->pdev->dev, mapping,
468 skb->protocol = eth_type_trans (skb, de->dev);
470 de->dev->stats.rx_packets++;
471 de->dev->stats.rx_bytes += skb->len;
478 de->rx_ring[rx_tail].opts2 =
479 cpu_to_le32(RingEnd | de->rx_buf_sz);
481 de->rx_ring[rx_tail].opts2 = cpu_to_le32(de->rx_buf_sz);
482 de->rx_ring[rx_tail].addr1 = cpu_to_le32(mapping);
484 de->rx_ring[rx_tail].opts1 = cpu_to_le32(DescOwn);
489 netdev_warn(de->dev, "rx work limit reached\n");
491 de->rx_tail = rx_tail;
497 struct de_private *de = netdev_priv(dev);
504 netif_dbg(de, intr, dev, "intr, status %08x mode %08x desc %u/%u/%u\n",
506 de->rx_tail, de->tx_head, de->tx_tail);
511 de_rx(de);
516 spin_lock(&de->lock);
519 de_tx(de);
522 de_media_interrupt(de, status);
524 spin_unlock(&de->lock);
529 pci_read_config_word(de->pdev, PCI_STATUS, &pci_status);
530 pci_write_config_word(de->pdev, PCI_STATUS, pci_status);
531 netdev_err(de->dev,
539 static void de_tx (struct de_private *de)
541 unsigned tx_head = de->tx_head;
542 unsigned tx_tail = de->tx_tail;
549 status = le32_to_cpu(de->tx_ring[tx_tail].opts1);
553 skb = de->tx_skb[tx_tail].skb;
559 dma_unmap_single(&de->pdev->dev,
560 de->tx_skb[tx_tail].mapping,
561 sizeof(de->setup_frame),
566 dma_unmap_single(&de->pdev->dev, de->tx_skb[tx_tail].mapping,
571 netif_dbg(de, tx_err, de->dev,
574 de->dev->stats.tx_errors++;
576 de->dev->stats.tx_window_errors++;
578 de->dev->stats.tx_aborted_errors++;
580 de->dev->stats.tx_carrier_errors++;
582 de->dev->stats.tx_fifo_errors++;
584 de->dev->stats.tx_packets++;
585 de->dev->stats.tx_bytes += skb->len;
586 netif_dbg(de, tx_done, de->dev,
593 de->tx_skb[tx_tail].skb = NULL;
598 de->tx_tail = tx_tail;
600 if (netif_queue_stopped(de->dev) && (TX_BUFFS_AVAIL(de) > (DE_TX_RING_SIZE / 4)))
601 netif_wake_queue(de->dev);
607 struct de_private *de = netdev_priv(dev);
612 spin_lock_irq(&de->lock);
614 tx_free = TX_BUFFS_AVAIL(de);
617 spin_unlock_irq(&de->lock);
622 entry = de->tx_head;
624 txd = &de->tx_ring[entry];
627 mapping = dma_map_single(&de->pdev->dev, skb->data, len,
637 de->tx_skb[entry].skb = skb;
638 de->tx_skb[entry].mapping = mapping;
644 de->tx_head = NEXT_TX(entry);
645 netif_dbg(de, tx_queued, dev, "tx queued, slot %d, skblen %d\n",
651 spin_unlock_irq(&de->lock);
661 new frame, not around filling de->setup_frame. This is non-deterministic
666 struct de_private *de = netdev_priv(dev);
685 setup_frm = &de->setup_frame[13*6];
696 struct de_private *de = netdev_priv(dev);
710 setup_frm = &de->setup_frame[15*6];
722 struct de_private *de = netdev_priv(dev);
745 build_setup_frame_hash (de->setup_frame, dev);
747 build_setup_frame_perfect (de->setup_frame, dev);
753 entry = de->tx_head;
757 de->tx_skb[entry].skb = DE_DUMMY_SKB;
759 dummy_txd = &de->tx_ring[entry];
769 de->tx_skb[entry].skb = DE_SETUP_SKB;
770 de->tx_skb[entry].mapping = mapping =
771 dma_map_single(&de->pdev->dev, de->setup_frame,
772 sizeof(de->setup_frame), DMA_TO_DEVICE);
775 txd = &de->tx_ring[entry];
777 txd->opts2 = cpu_to_le32(SetupFrame | RingEnd | sizeof (de->setup_frame));
779 txd->opts2 = cpu_to_le32(SetupFrame | sizeof (de->setup_frame));
791 de->tx_head = NEXT_TX(entry);
793 if (TX_BUFFS_AVAIL(de) == 0)
807 struct de_private *de = netdev_priv(dev);
809 spin_lock_irqsave (&de->lock, flags);
811 spin_unlock_irqrestore (&de->lock, flags);
814 static inline void de_rx_missed(struct de_private *de, u32 rx_missed)
817 de->dev->stats.rx_missed_errors += RxMissedMask;
819 de->dev->stats.rx_missed_errors += (rx_missed & RxMissedMask);
822 static void __de_get_stats(struct de_private *de)
826 de_rx_missed(de, tmp);
831 struct de_private *de = netdev_priv(dev);
834 spin_lock_irq(&de->lock);
836 __de_get_stats(de);
837 spin_unlock_irq(&de->lock);
842 static inline int de_is_running (struct de_private *de)
847 static void de_stop_rxtx (struct de_private *de)
863 if (!de_is_running(de))
868 netdev_warn(de->dev, "timeout expired, stopping DMA\n");
871 static inline void de_start_rxtx (struct de_private *de)
882 static void de_stop_hw (struct de_private *de)
888 de_stop_rxtx(de);
894 de->rx_tail = 0;
895 de->tx_head = de->tx_tail = 0;
898 static void de_link_up(struct de_private *de)
900 if (!netif_carrier_ok(de->dev)) {
901 netif_carrier_on(de->dev);
902 netif_info(de, link, de->dev, "link up, media %s\n",
903 media_name[de->media_type]);
907 static void de_link_down(struct de_private *de)
909 if (netif_carrier_ok(de->dev)) {
910 netif_carrier_off(de->dev);
911 netif_info(de, link, de->dev, "link down\n");
915 static void de_set_media (struct de_private *de)
917 unsigned media = de->media_type;
920 if (de_is_running(de))
921 netdev_warn(de->dev, "chip is running while changing media!\n");
923 if (de->de21040)
926 dw32(CSR14, de->media[media].csr14);
927 dw32(CSR15, de->media[media].csr15);
928 dw32(CSR13, de->media[media].csr13);
940 netif_info(de, link, de->dev, "set link %s\n", media_name[media]);
941 netif_info(de, hw, de->dev, "mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n",
944 netif_info(de, hw, de->dev, "set mode 0x%x, set sia 0x%x,0x%x,0x%x\n",
945 macmode, de->media[media].csr13,
946 de->media[media].csr14, de->media[media].csr15);
951 static void de_next_media (struct de_private *de, const u32 *media,
957 if (de_ok_to_advertise(de, media[i])) {
958 de->media_type = media[i];
966 struct de_private *de = from_timer(de, t, media_timer);
967 struct net_device *dev = de->dev;
975 if (de->media_type != DE_MEDIA_AUI && (status & LinkFailStatus))
978 de->media_timer.expires = jiffies + DE_TIMER_LINK;
979 add_timer(&de->media_timer);
981 de_link_up(de);
983 netif_info(de, timer, dev, "%s link ok, status %x\n",
984 media_name[de->media_type], status);
988 de_link_down(de);
990 if (de->media_lock)
993 if (de->media_type == DE_MEDIA_AUI) {
995 de_next_media(de, &next_state, 1);
998 de_next_media(de, &next_state, 1);
1001 spin_lock_irqsave(&de->lock, flags);
1002 de_stop_rxtx(de);
1003 spin_unlock_irqrestore(&de->lock, flags);
1004 de_set_media(de);
1005 de_start_rxtx(de);
1008 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1009 add_timer(&de->media_timer);
1011 netif_info(de, timer, dev, "no link, trying media %s, status %x\n",
1012 media_name[de->media_type], status);
1015 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media)
1019 if (!(de->media_advertise & ADVERTISED_Autoneg))
1021 if (!(de->media_advertise & (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full)))
1025 if (!(de->media_advertise & ADVERTISED_BNC))
1029 if (!(de->media_advertise & ADVERTISED_AUI))
1033 if (!(de->media_advertise & ADVERTISED_10baseT_Half))
1037 if (!(de->media_advertise & ADVERTISED_10baseT_Full))
1047 struct de_private *de = from_timer(de, t, media_timer);
1048 struct net_device *dev = de->dev;
1059 if ((de->media_type == DE_MEDIA_TP_AUTO ||
1060 de->media_type == DE_MEDIA_TP ||
1061 de->media_type == DE_MEDIA_TP_FD) &&
1065 de->media_timer.expires = jiffies + DE_TIMER_LINK;
1066 add_timer(&de->media_timer);
1068 de_link_up(de);
1070 netif_info(de, timer, dev,
1072 media_name[de->media_type],
1077 de_link_down(de);
1080 if (de->media_lock)
1088 if (de->media_type == DE_MEDIA_AUI ||
1089 de->media_type == DE_MEDIA_BNC) {
1090 if (de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))
1091 de->media_type = DE_MEDIA_TP_AUTO;
1097 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_BNC) &&
1098 de_ok_to_advertise(de, DE_MEDIA_BNC))
1099 de->media_type = DE_MEDIA_BNC;
1102 else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_AUI) &&
1103 de_ok_to_advertise(de, DE_MEDIA_AUI))
1104 de->media_type = DE_MEDIA_AUI;
1116 * media state. If de->media_type is left unchanged, this
1119 if (de->media_type == DE_MEDIA_AUI) {
1123 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1124 } else if (de->media_type == DE_MEDIA_BNC) {
1128 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1133 de_next_media(de, next_states, ARRAY_SIZE(next_states));
1137 spin_lock_irqsave(&de->lock, flags);
1138 de_stop_rxtx(de);
1139 spin_unlock_irqrestore(&de->lock, flags);
1140 de_set_media(de);
1141 de_start_rxtx(de);
1144 de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1145 add_timer(&de->media_timer);
1147 netif_info(de, timer, dev, "no link, trying media %s, status %x\n",
1148 media_name[de->media_type], status);
1151 static void de_media_interrupt (struct de_private *de, u32 status)
1155 if ((de->media_type == DE_MEDIA_AUI ||
1156 de->media_type == DE_MEDIA_BNC) &&
1157 (de->media_lock ||
1158 !de_ok_to_advertise(de, DE_MEDIA_TP_AUTO)))
1161 if ((de->media_type == DE_MEDIA_AUI ||
1162 de->media_type == DE_MEDIA_BNC)) {
1163 de->media_type = DE_MEDIA_TP_AUTO;
1164 de_stop_rxtx(de);
1165 de_set_media(de);
1166 de_start_rxtx(de);
1168 de_link_up(de);
1169 mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK);
1175 if (netif_carrier_ok(de->dev) && de->media_type != DE_MEDIA_AUI &&
1176 de->media_type != DE_MEDIA_BNC) {
1177 de_link_down(de);
1178 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1182 static int de_reset_mac (struct de_private *de)
1216 static void de_adapter_wake (struct de_private *de)
1220 if (de->de21040)
1223 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1226 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1233 static void de_adapter_sleep (struct de_private *de)
1237 if (de->de21040)
1241 pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1243 pci_write_config_dword(de->pdev, PCIPM, pmctl);
1246 static int de_init_hw (struct de_private *de)
1248 struct net_device *dev = de->dev;
1252 de_adapter_wake(de);
1256 rc = de_reset_mac(de);
1260 de_set_media(de); /* reset phy */
1262 dw32(RxRingAddr, de->ring_dma);
1263 dw32(TxRingAddr, de->ring_dma + (sizeof(struct de_desc) * DE_RX_RING_SIZE));
1276 static int de_refill_rx (struct de_private *de)
1283 skb = netdev_alloc_skb(de->dev, de->rx_buf_sz);
1287 de->rx_skb[i].mapping = dma_map_single(&de->pdev->dev,
1289 de->rx_buf_sz,
1291 de->rx_skb[i].skb = skb;
1293 de->rx_ring[i].opts1 = cpu_to_le32(DescOwn);
1295 de->rx_ring[i].opts2 =
1296 cpu_to_le32(RingEnd | de->rx_buf_sz);
1298 de->rx_ring[i].opts2 = cpu_to_le32(de->rx_buf_sz);
1299 de->rx_ring[i].addr1 = cpu_to_le32(de->rx_skb[i].mapping);
1300 de->rx_ring[i].addr2 = 0;
1306 de_clean_rings(de);
1310 static int de_init_rings (struct de_private *de)
1312 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1313 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1315 de->rx_tail = 0;
1316 de->tx_head = de->tx_tail = 0;
1318 return de_refill_rx (de);
1321 static int de_alloc_rings (struct de_private *de)
1323 de->rx_ring = dma_alloc_coherent(&de->pdev->dev, DE_RING_BYTES,
1324 &de->ring_dma, GFP_KERNEL);
1325 if (!de->rx_ring)
1327 de->tx_ring = &de->rx_ring[DE_RX_RING_SIZE];
1328 return de_init_rings(de);
1331 static void de_clean_rings (struct de_private *de)
1335 memset(de->rx_ring, 0, sizeof(struct de_desc) * DE_RX_RING_SIZE);
1336 de->rx_ring[DE_RX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1338 memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1339 de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1343 if (de->rx_skb[i].skb) {
1344 dma_unmap_single(&de->pdev->dev,
1345 de->rx_skb[i].mapping, de->rx_buf_sz,
1347 dev_kfree_skb(de->rx_skb[i].skb);
1352 struct sk_buff *skb = de->tx_skb[i].skb;
1355 de->dev->stats.tx_dropped++;
1356 dma_unmap_single(&de->pdev->dev,
1357 de->tx_skb[i].mapping,
1361 dma_unmap_single(&de->pdev->dev,
1362 de->tx_skb[i].mapping,
1363 sizeof(de->setup_frame),
1369 memset(&de->rx_skb, 0, sizeof(struct ring_info) * DE_RX_RING_SIZE);
1370 memset(&de->tx_skb, 0, sizeof(struct ring_info) * DE_TX_RING_SIZE);
1373 static void de_free_rings (struct de_private *de)
1375 de_clean_rings(de);
1376 dma_free_coherent(&de->pdev->dev, DE_RING_BYTES, de->rx_ring,
1377 de->ring_dma);
1378 de->rx_ring = NULL;
1379 de->tx_ring = NULL;
1384 struct de_private *de = netdev_priv(dev);
1385 const int irq = de->pdev->irq;
1388 netif_dbg(de, ifup, dev, "enabling interface\n");
1390 de->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
1392 rc = de_alloc_rings(de);
1406 rc = de_init_hw(de);
1413 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1420 de_free_rings(de);
1426 struct de_private *de = netdev_priv(dev);
1429 netif_dbg(de, ifdown, dev, "disabling interface\n");
1431 del_timer_sync(&de->media_timer);
1433 spin_lock_irqsave(&de->lock, flags);
1434 de_stop_hw(de);
1437 spin_unlock_irqrestore(&de->lock, flags);
1439 free_irq(de->pdev->irq, dev);
1441 de_free_rings(de);
1442 de_adapter_sleep(de);
1448 struct de_private *de = netdev_priv(dev);
1449 const int irq = de->pdev->irq;
1453 de->rx_tail, de->tx_head, de->tx_tail);
1455 del_timer_sync(&de->media_timer);
1458 spin_lock_irq(&de->lock);
1460 de_stop_hw(de);
1464 spin_unlock_irq(&de->lock);
1468 __de_get_stats(de);
1471 de_clean_rings(de);
1473 de_init_rings(de);
1475 de_init_hw(de);
1480 static void __de_get_regs(struct de_private *de, u8 *buf)
1490 de_rx_missed(de, rbuf[8]);
1493 static void __de_get_link_ksettings(struct de_private *de,
1497 de->media_supported);
1500 de->media_advertise);
1502 switch (de->media_type) {
1521 if (de->media_lock)
1529 static int __de_set_link_ksettings(struct de_private *de,
1548 if (de->de21040 && port == PORT_BNC)
1552 if (advertising & ~de->media_supported)
1586 if ((new_media == de->media_type) &&
1587 (media_lock == de->media_lock) &&
1588 (advertising == de->media_advertise))
1591 de_link_down(de);
1592 mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1593 de_stop_rxtx(de);
1595 de->media_type = new_media;
1596 de->media_lock = media_lock;
1597 de->media_advertise = advertising;
1598 de_set_media(de);
1599 if (netif_running(de->dev))
1600 de_start_rxtx(de);
1607 struct de_private *de = netdev_priv(dev);
1610 strscpy(info->bus_info, pci_name(de->pdev), sizeof(info->bus_info));
1621 struct de_private *de = netdev_priv(dev);
1623 spin_lock_irq(&de->lock);
1624 __de_get_link_ksettings(de, cmd);
1625 spin_unlock_irq(&de->lock);
1633 struct de_private *de = netdev_priv(dev);
1636 spin_lock_irq(&de->lock);
1637 rc = __de_set_link_ksettings(de, cmd);
1638 spin_unlock_irq(&de->lock);
1645 struct de_private *de = netdev_priv(dev);
1647 return de->msg_enable;
1652 struct de_private *de = netdev_priv(dev);
1654 de->msg_enable = msglvl;
1660 struct de_private *de = netdev_priv(dev);
1662 if (!de->ee_data)
1667 memcpy(data, de->ee_data, eeprom->len);
1674 struct de_private *de = netdev_priv(dev);
1677 if (de->media_type != DE_MEDIA_TP_AUTO)
1679 if (netif_carrier_ok(de->dev))
1680 de_link_down(de);
1684 netif_info(de, link, dev, "link nway restart, status %x,%x\n",
1692 struct de_private *de = netdev_priv(dev);
1694 regs->version = (DE_REGS_VER << 2) | de->de21040;
1696 spin_lock_irq(&de->lock);
1697 __de_get_regs(de, data);
1698 spin_unlock_irq(&de->lock);
1714 static void de21040_get_mac_address(struct de_private *de)
1734 eth_hw_addr_set(de->dev, addr);
1737 static void de21040_get_media_info(struct de_private *de)
1741 de->media_type = DE_MEDIA_TP;
1742 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full |
1744 de->media_advertise = de->media_supported;
1751 de->media[i].type = i;
1752 de->media[i].csr13 = t21040_csr13[i];
1753 de->media[i].csr14 = t21040_csr14[i];
1754 de->media[i].csr15 = t21040_csr15[i];
1757 de->media[i].type = DE_MEDIA_INVALID;
1800 static void de21041_get_srom_info(struct de_private *de)
1804 unsigned ee_addr_size = tulip_read_eeprom(de->regs, 0xff, 8) & 0x40000 ? 8 : 6;
1811 cpu_to_le16(tulip_read_eeprom(de->regs, i, ee_addr_size));
1826 eth_hw_addr_set(de->dev, &ee_data[sa_offset]);
1845 case 0x0001: de->media_type = DE_MEDIA_BNC; break;
1846 case 0x0002: de->media_type = DE_MEDIA_AUI; break;
1847 case 0x0204: de->media_type = DE_MEDIA_TP_FD; break;
1848 default: de->media_type = DE_MEDIA_TP_AUTO; break;
1851 if (netif_msg_probe(de))
1852 pr_info("de%d: SROM leaf offset %u, default media %s\n",
1853 de->board_idx, ofs, media_name[de->media_type]);
1857 de->media[i].type = DE_MEDIA_INVALID;
1858 de->media[i].csr13 = 0xffff;
1859 de->media[i].csr14 = 0xffff;
1860 de->media[i].csr15 = 0xffff;
1874 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half
1877 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1880 de->media_supported |= SUPPORTED_BNC;
1884 de->media_supported |= SUPPORTED_AUI;
1888 de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full
1891 de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1897 de->media[idx].type = idx;
1899 if (netif_msg_probe(de))
1900 pr_info("de%d: media block #%u: %s",
1901 de->board_idx, i,
1902 media_name[de->media[idx].type]);
1907 de->media[idx].csr13 = get_unaligned(&ib->csr13);
1908 de->media[idx].csr14 = get_unaligned(&ib->csr14);
1909 de->media[idx].csr15 = get_unaligned(&ib->csr15);
1913 if (netif_msg_probe(de))
1915 de->media[idx].csr13,
1916 de->media[idx].csr14,
1917 de->media[idx].csr15);
1920 if (netif_msg_probe(de))
1928 de->media_advertise = de->media_supported;
1933 if (de->media[i].csr13 == 0xffff)
1934 de->media[i].csr13 = t21041_csr13[i];
1935 if (de->media[i].csr14 == 0xffff) {
1938 if (de->pdev->revision < 0x20)
1939 de->media[i].csr14 = t21041_csr14_brk[i];
1941 de->media[i].csr14 = t21041_csr14[i];
1943 if (de->media[i].csr15 == 0xffff)
1944 de->media[i].csr15 = t21041_csr15[i];
1947 de->ee_data = kmemdup(&ee_data[0], DE_EEPROM_SIZE, GFP_KERNEL);
1954 de->media[i].type = i;
1955 de->media_supported =
1979 struct de_private *de;
1997 de = netdev_priv(dev);
1998 de->de21040 = ent->driver_data == 0 ? 1 : 0;
1999 de->pdev = pdev;
2000 de->dev = dev;
2001 de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug);
2002 de->board_idx = board_idx;
2003 spin_lock_init (&de->lock);
2004 timer_setup(&de->media_timer,
2005 de->de21040 ? de21040_media_timer : de21041_media_timer,
2052 de->regs = regs;
2054 de_adapter_wake(de);
2057 rc = de_reset_mac(de);
2066 if (de->de21040) {
2067 de21040_get_mac_address(de);
2068 de21040_get_media_info(de);
2070 de21041_get_srom_info(de);
2080 de->de21040 ? "21040" : "21041",
2089 de_adapter_sleep(de);
2094 kfree(de->ee_data);
2108 struct de_private *de = netdev_priv(dev);
2112 kfree(de->ee_data);
2113 iounmap(de->regs);
2123 struct de_private *de = netdev_priv(dev);
2129 del_timer_sync(&de->media_timer);
2132 spin_lock_irq(&de->lock);
2134 de_stop_hw(de);
2139 spin_unlock_irq(&de->lock);
2143 __de_get_stats(de);
2146 de_clean_rings(de);
2148 de_adapter_sleep(de);
2160 struct de_private *de = netdev_priv(dev);
2168 de_init_rings(de);
2169 de_init_hw(de);