Lines Matching +full:hardware +full:- +full:wise
1 // SPDX-License-Identifier: GPL-2.0-or-later
31 #include <linux/dma-mapping.h>
63 card->irq_mask |= GELIC_CARD_RXINT;
64 gelic_card_set_irq_mask(card, card->irq_mask);
68 card->irq_mask &= ~GELIC_CARD_RXINT;
69 gelic_card_set_irq_mask(card, card->irq_mask);
81 &card->ether_port_status, &v2);
84 ether_netdev = card->netdev[GELIC_PORT_ETHERNET_0];
85 if (card->ether_port_status & GELIC_LV1_ETHER_LINK_UP)
93 * gelic_descr_get_status -- returns the status of a descriptor
101 return be32_to_cpu(descr->hw_regs.dmac_cmd_status) &
116 return -EBUSY;
119 card->link_mode = mode;
124 * gelic_card_disable_txdmac - disables the transmit DMA controller
142 * gelic_card_enable_rxdmac - enables the receive DMA controller
153 if (gelic_descr_get_status(card->rx_chain.head) !=
156 be32_to_cpu(card->rx_chain.head->hw_regs.dmac_cmd_status));
158 be32_to_cpu(card->rx_chain.head->hw_regs.next_descr_addr));
160 card->rx_chain.head);
164 card->rx_chain.head->link.cpu_addr, 0);
171 * gelic_card_disable_rxdmac - disables the receive DMA controller
189 * gelic_descr_set_status -- sets the status of a descriptor
199 descr->hw_regs.dmac_cmd_status = cpu_to_be32(status |
200 (be32_to_cpu(descr->hw_regs.dmac_cmd_status) &
206 * hardware, so we assure here the hardware sees the change.
212 * gelic_card_reset_chain - reset status of a descriptor chain
218 * and re-initialize the hardware chain for later use
226 for (descr = start_descr; start_descr != descr->next; descr++) {
228 descr->hw_regs.next_descr_addr
229 = cpu_to_be32(descr->next->link.cpu_addr);
232 chain->head = start_descr;
233 chain->tail = (descr - 1);
235 (descr - 1)->hw_regs.next_descr_addr = 0;
241 mutex_lock(&card->updown_lock);
242 if (atomic_inc_return(&card->users) == 1) {
245 gelic_card_set_irq_mask(card, card->irq_mask);
249 napi_enable(&card->napi);
251 mutex_unlock(&card->updown_lock);
259 mutex_lock(&card->updown_lock);
260 if (atomic_dec_if_positive(&card->users) == 0) {
262 napi_disable(&card->napi);
263 timer_delete_sync(&card->rx_oom_timer);
268 mask = card->irq_mask & (GELIC_CARD_WLAN_EVENT_RECEIVED |
273 gelic_card_reset_chain(card, &card->rx_chain,
274 card->descr + GELIC_NET_TX_DESCRIPTORS);
278 mutex_unlock(&card->updown_lock);
283 * gelic_card_free_chain - free descriptor chain
292 for (descr = descr_in; descr && descr->link.cpu_addr;
293 descr = descr->next) {
294 dma_unmap_single(ctodev(card), descr->link.cpu_addr,
295 descr->link.size, DMA_BIDIRECTIONAL);
296 descr->link.cpu_addr = 0;
297 descr->link.size = 0;
302 * gelic_card_init_chain - links descriptor chain
308 * we manage a circular list that mirrors the hardware structure,
309 * except that the hardware uses bus addresses.
323 /* set up the hardware pointers in each descriptor */
327 descr->link.size = sizeof(struct gelic_hw_regs);
328 descr->link.cpu_addr = dma_map_single(ctodev(card), descr,
329 descr->link.size, DMA_BIDIRECTIONAL);
331 if (dma_mapping_error(ctodev(card), descr->link.cpu_addr)) {
332 for (i--, descr--; 0 <= i; i--, descr--) {
334 descr->link.cpu_addr, descr->link.size,
337 return -ENOMEM;
340 descr->next = descr + 1;
341 descr->prev = descr - 1;
344 (descr - 1)->next = start_descr;
345 start_descr->prev = (descr - 1);
350 descr->hw_regs.next_descr_addr =
351 cpu_to_be32(descr->next->link.cpu_addr);
354 chain->head = start_descr;
355 chain->tail = start_descr;
358 (descr - 1)->hw_regs.next_descr_addr = 0;
364 * gelic_descr_prepare_rx - reinitializes a rx descriptor
366 * @descr: descriptor to re-init
371 * allocates a new rx skb, iommu-maps it and attaches it to the descriptor.
372 * Activate the descriptor state-wise
383 GELIC_NET_RXBUF_ALIGN - 1;
390 descr->hw_regs.dmac_cmd_status = 0;
391 descr->hw_regs.result_size = 0;
392 descr->hw_regs.valid_size = 0;
393 descr->hw_regs.data_error = 0;
394 descr->hw_regs.payload.dev_addr = 0;
395 descr->hw_regs.payload.size = 0;
398 descr->skb = napi_alloc_skb(&card->napi, rx_skb_size);
400 descr->skb = netdev_alloc_skb(*card->netdev, rx_skb_size);
401 if (!descr->skb) {
402 descr->hw_regs.payload.dev_addr = 0; /* tell DMAC don't touch memory */
403 return -ENOMEM;
406 offset = ((unsigned long)descr->skb->data) &
407 (GELIC_NET_RXBUF_ALIGN - 1);
409 skb_reserve(descr->skb, GELIC_NET_RXBUF_ALIGN - offset);
410 /* io-mmu-map the skb */
411 cpu_addr = dma_map_single(ctodev(card), descr->skb->data,
413 descr->hw_regs.payload.dev_addr = cpu_to_be32(cpu_addr);
415 dev_kfree_skb_any(descr->skb);
416 descr->skb = NULL;
418 "%s:Could not iommu-map rx buffer\n", __func__);
420 return -ENOMEM;
423 descr->hw_regs.payload.size = cpu_to_be32(GELIC_NET_MAX_FRAME);
424 descr->hw_regs.payload.dev_addr = cpu_to_be32(cpu_addr);
432 * gelic_card_release_rx_chain - free all skb of rx descr
438 struct gelic_descr *descr = card->rx_chain.head;
441 if (descr->skb) {
443 be32_to_cpu(descr->hw_regs.payload.dev_addr),
444 descr->skb->len,
446 descr->hw_regs.payload.dev_addr = 0;
447 descr->hw_regs.payload.size = 0;
448 dev_kfree_skb_any(descr->skb);
449 descr->skb = NULL;
453 descr = descr->next;
454 } while (descr != card->rx_chain.head);
458 * gelic_card_fill_rx_chain - fills descriptors/skbs in the rx chains
462 * and iommu-maps them.
467 struct gelic_descr *descr = card->rx_chain.head;
471 if (!descr->skb) {
476 descr = descr->next;
477 } while (descr != card->rx_chain.head);
486 * gelic_card_alloc_rx_skbs - allocates rx skbs in rx descriptor chains
495 chain = &card->rx_chain;
497 chain->tail = card->rx_top->prev; /* point to the last */
502 * gelic_descr_release_tx - processes a used tx descriptor
511 struct sk_buff *skb = descr->skb;
513 BUG_ON(!(be32_to_cpu(descr->hw_regs.data_status) & GELIC_DESCR_TX_TAIL));
516 be32_to_cpu(descr->hw_regs.payload.dev_addr), skb->len,
520 descr->hw_regs.payload.dev_addr = 0;
521 descr->hw_regs.payload.size = 0;
522 descr->hw_regs.next_descr_addr = 0;
523 descr->hw_regs.result_size = 0;
524 descr->hw_regs.valid_size = 0;
525 descr->hw_regs.data_status = 0;
526 descr->hw_regs.data_error = 0;
527 descr->skb = NULL;
535 netif_stop_queue(card->netdev[GELIC_PORT_ETHERNET_0]);
537 if (card->netdev[GELIC_PORT_WIRELESS])
538 netif_stop_queue(card->netdev[GELIC_PORT_WIRELESS]);
542 netif_wake_queue(card->netdev[GELIC_PORT_ETHERNET_0]);
544 if (card->netdev[GELIC_PORT_WIRELESS])
545 netif_wake_queue(card->netdev[GELIC_PORT_WIRELESS]);
548 * gelic_card_release_tx_chain - processes sent tx descriptors
561 for (tx_chain = &card->tx_chain;
562 tx_chain->head != tx_chain->tail && tx_chain->tail;
563 tx_chain->tail = tx_chain->tail->next) {
564 status = gelic_descr_get_status(tx_chain->tail);
565 netdev = tx_chain->tail->skb->dev;
575 netdev->stats.tx_dropped++;
579 if (tx_chain->tail->skb) {
580 netdev->stats.tx_packets++;
581 netdev->stats.tx_bytes +=
582 tx_chain->tail->skb->len;
593 gelic_descr_release_tx(card, tx_chain->tail);
602 * gelic_net_set_multi - sets multicast addresses and promisc flags
633 if ((netdev->flags & IFF_ALLMULTI) ||
648 p = ha->addr;
664 * gelic_net_stop - called upon ifconfig down
686 * gelic_card_get_next_tx_descr - returns the next available tx descriptor
694 if (!card->tx_chain.head)
697 if (card->tx_chain.tail != card->tx_chain.head->next &&
698 gelic_descr_get_status(card->tx_chain.head) ==
700 return card->tx_chain.head;
707 * gelic_descr_set_tx_cmdstat - sets the tx descriptor command field
712 * depending on hardware checksum settings. This function assumes a wmb()
718 if (skb->ip_summed != CHECKSUM_PARTIAL)
719 descr->hw_regs.dmac_cmd_status =
725 if (skb->protocol == htons(ETH_P_IP)) {
726 if (ip_hdr(skb)->protocol == IPPROTO_TCP)
727 descr->hw_regs.dmac_cmd_status =
731 else if (ip_hdr(skb)->protocol == IPPROTO_UDP)
732 descr->hw_regs.dmac_cmd_status =
736 * the stack should checksum non-tcp and non-udp
739 descr->hw_regs.dmac_cmd_status =
763 memmove(skb->data, skb->data + VLAN_HLEN, 2 * ETH_ALEN);
765 veth->h_vlan_proto = cpu_to_be16(ETH_P_8021Q);
766 veth->h_vlan_TCI = htons(tag);
772 * gelic_descr_prepare_tx - setup a descriptor for sending packets
786 if (card->vlan_required) {
790 type = netdev_port(skb->dev)->type;
792 card->vlan[type].tx);
794 return -ENOMEM;
798 buf = dma_map_single(ctodev(card), skb->data, skb->len, DMA_TO_DEVICE);
803 skb->data, skb->len);
804 return -ENOMEM;
807 descr->hw_regs.payload.dev_addr = cpu_to_be32(buf);
808 descr->hw_regs.payload.size = cpu_to_be32(skb->len);
809 descr->skb = skb;
810 descr->hw_regs.data_status = 0;
811 descr->hw_regs.next_descr_addr = 0; /* terminate hw descr */
815 card->tx_chain.head = descr->next;
820 * gelic_card_kick_txdma - enables TX DMA processing
830 if (card->tx_dma_progress)
834 card->tx_dma_progress = 1;
836 descr->link.cpu_addr, 0);
838 card->tx_dma_progress = 0;
847 * gelic_net_xmit - transmits a frame over the device
860 spin_lock_irqsave(&card->tx_lock, flags);
870 spin_unlock_irqrestore(&card->tx_lock, flags);
880 netdev->stats.tx_dropped++;
882 spin_unlock_irqrestore(&card->tx_lock, flags);
889 descr->prev->hw_regs.next_descr_addr =
890 cpu_to_be32(descr->link.cpu_addr);
892 * as hardware descriptor is modified in the above lines,
893 * ensure that the hardware sees it
901 netdev->stats.tx_dropped++;
903 descr->hw_regs.data_status = cpu_to_be32(GELIC_DESCR_TX_TAIL);
906 card->tx_chain.head = descr;
908 descr->prev->hw_regs.next_descr_addr = 0;
912 spin_unlock_irqrestore(&card->tx_lock, flags);
917 * gelic_net_pass_skb_up - takes an skb from a descriptor and passes it on
922 * iommu-unmaps the skb, fills out skb structure and passes the data to the
930 struct sk_buff *skb = descr->skb;
933 data_status = be32_to_cpu(descr->hw_regs.data_status);
934 data_error = be32_to_cpu(descr->hw_regs.data_error);
937 be32_to_cpu(descr->hw_regs.payload.dev_addr),
938 be32_to_cpu(descr->hw_regs.payload.size), DMA_FROM_DEVICE);
940 skb_put(skb, be32_to_cpu(descr->hw_regs.valid_size)?
941 be32_to_cpu(descr->hw_regs.valid_size) :
942 be32_to_cpu(descr->hw_regs.result_size));
943 if (!descr->hw_regs.valid_size)
945 be32_to_cpu(descr->hw_regs.result_size),
946 be32_to_cpu(descr->hw_regs.payload.size),
947 be32_to_cpu(descr->hw_regs.dmac_cmd_status));
949 descr->skb = NULL;
955 skb->protocol = eth_type_trans(skb, netdev);
958 if (netdev->features & NETIF_F_RXCSUM) {
961 skb->ip_summed = CHECKSUM_UNNECESSARY;
968 netdev->stats.rx_packets++;
969 netdev->stats.rx_bytes += skb->len;
972 napi_gro_receive(&card->napi, skb);
976 * gelic_card_decode_one_descr - processes an rx descriptor
979 * returns 1 if a packet has been sent to the stack, -ENOMEM on skb alloc
982 * processes an rx descriptor by iommu-unmapping the data buffer and passing
988 struct gelic_descr_chain *chain = &card->rx_chain;
989 struct gelic_descr *descr = chain->head;
999 if (status == GELIC_DESCR_DMA_NOT_IN_USE || !descr->skb) {
1006 if (card->vlan_required) {
1009 vid = *(u16 *)(descr->skb->data) & VLAN_VID_MASK;
1011 if (card->vlan[i].rx == vid) {
1012 netdev = card->netdev[i];
1021 netdev = card->netdev[GELIC_PORT_ETHERNET_0];
1028 netdev->stats.rx_dropped++;
1062 be32_to_cpu(descr->hw_regs.dmac_cmd_status) &
1069 descr->hw_regs.next_descr_addr = 0;
1081 chain->tail = descr;
1082 chain->head = descr->next;
1087 descr->prev->hw_regs.next_descr_addr =
1088 cpu_to_be32(descr->link.cpu_addr);
1092 * thus re-enable it
1105 napi_schedule(&card->napi);
1109 * gelic_net_poll - NAPI poll function called by the stack to return packets
1130 if (work_result == -ENOMEM) {
1132 mod_timer(&card->rx_oom_timer, jiffies + 1);
1144 * gelic_card_interrupt - event handler for gelic_net
1152 status = card->irq_status;
1157 status &= card->irq_mask;
1161 napi_schedule(&card->napi);
1165 spin_lock_irqsave(&card->tx_lock, flags);
1166 card->tx_dma_progress = 0;
1169 gelic_card_kick_txdma(card, card->tx_chain.tail);
1170 spin_unlock_irqrestore(&card->tx_lock, flags);
1180 gelic_wl_interrupt(card->netdev[GELIC_PORT_WIRELESS], status);
1188 * gelic_net_poll_controller - artificial interrupt for netconsole etc.
1198 gelic_card_interrupt(netdev->irq, netdev);
1199 gelic_card_set_irq_mask(card, card->irq_mask);
1204 * gelic_net_open - called upon ifconfig up
1216 dev_dbg(ctodev(card), " -> %s %p\n", __func__, netdev);
1223 dev_dbg(ctodev(card), " <- %s\n", __func__);
1230 strscpy(info->driver, DRV_NAME, sizeof(info->driver));
1231 strscpy(info->version, DRV_VERSION, sizeof(info->version));
1242 if (card->ether_port_status & GELIC_LV1_ETHER_FULL_DUPLEX)
1243 cmd->base.duplex = DUPLEX_FULL;
1245 cmd->base.duplex = DUPLEX_HALF;
1247 switch (card->ether_port_status & GELIC_LV1_ETHER_SPEED_MASK) {
1249 cmd->base.speed = SPEED_10;
1252 cmd->base.speed = SPEED_100;
1255 cmd->base.speed = SPEED_1000;
1259 cmd->base.speed = SPEED_10;
1268 if (card->link_mode & GELIC_LV1_ETHER_AUTO_NEG) {
1269 cmd->base.autoneg = AUTONEG_ENABLE;
1271 cmd->base.autoneg = AUTONEG_DISABLE;
1274 cmd->base.port = PORT_TP;
1276 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
1278 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
1292 if (cmd->base.autoneg == AUTONEG_ENABLE) {
1295 switch (cmd->base.speed) {
1306 return -EINVAL;
1308 if (cmd->base.duplex == DUPLEX_FULL) {
1310 } else if (cmd->base.speed == SPEED_1000) {
1312 return -EINVAL;
1328 wol->supported = WAKE_MAGIC;
1330 wol->supported = 0;
1332 wol->wolopts = ps3_sys_manager_get_wol() ? wol->supported : 0;
1333 memset(&wol->sopass, 0, sizeof(wol->sopass));
1344 return -EPERM;
1346 if (wol->wolopts & ~WAKE_MAGIC)
1347 return -EINVAL;
1350 if (wol->wolopts & WAKE_MAGIC) {
1359 status = -EIO;
1372 status = -EIO;
1383 status = -EIO;
1396 status = -EIO;
1413 * gelic_net_tx_timeout_task - task scheduled by the watchdog timeout
1423 struct net_device *netdev = card->netdev[GELIC_PORT_ETHERNET_0];
1427 if (!(netdev->flags & IFF_UP))
1437 atomic_dec(&card->tx_timeout_task_counter);
1441 * gelic_net_tx_timeout - called when the tx timeout watchdog kicks in.
1452 atomic_inc(&card->tx_timeout_task_counter);
1453 if (netdev->flags & IFF_UP)
1454 schedule_work(&card->tx_timeout_task);
1456 atomic_dec(&card->tx_timeout_task_counter);
1473 * gelic_ether_setup_netdev_ops - initialization of net_device operations
1482 netdev->watchdog_timeo = GELIC_NET_WATCHDOG_TIMEOUT;
1485 netdev->ethtool_ops = &gelic_ether_ethtool_ops;
1486 netdev->netdev_ops = &gelic_netdevice_ops;
1490 * gelic_net_setup_netdev - initialization of net_device
1504 netdev->hw_features = NETIF_F_IP_CSUM | NETIF_F_RXCSUM;
1506 netdev->features = NETIF_F_IP_CSUM;
1508 netdev->features |= NETIF_F_RXCSUM;
1518 return -EINVAL;
1522 if (card->vlan_required) {
1523 netdev->hard_header_len += VLAN_HLEN;
1528 netdev->features |= NETIF_F_VLAN_CHALLENGED;
1531 /* MTU range: 64 - 1518 */
1532 netdev->min_mtu = GELIC_NET_MIN_MTU;
1533 netdev->max_mtu = GELIC_NET_MAX_MTU;
1538 __func__, netdev->name, status);
1542 netdev->name, netdev->dev_addr);
1550 * gelic_alloc_card_net - allocates net_device and card structure
1573 GELIC_ALIGN - 1;
1579 card->unalign = p;
1586 kfree(card->unalign);
1592 port->netdev = *netdev;
1593 port->card = card;
1594 port->type = GELIC_PORT_ETHERNET_0;
1597 card->netdev[GELIC_PORT_ETHERNET_0] = *netdev;
1599 INIT_WORK(&card->tx_timeout_task, gelic_net_tx_timeout_task);
1600 init_waitqueue_head(&card->waitq);
1601 atomic_set(&card->tx_timeout_task_counter, 0);
1602 mutex_init(&card->updown_lock);
1603 atomic_set(&card->users, 0);
1605 timer_setup(&card->rx_oom_timer, gelic_rx_oom_timer, 0);
1640 card->vlan[i].tx = 0;
1641 card->vlan[i].rx = 0;
1644 card->vlan[i].tx = (u16)v1;
1656 card->vlan[i].tx = 0;
1657 card->vlan[i].rx = 0;
1660 card->vlan[i].rx = (u16)v1;
1663 i, card->vlan[i].tx, card->vlan[i].rx);
1666 if (card->vlan[GELIC_PORT_ETHERNET_0].tx) {
1667 BUG_ON(!card->vlan[GELIC_PORT_WIRELESS].tx);
1668 card->vlan_required = 1;
1670 card->vlan_required = 0;
1674 card->vlan[GELIC_PORT_WIRELESS].tx = 0;
1675 card->vlan[GELIC_PORT_WIRELESS].rx = 0;
1679 card->vlan_required? "enabled" : "disabled");
1682 * ps3_gelic_driver_probe - add a device to the control of this driver
1697 dev_dbg(&dev->core, "%s:ps3_open_hv_device failed\n",
1702 result = ps3_dma_region_create(dev->d_region);
1705 dev_dbg(&dev->core, "%s:ps3_dma_region_create failed(%d)\n",
1714 dev_info(&dev->core, "%s:gelic_net_alloc_card failed\n",
1716 result = -ENOMEM;
1720 card->dev = dev;
1725 card->link_mode = GELIC_LV1_ETHER_AUTO_NEG;
1730 ps3_mm_phys_to_lpar(__pa(&card->irq_status)),
1734 dev_dbg(&dev->core,
1737 result = -EIO;
1742 &card->irq);
1748 result = -EPERM;
1751 result = request_irq(card->irq, gelic_card_interrupt,
1752 0, netdev->name, card);
1761 card->irq_mask = GELIC_CARD_RXINT | GELIC_CARD_TXINT |
1765 result = gelic_card_init_chain(card, &card->tx_chain,
1766 card->descr, GELIC_NET_TX_DESCRIPTORS);
1769 result = gelic_card_init_chain(card, &card->rx_chain,
1770 card->descr + GELIC_NET_TX_DESCRIPTORS,
1776 card->tx_top = card->tx_chain.head;
1777 card->rx_top = card->rx_chain.head;
1779 card->rx_top, card->tx_top, sizeof(struct gelic_descr),
1786 spin_lock_init(&card->tx_lock);
1787 card->tx_dma_progress = 0;
1790 netdev->irq = card->irq;
1791 SET_NETDEV_DEV(netdev, &card->dev->core);
1792 gelic_ether_setup_netdev_ops(netdev, &card->napi);
1795 dev_dbg(&dev->core, "%s: setup_netdev failed %d\n",
1803 dev_dbg(&dev->core, "%s: WL init failed\n", __func__);
1812 gelic_card_free_chain(card, card->rx_chain.head);
1814 gelic_card_free_chain(card, card->tx_chain.head);
1816 free_irq(card->irq, card);
1817 netdev->irq = 0;
1819 ps3_sb_event_receive_port_destroy(dev, card->irq);
1826 kfree(netdev_card(netdev)->unalign);
1829 ps3_dma_region_free(dev->d_region);
1837 * ps3_gelic_driver_remove - remove a device from the control of this driver
1846 /* set auto-negotiation */
1863 gelic_card_free_chain(card, card->tx_top);
1864 gelic_card_free_chain(card, card->rx_top);
1866 netdev0 = card->netdev[GELIC_PORT_ETHERNET_0];
1868 free_irq(card->irq, card);
1869 netdev0->irq = 0;
1870 ps3_sb_event_receive_port_destroy(card->dev, card->irq);
1872 wait_event(card->waitq,
1873 atomic_read(&card->tx_timeout_task_counter) == 0);
1879 kfree(netdev_card(netdev0)->unalign);
1884 ps3_dma_region_free(dev->d_region);
1904 : -ENODEV;