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