drivers/net/ethernet/alacritech/slicoss.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Driver for Gigabit Ethernet adapters based on the Session Layer
   4  * Interface (SLIC) technology by Alacritech. The driver does not
   5  * support the hardware acceleration features provided by these cards.
   6  *
   7  * Copyright (C) 2016 Lino Sanfilippo <LinoSanfilippo@gmx.de>
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/pci.h>
  13 #include <linux/netdevice.h>
  14 #include <linux/etherdevice.h>
  15 #include <linux/if_ether.h>
  16 #include <linux/crc32.h>
  17 #include <linux/dma-mapping.h>
  18 #include <linux/ethtool.h>
  19 #include <linux/mii.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/delay.h>
  22 #include <linux/firmware.h>
  23 #include <linux/list.h>
  24 #include <linux/u64_stats_sync.h>
  25
  26 #include "slic.h"
  27
  28 #define DRV_NAME                        "slicoss"
  29 #define DRV_VERSION                     "1.0"
  30
  31 static const struct pci_device_id slic_id_tbl[] = {
  32         { PCI_DEVICE(PCI_VENDOR_ID_ALACRITECH,
  33                      PCI_DEVICE_ID_ALACRITECH_MOJAVE) },
  34         { PCI_DEVICE(PCI_VENDOR_ID_ALACRITECH,
  35                      PCI_DEVICE_ID_ALACRITECH_OASIS) },
  36         { 0 }
  37 };
  38
  39 static const char slic_stats_strings[][ETH_GSTRING_LEN] = {
  40         "rx_packets",
  41         "rx_bytes",
  42         "rx_multicasts",
  43         "rx_errors",
  44         "rx_buff_miss",
  45         "rx_tp_csum",
  46         "rx_tp_oflow",
  47         "rx_tp_hlen",
  48         "rx_ip_csum",
  49         "rx_ip_len",
  50         "rx_ip_hdr_len",
  51         "rx_early",
  52         "rx_buff_oflow",
  53         "rx_lcode",
  54         "rx_drbl",
  55         "rx_crc",
  56         "rx_oflow_802",
  57         "rx_uflow_802",
  58         "tx_packets",
  59         "tx_bytes",
  60         "tx_carrier",
  61         "tx_dropped",
  62         "irq_errs",
  63 };
  64
  65 static inline int slic_next_queue_idx(unsigned int idx, unsigned int qlen)
  66 {
  67         return (idx + 1) & (qlen - 1);
  68 }
  69
  70 static inline int slic_get_free_queue_descs(unsigned int put_idx,
  71                                             unsigned int done_idx,
  72                                             unsigned int qlen)
  73 {
  74         if (put_idx >= done_idx)
  75                 return (qlen - (put_idx - done_idx) - 1);
  76         return (done_idx - put_idx - 1);
  77 }
  78
  79 static unsigned int slic_next_compl_idx(struct slic_device *sdev)
  80 {
  81         struct slic_stat_queue *stq = &sdev->stq;
  82         unsigned int active = stq->active_array;
  83         struct slic_stat_desc *descs;
  84         struct slic_stat_desc *stat;
  85         unsigned int idx;
  86
  87         descs = stq->descs[active];
  88         stat = &descs[stq->done_idx];
  89
  90         if (!stat->status)
  91                 return SLIC_INVALID_STAT_DESC_IDX;
  92
  93         idx = (le32_to_cpu(stat->hnd) & 0xffff) - 1;
  94         /* reset desc */
  95         stat->hnd = 0;
  96         stat->status = 0;
  97
  98         stq->done_idx = slic_next_queue_idx(stq->done_idx, stq->len);
  99         /* check for wraparound */
 100         if (!stq->done_idx) {
 101                 dma_addr_t paddr = stq->paddr[active];
 102
 103                 slic_write(sdev, SLIC_REG_RBAR, lower_32_bits(paddr) |
 104                                                 stq->len);
 105                 /* make sure new status descriptors are immediately available */
 106                 slic_flush_write(sdev);
 107                 active++;
 108                 active &= (SLIC_NUM_STAT_DESC_ARRAYS - 1);
 109                 stq->active_array = active;
 110         }
 111         return idx;
 112 }
 113
 114 static unsigned int slic_get_free_tx_descs(struct slic_tx_queue *txq)
 115 {
 116         /* ensure tail idx is updated */
 117         smp_mb();
 118         return slic_get_free_queue_descs(txq->put_idx, txq->done_idx, txq->len);
 119 }
 120
 121 static unsigned int slic_get_free_rx_descs(struct slic_rx_queue *rxq)
 122 {
 123         return slic_get_free_queue_descs(rxq->put_idx, rxq->done_idx, rxq->len);
 124 }
 125
 126 static void slic_clear_upr_list(struct slic_upr_list *upr_list)
 127 {
 128         struct slic_upr *upr;
 129         struct slic_upr *tmp;
 130
 131         spin_lock_bh(&upr_list->lock);
 132         list_for_each_entry_safe(upr, tmp, &upr_list->list, list) {
 133                 list_del(&upr->list);
 134                 kfree(upr);
 135         }
 136         upr_list->pending = false;
 137         spin_unlock_bh(&upr_list->lock);
 138 }
 139
 140 static void slic_start_upr(struct slic_device *sdev, struct slic_upr *upr)
 141 {
 142         u32 reg;
 143
 144         reg = (upr->type == SLIC_UPR_CONFIG) ? SLIC_REG_RCONFIG :
 145                                                SLIC_REG_LSTAT;
 146         slic_write(sdev, reg, lower_32_bits(upr->paddr));
 147         slic_flush_write(sdev);
 148 }
 149
 150 static void slic_queue_upr(struct slic_device *sdev, struct slic_upr *upr)
 151 {
 152         struct slic_upr_list *upr_list = &sdev->upr_list;
 153         bool pending;
 154
 155         spin_lock_bh(&upr_list->lock);
 156         pending = upr_list->pending;
 157         INIT_LIST_HEAD(&upr->list);
 158         list_add_tail(&upr->list, &upr_list->list);
 159         upr_list->pending = true;
 160         spin_unlock_bh(&upr_list->lock);
 161
 162         if (!pending)
 163                 slic_start_upr(sdev, upr);
 164 }
 165
 166 static struct slic_upr *slic_dequeue_upr(struct slic_device *sdev)
 167 {
 168         struct slic_upr_list *upr_list = &sdev->upr_list;
 169         struct slic_upr *next_upr = NULL;
 170         struct slic_upr *upr = NULL;
 171
 172         spin_lock_bh(&upr_list->lock);
 173         if (!list_empty(&upr_list->list)) {
 174                 upr = list_first_entry(&upr_list->list, struct slic_upr, list);
 175                 list_del(&upr->list);
 176
 177                 if (list_empty(&upr_list->list))
 178                         upr_list->pending = false;
 179                 else
 180                         next_upr = list_first_entry(&upr_list->list,
 181                                                     struct slic_upr, list);
 182         }
 183         spin_unlock_bh(&upr_list->lock);
 184         /* trigger processing of the next upr in list */
 185         if (next_upr)
 186                 slic_start_upr(sdev, next_upr);
 187
 188         return upr;
 189 }
 190
 191 static int slic_new_upr(struct slic_device *sdev, unsigned int type,
 192                         dma_addr_t paddr)
 193 {
 194         struct slic_upr *upr;
 195
 196         upr = kmalloc(sizeof(*upr), GFP_ATOMIC);
 197         if (!upr)
 198                 return -ENOMEM;
 199         upr->type = type;
 200         upr->paddr = paddr;
 201
 202         slic_queue_upr(sdev, upr);
 203
 204         return 0;
 205 }
 206
 207 static void slic_set_mcast_bit(u64 *mcmask, unsigned char const *addr)
 208 {
 209         u64 mask = *mcmask;
 210         u8 crc;
 211         /* Get the CRC polynomial for the mac address: we use bits 1-8 (lsb),
 212          * bitwise reversed, msb (= lsb bit 0 before bitrev) is automatically
 213          * discarded.
 214          */
 215         crc = ether_crc(ETH_ALEN, addr) >> 23;
 216          /* we only have space on the SLIC for 64 entries */
 217         crc &= 0x3F;
 218         mask |= (u64)1 << crc;
 219         *mcmask = mask;
 220 }
 221
 222 /* must be called with link_lock held */
 223 static void slic_configure_rcv(struct slic_device *sdev)
 224 {
 225         u32 val;
 226
 227         val = SLIC_GRCR_RESET | SLIC_GRCR_ADDRAEN | SLIC_GRCR_RCVEN |
 228               SLIC_GRCR_HASHSIZE << SLIC_GRCR_HASHSIZE_SHIFT | SLIC_GRCR_RCVBAD;
 229
 230         if (sdev->duplex == DUPLEX_FULL)
 231                 val |= SLIC_GRCR_CTLEN;
 232
 233         if (sdev->promisc)
 234                 val |= SLIC_GRCR_RCVALL;
 235
 236         slic_write(sdev, SLIC_REG_WRCFG, val);
 237 }
 238
 239 /* must be called with link_lock held */
 240 static void slic_configure_xmt(struct slic_device *sdev)
 241 {
 242         u32 val;
 243
 244         val = SLIC_GXCR_RESET | SLIC_GXCR_XMTEN;
 245
 246         if (sdev->duplex == DUPLEX_FULL)
 247                 val |= SLIC_GXCR_PAUSEEN;
 248
 249         slic_write(sdev, SLIC_REG_WXCFG, val);
 250 }
 251
 252 /* must be called with link_lock held */
 253 static void slic_configure_mac(struct slic_device *sdev)
 254 {
 255         u32 val;
 256
 257         if (sdev->speed == SPEED_1000) {
 258                 val = SLIC_GMCR_GAPBB_1000 << SLIC_GMCR_GAPBB_SHIFT |
 259                       SLIC_GMCR_GAPR1_1000 << SLIC_GMCR_GAPR1_SHIFT |
 260                       SLIC_GMCR_GAPR2_1000 << SLIC_GMCR_GAPR2_SHIFT |
 261                       SLIC_GMCR_GBIT; /* enable GMII */
 262         } else {
 263                 val = SLIC_GMCR_GAPBB_100 << SLIC_GMCR_GAPBB_SHIFT |
 264                       SLIC_GMCR_GAPR1_100 << SLIC_GMCR_GAPR1_SHIFT |
 265                       SLIC_GMCR_GAPR2_100 << SLIC_GMCR_GAPR2_SHIFT;
 266         }
 267
 268         if (sdev->duplex == DUPLEX_FULL)
 269                 val |= SLIC_GMCR_FULLD;
 270
 271         slic_write(sdev, SLIC_REG_WMCFG, val);
 272 }
 273
 274 static void slic_configure_link_locked(struct slic_device *sdev, int speed,
 275                                        unsigned int duplex)
 276 {
 277         struct net_device *dev = sdev->netdev;
 278
 279         if (sdev->speed == speed && sdev->duplex == duplex)
 280                 return;
 281
 282         sdev->speed = speed;
 283         sdev->duplex = duplex;
 284
 285         if (sdev->speed == SPEED_UNKNOWN) {
 286                 if (netif_carrier_ok(dev))
 287                         netif_carrier_off(dev);
 288         } else {
 289                 /* (re)configure link settings */
 290                 slic_configure_mac(sdev);
 291                 slic_configure_xmt(sdev);
 292                 slic_configure_rcv(sdev);
 293                 slic_flush_write(sdev);
 294
 295                 if (!netif_carrier_ok(dev))
 296                         netif_carrier_on(dev);
 297         }
 298 }
 299
 300 static void slic_configure_link(struct slic_device *sdev, int speed,
 301                                 unsigned int duplex)
 302 {
 303         spin_lock_bh(&sdev->link_lock);
 304         slic_configure_link_locked(sdev, speed, duplex);
 305         spin_unlock_bh(&sdev->link_lock);
 306 }
 307
 308 static void slic_set_rx_mode(struct net_device *dev)
 309 {
 310         struct slic_device *sdev = netdev_priv(dev);
 311         struct netdev_hw_addr *hwaddr;
 312         bool set_promisc;
 313         u64 mcmask;
 314
 315         if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) {
 316                 /* Turn on all multicast addresses. We have to do this for
 317                  * promiscuous mode as well as ALLMCAST mode (it saves the
 318                  * microcode from having to keep state about the MAC
 319                  * configuration).
 320                  */
 321                 mcmask = ~(u64)0;
 322         } else  {
 323                 mcmask = 0;
 324
 325                 netdev_for_each_mc_addr(hwaddr, dev) {
 326                         slic_set_mcast_bit(&mcmask, hwaddr->addr);
 327                 }
 328         }
 329
 330         slic_write(sdev, SLIC_REG_MCASTLOW, lower_32_bits(mcmask));
 331         slic_write(sdev, SLIC_REG_MCASTHIGH, upper_32_bits(mcmask));
 332
 333         set_promisc = !!(dev->flags & IFF_PROMISC);
 334
 335         spin_lock_bh(&sdev->link_lock);
 336         if (sdev->promisc != set_promisc) {
 337                 sdev->promisc = set_promisc;
 338                 slic_configure_rcv(sdev);
 339         }
 340         spin_unlock_bh(&sdev->link_lock);
 341 }
 342
 343 static void slic_xmit_complete(struct slic_device *sdev)
 344 {
 345         struct slic_tx_queue *txq = &sdev->txq;
 346         struct net_device *dev = sdev->netdev;
 347         struct slic_tx_buffer *buff;
 348         unsigned int frames = 0;
 349         unsigned int bytes = 0;
 350         unsigned int idx;
 351
 352         /* Limit processing to SLIC_MAX_TX_COMPLETIONS frames to avoid that new
 353          * completions during processing keeps the loop running endlessly.
 354          */
 355         do {
 356                 idx = slic_next_compl_idx(sdev);
 357                 if (idx == SLIC_INVALID_STAT_DESC_IDX)
 358                         break;
 359
 360                 txq->done_idx = idx;
 361                 buff = &txq->txbuffs[idx];
 362
 363                 if (unlikely(!buff->skb)) {
 364                         netdev_warn(dev,
 365                                     "no skb found for desc idx %i\n", idx);
 366                         continue;
 367                 }
 368                 dma_unmap_single(&sdev->pdev->dev,
 369                                  dma_unmap_addr(buff, map_addr),
 370                                  dma_unmap_len(buff, map_len), DMA_TO_DEVICE);
 371
 372                 bytes += buff->skb->len;
 373                 frames++;
 374
 375                 dev_kfree_skb_any(buff->skb);
 376                 buff->skb = NULL;
 377         } while (frames < SLIC_MAX_TX_COMPLETIONS);
 378         /* make sure xmit sees the new value for done_idx */
 379         smp_wmb();
 380
 381         u64_stats_update_begin(&sdev->stats.syncp);
 382         sdev->stats.tx_bytes += bytes;
 383         sdev->stats.tx_packets += frames;
 384         u64_stats_update_end(&sdev->stats.syncp);
 385
 386         netif_tx_lock(dev);
 387         if (netif_queue_stopped(dev) &&
 388             (slic_get_free_tx_descs(txq) >= SLIC_MIN_TX_WAKEUP_DESCS))
 389                 netif_wake_queue(dev);
 390         netif_tx_unlock(dev);
 391 }
 392
 393 static void slic_refill_rx_queue(struct slic_device *sdev, gfp_t gfp)
 394 {
 395         const unsigned int ALIGN_MASK = SLIC_RX_BUFF_ALIGN - 1;
 396         unsigned int maplen = SLIC_RX_BUFF_SIZE;
 397         struct slic_rx_queue *rxq = &sdev->rxq;
 398         struct net_device *dev = sdev->netdev;
 399         struct slic_rx_buffer *buff;
 400         struct slic_rx_desc *desc;
 401         unsigned int misalign;
 402         unsigned int offset;
 403         struct sk_buff *skb;
 404         dma_addr_t paddr;
 405
 406         while (slic_get_free_rx_descs(rxq) > SLIC_MAX_REQ_RX_DESCS) {
 407                 skb = alloc_skb(maplen + ALIGN_MASK, gfp);
 408                 if (!skb)
 409                         break;
 410
 411                 paddr = dma_map_single(&sdev->pdev->dev, skb->data, maplen,
 412                                        DMA_FROM_DEVICE);
 413                 if (dma_mapping_error(&sdev->pdev->dev, paddr)) {
 414                         netdev_err(dev, "mapping rx packet failed\n");
 415                         /* drop skb */
 416                         dev_kfree_skb_any(skb);
 417                         break;
 418                 }
 419                 /* ensure head buffer descriptors are 256 byte aligned */
 420                 offset = 0;
 421                 misalign = paddr & ALIGN_MASK;
 422                 if (misalign) {
 423                         offset = SLIC_RX_BUFF_ALIGN - misalign;
 424                         skb_reserve(skb, offset);
 425                 }
 426                 /* the HW expects dma chunks for descriptor + frame data */
 427                 desc = (struct slic_rx_desc *)skb->data;
 428                 /* temporarily sync descriptor for CPU to clear status */
 429                 dma_sync_single_for_cpu(&sdev->pdev->dev, paddr,
 430                                         offset + sizeof(*desc),
 431                                         DMA_FROM_DEVICE);
 432                 desc->status = 0;
 433                 /* return it to HW again */
 434                 dma_sync_single_for_device(&sdev->pdev->dev, paddr,
 435                                            offset + sizeof(*desc),
 436                                            DMA_FROM_DEVICE);
 437
 438                 buff = &rxq->rxbuffs[rxq->put_idx];
 439                 buff->skb = skb;
 440                 dma_unmap_addr_set(buff, map_addr, paddr);
 441                 dma_unmap_len_set(buff, map_len, maplen);
 442                 buff->addr_offset = offset;
 443                 /* complete write to descriptor before it is handed to HW */
 444                 wmb();
 445                 /* head buffer descriptors are placed immediately before skb */
 446                 slic_write(sdev, SLIC_REG_HBAR, lower_32_bits(paddr) + offset);
 447                 rxq->put_idx = slic_next_queue_idx(rxq->put_idx, rxq->len);
 448         }
 449 }
 450
 451 static void slic_handle_frame_error(struct slic_device *sdev,
 452                                     struct sk_buff *skb)
 453 {
 454         struct slic_stats *stats = &sdev->stats;
 455
 456         if (sdev->model == SLIC_MODEL_OASIS) {
 457                 struct slic_rx_info_oasis *info;
 458                 u32 status_b;
 459                 u32 status;
 460
 461                 info = (struct slic_rx_info_oasis *)skb->data;
 462                 status = le32_to_cpu(info->frame_status);
 463                 status_b = le32_to_cpu(info->frame_status_b);
 464                 /* transport layer */
 465                 if (status_b & SLIC_VRHSTATB_TPCSUM)
 466                         SLIC_INC_STATS_COUNTER(stats, rx_tpcsum);
 467                 if (status & SLIC_VRHSTAT_TPOFLO)
 468                         SLIC_INC_STATS_COUNTER(stats, rx_tpoflow);
 469                 if (status_b & SLIC_VRHSTATB_TPHLEN)
 470                         SLIC_INC_STATS_COUNTER(stats, rx_tphlen);
 471                 /* ip layer */
 472                 if (status_b & SLIC_VRHSTATB_IPCSUM)
 473                         SLIC_INC_STATS_COUNTER(stats, rx_ipcsum);
 474                 if (status_b & SLIC_VRHSTATB_IPLERR)
 475                         SLIC_INC_STATS_COUNTER(stats, rx_iplen);
 476                 if (status_b & SLIC_VRHSTATB_IPHERR)
 477                         SLIC_INC_STATS_COUNTER(stats, rx_iphlen);
 478                 /* link layer */
 479                 if (status_b & SLIC_VRHSTATB_RCVE)
 480                         SLIC_INC_STATS_COUNTER(stats, rx_early);
 481                 if (status_b & SLIC_VRHSTATB_BUFF)
 482                         SLIC_INC_STATS_COUNTER(stats, rx_buffoflow);
 483                 if (status_b & SLIC_VRHSTATB_CODE)
 484                         SLIC_INC_STATS_COUNTER(stats, rx_lcode);
 485                 if (status_b & SLIC_VRHSTATB_DRBL)
 486                         SLIC_INC_STATS_COUNTER(stats, rx_drbl);
 487                 if (status_b & SLIC_VRHSTATB_CRC)
 488                         SLIC_INC_STATS_COUNTER(stats, rx_crc);
 489                 if (status & SLIC_VRHSTAT_802OE)
 490                         SLIC_INC_STATS_COUNTER(stats, rx_oflow802);
 491                 if (status_b & SLIC_VRHSTATB_802UE)
 492                         SLIC_INC_STATS_COUNTER(stats, rx_uflow802);
 493                 if (status_b & SLIC_VRHSTATB_CARRE)
 494                         SLIC_INC_STATS_COUNTER(stats, tx_carrier);
 495         } else { /* mojave */
 496                 struct slic_rx_info_mojave *info;
 497                 u32 status;
 498
 499                 info = (struct slic_rx_info_mojave *)skb->data;
 500                 status = le32_to_cpu(info->frame_status);
 501                 /* transport layer */
 502                 if (status & SLIC_VGBSTAT_XPERR) {
 503                         u32 xerr = status >> SLIC_VGBSTAT_XERRSHFT;
 504
 505                         if (xerr == SLIC_VGBSTAT_XCSERR)
 506                                 SLIC_INC_STATS_COUNTER(stats, rx_tpcsum);
 507                         if (xerr == SLIC_VGBSTAT_XUFLOW)
 508                                 SLIC_INC_STATS_COUNTER(stats, rx_tpoflow);
 509                         if (xerr == SLIC_VGBSTAT_XHLEN)
 510                                 SLIC_INC_STATS_COUNTER(stats, rx_tphlen);
 511                 }
 512                 /* ip layer */
 513                 if (status & SLIC_VGBSTAT_NETERR) {
 514                         u32 nerr = status >> SLIC_VGBSTAT_NERRSHFT &
 515                                    SLIC_VGBSTAT_NERRMSK;
 516
 517                         if (nerr == SLIC_VGBSTAT_NCSERR)
 518                                 SLIC_INC_STATS_COUNTER(stats, rx_ipcsum);
 519                         if (nerr == SLIC_VGBSTAT_NUFLOW)
 520                                 SLIC_INC_STATS_COUNTER(stats, rx_iplen);
 521                         if (nerr == SLIC_VGBSTAT_NHLEN)
 522                                 SLIC_INC_STATS_COUNTER(stats, rx_iphlen);
 523                 }
 524                 /* link layer */
 525                 if (status & SLIC_VGBSTAT_LNKERR) {
 526                         u32 lerr = status & SLIC_VGBSTAT_LERRMSK;
 527
 528                         if (lerr == SLIC_VGBSTAT_LDEARLY)
 529                                 SLIC_INC_STATS_COUNTER(stats, rx_early);
 530                         if (lerr == SLIC_VGBSTAT_LBOFLO)
 531                                 SLIC_INC_STATS_COUNTER(stats, rx_buffoflow);
 532                         if (lerr == SLIC_VGBSTAT_LCODERR)
 533                                 SLIC_INC_STATS_COUNTER(stats, rx_lcode);
 534                         if (lerr == SLIC_VGBSTAT_LDBLNBL)
 535                                 SLIC_INC_STATS_COUNTER(stats, rx_drbl);
 536                         if (lerr == SLIC_VGBSTAT_LCRCERR)
 537                                 SLIC_INC_STATS_COUNTER(stats, rx_crc);
 538                         if (lerr == SLIC_VGBSTAT_LOFLO)
 539                                 SLIC_INC_STATS_COUNTER(stats, rx_oflow802);
 540                         if (lerr == SLIC_VGBSTAT_LUFLO)
 541                                 SLIC_INC_STATS_COUNTER(stats, rx_uflow802);
 542                 }
 543         }
 544         SLIC_INC_STATS_COUNTER(stats, rx_errors);
 545 }
 546
 547 static void slic_handle_receive(struct slic_device *sdev, unsigned int todo,
 548                                 unsigned int *done)
 549 {
 550         struct slic_rx_queue *rxq = &sdev->rxq;
 551         struct net_device *dev = sdev->netdev;
 552         struct slic_rx_buffer *buff;
 553         struct slic_rx_desc *desc;
 554         unsigned int frames = 0;
 555         unsigned int bytes = 0;
 556         struct sk_buff *skb;
 557         u32 status;
 558         u32 len;
 559
 560         while (todo && (rxq->done_idx != rxq->put_idx)) {
 561                 buff = &rxq->rxbuffs[rxq->done_idx];
 562
 563                 skb = buff->skb;
 564                 if (!skb)
 565                         break;
 566
 567                 desc = (struct slic_rx_desc *)skb->data;
 568
 569                 dma_sync_single_for_cpu(&sdev->pdev->dev,
 570                                         dma_unmap_addr(buff, map_addr),
 571                                         buff->addr_offset + sizeof(*desc),
 572                                         DMA_FROM_DEVICE);
 573
 574                 status = le32_to_cpu(desc->status);
 575                 if (!(status & SLIC_IRHDDR_SVALID)) {
 576                         dma_sync_single_for_device(&sdev->pdev->dev,
 577                                                    dma_unmap_addr(buff,
 578                                                                   map_addr),
 579                                                    buff->addr_offset +
 580                                                    sizeof(*desc),
 581                                                    DMA_FROM_DEVICE);
 582                         break;
 583                 }
 584
 585                 buff->skb = NULL;
 586
 587                 dma_unmap_single(&sdev->pdev->dev,
 588                                  dma_unmap_addr(buff, map_addr),
 589                                  dma_unmap_len(buff, map_len),
 590                                  DMA_FROM_DEVICE);
 591
 592                 /* skip rx descriptor that is placed before the frame data */
 593                 skb_reserve(skb, SLIC_RX_BUFF_HDR_SIZE);
 594
 595                 if (unlikely(status & SLIC_IRHDDR_ERR)) {
 596                         slic_handle_frame_error(sdev, skb);
 597                         dev_kfree_skb_any(skb);
 598                 } else {
 599                         struct ethhdr *eh = (struct ethhdr *)skb->data;
 600
 601                         if (is_multicast_ether_addr(eh->h_dest))
 602                                 SLIC_INC_STATS_COUNTER(&sdev->stats, rx_mcasts);
 603
 604                         len = le32_to_cpu(desc->length) & SLIC_IRHDDR_FLEN_MSK;
 605                         skb_put(skb, len);
 606                         skb->protocol = eth_type_trans(skb, dev);
 607                         skb->ip_summed = CHECKSUM_UNNECESSARY;
 608
 609                         napi_gro_receive(&sdev->napi, skb);
 610
 611                         bytes += len;
 612                         frames++;
 613                 }
 614                 rxq->done_idx = slic_next_queue_idx(rxq->done_idx, rxq->len);
 615                 todo--;
 616         }
 617
 618         u64_stats_update_begin(&sdev->stats.syncp);
 619         sdev->stats.rx_bytes += bytes;
 620         sdev->stats.rx_packets += frames;
 621         u64_stats_update_end(&sdev->stats.syncp);
 622
 623         slic_refill_rx_queue(sdev, GFP_ATOMIC);
 624 }
 625
 626 static void slic_handle_link_irq(struct slic_device *sdev)
 627 {
 628         struct slic_shmem *sm = &sdev->shmem;
 629         struct slic_shmem_data *sm_data = sm->shmem_data;
 630         unsigned int duplex;
 631         int speed;
 632         u32 link;
 633
 634         link = le32_to_cpu(sm_data->link);
 635
 636         if (link & SLIC_GIG_LINKUP) {
 637                 if (link & SLIC_GIG_SPEED_1000)
 638                         speed = SPEED_1000;
 639                 else if (link & SLIC_GIG_SPEED_100)
 640                         speed = SPEED_100;
 641                 else
 642                         speed = SPEED_10;
 643
 644                 duplex = (link & SLIC_GIG_FULLDUPLEX) ? DUPLEX_FULL :
 645                                                         DUPLEX_HALF;
 646         } else {
 647                 duplex = DUPLEX_UNKNOWN;
 648                 speed = SPEED_UNKNOWN;
 649         }
 650         slic_configure_link(sdev, speed, duplex);
 651 }
 652
 653 static void slic_handle_upr_irq(struct slic_device *sdev, u32 irqs)
 654 {
 655         struct slic_upr *upr;
 656
 657         /* remove upr that caused this irq (always the first entry in list) */
 658         upr = slic_dequeue_upr(sdev);
 659         if (!upr) {
 660                 netdev_warn(sdev->netdev, "no upr found on list\n");
 661                 return;
 662         }
 663
 664         if (upr->type == SLIC_UPR_LSTAT) {
 665                 if (unlikely(irqs & SLIC_ISR_UPCERR_MASK)) {
 666                         /* try again */
 667                         slic_queue_upr(sdev, upr);
 668                         return;
 669                 }
 670                 slic_handle_link_irq(sdev);
 671         }
 672         kfree(upr);
 673 }
 674
 675 static int slic_handle_link_change(struct slic_device *sdev)
 676 {
 677         return slic_new_upr(sdev, SLIC_UPR_LSTAT, sdev->shmem.link_paddr);
 678 }
 679
 680 static void slic_handle_err_irq(struct slic_device *sdev, u32 isr)
 681 {
 682         struct slic_stats *stats = &sdev->stats;
 683
 684         if (isr & SLIC_ISR_RMISS)
 685                 SLIC_INC_STATS_COUNTER(stats, rx_buff_miss);
 686         if (isr & SLIC_ISR_XDROP)
 687                 SLIC_INC_STATS_COUNTER(stats, tx_dropped);
 688         if (!(isr & (SLIC_ISR_RMISS | SLIC_ISR_XDROP)))
 689                 SLIC_INC_STATS_COUNTER(stats, irq_errs);
 690 }
 691
 692 static void slic_handle_irq(struct slic_device *sdev, u32 isr,
 693                             unsigned int todo, unsigned int *done)
 694 {
 695         if (isr & SLIC_ISR_ERR)
 696                 slic_handle_err_irq(sdev, isr);
 697
 698         if (isr & SLIC_ISR_LEVENT)
 699                 slic_handle_link_change(sdev);
 700
 701         if (isr & SLIC_ISR_UPC_MASK)
 702                 slic_handle_upr_irq(sdev, isr);
 703
 704         if (isr & SLIC_ISR_RCV)
 705                 slic_handle_receive(sdev, todo, done);
 706
 707         if (isr & SLIC_ISR_CMD)
 708                 slic_xmit_complete(sdev);
 709 }
 710
 711 static int slic_poll(struct napi_struct *napi, int todo)
 712 {
 713         struct slic_device *sdev = container_of(napi, struct slic_device, napi);
 714         struct slic_shmem *sm = &sdev->shmem;
 715         struct slic_shmem_data *sm_data = sm->shmem_data;
 716         u32 isr = le32_to_cpu(sm_data->isr);
 717         int done = 0;
 718
 719         slic_handle_irq(sdev, isr, todo, &done);
 720
 721         if (done < todo) {
 722                 napi_complete_done(napi, done);
 723                 /* reenable irqs */
 724                 sm_data->isr = 0;
 725                 /* make sure sm_data->isr is cleard before irqs are reenabled */
 726                 wmb();
 727                 slic_write(sdev, SLIC_REG_ISR, 0);
 728                 slic_flush_write(sdev);
 729         }
 730
 731         return done;
 732 }
 733
 734 static irqreturn_t slic_irq(int irq, void *dev_id)
 735 {
 736         struct slic_device *sdev = dev_id;
 737         struct slic_shmem *sm = &sdev->shmem;
 738         struct slic_shmem_data *sm_data = sm->shmem_data;
 739
 740         slic_write(sdev, SLIC_REG_ICR, SLIC_ICR_INT_MASK);
 741         slic_flush_write(sdev);
 742         /* make sure sm_data->isr is read after ICR_INT_MASK is set */
 743         wmb();
 744
 745         if (!sm_data->isr) {
 746                 dma_rmb();
 747                 /* spurious interrupt */
 748                 slic_write(sdev, SLIC_REG_ISR, 0);
 749                 slic_flush_write(sdev);
 750                 return IRQ_NONE;
 751         }
 752
 753         napi_schedule_irqoff(&sdev->napi);
 754
 755         return IRQ_HANDLED;
 756 }
 757
 758 static void slic_card_reset(struct slic_device *sdev)
 759 {
 760         u16 cmd;
 761
 762         slic_write(sdev, SLIC_REG_RESET, SLIC_RESET_MAGIC);
 763         /* flush write by means of config space */
 764         pci_read_config_word(sdev->pdev, PCI_COMMAND, &cmd);
 765         mdelay(1);
 766 }
 767
 768 static int slic_init_stat_queue(struct slic_device *sdev)
 769 {
 770         const unsigned int DESC_ALIGN_MASK = SLIC_STATS_DESC_ALIGN - 1;
 771         struct slic_stat_queue *stq = &sdev->stq;
 772         struct slic_stat_desc *descs;
 773         unsigned int misalign;
 774         unsigned int offset;
 775         dma_addr_t paddr;
 776         size_t size;
 777         int err;
 778         int i;
 779
 780         stq->len = SLIC_NUM_STAT_DESCS;
 781         stq->active_array = 0;
 782         stq->done_idx = 0;
 783
 784         size = stq->len * sizeof(*descs) + DESC_ALIGN_MASK;
 785
 786         for (i = 0; i < SLIC_NUM_STAT_DESC_ARRAYS; i++) {
 787                 descs = dma_alloc_coherent(&sdev->pdev->dev, size, &paddr,
 788                                            GFP_KERNEL);
 789                 if (!descs) {
 790                         netdev_err(sdev->netdev,
 791                                    "failed to allocate status descriptors\n");
 792                         err = -ENOMEM;
 793                         goto free_descs;
 794                 }
 795                 /* ensure correct alignment */
 796                 offset = 0;
 797                 misalign = paddr & DESC_ALIGN_MASK;
 798                 if (misalign) {
 799                         offset = SLIC_STATS_DESC_ALIGN - misalign;
 800                         descs += offset;
 801                         paddr += offset;
 802                 }
 803
 804                 slic_write(sdev, SLIC_REG_RBAR, lower_32_bits(paddr) |
 805                                                 stq->len);
 806                 stq->descs[i] = descs;
 807                 stq->paddr[i] = paddr;
 808                 stq->addr_offset[i] = offset;
 809         }
 810
 811         stq->mem_size = size;
 812
 813         return 0;
 814
 815 free_descs:
 816         while (i--) {
 817                 dma_free_coherent(&sdev->pdev->dev, stq->mem_size,
 818                                   stq->descs[i] - stq->addr_offset[i],
 819                                   stq->paddr[i] - stq->addr_offset[i]);
 820         }
 821
 822         return err;
 823 }
 824
 825 static void slic_free_stat_queue(struct slic_device *sdev)
 826 {
 827         struct slic_stat_queue *stq = &sdev->stq;
 828         int i;
 829
 830         for (i = 0; i < SLIC_NUM_STAT_DESC_ARRAYS; i++) {
 831                 dma_free_coherent(&sdev->pdev->dev, stq->mem_size,
 832                                   stq->descs[i] - stq->addr_offset[i],
 833                                   stq->paddr[i] - stq->addr_offset[i]);
 834         }
 835 }
 836
 837 static int slic_init_tx_queue(struct slic_device *sdev)
 838 {
 839         struct slic_tx_queue *txq = &sdev->txq;
 840         struct slic_tx_buffer *buff;
 841         struct slic_tx_desc *desc;
 842         unsigned int i;
 843         int err;
 844
 845         txq->len = SLIC_NUM_TX_DESCS;
 846         txq->put_idx = 0;
 847         txq->done_idx = 0;
 848
 849         txq->txbuffs = kcalloc(txq->len, sizeof(*buff), GFP_KERNEL);
 850         if (!txq->txbuffs)
 851                 return -ENOMEM;
 852
 853         txq->dma_pool = dma_pool_create("slic_pool", &sdev->pdev->dev,
 854                                         sizeof(*desc), SLIC_TX_DESC_ALIGN,
 855                                         4096);
 856         if (!txq->dma_pool) {
 857                 err = -ENOMEM;
 858                 netdev_err(sdev->netdev, "failed to create dma pool\n");
 859                 goto free_buffs;
 860         }
 861
 862         for (i = 0; i < txq->len; i++) {
 863                 buff = &txq->txbuffs[i];
 864                 desc = dma_pool_zalloc(txq->dma_pool, GFP_KERNEL,
 865                                        &buff->desc_paddr);
 866                 if (!desc) {
 867                         netdev_err(sdev->netdev,
 868                                    "failed to alloc pool chunk (%i)\n", i);
 869                         err = -ENOMEM;
 870                         goto free_descs;
 871                 }
 872
 873                 desc->hnd = cpu_to_le32((u32)(i + 1));
 874                 desc->cmd = SLIC_CMD_XMT_REQ;
 875                 desc->flags = 0;
 876                 desc->type = cpu_to_le32(SLIC_CMD_TYPE_DUMB);
 877                 buff->desc = desc;
 878         }
 879
 880         return 0;
 881
 882 free_descs:
 883         while (i--) {
 884                 buff = &txq->txbuffs[i];
 885                 dma_pool_free(txq->dma_pool, buff->desc, buff->desc_paddr);
 886         }
 887         dma_pool_destroy(txq->dma_pool);
 888
 889 free_buffs:
 890         kfree(txq->txbuffs);
 891
 892         return err;
 893 }
 894
 895 static void slic_free_tx_queue(struct slic_device *sdev)
 896 {
 897         struct slic_tx_queue *txq = &sdev->txq;
 898         struct slic_tx_buffer *buff;
 899         unsigned int i;
 900
 901         for (i = 0; i < txq->len; i++) {
 902                 buff = &txq->txbuffs[i];
 903                 dma_pool_free(txq->dma_pool, buff->desc, buff->desc_paddr);
 904                 if (!buff->skb)
 905                         continue;
 906
 907                 dma_unmap_single(&sdev->pdev->dev,
 908                                  dma_unmap_addr(buff, map_addr),
 909                                  dma_unmap_len(buff, map_len), DMA_TO_DEVICE);
 910                 consume_skb(buff->skb);
 911         }
 912         dma_pool_destroy(txq->dma_pool);
 913
 914         kfree(txq->txbuffs);
 915 }
 916
 917 static int slic_init_rx_queue(struct slic_device *sdev)
 918 {
 919         struct slic_rx_queue *rxq = &sdev->rxq;
 920         struct slic_rx_buffer *buff;
 921
 922         rxq->len = SLIC_NUM_RX_LES;
 923         rxq->done_idx = 0;
 924         rxq->put_idx = 0;
 925
 926         buff = kcalloc(rxq->len, sizeof(*buff), GFP_KERNEL);
 927         if (!buff)
 928                 return -ENOMEM;
 929
 930         rxq->rxbuffs = buff;
 931         slic_refill_rx_queue(sdev, GFP_KERNEL);
 932
 933         return 0;
 934 }
 935
 936 static void slic_free_rx_queue(struct slic_device *sdev)
 937 {
 938         struct slic_rx_queue *rxq = &sdev->rxq;
 939         struct slic_rx_buffer *buff;
 940         unsigned int i;
 941
 942         /* free rx buffers */
 943         for (i = 0; i < rxq->len; i++) {
 944                 buff = &rxq->rxbuffs[i];
 945
 946                 if (!buff->skb)
 947                         continue;
 948
 949                 dma_unmap_single(&sdev->pdev->dev,
 950                                  dma_unmap_addr(buff, map_addr),
 951                                  dma_unmap_len(buff, map_len),
 952                                  DMA_FROM_DEVICE);
 953                 consume_skb(buff->skb);
 954         }
 955         kfree(rxq->rxbuffs);
 956 }
 957
 958 static void slic_set_link_autoneg(struct slic_device *sdev)
 959 {
 960         unsigned int subid = sdev->pdev->subsystem_device;
 961         u32 val;
 962
 963         if (sdev->is_fiber) {
 964                 /* We've got a fiber gigabit interface, and register 4 is
 965                  * different in fiber mode than in copper mode.
 966                  */
 967                 /* advertise FD only @1000 Mb */
 968                 val = MII_ADVERTISE << 16 | ADVERTISE_1000XFULL |
 969                       ADVERTISE_1000XPAUSE | ADVERTISE_1000XPSE_ASYM;
 970                 /* enable PAUSE frames */
 971                 slic_write(sdev, SLIC_REG_WPHY, val);
 972                 /* reset phy, enable auto-neg  */
 973                 val = MII_BMCR << 16 | BMCR_RESET | BMCR_ANENABLE |
 974                       BMCR_ANRESTART;
 975                 slic_write(sdev, SLIC_REG_WPHY, val);
 976         } else {        /* copper gigabit */
 977                 /* We've got a copper gigabit interface, and register 4 is
 978                  * different in copper mode than in fiber mode.
 979                  */
 980                 /* advertise 10/100 Mb modes   */
 981                 val = MII_ADVERTISE << 16 | ADVERTISE_100FULL |
 982                       ADVERTISE_100HALF | ADVERTISE_10FULL | ADVERTISE_10HALF;
 983                 /* enable PAUSE frames  */
 984                 val |= ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
 985                 /* required by the Cicada PHY  */
 986                 val |= ADVERTISE_CSMA;
 987                 slic_write(sdev, SLIC_REG_WPHY, val);
 988
 989                 /* advertise FD only @1000 Mb  */
 990                 val = MII_CTRL1000 << 16 | ADVERTISE_1000FULL;
 991                 slic_write(sdev, SLIC_REG_WPHY, val);
 992
 993                 if (subid != PCI_SUBDEVICE_ID_ALACRITECH_CICADA) {
 994                          /* if a Marvell PHY enable auto crossover */
 995                         val = SLIC_MIICR_REG_16 | SLIC_MRV_REG16_XOVERON;
 996                         slic_write(sdev, SLIC_REG_WPHY, val);
 997
 998                         /* reset phy, enable auto-neg  */
 999                         val = MII_BMCR << 16 | BMCR_RESET | BMCR_ANENABLE |
1000                               BMCR_ANRESTART;
1001                         slic_write(sdev, SLIC_REG_WPHY, val);
1002                 } else {
1003                         /* enable and restart auto-neg (don't reset)  */
1004                         val = MII_BMCR << 16 | BMCR_ANENABLE | BMCR_ANRESTART;
1005                         slic_write(sdev, SLIC_REG_WPHY, val);
1006                 }
1007         }
1008 }
1009
1010 static void slic_set_mac_address(struct slic_device *sdev)
1011 {
1012         u8 *addr = sdev->netdev->dev_addr;
1013         u32 val;
1014
1015         val = addr[5] | addr[4] << 8 | addr[3] << 16 | addr[2] << 24;
1016
1017         slic_write(sdev, SLIC_REG_WRADDRAL, val);
1018         slic_write(sdev, SLIC_REG_WRADDRBL, val);
1019
1020         val = addr[0] << 8 | addr[1];
1021
1022         slic_write(sdev, SLIC_REG_WRADDRAH, val);
1023         slic_write(sdev, SLIC_REG_WRADDRBH, val);
1024         slic_flush_write(sdev);
1025 }
1026
1027 static u32 slic_read_dword_from_firmware(const struct firmware *fw, int *offset)
1028 {
1029         int idx = *offset;
1030         __le32 val;
1031
1032         memcpy(&val, fw->data + *offset, sizeof(val));
1033         idx += 4;
1034         *offset = idx;
1035
1036         return le32_to_cpu(val);
1037 }
1038
1039 /*(DEBLOBBED)*/
1040
1041 static int slic_load_rcvseq_firmware(struct slic_device *sdev)
1042 {
1043         const struct firmware *fw;
1044         const char *file;
1045         u32 codelen;
1046         int idx = 0;
1047         u32 instr;
1048         u32 addr;
1049         int err;
1050
1051         file = (sdev->model == SLIC_MODEL_OASIS) ?  SLIC_RCV_FIRMWARE_OASIS :
1052                                                     SLIC_RCV_FIRMWARE_MOJAVE;
1053         err = reject_firmware(&fw, file, &sdev->pdev->dev);
1054         if (err) {
1055                 dev_err(&sdev->pdev->dev,
1056                         "failed to load receive sequencer firmware %s\n", file);
1057                 return err;
1058         }
1059         /* Do an initial sanity check concerning firmware size now. A further
1060          * check follows below.
1061          */
1062         if (fw->size < SLIC_FIRMWARE_MIN_SIZE) {
1063                 dev_err(&sdev->pdev->dev,
1064                         "invalid firmware size %zu (min %u expected)\n",
1065                         fw->size, SLIC_FIRMWARE_MIN_SIZE);
1066                 err = -EINVAL;
1067                 goto release;
1068         }
1069
1070         codelen = slic_read_dword_from_firmware(fw, &idx);
1071
1072         /* do another sanity check against firmware size */
1073         if ((codelen + 4) > fw->size) {
1074                 dev_err(&sdev->pdev->dev,
1075                         "invalid rcv-sequencer firmware size %zu\n", fw->size);
1076                 err = -EINVAL;
1077                 goto release;
1078         }
1079
1080         /* download sequencer code to card */
1081         slic_write(sdev, SLIC_REG_RCV_WCS, SLIC_RCVWCS_BEGIN);
1082         for (addr = 0; addr < codelen; addr++) {
1083                 __le32 val;
1084                 /* write out instruction address */
1085                 slic_write(sdev, SLIC_REG_RCV_WCS, addr);
1086
1087                 instr = slic_read_dword_from_firmware(fw, &idx);
1088                 /* write out the instruction data low addr */
1089                 slic_write(sdev, SLIC_REG_RCV_WCS, instr);
1090
1091                 val = (__le32)fw->data[idx];
1092                 instr = le32_to_cpu(val);
1093                 idx++;
1094                 /* write out the instruction data high addr */
1095                 slic_write(sdev, SLIC_REG_RCV_WCS, instr);
1096         }
1097         /* finish download */
1098         slic_write(sdev, SLIC_REG_RCV_WCS, SLIC_RCVWCS_FINISH);
1099         slic_flush_write(sdev);
1100 release:
1101         release_firmware(fw);
1102
1103         return err;
1104 }
1105
1106 /*(DEBLOBBED)*/
1107
1108 static int slic_load_firmware(struct slic_device *sdev)
1109 {
1110         u32 sectstart[SLIC_FIRMWARE_MAX_SECTIONS];
1111         u32 sectsize[SLIC_FIRMWARE_MAX_SECTIONS];
1112         const struct firmware *fw;
1113         unsigned int datalen;
1114         const char *file;
1115         int code_start;
1116         unsigned int i;
1117         u32 numsects;
1118         int idx = 0;
1119         u32 sect;
1120         u32 instr;
1121         u32 addr;
1122         u32 base;
1123         int err;
1124
1125         file = (sdev->model == SLIC_MODEL_OASIS) ?  SLIC_FIRMWARE_OASIS :
1126                                                     SLIC_FIRMWARE_MOJAVE;
1127         err = reject_firmware(&fw, file, &sdev->pdev->dev);
1128         if (err) {
1129                 dev_err(&sdev->pdev->dev, "failed to load firmware %s\n", file);
1130                 return err;
1131         }
1132         /* Do an initial sanity check concerning firmware size now. A further
1133          * check follows below.
1134          */
1135         if (fw->size < SLIC_FIRMWARE_MIN_SIZE) {
1136                 dev_err(&sdev->pdev->dev,
1137                         "invalid firmware size %zu (min is %u)\n", fw->size,
1138                         SLIC_FIRMWARE_MIN_SIZE);
1139                 err = -EINVAL;
1140                 goto release;
1141         }
1142
1143         numsects = slic_read_dword_from_firmware(fw, &idx);
1144         if (numsects == 0 || numsects > SLIC_FIRMWARE_MAX_SECTIONS) {
1145                 dev_err(&sdev->pdev->dev,
1146                         "invalid number of sections in firmware: %u", numsects);
1147                 err = -EINVAL;
1148                 goto release;
1149         }
1150
1151         datalen = numsects * 8 + 4;
1152         for (i = 0; i < numsects; i++) {
1153                 sectsize[i] = slic_read_dword_from_firmware(fw, &idx);
1154                 datalen += sectsize[i];
1155         }
1156
1157         /* do another sanity check against firmware size */
1158         if (datalen > fw->size) {
1159                 dev_err(&sdev->pdev->dev,
1160                         "invalid firmware size %zu (expected >= %u)\n",
1161                         fw->size, datalen);
1162                 err = -EINVAL;
1163                 goto release;
1164         }
1165         /* get sections */
1166         for (i = 0; i < numsects; i++)
1167                 sectstart[i] = slic_read_dword_from_firmware(fw, &idx);
1168
1169         code_start = idx;
1170         instr = slic_read_dword_from_firmware(fw, &idx);
1171
1172         for (sect = 0; sect < numsects; sect++) {
1173                 unsigned int ssize = sectsize[sect] >> 3;
1174
1175                 base = sectstart[sect];
1176
1177                 for (addr = 0; addr < ssize; addr++) {
1178                         /* write out instruction address */
1179                         slic_write(sdev, SLIC_REG_WCS, base + addr);
1180                         /* write out instruction to low addr */
1181                         slic_write(sdev, SLIC_REG_WCS, instr);
1182                         instr = slic_read_dword_from_firmware(fw, &idx);
1183                         /* write out instruction to high addr */
1184                         slic_write(sdev, SLIC_REG_WCS, instr);
1185                         instr = slic_read_dword_from_firmware(fw, &idx);
1186                 }
1187         }
1188
1189         idx = code_start;
1190
1191         for (sect = 0; sect < numsects; sect++) {
1192                 unsigned int ssize = sectsize[sect] >> 3;
1193
1194                 instr = slic_read_dword_from_firmware(fw, &idx);
1195                 base = sectstart[sect];
1196                 if (base < 0x8000)
1197                         continue;
1198
1199                 for (addr = 0; addr < ssize; addr++) {
1200                         /* write out instruction address */
1201                         slic_write(sdev, SLIC_REG_WCS,
1202                                    SLIC_WCS_COMPARE | (base + addr));
1203                         /* write out instruction to low addr */
1204                         slic_write(sdev, SLIC_REG_WCS, instr);
1205                         instr = slic_read_dword_from_firmware(fw, &idx);
1206                         /* write out instruction to high addr */
1207                         slic_write(sdev, SLIC_REG_WCS, instr);
1208                         instr = slic_read_dword_from_firmware(fw, &idx);
1209                 }
1210         }
1211         slic_flush_write(sdev);
1212         mdelay(10);
1213         /* everything OK, kick off the card */
1214         slic_write(sdev, SLIC_REG_WCS, SLIC_WCS_START);
1215         slic_flush_write(sdev);
1216         /* wait long enough for ucode to init card and reach the mainloop */
1217         mdelay(20);
1218 release:
1219         release_firmware(fw);
1220
1221         return err;
1222 }
1223
1224 static int slic_init_shmem(struct slic_device *sdev)
1225 {
1226         struct slic_shmem *sm = &sdev->shmem;
1227         struct slic_shmem_data *sm_data;
1228         dma_addr_t paddr;
1229
1230         sm_data = dma_alloc_coherent(&sdev->pdev->dev, sizeof(*sm_data),
1231                                      &paddr, GFP_KERNEL);
1232         if (!sm_data) {
1233                 dev_err(&sdev->pdev->dev, "failed to allocate shared memory\n");
1234                 return -ENOMEM;
1235         }
1236
1237         sm->shmem_data = sm_data;
1238         sm->isr_paddr = paddr;
1239         sm->link_paddr = paddr + offsetof(struct slic_shmem_data, link);
1240
1241         return 0;
1242 }
1243
1244 static void slic_free_shmem(struct slic_device *sdev)
1245 {
1246         struct slic_shmem *sm = &sdev->shmem;
1247         struct slic_shmem_data *sm_data = sm->shmem_data;
1248
1249         dma_free_coherent(&sdev->pdev->dev, sizeof(*sm_data), sm_data,
1250                           sm->isr_paddr);
1251 }
1252
1253 static int slic_init_iface(struct slic_device *sdev)
1254 {
1255         struct slic_shmem *sm = &sdev->shmem;
1256         int err;
1257
1258         sdev->upr_list.pending = false;
1259
1260         err = slic_init_shmem(sdev);
1261         if (err) {
1262                 netdev_err(sdev->netdev, "failed to init shared memory\n");
1263                 return err;
1264         }
1265
1266         err = slic_load_firmware(sdev);
1267         if (err) {
1268                 netdev_err(sdev->netdev, "failed to load firmware\n");
1269                 goto free_sm;
1270         }
1271
1272         err = slic_load_rcvseq_firmware(sdev);
1273         if (err) {
1274                 netdev_err(sdev->netdev,
1275                            "failed to load firmware for receive sequencer\n");
1276                 goto free_sm;
1277         }
1278
1279         slic_write(sdev, SLIC_REG_ICR, SLIC_ICR_INT_OFF);
1280         slic_flush_write(sdev);
1281         mdelay(1);
1282
1283         err = slic_init_rx_queue(sdev);
1284         if (err) {
1285                 netdev_err(sdev->netdev, "failed to init rx queue: %u\n", err);
1286                 goto free_sm;
1287         }
1288
1289         err = slic_init_tx_queue(sdev);
1290         if (err) {
1291                 netdev_err(sdev->netdev, "failed to init tx queue: %u\n", err);
1292                 goto free_rxq;
1293         }
1294
1295         err = slic_init_stat_queue(sdev);
1296         if (err) {
1297                 netdev_err(sdev->netdev, "failed to init status queue: %u\n",
1298                            err);
1299                 goto free_txq;
1300         }
1301
1302         slic_write(sdev, SLIC_REG_ISP, lower_32_bits(sm->isr_paddr));
1303         napi_enable(&sdev->napi);
1304         /* disable irq mitigation */
1305         slic_write(sdev, SLIC_REG_INTAGG, 0);
1306         slic_write(sdev, SLIC_REG_ISR, 0);
1307         slic_flush_write(sdev);
1308
1309         slic_set_mac_address(sdev);
1310
1311         spin_lock_bh(&sdev->link_lock);
1312         sdev->duplex = DUPLEX_UNKNOWN;
1313         sdev->speed = SPEED_UNKNOWN;
1314         spin_unlock_bh(&sdev->link_lock);
1315
1316         slic_set_link_autoneg(sdev);
1317
1318         err = request_irq(sdev->pdev->irq, slic_irq, IRQF_SHARED, DRV_NAME,
1319                           sdev);
1320         if (err) {
1321                 netdev_err(sdev->netdev, "failed to request irq: %u\n", err);
1322                 goto disable_napi;
1323         }
1324
1325         slic_write(sdev, SLIC_REG_ICR, SLIC_ICR_INT_ON);
1326         slic_flush_write(sdev);
1327         /* request initial link status */
1328         err = slic_handle_link_change(sdev);
1329         if (err)
1330                 netdev_warn(sdev->netdev,
1331                             "failed to set initial link state: %u\n", err);
1332         return 0;
1333
1334 disable_napi:
1335         napi_disable(&sdev->napi);
1336         slic_free_stat_queue(sdev);
1337 free_txq:
1338         slic_free_tx_queue(sdev);
1339 free_rxq:
1340         slic_free_rx_queue(sdev);
1341 free_sm:
1342         slic_free_shmem(sdev);
1343         slic_card_reset(sdev);
1344
1345         return err;
1346 }
1347
1348 static int slic_open(struct net_device *dev)
1349 {
1350         struct slic_device *sdev = netdev_priv(dev);
1351         int err;
1352
1353         netif_carrier_off(dev);
1354
1355         err = slic_init_iface(sdev);
1356         if (err) {
1357                 netdev_err(dev, "failed to initialize interface: %i\n", err);
1358                 return err;
1359         }
1360
1361         netif_start_queue(dev);
1362
1363         return 0;
1364 }
1365
1366 static int slic_close(struct net_device *dev)
1367 {
1368         struct slic_device *sdev = netdev_priv(dev);
1369         u32 val;
1370
1371         netif_stop_queue(dev);
1372
1373         /* stop irq handling */
1374         napi_disable(&sdev->napi);
1375         slic_write(sdev, SLIC_REG_ICR, SLIC_ICR_INT_OFF);
1376         slic_write(sdev, SLIC_REG_ISR, 0);
1377         slic_flush_write(sdev);
1378
1379         free_irq(sdev->pdev->irq, sdev);
1380         /* turn off RCV and XMT and power down PHY */
1381         val = SLIC_GXCR_RESET | SLIC_GXCR_PAUSEEN;
1382         slic_write(sdev, SLIC_REG_WXCFG, val);
1383
1384         val = SLIC_GRCR_RESET | SLIC_GRCR_CTLEN | SLIC_GRCR_ADDRAEN |
1385               SLIC_GRCR_HASHSIZE << SLIC_GRCR_HASHSIZE_SHIFT;
1386         slic_write(sdev, SLIC_REG_WRCFG, val);
1387
1388         val = MII_BMCR << 16 | BMCR_PDOWN;
1389         slic_write(sdev, SLIC_REG_WPHY, val);
1390         slic_flush_write(sdev);
1391
1392         slic_clear_upr_list(&sdev->upr_list);
1393         slic_write(sdev, SLIC_REG_QUIESCE, 0);
1394
1395         slic_free_stat_queue(sdev);
1396         slic_free_tx_queue(sdev);
1397         slic_free_rx_queue(sdev);
1398         slic_free_shmem(sdev);
1399
1400         slic_card_reset(sdev);
1401         netif_carrier_off(dev);
1402
1403         return 0;
1404 }
1405
1406 static netdev_tx_t slic_xmit(struct sk_buff *skb, struct net_device *dev)
1407 {
1408         struct slic_device *sdev = netdev_priv(dev);
1409         struct slic_tx_queue *txq = &sdev->txq;
1410         struct slic_tx_buffer *buff;
1411         struct slic_tx_desc *desc;
1412         dma_addr_t paddr;
1413         u32 cbar_val;
1414         u32 maplen;
1415
1416         if (unlikely(slic_get_free_tx_descs(txq) < SLIC_MAX_REQ_TX_DESCS)) {
1417                 netdev_err(dev, "BUG! not enough tx LEs left: %u\n",
1418                            slic_get_free_tx_descs(txq));
1419                 return NETDEV_TX_BUSY;
1420         }
1421
1422         maplen = skb_headlen(skb);
1423         paddr = dma_map_single(&sdev->pdev->dev, skb->data, maplen,
1424                                DMA_TO_DEVICE);
1425         if (dma_mapping_error(&sdev->pdev->dev, paddr)) {
1426                 netdev_err(dev, "failed to map tx buffer\n");
1427                 goto drop_skb;
1428         }
1429
1430         buff = &txq->txbuffs[txq->put_idx];
1431         buff->skb = skb;
1432         dma_unmap_addr_set(buff, map_addr, paddr);
1433         dma_unmap_len_set(buff, map_len, maplen);
1434
1435         desc = buff->desc;
1436         desc->totlen = cpu_to_le32(maplen);
1437         desc->paddrl = cpu_to_le32(lower_32_bits(paddr));
1438         desc->paddrh = cpu_to_le32(upper_32_bits(paddr));
1439         desc->len = cpu_to_le32(maplen);
1440
1441         txq->put_idx = slic_next_queue_idx(txq->put_idx, txq->len);
1442
1443         cbar_val = lower_32_bits(buff->desc_paddr) | 1;
1444         /* complete writes to RAM and DMA before hardware is informed */
1445         wmb();
1446
1447         slic_write(sdev, SLIC_REG_CBAR, cbar_val);
1448
1449         if (slic_get_free_tx_descs(txq) < SLIC_MAX_REQ_TX_DESCS)
1450                 netif_stop_queue(dev);
1451
1452         return NETDEV_TX_OK;
1453 drop_skb:
1454         dev_kfree_skb_any(skb);
1455
1456         return NETDEV_TX_OK;
1457 }
1458
1459 static void slic_get_stats(struct net_device *dev,
1460                            struct rtnl_link_stats64 *lst)
1461 {
1462         struct slic_device *sdev = netdev_priv(dev);
1463         struct slic_stats *stats = &sdev->stats;
1464
1465         SLIC_GET_STATS_COUNTER(lst->rx_packets, stats, rx_packets);
1466         SLIC_GET_STATS_COUNTER(lst->tx_packets, stats, tx_packets);
1467         SLIC_GET_STATS_COUNTER(lst->rx_bytes, stats, rx_bytes);
1468         SLIC_GET_STATS_COUNTER(lst->tx_bytes, stats, tx_bytes);
1469         SLIC_GET_STATS_COUNTER(lst->rx_errors, stats, rx_errors);
1470         SLIC_GET_STATS_COUNTER(lst->rx_dropped, stats, rx_buff_miss);
1471         SLIC_GET_STATS_COUNTER(lst->tx_dropped, stats, tx_dropped);
1472         SLIC_GET_STATS_COUNTER(lst->multicast, stats, rx_mcasts);
1473         SLIC_GET_STATS_COUNTER(lst->rx_over_errors, stats, rx_buffoflow);
1474         SLIC_GET_STATS_COUNTER(lst->rx_crc_errors, stats, rx_crc);
1475         SLIC_GET_STATS_COUNTER(lst->rx_fifo_errors, stats, rx_oflow802);
1476         SLIC_GET_STATS_COUNTER(lst->tx_carrier_errors, stats, tx_carrier);
1477 }
1478
1479 static int slic_get_sset_count(struct net_device *dev, int sset)
1480 {
1481         switch (sset) {
1482         case ETH_SS_STATS:
1483                 return ARRAY_SIZE(slic_stats_strings);
1484         default:
1485                 return -EOPNOTSUPP;
1486         }
1487 }
1488
1489 static void slic_get_ethtool_stats(struct net_device *dev,
1490                                    struct ethtool_stats *eth_stats, u64 *data)
1491 {
1492         struct slic_device *sdev = netdev_priv(dev);
1493         struct slic_stats *stats = &sdev->stats;
1494
1495         SLIC_GET_STATS_COUNTER(data[0], stats, rx_packets);
1496         SLIC_GET_STATS_COUNTER(data[1], stats, rx_bytes);
1497         SLIC_GET_STATS_COUNTER(data[2], stats, rx_mcasts);
1498         SLIC_GET_STATS_COUNTER(data[3], stats, rx_errors);
1499         SLIC_GET_STATS_COUNTER(data[4], stats, rx_buff_miss);
1500         SLIC_GET_STATS_COUNTER(data[5], stats, rx_tpcsum);
1501         SLIC_GET_STATS_COUNTER(data[6], stats, rx_tpoflow);
1502         SLIC_GET_STATS_COUNTER(data[7], stats, rx_tphlen);
1503         SLIC_GET_STATS_COUNTER(data[8], stats, rx_ipcsum);
1504         SLIC_GET_STATS_COUNTER(data[9], stats, rx_iplen);
1505         SLIC_GET_STATS_COUNTER(data[10], stats, rx_iphlen);
1506         SLIC_GET_STATS_COUNTER(data[11], stats, rx_early);
1507         SLIC_GET_STATS_COUNTER(data[12], stats, rx_buffoflow);
1508         SLIC_GET_STATS_COUNTER(data[13], stats, rx_lcode);
1509         SLIC_GET_STATS_COUNTER(data[14], stats, rx_drbl);
1510         SLIC_GET_STATS_COUNTER(data[15], stats, rx_crc);
1511         SLIC_GET_STATS_COUNTER(data[16], stats, rx_oflow802);
1512         SLIC_GET_STATS_COUNTER(data[17], stats, rx_uflow802);
1513         SLIC_GET_STATS_COUNTER(data[18], stats, tx_packets);
1514         SLIC_GET_STATS_COUNTER(data[19], stats, tx_bytes);
1515         SLIC_GET_STATS_COUNTER(data[20], stats, tx_carrier);
1516         SLIC_GET_STATS_COUNTER(data[21], stats, tx_dropped);
1517         SLIC_GET_STATS_COUNTER(data[22], stats, irq_errs);
1518 }
1519
1520 static void slic_get_strings(struct net_device *dev, u32 stringset, u8 *data)
1521 {
1522         if (stringset == ETH_SS_STATS) {
1523                 memcpy(data, slic_stats_strings, sizeof(slic_stats_strings));
1524                 data += sizeof(slic_stats_strings);
1525         }
1526 }
1527
1528 static void slic_get_drvinfo(struct net_device *dev,
1529                              struct ethtool_drvinfo *info)
1530 {
1531         struct slic_device *sdev = netdev_priv(dev);
1532
1533         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1534         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1535         strlcpy(info->bus_info, pci_name(sdev->pdev), sizeof(info->bus_info));
1536 }
1537
1538 static const struct ethtool_ops slic_ethtool_ops = {
1539         .get_drvinfo            = slic_get_drvinfo,
1540         .get_link               = ethtool_op_get_link,
1541         .get_strings            = slic_get_strings,
1542         .get_ethtool_stats      = slic_get_ethtool_stats,
1543         .get_sset_count         = slic_get_sset_count,
1544 };
1545
1546 static const struct net_device_ops slic_netdev_ops = {
1547         .ndo_open               = slic_open,
1548         .ndo_stop               = slic_close,
1549         .ndo_start_xmit         = slic_xmit,
1550         .ndo_set_mac_address    = eth_mac_addr,
1551         .ndo_get_stats64        = slic_get_stats,
1552         .ndo_set_rx_mode        = slic_set_rx_mode,
1553         .ndo_validate_addr      = eth_validate_addr,
1554 };
1555
1556 static u16 slic_eeprom_csum(unsigned char *eeprom, unsigned int len)
1557 {
1558         unsigned char *ptr = eeprom;
1559         u32 csum = 0;
1560         __le16 data;
1561
1562         while (len > 1) {
1563                 memcpy(&data, ptr, sizeof(data));
1564                 csum += le16_to_cpu(data);
1565                 ptr += 2;
1566                 len -= 2;
1567         }
1568         if (len > 0)
1569                 csum += *(u8 *)ptr;
1570         while (csum >> 16)
1571                 csum = (csum & 0xFFFF) + ((csum >> 16) & 0xFFFF);
1572         return ~csum;
1573 }
1574
1575 /* check eeprom size, magic and checksum */
1576 static bool slic_eeprom_valid(unsigned char *eeprom, unsigned int size)
1577 {
1578         const unsigned int MAX_SIZE = 128;
1579         const unsigned int MIN_SIZE = 98;
1580         __le16 magic;
1581         __le16 csum;
1582
1583         if (size < MIN_SIZE || size > MAX_SIZE)
1584                 return false;
1585         memcpy(&magic, eeprom, sizeof(magic));
1586         if (le16_to_cpu(magic) != SLIC_EEPROM_MAGIC)
1587                 return false;
1588         /* cut checksum bytes */
1589         size -= 2;
1590         memcpy(&csum, eeprom + size, sizeof(csum));
1591
1592         return (le16_to_cpu(csum) == slic_eeprom_csum(eeprom, size));
1593 }
1594
1595 static int slic_read_eeprom(struct slic_device *sdev)
1596 {
1597         unsigned int devfn = PCI_FUNC(sdev->pdev->devfn);
1598         struct slic_shmem *sm = &sdev->shmem;
1599         struct slic_shmem_data *sm_data = sm->shmem_data;
1600         const unsigned int MAX_LOOPS = 5000;
1601         unsigned int codesize;
1602         unsigned char *eeprom;
1603         struct slic_upr *upr;
1604         unsigned int i = 0;
1605         dma_addr_t paddr;
1606         int err = 0;
1607         u8 *mac[2];
1608
1609         eeprom = dma_alloc_coherent(&sdev->pdev->dev, SLIC_EEPROM_SIZE,
1610                                     &paddr, GFP_KERNEL);
1611         if (!eeprom)
1612                 return -ENOMEM;
1613
1614         slic_write(sdev, SLIC_REG_ICR, SLIC_ICR_INT_OFF);
1615         /* setup ISP temporarily */
1616         slic_write(sdev, SLIC_REG_ISP, lower_32_bits(sm->isr_paddr));
1617
1618         err = slic_new_upr(sdev, SLIC_UPR_CONFIG, paddr);
1619         if (!err) {
1620                 for (i = 0; i < MAX_LOOPS; i++) {
1621                         if (le32_to_cpu(sm_data->isr) & SLIC_ISR_UPC)
1622                                 break;
1623                         mdelay(1);
1624                 }
1625                 if (i == MAX_LOOPS) {
1626                         dev_err(&sdev->pdev->dev,
1627                                 "timed out while waiting for eeprom data\n");
1628                         err = -ETIMEDOUT;
1629                 }
1630                 upr = slic_dequeue_upr(sdev);
1631                 kfree(upr);
1632         }
1633
1634         slic_write(sdev, SLIC_REG_ISP, 0);
1635         slic_write(sdev, SLIC_REG_ISR, 0);
1636         slic_flush_write(sdev);
1637
1638         if (err)
1639                 goto free_eeprom;
1640
1641         if (sdev->model == SLIC_MODEL_OASIS) {
1642                 struct slic_oasis_eeprom *oee;
1643
1644                 oee = (struct slic_oasis_eeprom *)eeprom;
1645                 mac[0] = oee->mac;
1646                 mac[1] = oee->mac2;
1647                 codesize = le16_to_cpu(oee->eeprom_code_size);
1648         } else {
1649                 struct slic_mojave_eeprom *mee;
1650
1651                 mee = (struct slic_mojave_eeprom *)eeprom;
1652                 mac[0] = mee->mac;
1653                 mac[1] = mee->mac2;
1654                 codesize = le16_to_cpu(mee->eeprom_code_size);
1655         }
1656
1657         if (!slic_eeprom_valid(eeprom, codesize)) {
1658                 dev_err(&sdev->pdev->dev, "invalid checksum in eeprom\n");
1659                 err = -EINVAL;
1660                 goto free_eeprom;
1661         }
1662         /* set mac address */
1663         ether_addr_copy(sdev->netdev->dev_addr, mac[devfn]);
1664 free_eeprom:
1665         dma_free_coherent(&sdev->pdev->dev, SLIC_EEPROM_SIZE, eeprom, paddr);
1666
1667         return err;
1668 }
1669
1670 static int slic_init(struct slic_device *sdev)
1671 {
1672         int err;
1673
1674         spin_lock_init(&sdev->upper_lock);
1675         spin_lock_init(&sdev->link_lock);
1676         INIT_LIST_HEAD(&sdev->upr_list.list);
1677         spin_lock_init(&sdev->upr_list.lock);
1678         u64_stats_init(&sdev->stats.syncp);
1679
1680         slic_card_reset(sdev);
1681
1682         err = slic_load_firmware(sdev);
1683         if (err) {
1684                 dev_err(&sdev->pdev->dev, "failed to load firmware\n");
1685                 return err;
1686         }
1687
1688         /* we need the shared memory to read EEPROM so set it up temporarily */
1689         err = slic_init_shmem(sdev);
1690         if (err) {
1691                 dev_err(&sdev->pdev->dev, "failed to init shared memory\n");
1692                 return err;
1693         }
1694
1695         err = slic_read_eeprom(sdev);
1696         if (err) {
1697                 dev_err(&sdev->pdev->dev, "failed to read eeprom\n");
1698                 goto free_sm;
1699         }
1700
1701         slic_card_reset(sdev);
1702         slic_free_shmem(sdev);
1703
1704         return 0;
1705 free_sm:
1706         slic_free_shmem(sdev);
1707
1708         return err;
1709 }
1710
1711 static bool slic_is_fiber(unsigned short subdev)
1712 {
1713         switch (subdev) {
1714         /* Mojave */
1715         case PCI_SUBDEVICE_ID_ALACRITECH_1000X1F: /* fallthrough */
1716         case PCI_SUBDEVICE_ID_ALACRITECH_SES1001F: /* fallthrough */
1717         /* Oasis */
1718         case PCI_SUBDEVICE_ID_ALACRITECH_SEN2002XF: /* fallthrough */
1719         case PCI_SUBDEVICE_ID_ALACRITECH_SEN2001XF: /* fallthrough */
1720         case PCI_SUBDEVICE_ID_ALACRITECH_SEN2104EF: /* fallthrough */
1721         case PCI_SUBDEVICE_ID_ALACRITECH_SEN2102EF: /* fallthrough */
1722                 return true;
1723         }
1724         return false;
1725 }
1726
1727 static void slic_configure_pci(struct pci_dev *pdev)
1728 {
1729         u16 old;
1730         u16 cmd;
1731
1732         pci_read_config_word(pdev, PCI_COMMAND, &old);
1733
1734         cmd = old | PCI_COMMAND_PARITY | PCI_COMMAND_SERR;
1735         if (old != cmd)
1736                 pci_write_config_word(pdev, PCI_COMMAND, cmd);
1737 }
1738
1739 static int slic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1740 {
1741         struct slic_device *sdev;
1742         struct net_device *dev;
1743         int err;
1744
1745         err = pci_enable_device(pdev);
1746         if (err) {
1747                 dev_err(&pdev->dev, "failed to enable PCI device\n");
1748                 return err;
1749         }
1750
1751         pci_set_master(pdev);
1752         pci_try_set_mwi(pdev);
1753
1754         slic_configure_pci(pdev);
1755
1756         err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
1757         if (err) {
1758                 dev_err(&pdev->dev, "failed to setup DMA\n");
1759                 goto disable;
1760         }
1761
1762         dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
1763
1764         err = pci_request_regions(pdev, DRV_NAME);
1765         if (err) {
1766                 dev_err(&pdev->dev, "failed to obtain PCI regions\n");
1767                 goto disable;
1768         }
1769
1770         dev = alloc_etherdev(sizeof(*sdev));
1771         if (!dev) {
1772                 dev_err(&pdev->dev, "failed to alloc ethernet device\n");
1773                 err = -ENOMEM;
1774                 goto free_regions;
1775         }
1776
1777         SET_NETDEV_DEV(dev, &pdev->dev);
1778         pci_set_drvdata(pdev, dev);
1779         dev->irq = pdev->irq;
1780         dev->netdev_ops = &slic_netdev_ops;
1781         dev->hw_features = NETIF_F_RXCSUM;
1782         dev->features |= dev->hw_features;
1783
1784         dev->ethtool_ops = &slic_ethtool_ops;
1785
1786         sdev = netdev_priv(dev);
1787         sdev->model = (pdev->device == PCI_DEVICE_ID_ALACRITECH_OASIS) ?
1788                       SLIC_MODEL_OASIS : SLIC_MODEL_MOJAVE;
1789         sdev->is_fiber = slic_is_fiber(pdev->subsystem_device);
1790         sdev->pdev = pdev;
1791         sdev->netdev = dev;
1792         sdev->regs = ioremap_nocache(pci_resource_start(pdev, 0),
1793                                      pci_resource_len(pdev, 0));
1794         if (!sdev->regs) {
1795                 dev_err(&pdev->dev, "failed to map registers\n");
1796                 err = -ENOMEM;
1797                 goto free_netdev;
1798         }
1799
1800         err = slic_init(sdev);
1801         if (err) {
1802                 dev_err(&pdev->dev, "failed to initialize driver\n");
1803                 goto unmap;
1804         }
1805
1806         netif_napi_add(dev, &sdev->napi, slic_poll, SLIC_NAPI_WEIGHT);
1807         netif_carrier_off(dev);
1808
1809         err = register_netdev(dev);
1810         if (err) {
1811                 dev_err(&pdev->dev, "failed to register net device: %i\n", err);
1812                 goto unmap;
1813         }
1814
1815         return 0;
1816
1817 unmap:
1818         iounmap(sdev->regs);
1819 free_netdev:
1820         free_netdev(dev);
1821 free_regions:
1822         pci_release_regions(pdev);
1823 disable:
1824         pci_disable_device(pdev);
1825
1826         return err;
1827 }
1828
1829 static void slic_remove(struct pci_dev *pdev)
1830 {
1831         struct net_device *dev = pci_get_drvdata(pdev);
1832         struct slic_device *sdev = netdev_priv(dev);
1833
1834         unregister_netdev(dev);
1835         iounmap(sdev->regs);
1836         free_netdev(dev);
1837         pci_release_regions(pdev);
1838         pci_disable_device(pdev);
1839 }
1840
1841 static struct pci_driver slic_driver = {
1842         .name = DRV_NAME,
1843         .id_table = slic_id_tbl,
1844         .probe = slic_probe,
1845         .remove = slic_remove,
1846 };
1847
1848 module_pci_driver(slic_driver);
1849
1850 MODULE_DESCRIPTION("Alacritech non-accelerated SLIC driver");
1851 MODULE_AUTHOR("Lino Sanfilippo <LinoSanfilippo@gmx.de>");
1852 MODULE_LICENSE("GPL");
1853 MODULE_VERSION(DRV_VERSION);