Lines Matching defs:hmp
273 the 'hmp->tx_full' flag.
277 empty by incrementing the dirty_tx mark. Iff the 'hmp->tx_full' flag is set, it
581 struct hamachi_private *hmp;
638 hmp = netdev_priv(dev);
639 spin_lock_init(&hmp->lock);
641 hmp->mii_if.dev = dev;
642 hmp->mii_if.mdio_read = mdio_read;
643 hmp->mii_if.mdio_write = mdio_write;
644 hmp->mii_if.phy_id_mask = 0x1f;
645 hmp->mii_if.reg_num_mask = 0x1f;
651 hmp->tx_ring = ring_space;
652 hmp->tx_ring_dma = ring_dma;
658 hmp->rx_ring = ring_space;
659 hmp->rx_ring_dma = ring_dma;
686 hmp->base = ioaddr;
689 hmp->chip_id = chip_id;
690 hmp->pci_dev = pdev;
694 hmp->option = option;
696 hmp->mii_if.full_duplex = 1;
698 hmp->mii_if.full_duplex = 0;
699 hmp->default_port = option & 15;
700 if (hmp->default_port)
701 hmp->mii_if.force_media = 1;
704 hmp->mii_if.full_duplex = 1;
707 if (hmp->mii_if.full_duplex || (option & 0x080))
708 hmp->duplex_lock = 1;
720 hmp->rx_int_var = rx_int_var >= 0 ? rx_int_var :
722 hmp->tx_int_var = tx_int_var >= 0 ? tx_int_var :
728 dev->ethtool_ops = (chip_tbl[hmp->chip_id].flags & CanHaveMII) ?
750 if (chip_tbl[hmp->chip_id].flags & CanHaveMII) {
756 hmp->phys[phy_idx++] = phy;
757 hmp->mii_if.advertising = mdio_read(dev, phy, MII_ADVERTISE);
760 dev->name, phy, mii_status, hmp->mii_if.advertising);
763 hmp->mii_cnt = phy_idx;
764 if (hmp->mii_cnt > 0)
765 hmp->mii_if.phy_id = hmp->phys[0];
767 memset(&hmp->mii_if, 0, sizeof(hmp->mii_if));
778 dma_free_coherent(&pdev->dev, RX_TOTAL_SIZE, hmp->rx_ring,
779 hmp->rx_ring_dma);
781 dma_free_coherent(&pdev->dev, TX_TOTAL_SIZE, hmp->tx_ring,
782 hmp->tx_ring_dma);
815 struct hamachi_private *hmp = netdev_priv(dev);
816 void __iomem *ioaddr = hmp->base;
833 struct hamachi_private *hmp = netdev_priv(dev);
834 void __iomem *ioaddr = hmp->base;
853 struct hamachi_private *hmp = netdev_priv(dev);
854 void __iomem *ioaddr = hmp->base;
859 i = request_irq(hmp->pci_dev->irq, hamachi_interrupt, IRQF_SHARED,
868 writel(hmp->rx_ring_dma, ioaddr + RxPtr);
869 writel(hmp->rx_ring_dma >> 32, ioaddr + RxPtr + 4);
870 writel(hmp->tx_ring_dma, ioaddr + TxPtr);
871 writel(hmp->tx_ring_dma >> 32, ioaddr + TxPtr + 4);
873 writel(hmp->rx_ring_dma, ioaddr + RxPtr);
874 writel(hmp->tx_ring_dma, ioaddr + TxPtr);
914 dev->if_port = hmp->default_port;
919 if (hmp->duplex_lock != 1)
920 hmp->mii_if.full_duplex = 1;
944 rx_int_var = hmp->rx_int_var;
945 tx_int_var = hmp->tx_int_var;
984 timer_setup(&hmp->timer, hamachi_timer, 0);
985 hmp->timer.expires = RUN_AT((24*HZ)/10); /* 2.4 sec. */
986 add_timer(&hmp->timer);
993 struct hamachi_private *hmp = netdev_priv(dev);
997 for (; hmp->cur_tx - hmp->dirty_tx > 0; hmp->dirty_tx++) {
998 int entry = hmp->dirty_tx % TX_RING_SIZE;
1001 if (hmp->tx_ring[entry].status_n_length & cpu_to_le32(DescOwn))
1004 skb = hmp->tx_skbuff[entry];
1006 dma_unmap_single(&hmp->pci_dev->dev,
1007 leXX_to_cpu(hmp->tx_ring[entry].addr),
1010 hmp->tx_skbuff[entry] = NULL;
1012 hmp->tx_ring[entry].status_n_length = 0;
1014 hmp->tx_ring[TX_RING_SIZE-1].status_n_length |=
1024 struct hamachi_private *hmp = from_timer(hmp, t, timer);
1025 struct net_device *dev = hmp->mii_if.dev;
1026 void __iomem *ioaddr = hmp->base;
1043 hmp->timer.expires = RUN_AT(next_tick);
1044 add_timer(&hmp->timer);
1050 struct hamachi_private *hmp = netdev_priv(dev);
1051 void __iomem *ioaddr = hmp->base;
1057 printk(KERN_DEBUG " Rx ring %p: ", hmp->rx_ring);
1060 le32_to_cpu(hmp->rx_ring[i].status_n_length));
1062 printk(KERN_DEBUG" Tx ring %p: ", hmp->tx_ring);
1065 le32_to_cpu(hmp->tx_ring[i].status_n_length));
1081 hmp->rx_ring[i].status_n_length &= cpu_to_le32(~DescOwn);
1090 hmp->tx_ring[i].status_n_length =
1092 (hmp->tx_ring[i].status_n_length &
1095 hmp->tx_ring[i].status_n_length &= cpu_to_le32(0x0000ffff);
1096 skb = hmp->tx_skbuff[i];
1098 dma_unmap_single(&hmp->pci_dev->dev,
1099 leXX_to_cpu(hmp->tx_ring[i].addr),
1102 hmp->tx_skbuff[i] = NULL;
1111 hmp->tx_full = 0;
1112 hmp->cur_rx = hmp->cur_tx = 0;
1113 hmp->dirty_rx = hmp->dirty_tx = 0;
1118 struct sk_buff *skb = hmp->rx_skbuff[i];
1121 dma_unmap_single(&hmp->pci_dev->dev,
1122 leXX_to_cpu(hmp->rx_ring[i].addr),
1123 hmp->rx_buf_sz, DMA_FROM_DEVICE);
1125 hmp->rx_skbuff[i] = NULL;
1132 skb = netdev_alloc_skb_ip_align(dev, hmp->rx_buf_sz);
1133 hmp->rx_skbuff[i] = skb;
1137 hmp->rx_ring[i].addr = cpu_to_leXX(dma_map_single(&hmp->pci_dev->dev,
1139 hmp->rx_buf_sz,
1141 hmp->rx_ring[i].status_n_length = cpu_to_le32(DescOwn |
1142 DescEndPacket | DescIntr | (hmp->rx_buf_sz - 2));
1144 hmp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
1146 hmp->rx_ring[RX_RING_SIZE-1].status_n_length |= cpu_to_le32(DescEndRing);
1164 struct hamachi_private *hmp = netdev_priv(dev);
1167 hmp->tx_full = 0;
1168 hmp->cur_rx = hmp->cur_tx = 0;
1169 hmp->dirty_rx = hmp->dirty_tx = 0;
1176 hmp->rx_buf_sz = (dev->mtu <= 1492 ? PKT_BUF_SZ :
1181 hmp->rx_ring[i].status_n_length = 0;
1182 hmp->rx_skbuff[i] = NULL;
1186 struct sk_buff *skb = netdev_alloc_skb(dev, hmp->rx_buf_sz + 2);
1187 hmp->rx_skbuff[i] = skb;
1191 hmp->rx_ring[i].addr = cpu_to_leXX(dma_map_single(&hmp->pci_dev->dev,
1193 hmp->rx_buf_sz,
1196 hmp->rx_ring[i].status_n_length = cpu_to_le32(DescOwn |
1197 DescEndPacket | DescIntr | (hmp->rx_buf_sz -2));
1199 hmp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
1200 hmp->rx_ring[RX_RING_SIZE-1].status_n_length |= cpu_to_le32(DescEndRing);
1203 hmp->tx_skbuff[i] = NULL;
1204 hmp->tx_ring[i].status_n_length = 0;
1207 hmp->tx_ring[TX_RING_SIZE-1].status_n_length |= cpu_to_le32(DescEndRing);
1214 struct hamachi_private *hmp = netdev_priv(dev);
1223 if (hmp->tx_full) {
1225 printk(KERN_WARNING "%s: Hamachi transmit queue full at slot %d.\n",dev->name, hmp->cur_tx);
1229 status=readw(hmp->base + TxStatus);
1231 writew(0x0001, hmp->base + TxCmd);
1239 entry = hmp->cur_tx % TX_RING_SIZE;
1241 hmp->tx_skbuff[entry] = skb;
1243 hmp->tx_ring[entry].addr = cpu_to_leXX(dma_map_single(&hmp->pci_dev->dev,
1258 hmp->tx_ring[entry].status_n_length = cpu_to_le32(DescOwn |
1261 hmp->tx_ring[entry].status_n_length = cpu_to_le32(DescOwn |
1263 hmp->cur_tx++;
1269 status=readw(hmp->base + TxStatus);
1271 writew(0x0001, hmp->base + TxCmd);
1282 if ((hmp->cur_tx - hmp->dirty_tx) < (TX_RING_SIZE - 4))
1285 hmp->tx_full = 1;
1291 dev->name, hmp->cur_tx, entry);
1301 struct hamachi_private *hmp = netdev_priv(dev);
1302 void __iomem *ioaddr = hmp->base;
1313 spin_lock(&hmp->lock);
1335 if (hmp->tx_full){
1336 for (; hmp->cur_tx - hmp->dirty_tx > 0; hmp->dirty_tx++){
1337 int entry = hmp->dirty_tx % TX_RING_SIZE;
1340 if (hmp->tx_ring[entry].status_n_length & cpu_to_le32(DescOwn))
1342 skb = hmp->tx_skbuff[entry];
1345 dma_unmap_single(&hmp->pci_dev->dev,
1346 leXX_to_cpu(hmp->tx_ring[entry].addr),
1350 hmp->tx_skbuff[entry] = NULL;
1352 hmp->tx_ring[entry].status_n_length = 0;
1354 hmp->tx_ring[TX_RING_SIZE-1].status_n_length |=
1358 if (hmp->cur_tx - hmp->dirty_tx < TX_RING_SIZE - 4){
1360 hmp->tx_full = 0;
1398 spin_unlock(&hmp->lock);
1406 struct hamachi_private *hmp = netdev_priv(dev);
1407 int entry = hmp->cur_rx % RX_RING_SIZE;
1408 int boguscnt = (hmp->dirty_rx + RX_RING_SIZE) - hmp->cur_rx;
1412 entry, hmp->rx_ring[entry].status_n_length);
1417 struct hamachi_desc *desc = &(hmp->rx_ring[entry]);
1425 dma_sync_single_for_cpu(&hmp->pci_dev->dev,
1427 hmp->rx_buf_sz, DMA_FROM_DEVICE);
1428 buf_addr = (u8 *) hmp->rx_skbuff[entry]->data;
1438 dev->name, hmp->cur_rx, data_size, desc_status);
1440 dev->name, desc, &hmp->rx_ring[hmp->cur_rx % RX_RING_SIZE]);
1443 le32_to_cpu(hmp->rx_ring[(hmp->cur_rx+1) % RX_RING_SIZE].status_n_length) & 0xffff0000,
1444 le32_to_cpu(hmp->rx_ring[(hmp->cur_rx+1) % RX_RING_SIZE].status_n_length) & 0x0000ffff,
1445 le32_to_cpu(hmp->rx_ring[(hmp->cur_rx-1) % RX_RING_SIZE].status_n_length));
1494 dma_sync_single_for_cpu(&hmp->pci_dev->dev,
1495 leXX_to_cpu(hmp->rx_ring[entry].addr),
1496 hmp->rx_buf_sz,
1501 hmp->rx_skbuff[entry]->data, pkt_len);
1504 skb_put_data(skb, hmp->rx_ring_dma
1507 dma_sync_single_for_device(&hmp->pci_dev->dev,
1508 leXX_to_cpu(hmp->rx_ring[entry].addr),
1509 hmp->rx_buf_sz,
1512 dma_unmap_single(&hmp->pci_dev->dev,
1513 leXX_to_cpu(hmp->rx_ring[entry].addr),
1514 hmp->rx_buf_sz,
1516 skb_put(skb = hmp->rx_skbuff[entry], pkt_len);
1517 hmp->rx_skbuff[entry] = NULL;
1582 entry = (++hmp->cur_rx) % RX_RING_SIZE;
1586 for (; hmp->cur_rx - hmp->dirty_rx > 0; hmp->dirty_rx++) {
1589 entry = hmp->dirty_rx % RX_RING_SIZE;
1590 desc = &(hmp->rx_ring[entry]);
1591 if (hmp->rx_skbuff[entry] == NULL) {
1592 struct sk_buff *skb = netdev_alloc_skb(dev, hmp->rx_buf_sz + 2);
1594 hmp->rx_skbuff[entry] = skb;
1598 desc->addr = cpu_to_leXX(dma_map_single(&hmp->pci_dev->dev,
1600 hmp->rx_buf_sz,
1603 desc->status_n_length = cpu_to_le32(hmp->rx_buf_sz);
1614 if (readw(hmp->base + RxStatus) & 0x0002)
1615 writew(0x0001, hmp->base + RxCmd);
1624 struct hamachi_private *hmp = netdev_priv(dev);
1625 void __iomem *ioaddr = hmp->base;
1658 struct hamachi_private *hmp = netdev_priv(dev);
1659 void __iomem *ioaddr = hmp->base;
1670 dev->name, hmp->cur_tx, hmp->dirty_tx, hmp->cur_rx, hmp->dirty_rx);
1683 (int)hmp->tx_ring_dma);
1686 readl(ioaddr + TxCurPtr) == (long)&hmp->tx_ring[i] ? '>' : ' ',
1687 i, hmp->tx_ring[i].status_n_length, hmp->tx_ring[i].addr);
1689 (int)hmp->rx_ring_dma);
1692 readl(ioaddr + RxCurPtr) == (long)&hmp->rx_ring[i] ? '>' : ' ',
1693 i, hmp->rx_ring[i].status_n_length, hmp->rx_ring[i].addr);
1695 if (*(u8*)hmp->rx_skbuff[i]->data != 0x69) {
1697 hmp->rx_skbuff[i]->data;
1709 free_irq(hmp->pci_dev->irq, dev);
1711 del_timer_sync(&hmp->timer);
1715 skb = hmp->rx_skbuff[i];
1716 hmp->rx_ring[i].status_n_length = 0;
1718 dma_unmap_single(&hmp->pci_dev->dev,
1719 leXX_to_cpu(hmp->rx_ring[i].addr),
1720 hmp->rx_buf_sz, DMA_FROM_DEVICE);
1722 hmp->rx_skbuff[i] = NULL;
1724 hmp->rx_ring[i].addr = cpu_to_leXX(0xBADF00D0); /* An invalid address. */
1727 skb = hmp->tx_skbuff[i];
1729 dma_unmap_single(&hmp->pci_dev->dev,
1730 leXX_to_cpu(hmp->tx_ring[i].addr),
1733 hmp->tx_skbuff[i] = NULL;
1744 struct hamachi_private *hmp = netdev_priv(dev);
1745 void __iomem *ioaddr = hmp->base;
1780 struct hamachi_private *hmp = netdev_priv(dev);
1781 void __iomem *ioaddr = hmp->base;
1911 struct hamachi_private *hmp = netdev_priv(dev);
1913 dma_free_coherent(&pdev->dev, RX_TOTAL_SIZE, hmp->rx_ring,
1914 hmp->rx_ring_dma);
1915 dma_free_coherent(&pdev->dev, TX_TOTAL_SIZE, hmp->tx_ring,
1916 hmp->tx_ring_dma);
1918 iounmap(hmp->base);