Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (c) 2010 ASIX Electronics Corporation
0004  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
0005  *
0006  * ASIX AX88796C SPI Fast Ethernet Linux driver
0007  */
0008 
0009 #define pr_fmt(fmt) "ax88796c: " fmt
0010 
0011 #include "ax88796c_main.h"
0012 #include "ax88796c_ioctl.h"
0013 
0014 #include <linux/bitmap.h>
0015 #include <linux/etherdevice.h>
0016 #include <linux/iopoll.h>
0017 #include <linux/lockdep.h>
0018 #include <linux/mdio.h>
0019 #include <linux/minmax.h>
0020 #include <linux/module.h>
0021 #include <linux/netdevice.h>
0022 #include <linux/of.h>
0023 #include <linux/phy.h>
0024 #include <linux/skbuff.h>
0025 #include <linux/spi/spi.h>
0026 
0027 static int comp = IS_ENABLED(CONFIG_SPI_AX88796C_COMPRESSION);
0028 static int msg_enable = NETIF_MSG_PROBE |
0029             NETIF_MSG_LINK |
0030             NETIF_MSG_RX_ERR |
0031             NETIF_MSG_TX_ERR;
0032 
0033 static const char *no_regs_list = "80018001,e1918001,8001a001,fc0d0000";
0034 unsigned long ax88796c_no_regs_mask[AX88796C_REGDUMP_LEN / (sizeof(unsigned long) * 8)];
0035 
0036 module_param(msg_enable, int, 0444);
0037 MODULE_PARM_DESC(msg_enable, "Message mask (see linux/netdevice.h for bitmap)");
0038 
0039 static int ax88796c_soft_reset(struct ax88796c_device *ax_local)
0040 {
0041     u16 temp;
0042     int ret;
0043 
0044     lockdep_assert_held(&ax_local->spi_lock);
0045 
0046     AX_WRITE(&ax_local->ax_spi, PSR_RESET, P0_PSR);
0047     AX_WRITE(&ax_local->ax_spi, PSR_RESET_CLR, P0_PSR);
0048 
0049     ret = read_poll_timeout(AX_READ, ret,
0050                 (ret & PSR_DEV_READY),
0051                 0, jiffies_to_usecs(160 * HZ / 1000), false,
0052                 &ax_local->ax_spi, P0_PSR);
0053     if (ret)
0054         return ret;
0055 
0056     temp = AX_READ(&ax_local->ax_spi, P4_SPICR);
0057     if (ax_local->priv_flags & AX_CAP_COMP) {
0058         AX_WRITE(&ax_local->ax_spi,
0059              (temp | SPICR_RCEN | SPICR_QCEN), P4_SPICR);
0060         ax_local->ax_spi.comp = 1;
0061     } else {
0062         AX_WRITE(&ax_local->ax_spi,
0063              (temp & ~(SPICR_RCEN | SPICR_QCEN)), P4_SPICR);
0064         ax_local->ax_spi.comp = 0;
0065     }
0066 
0067     return 0;
0068 }
0069 
0070 static int ax88796c_reload_eeprom(struct ax88796c_device *ax_local)
0071 {
0072     int ret;
0073 
0074     lockdep_assert_held(&ax_local->spi_lock);
0075 
0076     AX_WRITE(&ax_local->ax_spi, EECR_RELOAD, P3_EECR);
0077 
0078     ret = read_poll_timeout(AX_READ, ret,
0079                 (ret & PSR_DEV_READY),
0080                 0, jiffies_to_usecs(2 * HZ / 1000), false,
0081                 &ax_local->ax_spi, P0_PSR);
0082     if (ret) {
0083         dev_err(&ax_local->spi->dev,
0084             "timeout waiting for reload eeprom\n");
0085         return ret;
0086     }
0087 
0088     return 0;
0089 }
0090 
0091 static void ax88796c_set_hw_multicast(struct net_device *ndev)
0092 {
0093     struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
0094     int mc_count = netdev_mc_count(ndev);
0095     u16 rx_ctl = RXCR_AB;
0096 
0097     lockdep_assert_held(&ax_local->spi_lock);
0098 
0099     memset(ax_local->multi_filter, 0, AX_MCAST_FILTER_SIZE);
0100 
0101     if (ndev->flags & IFF_PROMISC) {
0102         rx_ctl |= RXCR_PRO;
0103 
0104     } else if (ndev->flags & IFF_ALLMULTI || mc_count > AX_MAX_MCAST) {
0105         rx_ctl |= RXCR_AMALL;
0106 
0107     } else if (mc_count == 0) {
0108         /* just broadcast and directed */
0109     } else {
0110         u32 crc_bits;
0111         int i;
0112         struct netdev_hw_addr *ha;
0113 
0114         netdev_for_each_mc_addr(ha, ndev) {
0115             crc_bits = ether_crc(ETH_ALEN, ha->addr);
0116             ax_local->multi_filter[crc_bits >> 29] |=
0117                         (1 << ((crc_bits >> 26) & 7));
0118         }
0119 
0120         for (i = 0; i < 4; i++) {
0121             AX_WRITE(&ax_local->ax_spi,
0122                  ((ax_local->multi_filter[i * 2 + 1] << 8) |
0123                   ax_local->multi_filter[i * 2]), P3_MFAR(i));
0124         }
0125     }
0126 
0127     AX_WRITE(&ax_local->ax_spi, rx_ctl, P2_RXCR);
0128 }
0129 
0130 static void ax88796c_set_mac_addr(struct net_device *ndev)
0131 {
0132     struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
0133 
0134     lockdep_assert_held(&ax_local->spi_lock);
0135 
0136     AX_WRITE(&ax_local->ax_spi, ((u16)(ndev->dev_addr[4] << 8) |
0137             (u16)ndev->dev_addr[5]), P3_MACASR0);
0138     AX_WRITE(&ax_local->ax_spi, ((u16)(ndev->dev_addr[2] << 8) |
0139             (u16)ndev->dev_addr[3]), P3_MACASR1);
0140     AX_WRITE(&ax_local->ax_spi, ((u16)(ndev->dev_addr[0] << 8) |
0141             (u16)ndev->dev_addr[1]), P3_MACASR2);
0142 }
0143 
0144 static void ax88796c_load_mac_addr(struct net_device *ndev)
0145 {
0146     struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
0147     u8 addr[ETH_ALEN];
0148     u16 temp;
0149 
0150     lockdep_assert_held(&ax_local->spi_lock);
0151 
0152     /* Try the device tree first */
0153     if (!platform_get_ethdev_address(&ax_local->spi->dev, ndev) &&
0154         is_valid_ether_addr(ndev->dev_addr)) {
0155         if (netif_msg_probe(ax_local))
0156             dev_info(&ax_local->spi->dev,
0157                  "MAC address read from device tree\n");
0158         return;
0159     }
0160 
0161     /* Read the MAC address from AX88796C */
0162     temp = AX_READ(&ax_local->ax_spi, P3_MACASR0);
0163     addr[5] = (u8)temp;
0164     addr[4] = (u8)(temp >> 8);
0165 
0166     temp = AX_READ(&ax_local->ax_spi, P3_MACASR1);
0167     addr[3] = (u8)temp;
0168     addr[2] = (u8)(temp >> 8);
0169 
0170     temp = AX_READ(&ax_local->ax_spi, P3_MACASR2);
0171     addr[1] = (u8)temp;
0172     addr[0] = (u8)(temp >> 8);
0173 
0174     if (is_valid_ether_addr(addr)) {
0175         eth_hw_addr_set(ndev, addr);
0176         if (netif_msg_probe(ax_local))
0177             dev_info(&ax_local->spi->dev,
0178                  "MAC address read from ASIX chip\n");
0179         return;
0180     }
0181 
0182     /* Use random address if none found */
0183     if (netif_msg_probe(ax_local))
0184         dev_info(&ax_local->spi->dev, "Use random MAC address\n");
0185     eth_hw_addr_random(ndev);
0186 }
0187 
0188 static void ax88796c_proc_tx_hdr(struct tx_pkt_info *info, u8 ip_summed)
0189 {
0190     u16 pkt_len_bar = (~info->pkt_len & TX_HDR_SOP_PKTLENBAR);
0191 
0192     /* Prepare SOP header */
0193     info->sop.flags_len = info->pkt_len |
0194         ((ip_summed == CHECKSUM_NONE) ||
0195          (ip_summed == CHECKSUM_UNNECESSARY) ? TX_HDR_SOP_DICF : 0);
0196 
0197     info->sop.seq_lenbar = ((info->seq_num << 11) & TX_HDR_SOP_SEQNUM)
0198                 | pkt_len_bar;
0199     cpu_to_be16s(&info->sop.flags_len);
0200     cpu_to_be16s(&info->sop.seq_lenbar);
0201 
0202     /* Prepare Segment header */
0203     info->seg.flags_seqnum_seglen = TX_HDR_SEG_FS | TX_HDR_SEG_LS
0204                         | info->pkt_len;
0205 
0206     info->seg.eo_so_seglenbar = pkt_len_bar;
0207 
0208     cpu_to_be16s(&info->seg.flags_seqnum_seglen);
0209     cpu_to_be16s(&info->seg.eo_so_seglenbar);
0210 
0211     /* Prepare EOP header */
0212     info->eop.seq_len = ((info->seq_num << 11) &
0213                  TX_HDR_EOP_SEQNUM) | info->pkt_len;
0214     info->eop.seqbar_lenbar = ((~info->seq_num << 11) &
0215                    TX_HDR_EOP_SEQNUMBAR) | pkt_len_bar;
0216 
0217     cpu_to_be16s(&info->eop.seq_len);
0218     cpu_to_be16s(&info->eop.seqbar_lenbar);
0219 }
0220 
0221 static int
0222 ax88796c_check_free_pages(struct ax88796c_device *ax_local, u8 need_pages)
0223 {
0224     u8 free_pages;
0225     u16 tmp;
0226 
0227     lockdep_assert_held(&ax_local->spi_lock);
0228 
0229     free_pages = AX_READ(&ax_local->ax_spi, P0_TFBFCR) & TX_FREEBUF_MASK;
0230     if (free_pages < need_pages) {
0231         /* schedule free page interrupt */
0232         tmp = AX_READ(&ax_local->ax_spi, P0_TFBFCR)
0233                 & TFBFCR_SCHE_FREE_PAGE;
0234         AX_WRITE(&ax_local->ax_spi, tmp | TFBFCR_TX_PAGE_SET |
0235                 TFBFCR_SET_FREE_PAGE(need_pages),
0236                 P0_TFBFCR);
0237         return -ENOMEM;
0238     }
0239 
0240     return 0;
0241 }
0242 
0243 static struct sk_buff *
0244 ax88796c_tx_fixup(struct net_device *ndev, struct sk_buff_head *q)
0245 {
0246     struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
0247     u8 spi_len = ax_local->ax_spi.comp ? 1 : 4;
0248     struct sk_buff *skb;
0249     struct tx_pkt_info info;
0250     struct skb_data *entry;
0251     u16 pkt_len;
0252     u8 padlen, seq_num;
0253     u8 need_pages;
0254     int headroom;
0255     int tailroom;
0256 
0257     if (skb_queue_empty(q))
0258         return NULL;
0259 
0260     skb = skb_peek(q);
0261     pkt_len = skb->len;
0262     need_pages = (pkt_len + TX_OVERHEAD + 127) >> 7;
0263     if (ax88796c_check_free_pages(ax_local, need_pages) != 0)
0264         return NULL;
0265 
0266     headroom = skb_headroom(skb);
0267     tailroom = skb_tailroom(skb);
0268     padlen = round_up(pkt_len, 4) - pkt_len;
0269     seq_num = ++ax_local->seq_num & 0x1F;
0270 
0271     info.pkt_len = pkt_len;
0272 
0273     if (skb_cloned(skb) ||
0274         (headroom < (TX_OVERHEAD + spi_len)) ||
0275         (tailroom < (padlen + TX_EOP_SIZE))) {
0276         size_t h = max((TX_OVERHEAD + spi_len) - headroom, 0);
0277         size_t t = max((padlen + TX_EOP_SIZE) - tailroom, 0);
0278 
0279         if (pskb_expand_head(skb, h, t, GFP_KERNEL))
0280             return NULL;
0281     }
0282 
0283     info.seq_num = seq_num;
0284     ax88796c_proc_tx_hdr(&info, skb->ip_summed);
0285 
0286     /* SOP and SEG header */
0287     memcpy(skb_push(skb, TX_OVERHEAD), &info.sop, TX_OVERHEAD);
0288 
0289     /* Write SPI TXQ header */
0290     memcpy(skb_push(skb, spi_len), ax88796c_tx_cmd_buf, spi_len);
0291 
0292     /* Make 32-bit alignment */
0293     skb_put(skb, padlen);
0294 
0295     /* EOP header */
0296     memcpy(skb_put(skb, TX_EOP_SIZE), &info.eop, TX_EOP_SIZE);
0297 
0298     skb_unlink(skb, q);
0299 
0300     entry = (struct skb_data *)skb->cb;
0301     memset(entry, 0, sizeof(*entry));
0302     entry->len = pkt_len;
0303 
0304     if (netif_msg_pktdata(ax_local)) {
0305         char pfx[IFNAMSIZ + 7];
0306 
0307         snprintf(pfx, sizeof(pfx), "%s:     ", ndev->name);
0308 
0309         netdev_info(ndev, "TX packet len %d, total len %d, seq %d\n",
0310                 pkt_len, skb->len, seq_num);
0311 
0312         netdev_info(ndev, "  SPI Header:\n");
0313         print_hex_dump(KERN_INFO, pfx, DUMP_PREFIX_OFFSET, 16, 1,
0314                    skb->data, 4, 0);
0315 
0316         netdev_info(ndev, "  TX SOP:\n");
0317         print_hex_dump(KERN_INFO, pfx, DUMP_PREFIX_OFFSET, 16, 1,
0318                    skb->data + 4, TX_OVERHEAD, 0);
0319 
0320         netdev_info(ndev, "  TX packet:\n");
0321         print_hex_dump(KERN_INFO, pfx, DUMP_PREFIX_OFFSET, 16, 1,
0322                    skb->data + 4 + TX_OVERHEAD,
0323                    skb->len - TX_EOP_SIZE - 4 - TX_OVERHEAD, 0);
0324 
0325         netdev_info(ndev, "  TX EOP:\n");
0326         print_hex_dump(KERN_INFO, pfx, DUMP_PREFIX_OFFSET, 16, 1,
0327                    skb->data + skb->len - 4, 4, 0);
0328     }
0329 
0330     return skb;
0331 }
0332 
0333 static int ax88796c_hard_xmit(struct ax88796c_device *ax_local)
0334 {
0335     struct ax88796c_pcpu_stats *stats;
0336     struct sk_buff *tx_skb;
0337     struct skb_data *entry;
0338     unsigned long flags;
0339 
0340     lockdep_assert_held(&ax_local->spi_lock);
0341 
0342     stats = this_cpu_ptr(ax_local->stats);
0343     tx_skb = ax88796c_tx_fixup(ax_local->ndev, &ax_local->tx_wait_q);
0344 
0345     if (!tx_skb) {
0346         this_cpu_inc(ax_local->stats->tx_dropped);
0347         return 0;
0348     }
0349     entry = (struct skb_data *)tx_skb->cb;
0350 
0351     AX_WRITE(&ax_local->ax_spi,
0352          (TSNR_TXB_START | TSNR_PKT_CNT(1)), P0_TSNR);
0353 
0354     axspi_write_txq(&ax_local->ax_spi, tx_skb->data, tx_skb->len);
0355 
0356     if (((AX_READ(&ax_local->ax_spi, P0_TSNR) & TXNR_TXB_IDLE) == 0) ||
0357         ((ISR_TXERR & AX_READ(&ax_local->ax_spi, P0_ISR)) != 0)) {
0358         /* Ack tx error int */
0359         AX_WRITE(&ax_local->ax_spi, ISR_TXERR, P0_ISR);
0360 
0361         this_cpu_inc(ax_local->stats->tx_dropped);
0362 
0363         if (net_ratelimit())
0364             netif_err(ax_local, tx_err, ax_local->ndev,
0365                   "TX FIFO error, re-initialize the TX bridge\n");
0366 
0367         /* Reinitial tx bridge */
0368         AX_WRITE(&ax_local->ax_spi, TXNR_TXB_REINIT |
0369             AX_READ(&ax_local->ax_spi, P0_TSNR), P0_TSNR);
0370         ax_local->seq_num = 0;
0371     } else {
0372         flags = u64_stats_update_begin_irqsave(&stats->syncp);
0373         u64_stats_inc(&stats->tx_packets);
0374         u64_stats_add(&stats->tx_bytes, entry->len);
0375         u64_stats_update_end_irqrestore(&stats->syncp, flags);
0376     }
0377 
0378     entry->state = tx_done;
0379     dev_kfree_skb(tx_skb);
0380 
0381     return 1;
0382 }
0383 
0384 static int
0385 ax88796c_start_xmit(struct sk_buff *skb, struct net_device *ndev)
0386 {
0387     struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
0388 
0389     skb_queue_tail(&ax_local->tx_wait_q, skb);
0390     if (skb_queue_len(&ax_local->tx_wait_q) > TX_QUEUE_HIGH_WATER)
0391         netif_stop_queue(ndev);
0392 
0393     set_bit(EVENT_TX, &ax_local->flags);
0394     schedule_work(&ax_local->ax_work);
0395 
0396     return NETDEV_TX_OK;
0397 }
0398 
0399 static void
0400 ax88796c_skb_return(struct ax88796c_device *ax_local,
0401             struct sk_buff *skb, struct rx_header *rxhdr)
0402 {
0403     struct net_device *ndev = ax_local->ndev;
0404     struct ax88796c_pcpu_stats *stats;
0405     unsigned long flags;
0406     int status;
0407 
0408     stats = this_cpu_ptr(ax_local->stats);
0409 
0410     do {
0411         if (!(ndev->features & NETIF_F_RXCSUM))
0412             break;
0413 
0414         /* checksum error bit is set */
0415         if ((rxhdr->flags & RX_HDR3_L3_ERR) ||
0416             (rxhdr->flags & RX_HDR3_L4_ERR))
0417             break;
0418 
0419         /* Other types may be indicated by more than one bit. */
0420         if ((rxhdr->flags & RX_HDR3_L4_TYPE_TCP) ||
0421             (rxhdr->flags & RX_HDR3_L4_TYPE_UDP))
0422             skb->ip_summed = CHECKSUM_UNNECESSARY;
0423     } while (0);
0424 
0425     flags = u64_stats_update_begin_irqsave(&stats->syncp);
0426     u64_stats_inc(&stats->rx_packets);
0427     u64_stats_add(&stats->rx_bytes, skb->len);
0428     u64_stats_update_end_irqrestore(&stats->syncp, flags);
0429 
0430     skb->dev = ndev;
0431     skb->protocol = eth_type_trans(skb, ax_local->ndev);
0432 
0433     netif_info(ax_local, rx_status, ndev, "< rx, len %zu, type 0x%x\n",
0434            skb->len + sizeof(struct ethhdr), skb->protocol);
0435 
0436     status = netif_rx(skb);
0437     if (status != NET_RX_SUCCESS && net_ratelimit())
0438         netif_info(ax_local, rx_err, ndev,
0439                "netif_rx status %d\n", status);
0440 }
0441 
0442 static void
0443 ax88796c_rx_fixup(struct ax88796c_device *ax_local, struct sk_buff *rx_skb)
0444 {
0445     struct rx_header *rxhdr = (struct rx_header *)rx_skb->data;
0446     struct net_device *ndev = ax_local->ndev;
0447     u16 len;
0448 
0449     be16_to_cpus(&rxhdr->flags_len);
0450     be16_to_cpus(&rxhdr->seq_lenbar);
0451     be16_to_cpus(&rxhdr->flags);
0452 
0453     if ((rxhdr->flags_len & RX_HDR1_PKT_LEN) !=
0454              (~rxhdr->seq_lenbar & 0x7FF)) {
0455         netif_err(ax_local, rx_err, ndev, "Header error\n");
0456 
0457         this_cpu_inc(ax_local->stats->rx_frame_errors);
0458         kfree_skb(rx_skb);
0459         return;
0460     }
0461 
0462     if ((rxhdr->flags_len & RX_HDR1_MII_ERR) ||
0463         (rxhdr->flags_len & RX_HDR1_CRC_ERR)) {
0464         netif_err(ax_local, rx_err, ndev, "CRC or MII error\n");
0465 
0466         this_cpu_inc(ax_local->stats->rx_crc_errors);
0467         kfree_skb(rx_skb);
0468         return;
0469     }
0470 
0471     len = rxhdr->flags_len & RX_HDR1_PKT_LEN;
0472     if (netif_msg_pktdata(ax_local)) {
0473         char pfx[IFNAMSIZ + 7];
0474 
0475         snprintf(pfx, sizeof(pfx), "%s:     ", ndev->name);
0476         netdev_info(ndev, "RX data, total len %d, packet len %d\n",
0477                 rx_skb->len, len);
0478 
0479         netdev_info(ndev, "  Dump RX packet header:");
0480         print_hex_dump(KERN_INFO, pfx, DUMP_PREFIX_OFFSET, 16, 1,
0481                    rx_skb->data, sizeof(*rxhdr), 0);
0482 
0483         netdev_info(ndev, "  Dump RX packet:");
0484         print_hex_dump(KERN_INFO, pfx, DUMP_PREFIX_OFFSET, 16, 1,
0485                    rx_skb->data + sizeof(*rxhdr), len, 0);
0486     }
0487 
0488     skb_pull(rx_skb, sizeof(*rxhdr));
0489     pskb_trim(rx_skb, len);
0490 
0491     ax88796c_skb_return(ax_local, rx_skb, rxhdr);
0492 }
0493 
0494 static int ax88796c_receive(struct net_device *ndev)
0495 {
0496     struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
0497     struct skb_data *entry;
0498     u16 w_count, pkt_len;
0499     struct sk_buff *skb;
0500     u8 pkt_cnt;
0501 
0502     lockdep_assert_held(&ax_local->spi_lock);
0503 
0504     /* check rx packet and total word count */
0505     AX_WRITE(&ax_local->ax_spi, AX_READ(&ax_local->ax_spi, P0_RTWCR)
0506           | RTWCR_RX_LATCH, P0_RTWCR);
0507 
0508     pkt_cnt = AX_READ(&ax_local->ax_spi, P0_RXBCR2) & RXBCR2_PKT_MASK;
0509     if (!pkt_cnt)
0510         return 0;
0511 
0512     pkt_len = AX_READ(&ax_local->ax_spi, P0_RCPHR) & 0x7FF;
0513 
0514     w_count = round_up(pkt_len + 6, 4) >> 1;
0515 
0516     skb = netdev_alloc_skb(ndev, w_count * 2);
0517     if (!skb) {
0518         AX_WRITE(&ax_local->ax_spi, RXBCR1_RXB_DISCARD, P0_RXBCR1);
0519         this_cpu_inc(ax_local->stats->rx_dropped);
0520         return 0;
0521     }
0522     entry = (struct skb_data *)skb->cb;
0523 
0524     AX_WRITE(&ax_local->ax_spi, RXBCR1_RXB_START | w_count, P0_RXBCR1);
0525 
0526     axspi_read_rxq(&ax_local->ax_spi,
0527                skb_put(skb, w_count * 2), skb->len);
0528 
0529     /* Check if rx bridge is idle */
0530     if ((AX_READ(&ax_local->ax_spi, P0_RXBCR2) & RXBCR2_RXB_IDLE) == 0) {
0531         if (net_ratelimit())
0532             netif_err(ax_local, rx_err, ndev,
0533                   "Rx Bridge is not idle\n");
0534         AX_WRITE(&ax_local->ax_spi, RXBCR2_RXB_REINIT, P0_RXBCR2);
0535 
0536         entry->state = rx_err;
0537     } else {
0538         entry->state = rx_done;
0539     }
0540 
0541     AX_WRITE(&ax_local->ax_spi, ISR_RXPKT, P0_ISR);
0542 
0543     ax88796c_rx_fixup(ax_local, skb);
0544 
0545     return 1;
0546 }
0547 
0548 static int ax88796c_process_isr(struct ax88796c_device *ax_local)
0549 {
0550     struct net_device *ndev = ax_local->ndev;
0551     int todo = 0;
0552     u16 isr;
0553 
0554     lockdep_assert_held(&ax_local->spi_lock);
0555 
0556     isr = AX_READ(&ax_local->ax_spi, P0_ISR);
0557     AX_WRITE(&ax_local->ax_spi, isr, P0_ISR);
0558 
0559     netif_dbg(ax_local, intr, ndev, "  ISR 0x%04x\n", isr);
0560 
0561     if (isr & ISR_TXERR) {
0562         netif_dbg(ax_local, intr, ndev, "  TXERR interrupt\n");
0563         AX_WRITE(&ax_local->ax_spi, TXNR_TXB_REINIT, P0_TSNR);
0564         ax_local->seq_num = 0x1f;
0565     }
0566 
0567     if (isr & ISR_TXPAGES) {
0568         netif_dbg(ax_local, intr, ndev, "  TXPAGES interrupt\n");
0569         set_bit(EVENT_TX, &ax_local->flags);
0570     }
0571 
0572     if (isr & ISR_LINK) {
0573         netif_dbg(ax_local, intr, ndev, "  Link change interrupt\n");
0574         phy_mac_interrupt(ax_local->ndev->phydev);
0575     }
0576 
0577     if (isr & ISR_RXPKT) {
0578         netif_dbg(ax_local, intr, ndev, "  RX interrupt\n");
0579         todo = ax88796c_receive(ax_local->ndev);
0580     }
0581 
0582     return todo;
0583 }
0584 
0585 static irqreturn_t ax88796c_interrupt(int irq, void *dev_instance)
0586 {
0587     struct ax88796c_device *ax_local;
0588     struct net_device *ndev;
0589 
0590     ndev = dev_instance;
0591     if (!ndev) {
0592         pr_err("irq %d for unknown device.\n", irq);
0593         return IRQ_RETVAL(0);
0594     }
0595     ax_local = to_ax88796c_device(ndev);
0596 
0597     disable_irq_nosync(irq);
0598 
0599     netif_dbg(ax_local, intr, ndev, "Interrupt occurred\n");
0600 
0601     set_bit(EVENT_INTR, &ax_local->flags);
0602     schedule_work(&ax_local->ax_work);
0603 
0604     return IRQ_HANDLED;
0605 }
0606 
0607 static void ax88796c_work(struct work_struct *work)
0608 {
0609     struct ax88796c_device *ax_local =
0610             container_of(work, struct ax88796c_device, ax_work);
0611 
0612     mutex_lock(&ax_local->spi_lock);
0613 
0614     if (test_bit(EVENT_SET_MULTI, &ax_local->flags)) {
0615         ax88796c_set_hw_multicast(ax_local->ndev);
0616         clear_bit(EVENT_SET_MULTI, &ax_local->flags);
0617     }
0618 
0619     if (test_bit(EVENT_INTR, &ax_local->flags)) {
0620         AX_WRITE(&ax_local->ax_spi, IMR_MASKALL, P0_IMR);
0621 
0622         while (ax88796c_process_isr(ax_local))
0623             /* nothing */;
0624 
0625         clear_bit(EVENT_INTR, &ax_local->flags);
0626 
0627         AX_WRITE(&ax_local->ax_spi, IMR_DEFAULT, P0_IMR);
0628 
0629         enable_irq(ax_local->ndev->irq);
0630     }
0631 
0632     if (test_bit(EVENT_TX, &ax_local->flags)) {
0633         while (skb_queue_len(&ax_local->tx_wait_q)) {
0634             if (!ax88796c_hard_xmit(ax_local))
0635                 break;
0636         }
0637 
0638         clear_bit(EVENT_TX, &ax_local->flags);
0639 
0640         if (netif_queue_stopped(ax_local->ndev) &&
0641             (skb_queue_len(&ax_local->tx_wait_q) < TX_QUEUE_LOW_WATER))
0642             netif_wake_queue(ax_local->ndev);
0643     }
0644 
0645     mutex_unlock(&ax_local->spi_lock);
0646 }
0647 
0648 static void ax88796c_get_stats64(struct net_device *ndev,
0649                  struct rtnl_link_stats64 *stats)
0650 {
0651     struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
0652     u32 rx_frame_errors = 0, rx_crc_errors = 0;
0653     u32 rx_dropped = 0, tx_dropped = 0;
0654     unsigned int start;
0655     int cpu;
0656 
0657     for_each_possible_cpu(cpu) {
0658         struct ax88796c_pcpu_stats *s;
0659         u64 rx_packets, rx_bytes;
0660         u64 tx_packets, tx_bytes;
0661 
0662         s = per_cpu_ptr(ax_local->stats, cpu);
0663 
0664         do {
0665             start = u64_stats_fetch_begin_irq(&s->syncp);
0666             rx_packets = u64_stats_read(&s->rx_packets);
0667             rx_bytes   = u64_stats_read(&s->rx_bytes);
0668             tx_packets = u64_stats_read(&s->tx_packets);
0669             tx_bytes   = u64_stats_read(&s->tx_bytes);
0670         } while (u64_stats_fetch_retry_irq(&s->syncp, start));
0671 
0672         stats->rx_packets += rx_packets;
0673         stats->rx_bytes   += rx_bytes;
0674         stats->tx_packets += tx_packets;
0675         stats->tx_bytes   += tx_bytes;
0676 
0677         rx_dropped      += s->rx_dropped;
0678         tx_dropped      += s->tx_dropped;
0679         rx_frame_errors += s->rx_frame_errors;
0680         rx_crc_errors   += s->rx_crc_errors;
0681     }
0682 
0683     stats->rx_dropped = rx_dropped;
0684     stats->tx_dropped = tx_dropped;
0685     stats->rx_frame_errors = rx_frame_errors;
0686     stats->rx_crc_errors = rx_crc_errors;
0687 }
0688 
0689 static void ax88796c_set_mac(struct  ax88796c_device *ax_local)
0690 {
0691     u16 maccr;
0692 
0693     maccr = (ax_local->link) ? MACCR_RXEN : 0;
0694 
0695     switch (ax_local->speed) {
0696     case SPEED_100:
0697         maccr |= MACCR_SPEED_100;
0698         break;
0699     case SPEED_10:
0700     case SPEED_UNKNOWN:
0701         break;
0702     default:
0703         return;
0704     }
0705 
0706     switch (ax_local->duplex) {
0707     case DUPLEX_FULL:
0708         maccr |= MACCR_SPEED_100;
0709         break;
0710     case DUPLEX_HALF:
0711     case DUPLEX_UNKNOWN:
0712         break;
0713     default:
0714         return;
0715     }
0716 
0717     if (ax_local->flowctrl & AX_FC_ANEG &&
0718         ax_local->phydev->autoneg) {
0719         maccr |= ax_local->pause ? MACCR_RXFC_ENABLE : 0;
0720         maccr |= !ax_local->pause != !ax_local->asym_pause ?
0721             MACCR_TXFC_ENABLE : 0;
0722     } else {
0723         maccr |= (ax_local->flowctrl & AX_FC_RX) ? MACCR_RXFC_ENABLE : 0;
0724         maccr |= (ax_local->flowctrl & AX_FC_TX) ? MACCR_TXFC_ENABLE : 0;
0725     }
0726 
0727     mutex_lock(&ax_local->spi_lock);
0728 
0729     maccr |= AX_READ(&ax_local->ax_spi, P0_MACCR) &
0730         ~(MACCR_DUPLEX_FULL | MACCR_SPEED_100 |
0731           MACCR_TXFC_ENABLE | MACCR_RXFC_ENABLE);
0732     AX_WRITE(&ax_local->ax_spi, maccr, P0_MACCR);
0733 
0734     mutex_unlock(&ax_local->spi_lock);
0735 }
0736 
0737 static void ax88796c_handle_link_change(struct net_device *ndev)
0738 {
0739     struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
0740     struct phy_device *phydev = ndev->phydev;
0741     bool update = false;
0742 
0743     if (phydev->link && (ax_local->speed != phydev->speed ||
0744                  ax_local->duplex != phydev->duplex ||
0745                  ax_local->pause != phydev->pause ||
0746                  ax_local->asym_pause != phydev->asym_pause)) {
0747         ax_local->speed = phydev->speed;
0748         ax_local->duplex = phydev->duplex;
0749         ax_local->pause = phydev->pause;
0750         ax_local->asym_pause = phydev->asym_pause;
0751         update = true;
0752     }
0753 
0754     if (phydev->link != ax_local->link) {
0755         if (!phydev->link) {
0756             ax_local->speed = SPEED_UNKNOWN;
0757             ax_local->duplex = DUPLEX_UNKNOWN;
0758         }
0759 
0760         ax_local->link = phydev->link;
0761         update = true;
0762     }
0763 
0764     if (update)
0765         ax88796c_set_mac(ax_local);
0766 
0767     if (net_ratelimit())
0768         phy_print_status(ndev->phydev);
0769 }
0770 
0771 static void ax88796c_set_csums(struct ax88796c_device *ax_local)
0772 {
0773     struct net_device *ndev = ax_local->ndev;
0774 
0775     lockdep_assert_held(&ax_local->spi_lock);
0776 
0777     if (ndev->features & NETIF_F_RXCSUM) {
0778         AX_WRITE(&ax_local->ax_spi, COERCR0_DEFAULT, P4_COERCR0);
0779         AX_WRITE(&ax_local->ax_spi, COERCR1_DEFAULT, P4_COERCR1);
0780     } else {
0781         AX_WRITE(&ax_local->ax_spi, 0, P4_COERCR0);
0782         AX_WRITE(&ax_local->ax_spi, 0, P4_COERCR1);
0783     }
0784 
0785     if (ndev->features & NETIF_F_HW_CSUM) {
0786         AX_WRITE(&ax_local->ax_spi, COETCR0_DEFAULT, P4_COETCR0);
0787         AX_WRITE(&ax_local->ax_spi, COETCR1_TXPPPE, P4_COETCR1);
0788     } else {
0789         AX_WRITE(&ax_local->ax_spi, 0, P4_COETCR0);
0790         AX_WRITE(&ax_local->ax_spi, 0, P4_COETCR1);
0791     }
0792 }
0793 
0794 static int
0795 ax88796c_open(struct net_device *ndev)
0796 {
0797     struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
0798     unsigned long irq_flag = 0;
0799     int fc = AX_FC_NONE;
0800     int ret;
0801     u16 t;
0802 
0803     ret = request_irq(ndev->irq, ax88796c_interrupt,
0804               irq_flag, ndev->name, ndev);
0805     if (ret) {
0806         netdev_err(ndev, "unable to get IRQ %d (errno=%d).\n",
0807                ndev->irq, ret);
0808         return ret;
0809     }
0810 
0811     mutex_lock(&ax_local->spi_lock);
0812 
0813     ret = ax88796c_soft_reset(ax_local);
0814     if (ret < 0) {
0815         free_irq(ndev->irq, ndev);
0816         mutex_unlock(&ax_local->spi_lock);
0817         return ret;
0818     }
0819     ax_local->seq_num = 0x1f;
0820 
0821     ax88796c_set_mac_addr(ndev);
0822     ax88796c_set_csums(ax_local);
0823 
0824     /* Disable stuffing packet */
0825     t = AX_READ(&ax_local->ax_spi, P1_RXBSPCR);
0826     t &= ~RXBSPCR_STUF_ENABLE;
0827     AX_WRITE(&ax_local->ax_spi, t, P1_RXBSPCR);
0828 
0829     /* Enable RX packet process */
0830     AX_WRITE(&ax_local->ax_spi, RPPER_RXEN, P1_RPPER);
0831 
0832     t = AX_READ(&ax_local->ax_spi, P0_FER);
0833     t |= FER_RXEN | FER_TXEN | FER_BSWAP | FER_IRQ_PULL;
0834     AX_WRITE(&ax_local->ax_spi, t, P0_FER);
0835 
0836     /* Setup LED mode */
0837     AX_WRITE(&ax_local->ax_spi,
0838          (LCR_LED0_EN | LCR_LED0_DUPLEX | LCR_LED1_EN |
0839          LCR_LED1_100MODE), P2_LCR0);
0840     AX_WRITE(&ax_local->ax_spi,
0841          (AX_READ(&ax_local->ax_spi, P2_LCR1) & LCR_LED2_MASK) |
0842          LCR_LED2_EN | LCR_LED2_LINK, P2_LCR1);
0843 
0844     /* Disable PHY auto-polling */
0845     AX_WRITE(&ax_local->ax_spi, PCR_PHYID(AX88796C_PHY_ID), P2_PCR);
0846 
0847     /* Enable MAC interrupts */
0848     AX_WRITE(&ax_local->ax_spi, IMR_DEFAULT, P0_IMR);
0849 
0850     mutex_unlock(&ax_local->spi_lock);
0851 
0852     /* Setup flow-control configuration */
0853     phy_support_asym_pause(ax_local->phydev);
0854 
0855     if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
0856                   ax_local->phydev->advertising) ||
0857         linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
0858                   ax_local->phydev->advertising))
0859         fc |= AX_FC_ANEG;
0860 
0861     fc |= linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
0862                 ax_local->phydev->advertising) ? AX_FC_RX : 0;
0863     fc |= (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
0864                  ax_local->phydev->advertising) !=
0865            linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
0866                  ax_local->phydev->advertising)) ? AX_FC_TX : 0;
0867     ax_local->flowctrl = fc;
0868 
0869     phy_start(ax_local->ndev->phydev);
0870 
0871     netif_start_queue(ndev);
0872 
0873     spi_message_init(&ax_local->ax_spi.rx_msg);
0874 
0875     return 0;
0876 }
0877 
0878 static int
0879 ax88796c_close(struct net_device *ndev)
0880 {
0881     struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
0882 
0883     phy_stop(ndev->phydev);
0884 
0885     /* We lock the mutex early not only to protect the device
0886      * against concurrent access, but also avoid waking up the
0887      * queue in ax88796c_work(). phy_stop() needs to be called
0888      * before because it locks the mutex to access SPI.
0889      */
0890     mutex_lock(&ax_local->spi_lock);
0891 
0892     netif_stop_queue(ndev);
0893 
0894     /* No more work can be scheduled now. Make any pending work,
0895      * including one already waiting for the mutex to be unlocked,
0896      * NOP.
0897      */
0898     netif_dbg(ax_local, ifdown, ndev, "clearing bits\n");
0899     clear_bit(EVENT_SET_MULTI, &ax_local->flags);
0900     clear_bit(EVENT_INTR, &ax_local->flags);
0901     clear_bit(EVENT_TX, &ax_local->flags);
0902 
0903     /* Disable MAC interrupts */
0904     AX_WRITE(&ax_local->ax_spi, IMR_MASKALL, P0_IMR);
0905     __skb_queue_purge(&ax_local->tx_wait_q);
0906     ax88796c_soft_reset(ax_local);
0907 
0908     mutex_unlock(&ax_local->spi_lock);
0909 
0910     cancel_work_sync(&ax_local->ax_work);
0911 
0912     free_irq(ndev->irq, ndev);
0913 
0914     return 0;
0915 }
0916 
0917 static int
0918 ax88796c_set_features(struct net_device *ndev, netdev_features_t features)
0919 {
0920     struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
0921     netdev_features_t changed = features ^ ndev->features;
0922 
0923     if (!(changed & (NETIF_F_RXCSUM | NETIF_F_HW_CSUM)))
0924         return 0;
0925 
0926     ndev->features = features;
0927 
0928     if (changed & (NETIF_F_RXCSUM | NETIF_F_HW_CSUM))
0929         ax88796c_set_csums(ax_local);
0930 
0931     return 0;
0932 }
0933 
0934 static const struct net_device_ops ax88796c_netdev_ops = {
0935     .ndo_open       = ax88796c_open,
0936     .ndo_stop       = ax88796c_close,
0937     .ndo_start_xmit     = ax88796c_start_xmit,
0938     .ndo_get_stats64    = ax88796c_get_stats64,
0939     .ndo_eth_ioctl      = ax88796c_ioctl,
0940     .ndo_set_mac_address    = eth_mac_addr,
0941     .ndo_set_features   = ax88796c_set_features,
0942 };
0943 
0944 static int ax88796c_hard_reset(struct ax88796c_device *ax_local)
0945 {
0946     struct device *dev = (struct device *)&ax_local->spi->dev;
0947     struct gpio_desc *reset_gpio;
0948 
0949     /* reset info */
0950     reset_gpio = gpiod_get(dev, "reset", 0);
0951     if (IS_ERR(reset_gpio)) {
0952         dev_err(dev, "Could not get 'reset' GPIO: %ld", PTR_ERR(reset_gpio));
0953         return PTR_ERR(reset_gpio);
0954     }
0955 
0956     /* set reset */
0957     gpiod_direction_output(reset_gpio, 1);
0958     msleep(100);
0959     gpiod_direction_output(reset_gpio, 0);
0960     gpiod_put(reset_gpio);
0961     msleep(20);
0962 
0963     return 0;
0964 }
0965 
0966 static int ax88796c_probe(struct spi_device *spi)
0967 {
0968     char phy_id[MII_BUS_ID_SIZE + 3];
0969     struct ax88796c_device *ax_local;
0970     struct net_device *ndev;
0971     u16 temp;
0972     int ret;
0973 
0974     ndev = devm_alloc_etherdev(&spi->dev, sizeof(*ax_local));
0975     if (!ndev)
0976         return -ENOMEM;
0977 
0978     SET_NETDEV_DEV(ndev, &spi->dev);
0979 
0980     ax_local = to_ax88796c_device(ndev);
0981 
0982     dev_set_drvdata(&spi->dev, ax_local);
0983     ax_local->spi = spi;
0984     ax_local->ax_spi.spi = spi;
0985 
0986     ax_local->stats =
0987         devm_netdev_alloc_pcpu_stats(&spi->dev,
0988                          struct ax88796c_pcpu_stats);
0989     if (!ax_local->stats)
0990         return -ENOMEM;
0991 
0992     ax_local->ndev = ndev;
0993     ax_local->priv_flags |= comp ? AX_CAP_COMP : 0;
0994     ax_local->msg_enable = msg_enable;
0995     mutex_init(&ax_local->spi_lock);
0996 
0997     ax_local->mdiobus = devm_mdiobus_alloc(&spi->dev);
0998     if (!ax_local->mdiobus)
0999         return -ENOMEM;
1000 
1001     ax_local->mdiobus->priv = ax_local;
1002     ax_local->mdiobus->read = ax88796c_mdio_read;
1003     ax_local->mdiobus->write = ax88796c_mdio_write;
1004     ax_local->mdiobus->name = "ax88976c-mdiobus";
1005     ax_local->mdiobus->phy_mask = (u32)~BIT(AX88796C_PHY_ID);
1006     ax_local->mdiobus->parent = &spi->dev;
1007 
1008     snprintf(ax_local->mdiobus->id, MII_BUS_ID_SIZE,
1009          "ax88796c-%s.%u", dev_name(&spi->dev), spi->chip_select);
1010 
1011     ret = devm_mdiobus_register(&spi->dev, ax_local->mdiobus);
1012     if (ret < 0) {
1013         dev_err(&spi->dev, "Could not register MDIO bus\n");
1014         return ret;
1015     }
1016 
1017     if (netif_msg_probe(ax_local)) {
1018         dev_info(&spi->dev, "AX88796C-SPI Configuration:\n");
1019         dev_info(&spi->dev, "    Compression : %s\n",
1020              ax_local->priv_flags & AX_CAP_COMP ? "ON" : "OFF");
1021     }
1022 
1023     ndev->irq = spi->irq;
1024     ndev->netdev_ops = &ax88796c_netdev_ops;
1025     ndev->ethtool_ops = &ax88796c_ethtool_ops;
1026     ndev->hw_features |= NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
1027     ndev->features |= NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
1028     ndev->needed_headroom = TX_OVERHEAD;
1029     ndev->needed_tailroom = TX_EOP_SIZE;
1030 
1031     mutex_lock(&ax_local->spi_lock);
1032 
1033     /* ax88796c gpio reset */
1034     ax88796c_hard_reset(ax_local);
1035 
1036     /* Reset AX88796C */
1037     ret = ax88796c_soft_reset(ax_local);
1038     if (ret < 0) {
1039         ret = -ENODEV;
1040         mutex_unlock(&ax_local->spi_lock);
1041         goto err;
1042     }
1043     /* Check board revision */
1044     temp = AX_READ(&ax_local->ax_spi, P2_CRIR);
1045     if ((temp & 0xF) != 0x0) {
1046         dev_err(&spi->dev, "spi read failed: %d\n", temp);
1047         ret = -ENODEV;
1048         mutex_unlock(&ax_local->spi_lock);
1049         goto err;
1050     }
1051 
1052     /*Reload EEPROM*/
1053     ax88796c_reload_eeprom(ax_local);
1054 
1055     ax88796c_load_mac_addr(ndev);
1056 
1057     if (netif_msg_probe(ax_local))
1058         dev_info(&spi->dev,
1059              "irq %d, MAC addr %02X:%02X:%02X:%02X:%02X:%02X\n",
1060              ndev->irq,
1061              ndev->dev_addr[0], ndev->dev_addr[1],
1062              ndev->dev_addr[2], ndev->dev_addr[3],
1063              ndev->dev_addr[4], ndev->dev_addr[5]);
1064 
1065     /* Disable power saving */
1066     AX_WRITE(&ax_local->ax_spi, (AX_READ(&ax_local->ax_spi, P0_PSCR)
1067                      & PSCR_PS_MASK) | PSCR_PS_D0, P0_PSCR);
1068 
1069     mutex_unlock(&ax_local->spi_lock);
1070 
1071     INIT_WORK(&ax_local->ax_work, ax88796c_work);
1072 
1073     skb_queue_head_init(&ax_local->tx_wait_q);
1074 
1075     snprintf(phy_id, MII_BUS_ID_SIZE + 3, PHY_ID_FMT,
1076          ax_local->mdiobus->id, AX88796C_PHY_ID);
1077     ax_local->phydev = phy_connect(ax_local->ndev, phy_id,
1078                        ax88796c_handle_link_change,
1079                        PHY_INTERFACE_MODE_MII);
1080     if (IS_ERR(ax_local->phydev)) {
1081         ret = PTR_ERR(ax_local->phydev);
1082         goto err;
1083     }
1084     ax_local->phydev->irq = PHY_POLL;
1085 
1086     ret = devm_register_netdev(&spi->dev, ndev);
1087     if (ret) {
1088         dev_err(&spi->dev, "failed to register a network device\n");
1089         goto err_phy_dis;
1090     }
1091 
1092     netif_info(ax_local, probe, ndev, "%s %s registered\n",
1093            dev_driver_string(&spi->dev),
1094            dev_name(&spi->dev));
1095     phy_attached_info(ax_local->phydev);
1096 
1097     return 0;
1098 
1099 err_phy_dis:
1100     phy_disconnect(ax_local->phydev);
1101 err:
1102     return ret;
1103 }
1104 
1105 static void ax88796c_remove(struct spi_device *spi)
1106 {
1107     struct ax88796c_device *ax_local = dev_get_drvdata(&spi->dev);
1108     struct net_device *ndev = ax_local->ndev;
1109 
1110     phy_disconnect(ndev->phydev);
1111 
1112     netif_info(ax_local, probe, ndev, "removing network device %s %s\n",
1113            dev_driver_string(&spi->dev),
1114            dev_name(&spi->dev));
1115 }
1116 
1117 #ifdef CONFIG_OF
1118 static const struct of_device_id ax88796c_dt_ids[] = {
1119     { .compatible = "asix,ax88796c" },
1120     {},
1121 };
1122 MODULE_DEVICE_TABLE(of, ax88796c_dt_ids);
1123 #endif
1124 
1125 static const struct spi_device_id asix_id[] = {
1126     { "ax88796c", 0 },
1127     { }
1128 };
1129 MODULE_DEVICE_TABLE(spi, asix_id);
1130 
1131 static struct spi_driver ax88796c_spi_driver = {
1132     .driver = {
1133         .name = DRV_NAME,
1134         .of_match_table = of_match_ptr(ax88796c_dt_ids),
1135     },
1136     .probe = ax88796c_probe,
1137     .remove = ax88796c_remove,
1138     .id_table = asix_id,
1139 };
1140 
1141 static __init int ax88796c_spi_init(void)
1142 {
1143     int ret;
1144 
1145     bitmap_zero(ax88796c_no_regs_mask, AX88796C_REGDUMP_LEN);
1146     ret = bitmap_parse(no_regs_list, 35,
1147                ax88796c_no_regs_mask, AX88796C_REGDUMP_LEN);
1148     if (ret) {
1149         bitmap_fill(ax88796c_no_regs_mask, AX88796C_REGDUMP_LEN);
1150         pr_err("Invalid bitmap description, masking all registers\n");
1151     }
1152 
1153     return spi_register_driver(&ax88796c_spi_driver);
1154 }
1155 
1156 static __exit void ax88796c_spi_exit(void)
1157 {
1158     spi_unregister_driver(&ax88796c_spi_driver);
1159 }
1160 
1161 module_init(ax88796c_spi_init);
1162 module_exit(ax88796c_spi_exit);
1163 
1164 MODULE_AUTHOR("Łukasz Stelmach <l.stelmach@samsung.com>");
1165 MODULE_DESCRIPTION("ASIX AX88796C SPI Ethernet driver");
1166 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!