Lines Matching refs:mac
83 static unsigned int read_mac_reg(const struct pasemi_mac *mac, unsigned int reg)
85 return pasemi_read_mac_reg(mac->dma_if, reg);
88 static void write_mac_reg(const struct pasemi_mac *mac, unsigned int reg,
91 pasemi_write_mac_reg(mac->dma_if, reg, val);
104 static struct pasemi_mac_rxring *rx_ring(const struct pasemi_mac *mac)
106 return mac->rx;
109 static struct pasemi_mac_txring *tx_ring(const struct pasemi_mac *mac)
111 return mac->tx;
124 static int mac_to_intf(struct pasemi_mac *mac)
126 struct pci_dev *pdev = mac->pdev;
152 static void pasemi_mac_intf_disable(struct pasemi_mac *mac)
156 flags = read_mac_reg(mac, PAS_MAC_CFG_PCFG);
158 write_mac_reg(mac, PAS_MAC_CFG_PCFG, flags);
161 static void pasemi_mac_intf_enable(struct pasemi_mac *mac)
165 flags = read_mac_reg(mac, PAS_MAC_CFG_PCFG);
167 write_mac_reg(mac, PAS_MAC_CFG_PCFG, flags);
170 static int pasemi_get_mac_addr(struct pasemi_mac *mac)
172 struct pci_dev *pdev = mac->pdev;
180 "No device node for mac, not configuring\n");
184 maddr = of_get_property(dn, "local-mac-address", &len);
187 memcpy(mac->mac_addr, maddr, ETH_ALEN);
191 /* Some old versions of firmware mistakenly uses mac-address
192 * (and as a string) instead of a byte array in local-mac-address.
196 maddr = of_get_property(dn, "mac-address", NULL);
200 "no mac address in device tree, not configuring\n");
206 "can't parse mac address, not configuring\n");
210 memcpy(mac->mac_addr, addr, ETH_ALEN);
217 struct pasemi_mac *mac = netdev_priv(dev);
230 adr1 = read_mac_reg(mac, PAS_MAC_CFG_ADR1);
234 pasemi_mac_intf_disable(mac);
235 write_mac_reg(mac, PAS_MAC_CFG_ADR0, adr0);
236 write_mac_reg(mac, PAS_MAC_CFG_ADR1, adr1);
237 pasemi_mac_intf_enable(mac);
242 static int pasemi_mac_unmap_tx_skb(struct pasemi_mac *mac,
248 struct pci_dev *pdev = mac->dma_pdev;
266 static struct pasemi_mac_csring *pasemi_mac_setup_csring(struct pasemi_mac *mac)
277 dev_err(&mac->pdev->dev, "Can't allocate checksum channel\n");
340 static void pasemi_mac_setup_csrings(struct pasemi_mac *mac)
343 mac->cs[0] = pasemi_mac_setup_csring(mac);
344 if (mac->type == MAC_TYPE_XAUI)
345 mac->cs[1] = pasemi_mac_setup_csring(mac);
347 mac->cs[1] = 0;
350 if (mac->cs[i])
351 mac->num_cs++;
367 struct pasemi_mac *mac = netdev_priv(dev);
375 dev_err(&mac->pdev->dev, "Can't allocate RX channel\n");
394 ring->buffers = dma_alloc_coherent(&mac->dma_pdev->dev,
414 write_dma_reg(PAS_DMA_RXINT_BASEL(mac->dma_if),
417 write_dma_reg(PAS_DMA_RXINT_BASEU(mac->dma_if),
428 write_dma_reg(PAS_DMA_RXINT_CFG(mac->dma_if), cfg);
432 ring->mac = mac;
433 mac->rx = ring;
448 struct pasemi_mac *mac = netdev_priv(dev);
458 dev_err(&mac->pdev->dev, "Can't allocate TX channel\n");
485 PAS_DMA_TXCHAN_CFG_TATTR(mac->dma_if) |
496 ring->mac = mac;
508 static void pasemi_mac_free_tx_resources(struct pasemi_mac *mac)
510 struct pasemi_mac_txring *txring = tx_ring(mac);
531 freed = pasemi_mac_unmap_tx_skb(mac, nfrags,
543 static void pasemi_mac_free_rx_buffers(struct pasemi_mac *mac)
545 struct pasemi_mac_rxring *rx = rx_ring(mac);
552 dma_unmap_single(&mac->dma_pdev->dev, info->dma,
564 static void pasemi_mac_free_rx_resources(struct pasemi_mac *mac)
566 pasemi_mac_free_rx_buffers(mac);
568 dma_free_coherent(&mac->dma_pdev->dev, RX_RING_SIZE * sizeof(u64),
569 rx_ring(mac)->buffers, rx_ring(mac)->buf_dma);
571 kfree(rx_ring(mac)->ring_info);
572 pasemi_dma_free_chan(&rx_ring(mac)->chan);
573 mac->rx = NULL;
579 const struct pasemi_mac *mac = netdev_priv(dev);
580 struct pasemi_mac_rxring *rx = rx_ring(mac);
586 fill = rx_ring(mac)->next_to_fill;
596 skb = netdev_alloc_skb(dev, mac->bufsz);
602 dma = dma_map_single(&mac->dma_pdev->dev, skb->data,
603 mac->bufsz - LOCAL_SKB_ALIGN,
606 if (dma_mapping_error(&mac->dma_pdev->dev, dma)) {
613 *buff = XCT_RXB_LEN(mac->bufsz) | XCT_RXB_ADDR(dma);
619 write_dma_reg(PAS_DMA_RXINT_INCR(mac->dma_if), count);
621 rx_ring(mac)->next_to_fill = (rx_ring(mac)->next_to_fill + count) &
625 static void pasemi_mac_restart_rx_intr(const struct pasemi_mac *mac)
627 struct pasemi_mac_rxring *rx = rx_ring(mac);
640 write_iob_reg(PAS_IOB_DMA_RXCH_RESET(mac->rx->chan.chno), reg);
643 static void pasemi_mac_restart_tx_intr(const struct pasemi_mac *mac)
648 pcnt = *tx_ring(mac)->chan.status & PAS_STATUS_PCNT_M;
652 write_iob_reg(PAS_IOB_DMA_TXCH_RESET(tx_ring(mac)->chan.chno), reg);
656 static inline void pasemi_mac_rx_error(const struct pasemi_mac *mac,
660 struct pasemi_dmachan *chan = &rx_ring(mac)->chan;
662 if (!netif_msg_rx_err(mac))
665 rcmdsta = read_dma_reg(PAS_DMA_RXINT_RCMDSTA(mac->dma_if));
675 static inline void pasemi_mac_tx_error(const struct pasemi_mac *mac,
679 struct pasemi_dmachan *chan = &tx_ring(mac)->chan;
681 if (!netif_msg_tx_err(mac))
696 struct pasemi_mac *mac = rx->mac;
697 struct pci_dev *pdev = mac->dma_pdev;
721 pasemi_mac_rx_error(mac, macrx);
744 mac->bufsz - LOCAL_SKB_ALIGN,
749 mac->netdev->stats.rx_errors++;
750 mac->netdev->stats.rx_crc_errors++;
772 skb->protocol = eth_type_trans(skb, mac->netdev);
773 napi_gro_receive(&mac->napi, skb);
793 rx_ring(mac)->next_to_clean = n;
799 write_dma_reg(PAS_DMA_RXCHAN_INCR(mac->rx->chan.chno), count << 1);
801 pasemi_mac_replenish_rx_ring(mac->netdev, count);
803 mac->netdev->stats.rx_bytes += tot_bytes;
804 mac->netdev->stats.rx_packets += packets;
806 spin_unlock(&rx_ring(mac)->lock);
817 struct pasemi_mac *mac = txring->mac;
853 pasemi_mac_tx_error(mac, mactx);
891 netif_wake_queue(mac->netdev);
894 pasemi_mac_unmap_tx_skb(mac, nf[i], skbs[i], dmas[i]);
909 struct pasemi_mac *mac = rxring->mac;
926 napi_schedule(&mac->napi);
938 struct pasemi_mac *mac = txring->mac;
944 pasemi_mac_restart_tx_intr(mac);
951 struct pasemi_mac *mac = txring->mac;
966 napi_schedule(&mac->napi);
976 struct pasemi_mac *mac = netdev_priv(dev);
985 if (mac->link && netif_msg_link(mac))
989 pasemi_mac_intf_disable(mac);
990 mac->link = 0;
994 pasemi_mac_intf_enable(mac);
998 flags = read_mac_reg(mac, PAS_MAC_CFG_PCFG);
1023 msg = mac->link != dev->phydev->link || flags != new_flags;
1025 mac->duplex = dev->phydev->duplex;
1026 mac->speed = dev->phydev->speed;
1027 mac->link = dev->phydev->link;
1030 write_mac_reg(mac, PAS_MAC_CFG_PCFG, new_flags);
1032 if (msg && netif_msg_link(mac))
1034 dev->name, mac->speed, mac->duplex ? "full" : "half");
1039 struct pasemi_mac *mac = netdev_priv(dev);
1043 dn = pci_device_to_OF_node(mac->pdev);
1046 mac->link = 0;
1047 mac->speed = 0;
1048 mac->duplex = -1;
1065 struct pasemi_mac *mac = netdev_priv(dev);
1073 write_mac_reg(mac, PAS_MAC_CFG_TXP, flags);
1079 mac->tx = pasemi_mac_setup_tx_resources(dev);
1081 if (!mac->tx) {
1089 if (dev->mtu > 1500 && !mac->num_cs) {
1090 pasemi_mac_setup_csrings(mac);
1091 if (!mac->num_cs) {
1099 write_mac_reg(mac, PAS_MAC_RMON(i), 0);
1105 write_iob_reg(PAS_IOB_DMA_RXCH_CFG(mac->rx->chan.chno),
1108 write_iob_reg(PAS_IOB_DMA_TXCH_CFG(mac->tx->chan.chno),
1111 write_mac_reg(mac, PAS_MAC_IPC_CHNL,
1112 PAS_MAC_IPC_CHNL_DCHNO(mac->rx->chan.chno) |
1113 PAS_MAC_IPC_CHNL_BCH(mac->rx->chan.chno));
1116 write_dma_reg(PAS_DMA_RXINT_RCMDSTA(mac->dma_if),
1124 pasemi_dma_start_chan(&rx_ring(mac)->chan, PAS_DMA_RXCHAN_CCMDSTA_DU |
1130 pasemi_dma_start_chan(&tx_ring(mac)->chan, PAS_DMA_TXCHAN_TCMDSTA_SZ |
1137 write_dma_reg(PAS_DMA_RXCHAN_INCR(rx_ring(mac)->chan.chno),
1141 pasemi_mac_restart_rx_intr(mac);
1142 pasemi_mac_restart_tx_intr(mac);
1146 if (mac->type == MAC_TYPE_GMAC)
1152 write_mac_reg(mac, PAS_MAC_CFG_PCFG, flags);
1157 pasemi_mac_intf_enable(mac);
1158 if (mac->type == MAC_TYPE_GMAC) {
1160 dev_warn(&mac->pdev->dev,
1162 dev_warn(&mac->pdev->dev,
1168 napi_enable(&mac->napi);
1170 snprintf(mac->tx_irq_name, sizeof(mac->tx_irq_name), "%s tx",
1173 ret = request_irq(mac->tx->chan.irq, pasemi_mac_tx_intr, 0,
1174 mac->tx_irq_name, mac->tx);
1176 dev_err(&mac->pdev->dev, "request_irq of irq %d failed: %d\n",
1177 mac->tx->chan.irq, ret);
1181 snprintf(mac->rx_irq_name, sizeof(mac->rx_irq_name), "%s rx",
1184 ret = request_irq(mac->rx->chan.irq, pasemi_mac_rx_intr, 0,
1185 mac->rx_irq_name, mac->rx);
1187 dev_err(&mac->pdev->dev, "request_irq of irq %d failed: %d\n",
1188 mac->rx->chan.irq, ret);
1195 timer_setup(&mac->tx->clean_timer, pasemi_mac_tx_timer, 0);
1196 mod_timer(&mac->tx->clean_timer, jiffies + HZ);
1201 free_irq(mac->tx->chan.irq, mac->tx);
1203 napi_disable(&mac->napi);
1206 if (mac->tx)
1207 pasemi_mac_free_tx_resources(mac);
1208 pasemi_mac_free_rx_resources(mac);
1216 static void pasemi_mac_pause_txchan(struct pasemi_mac *mac)
1219 int txch = tx_ring(mac)->chan.chno;
1232 dev_err(&mac->dma_pdev->dev,
1238 static void pasemi_mac_pause_rxchan(struct pasemi_mac *mac)
1241 int rxch = rx_ring(mac)->chan.chno;
1253 dev_err(&mac->dma_pdev->dev,
1258 static void pasemi_mac_pause_rxint(struct pasemi_mac *mac)
1262 write_dma_reg(PAS_DMA_RXINT_RCMDSTA(mac->dma_if),
1265 sta = read_dma_reg(PAS_DMA_RXINT_RCMDSTA(mac->dma_if));
1272 dev_err(&mac->dma_pdev->dev,
1274 write_dma_reg(PAS_DMA_RXINT_RCMDSTA(mac->dma_if), 0);
1279 struct pasemi_mac *mac = netdev_priv(dev);
1283 rxch = rx_ring(mac)->chan.chno;
1284 txch = tx_ring(mac)->chan.chno;
1291 del_timer_sync(&mac->tx->clean_timer);
1294 napi_disable(&mac->napi);
1296 sta = read_dma_reg(PAS_DMA_RXINT_RCMDSTA(mac->dma_if));
1315 pasemi_mac_clean_tx(tx_ring(mac));
1316 pasemi_mac_clean_rx(rx_ring(mac), RX_RING_SIZE);
1318 pasemi_mac_pause_txchan(mac);
1319 pasemi_mac_pause_rxint(mac);
1320 pasemi_mac_pause_rxchan(mac);
1321 pasemi_mac_intf_disable(mac);
1323 free_irq(mac->tx->chan.irq, mac->tx);
1324 free_irq(mac->rx->chan.irq, mac->rx);
1326 for (i = 0; i < mac->num_cs; i++) {
1327 pasemi_mac_free_csring(mac->cs[i]);
1328 mac->cs[i] = NULL;
1331 mac->num_cs = 0;
1334 pasemi_mac_free_rx_resources(mac);
1335 pasemi_mac_free_tx_resources(mac);
1428 struct pasemi_mac * const mac = netdev_priv(dev);
1429 struct pasemi_mac_txring * const txring = tx_ring(mac);
1447 map[0] = dma_map_single(&mac->dma_pdev->dev, skb->data,
1450 if (dma_mapping_error(&mac->dma_pdev->dev, map[0]))
1456 map[i + 1] = skb_frag_dma_map(&mac->dma_pdev->dev, frag, 0,
1459 if (dma_mapping_error(&mac->dma_pdev->dev, map[i + 1])) {
1497 if (mac->num_cs && skb->ip_summed == CHECKSUM_PARTIAL && skb->len > 1540) {
1498 csring = mac->cs[mac->last_cs];
1499 mac->last_cs = (mac->last_cs + 1) % mac->num_cs;
1537 dma_unmap_single(&mac->dma_pdev->dev, map[nfrags],
1545 const struct pasemi_mac *mac = netdev_priv(dev);
1548 flags = read_mac_reg(mac, PAS_MAC_CFG_PCFG);
1556 write_mac_reg(mac, PAS_MAC_CFG_PCFG, flags);
1562 struct pasemi_mac *mac = container_of(napi, struct pasemi_mac, napi);
1565 pasemi_mac_clean_tx(tx_ring(mac));
1566 pkts = pasemi_mac_clean_rx(rx_ring(mac), budget);
1571 pasemi_mac_restart_rx_intr(mac);
1572 pasemi_mac_restart_tx_intr(mac);
1585 const struct pasemi_mac *mac = netdev_priv(dev);
1587 disable_irq(mac->tx->chan.irq);
1588 pasemi_mac_tx_intr(mac->tx->chan.irq, mac->tx);
1589 enable_irq(mac->tx->chan.irq);
1591 disable_irq(mac->rx->chan.irq);
1592 pasemi_mac_rx_intr(mac->rx->chan.irq, mac->rx);
1593 enable_irq(mac->rx->chan.irq);
1599 struct pasemi_mac *mac = netdev_priv(dev);
1614 napi_disable(&mac->napi);
1616 pasemi_mac_intf_disable(mac);
1618 rcmdsta = read_dma_reg(PAS_DMA_RXINT_RCMDSTA(mac->dma_if));
1619 pasemi_mac_pause_rxint(mac);
1620 pasemi_mac_clean_rx(rx_ring(mac), RX_RING_SIZE);
1621 pasemi_mac_free_rx_buffers(mac);
1626 if (new_mtu > PE_DEF_MTU && !mac->num_cs) {
1627 pasemi_mac_setup_csrings(mac);
1628 if (!mac->num_cs) {
1637 reg = read_mac_reg(mac, PAS_MAC_CFG_MACCFG);
1640 write_mac_reg(mac, PAS_MAC_CFG_MACCFG, reg);
1644 mac->bufsz = new_mtu + ETH_HLEN + ETH_FCS_LEN + LOCAL_SKB_ALIGN + 128;
1648 write_dma_reg(PAS_DMA_RXINT_RCMDSTA(mac->dma_if),
1651 rx_ring(mac)->next_to_fill = 0;
1654 napi_enable(&mac->napi);
1656 pasemi_mac_intf_enable(mac);
1679 struct pasemi_mac *mac;
1695 mac = netdev_priv(dev);
1697 mac->pdev = pdev;
1698 mac->netdev = dev;
1700 netif_napi_add(dev, &mac->napi, pasemi_mac_poll);
1705 mac->dma_pdev = pci_get_device(PCI_VENDOR_ID_PASEMI, 0xa007, NULL);
1706 if (!mac->dma_pdev) {
1707 dev_err(&mac->pdev->dev, "Can't find DMA Controller\n");
1711 dma_set_mask(&mac->dma_pdev->dev, DMA_BIT_MASK(64));
1713 mac->iob_pdev = pci_get_device(PCI_VENDOR_ID_PASEMI, 0xa001, NULL);
1714 if (!mac->iob_pdev) {
1715 dev_err(&mac->pdev->dev, "Can't find I/O Bridge\n");
1720 /* get mac addr from device tree */
1721 if (pasemi_get_mac_addr(mac) || !is_valid_ether_addr(mac->mac_addr)) {
1725 eth_hw_addr_set(dev, mac->mac_addr);
1727 ret = mac_to_intf(mac);
1729 dev_err(&mac->pdev->dev, "Can't map DMA interface\n");
1733 mac->dma_if = ret;
1737 mac->type = MAC_TYPE_GMAC;
1740 mac->type = MAC_TYPE_XAUI;
1755 mac->bufsz = dev->mtu + ETH_HLEN + ETH_FCS_LEN + LOCAL_SKB_ALIGN + 128;
1762 mac->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
1765 mac->msg_enable = (NETIF_MSG_IFUP << 1 ) - 1;
1770 dev_err(&mac->pdev->dev, "register_netdev failed with error %d\n",
1773 } else if (netif_msg_probe(mac)) {
1775 dev->name, mac->type == MAC_TYPE_GMAC ? "GMAC" : "XAUI",
1776 mac->dma_if, dev->dev_addr);
1782 pci_dev_put(mac->iob_pdev);
1783 pci_dev_put(mac->dma_pdev);
1795 struct pasemi_mac *mac;
1800 mac = netdev_priv(netdev);
1805 pci_dev_put(mac->dma_pdev);
1806 pci_dev_put(mac->iob_pdev);
1808 pasemi_dma_free_chan(&mac->tx->chan);
1809 pasemi_dma_free_chan(&mac->rx->chan);