drivers/staging/rdma/amso1100/c2.c

   1 /*
   2  * Copyright (c) 2005 Ammasso, Inc. All rights reserved.
   3  * Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
   4  *
   5  * This software is available to you under a choice of one of two
   6  * licenses.  You may choose to be licensed under the terms of the GNU
   7  * General Public License (GPL) Version 2, available from the file
   8  * COPYING in the main directory of this source tree, or the
   9  * OpenIB.org BSD license below:
  10  *
  11  *     Redistribution and use in source and binary forms, with or
  12  *     without modification, are permitted provided that the following
  13  *     conditions are met:
  14  *
  15  *      - Redistributions of source code must retain the above
  16  *        copyright notice, this list of conditions and the following
  17  *        disclaimer.
  18  *
  19  *      - Redistributions in binary form must reproduce the above
  20  *        copyright notice, this list of conditions and the following
  21  *        disclaimer in the documentation and/or other materials
  22  *        provided with the distribution.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  31  * SOFTWARE.
  32  */
  33 #include <linux/module.h>
  34 #include <linux/moduleparam.h>
  35 #include <linux/pci.h>
  36 #include <linux/netdevice.h>
  37 #include <linux/etherdevice.h>
  38 #include <linux/inetdevice.h>
  39 #include <linux/interrupt.h>
  40 #include <linux/delay.h>
  41 #include <linux/ethtool.h>
  42 #include <linux/mii.h>
  43 #include <linux/if_vlan.h>
  44 #include <linux/crc32.h>
  45 #include <linux/in.h>
  46 #include <linux/ip.h>
  47 #include <linux/tcp.h>
  48 #include <linux/init.h>
  49 #include <linux/dma-mapping.h>
  50 #include <linux/slab.h>
  51 #include <linux/prefetch.h>
  52
  53 #include <asm/io.h>
  54 #include <asm/irq.h>
  55 #include <asm/byteorder.h>
  56
  57 #include <rdma/ib_smi.h>
  58 #include "c2.h"
  59 #include "c2_provider.h"
  60
  61 MODULE_AUTHOR("Tom Tucker <tom@opengridcomputing.com>");
  62 MODULE_DESCRIPTION("Ammasso AMSO1100 Low-level iWARP Driver");
  63 MODULE_LICENSE("Dual BSD/GPL");
  64 MODULE_VERSION(DRV_VERSION);
  65
  66 static const u32 default_msg = NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK
  67     | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN;
  68
  69 static int debug = -1;          /* defaults above */
  70 module_param(debug, int, 0);
  71 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
  72
  73 static int c2_up(struct net_device *netdev);
  74 static int c2_down(struct net_device *netdev);
  75 static int c2_xmit_frame(struct sk_buff *skb, struct net_device *netdev);
  76 static void c2_tx_interrupt(struct net_device *netdev);
  77 static void c2_rx_interrupt(struct net_device *netdev);
  78 static irqreturn_t c2_interrupt(int irq, void *dev_id);
  79 static void c2_tx_timeout(struct net_device *netdev);
  80 static int c2_change_mtu(struct net_device *netdev, int new_mtu);
  81 static void c2_reset(struct c2_port *c2_port);
  82
  83 static struct pci_device_id c2_pci_table[] = {
  84         { PCI_DEVICE(0x18b8, 0xb001) },
  85         { 0 }
  86 };
  87
  88 MODULE_DEVICE_TABLE(pci, c2_pci_table);
  89
  90 static void c2_set_rxbufsize(struct c2_port *c2_port)
  91 {
  92         struct net_device *netdev = c2_port->netdev;
  93
  94         if (netdev->mtu > RX_BUF_SIZE)
  95                 c2_port->rx_buf_size =
  96                     netdev->mtu + ETH_HLEN + sizeof(struct c2_rxp_hdr) +
  97                     NET_IP_ALIGN;
  98         else
  99                 c2_port->rx_buf_size = sizeof(struct c2_rxp_hdr) + RX_BUF_SIZE;
 100 }
 101
 102 /*
 103  * Allocate TX ring elements and chain them together.
 104  * One-to-one association of adapter descriptors with ring elements.
 105  */
 106 static int c2_tx_ring_alloc(struct c2_ring *tx_ring, void *vaddr,
 107                             dma_addr_t base, void __iomem * mmio_txp_ring)
 108 {
 109         struct c2_tx_desc *tx_desc;
 110         struct c2_txp_desc __iomem *txp_desc;
 111         struct c2_element *elem;
 112         int i;
 113
 114         tx_ring->start = kmalloc_array(tx_ring->count, sizeof(*elem),
 115                                        GFP_KERNEL);
 116         if (!tx_ring->start)
 117                 return -ENOMEM;
 118
 119         elem = tx_ring->start;
 120         tx_desc = vaddr;
 121         txp_desc = mmio_txp_ring;
 122         for (i = 0; i < tx_ring->count; i++, elem++, tx_desc++, txp_desc++) {
 123                 tx_desc->len = 0;
 124                 tx_desc->status = 0;
 125
 126                 /* Set TXP_HTXD_UNINIT */
 127                 __raw_writeq((__force u64) cpu_to_be64(0x1122334455667788ULL),
 128                              (void __iomem *) txp_desc + C2_TXP_ADDR);
 129                 __raw_writew(0, (void __iomem *) txp_desc + C2_TXP_LEN);
 130                 __raw_writew((__force u16) cpu_to_be16(TXP_HTXD_UNINIT),
 131                              (void __iomem *) txp_desc + C2_TXP_FLAGS);
 132
 133                 elem->skb = NULL;
 134                 elem->ht_desc = tx_desc;
 135                 elem->hw_desc = txp_desc;
 136
 137                 if (i == tx_ring->count - 1) {
 138                         elem->next = tx_ring->start;
 139                         tx_desc->next_offset = base;
 140                 } else {
 141                         elem->next = elem + 1;
 142                         tx_desc->next_offset =
 143                             base + (i + 1) * sizeof(*tx_desc);
 144                 }
 145         }
 146
 147         tx_ring->to_use = tx_ring->to_clean = tx_ring->start;
 148
 149         return 0;
 150 }
 151
 152 /*
 153  * Allocate RX ring elements and chain them together.
 154  * One-to-one association of adapter descriptors with ring elements.
 155  */
 156 static int c2_rx_ring_alloc(struct c2_ring *rx_ring, void *vaddr,
 157                             dma_addr_t base, void __iomem * mmio_rxp_ring)
 158 {
 159         struct c2_rx_desc *rx_desc;
 160         struct c2_rxp_desc __iomem *rxp_desc;
 161         struct c2_element *elem;
 162         int i;
 163
 164         rx_ring->start = kmalloc_array(rx_ring->count, sizeof(*elem),
 165                                        GFP_KERNEL);
 166         if (!rx_ring->start)
 167                 return -ENOMEM;
 168
 169         elem = rx_ring->start;
 170         rx_desc = vaddr;
 171         rxp_desc = mmio_rxp_ring;
 172         for (i = 0; i < rx_ring->count; i++, elem++, rx_desc++, rxp_desc++) {
 173                 rx_desc->len = 0;
 174                 rx_desc->status = 0;
 175
 176                 /* Set RXP_HRXD_UNINIT */
 177                 __raw_writew((__force u16) cpu_to_be16(RXP_HRXD_OK),
 178                        (void __iomem *) rxp_desc + C2_RXP_STATUS);
 179                 __raw_writew(0, (void __iomem *) rxp_desc + C2_RXP_COUNT);
 180                 __raw_writew(0, (void __iomem *) rxp_desc + C2_RXP_LEN);
 181                 __raw_writeq((__force u64) cpu_to_be64(0x99aabbccddeeffULL),
 182                              (void __iomem *) rxp_desc + C2_RXP_ADDR);
 183                 __raw_writew((__force u16) cpu_to_be16(RXP_HRXD_UNINIT),
 184                              (void __iomem *) rxp_desc + C2_RXP_FLAGS);
 185
 186                 elem->skb = NULL;
 187                 elem->ht_desc = rx_desc;
 188                 elem->hw_desc = rxp_desc;
 189
 190                 if (i == rx_ring->count - 1) {
 191                         elem->next = rx_ring->start;
 192                         rx_desc->next_offset = base;
 193                 } else {
 194                         elem->next = elem + 1;
 195                         rx_desc->next_offset =
 196                             base + (i + 1) * sizeof(*rx_desc);
 197                 }
 198         }
 199
 200         rx_ring->to_use = rx_ring->to_clean = rx_ring->start;
 201
 202         return 0;
 203 }
 204
 205 /* Setup buffer for receiving */
 206 static inline int c2_rx_alloc(struct c2_port *c2_port, struct c2_element *elem)
 207 {
 208         struct c2_dev *c2dev = c2_port->c2dev;
 209         struct c2_rx_desc *rx_desc = elem->ht_desc;
 210         struct sk_buff *skb;
 211         dma_addr_t mapaddr;
 212         u32 maplen;
 213         struct c2_rxp_hdr *rxp_hdr;
 214
 215         skb = dev_alloc_skb(c2_port->rx_buf_size);
 216         if (unlikely(!skb)) {
 217                 pr_debug("%s: out of memory for receive\n",
 218                         c2_port->netdev->name);
 219                 return -ENOMEM;
 220         }
 221
 222         /* Zero out the rxp hdr in the sk_buff */
 223         memset(skb->data, 0, sizeof(*rxp_hdr));
 224
 225         skb->dev = c2_port->netdev;
 226
 227         maplen = c2_port->rx_buf_size;
 228         mapaddr =
 229             pci_map_single(c2dev->pcidev, skb->data, maplen,
 230                            PCI_DMA_FROMDEVICE);
 231
 232         /* Set the sk_buff RXP_header to RXP_HRXD_READY */
 233         rxp_hdr = (struct c2_rxp_hdr *) skb->data;
 234         rxp_hdr->flags = RXP_HRXD_READY;
 235
 236         __raw_writew(0, elem->hw_desc + C2_RXP_STATUS);
 237         __raw_writew((__force u16) cpu_to_be16((u16) maplen - sizeof(*rxp_hdr)),
 238                      elem->hw_desc + C2_RXP_LEN);
 239         __raw_writeq((__force u64) cpu_to_be64(mapaddr), elem->hw_desc + C2_RXP_ADDR);
 240         __raw_writew((__force u16) cpu_to_be16(RXP_HRXD_READY),
 241                      elem->hw_desc + C2_RXP_FLAGS);
 242
 243         elem->skb = skb;
 244         elem->mapaddr = mapaddr;
 245         elem->maplen = maplen;
 246         rx_desc->len = maplen;
 247
 248         return 0;
 249 }
 250
 251 /*
 252  * Allocate buffers for the Rx ring
 253  * For receive:  rx_ring.to_clean is next received frame
 254  */
 255 static int c2_rx_fill(struct c2_port *c2_port)
 256 {
 257         struct c2_ring *rx_ring = &c2_port->rx_ring;
 258         struct c2_element *elem;
 259         int ret = 0;
 260
 261         elem = rx_ring->start;
 262         do {
 263                 if (c2_rx_alloc(c2_port, elem)) {
 264                         ret = 1;
 265                         break;
 266                 }
 267         } while ((elem = elem->next) != rx_ring->start);
 268
 269         rx_ring->to_clean = rx_ring->start;
 270         return ret;
 271 }
 272
 273 /* Free all buffers in RX ring, assumes receiver stopped */
 274 static void c2_rx_clean(struct c2_port *c2_port)
 275 {
 276         struct c2_dev *c2dev = c2_port->c2dev;
 277         struct c2_ring *rx_ring = &c2_port->rx_ring;
 278         struct c2_element *elem;
 279         struct c2_rx_desc *rx_desc;
 280
 281         elem = rx_ring->start;
 282         do {
 283                 rx_desc = elem->ht_desc;
 284                 rx_desc->len = 0;
 285
 286                 __raw_writew(0, elem->hw_desc + C2_RXP_STATUS);
 287                 __raw_writew(0, elem->hw_desc + C2_RXP_COUNT);
 288                 __raw_writew(0, elem->hw_desc + C2_RXP_LEN);
 289                 __raw_writeq((__force u64) cpu_to_be64(0x99aabbccddeeffULL),
 290                              elem->hw_desc + C2_RXP_ADDR);
 291                 __raw_writew((__force u16) cpu_to_be16(RXP_HRXD_UNINIT),
 292                              elem->hw_desc + C2_RXP_FLAGS);
 293
 294                 if (elem->skb) {
 295                         pci_unmap_single(c2dev->pcidev, elem->mapaddr,
 296                                          elem->maplen, PCI_DMA_FROMDEVICE);
 297                         dev_kfree_skb(elem->skb);
 298                         elem->skb = NULL;
 299                 }
 300         } while ((elem = elem->next) != rx_ring->start);
 301 }
 302
 303 static inline int c2_tx_free(struct c2_dev *c2dev, struct c2_element *elem)
 304 {
 305         struct c2_tx_desc *tx_desc = elem->ht_desc;
 306
 307         tx_desc->len = 0;
 308
 309         pci_unmap_single(c2dev->pcidev, elem->mapaddr, elem->maplen,
 310                          PCI_DMA_TODEVICE);
 311
 312         if (elem->skb) {
 313                 dev_kfree_skb_any(elem->skb);
 314                 elem->skb = NULL;
 315         }
 316
 317         return 0;
 318 }
 319
 320 /* Free all buffers in TX ring, assumes transmitter stopped */
 321 static void c2_tx_clean(struct c2_port *c2_port)
 322 {
 323         struct c2_ring *tx_ring = &c2_port->tx_ring;
 324         struct c2_element *elem;
 325         struct c2_txp_desc txp_htxd;
 326         int retry;
 327         unsigned long flags;
 328
 329         spin_lock_irqsave(&c2_port->tx_lock, flags);
 330
 331         elem = tx_ring->start;
 332
 333         do {
 334                 retry = 0;
 335                 do {
 336                         txp_htxd.flags =
 337                             readw(elem->hw_desc + C2_TXP_FLAGS);
 338
 339                         if (txp_htxd.flags == TXP_HTXD_READY) {
 340                                 retry = 1;
 341                                 __raw_writew(0,
 342                                              elem->hw_desc + C2_TXP_LEN);
 343                                 __raw_writeq(0,
 344                                              elem->hw_desc + C2_TXP_ADDR);
 345                                 __raw_writew((__force u16) cpu_to_be16(TXP_HTXD_DONE),
 346                                              elem->hw_desc + C2_TXP_FLAGS);
 347                                 c2_port->netdev->stats.tx_dropped++;
 348                                 break;
 349                         } else {
 350                                 __raw_writew(0,
 351                                              elem->hw_desc + C2_TXP_LEN);
 352                                 __raw_writeq((__force u64) cpu_to_be64(0x1122334455667788ULL),
 353                                              elem->hw_desc + C2_TXP_ADDR);
 354                                 __raw_writew((__force u16) cpu_to_be16(TXP_HTXD_UNINIT),
 355                                              elem->hw_desc + C2_TXP_FLAGS);
 356                         }
 357
 358                         c2_tx_free(c2_port->c2dev, elem);
 359
 360                 } while ((elem = elem->next) != tx_ring->start);
 361         } while (retry);
 362
 363         c2_port->tx_avail = c2_port->tx_ring.count - 1;
 364         c2_port->c2dev->cur_tx = tx_ring->to_use - tx_ring->start;
 365
 366         if (c2_port->tx_avail > MAX_SKB_FRAGS + 1)
 367                 netif_wake_queue(c2_port->netdev);
 368
 369         spin_unlock_irqrestore(&c2_port->tx_lock, flags);
 370 }
 371
 372 /*
 373  * Process transmit descriptors marked 'DONE' by the firmware,
 374  * freeing up their unneeded sk_buffs.
 375  */
 376 static void c2_tx_interrupt(struct net_device *netdev)
 377 {
 378         struct c2_port *c2_port = netdev_priv(netdev);
 379         struct c2_dev *c2dev = c2_port->c2dev;
 380         struct c2_ring *tx_ring = &c2_port->tx_ring;
 381         struct c2_element *elem;
 382         struct c2_txp_desc txp_htxd;
 383
 384         spin_lock(&c2_port->tx_lock);
 385
 386         for (elem = tx_ring->to_clean; elem != tx_ring->to_use;
 387              elem = elem->next) {
 388                 txp_htxd.flags =
 389                     be16_to_cpu((__force __be16) readw(elem->hw_desc + C2_TXP_FLAGS));
 390
 391                 if (txp_htxd.flags != TXP_HTXD_DONE)
 392                         break;
 393
 394                 if (netif_msg_tx_done(c2_port)) {
 395                         /* PCI reads are expensive in fast path */
 396                         txp_htxd.len =
 397                             be16_to_cpu((__force __be16) readw(elem->hw_desc + C2_TXP_LEN));
 398                         pr_debug("%s: tx done slot %3Zu status 0x%x len "
 399                                 "%5u bytes\n",
 400                                 netdev->name, elem - tx_ring->start,
 401                                 txp_htxd.flags, txp_htxd.len);
 402                 }
 403
 404                 c2_tx_free(c2dev, elem);
 405                 ++(c2_port->tx_avail);
 406         }
 407
 408         tx_ring->to_clean = elem;
 409
 410         if (netif_queue_stopped(netdev)
 411             && c2_port->tx_avail > MAX_SKB_FRAGS + 1)
 412                 netif_wake_queue(netdev);
 413
 414         spin_unlock(&c2_port->tx_lock);
 415 }
 416
 417 static void c2_rx_error(struct c2_port *c2_port, struct c2_element *elem)
 418 {
 419         struct c2_rx_desc *rx_desc = elem->ht_desc;
 420         struct c2_rxp_hdr *rxp_hdr = (struct c2_rxp_hdr *) elem->skb->data;
 421
 422         if (rxp_hdr->status != RXP_HRXD_OK ||
 423             rxp_hdr->len > (rx_desc->len - sizeof(*rxp_hdr))) {
 424                 pr_debug("BAD RXP_HRXD\n");
 425                 pr_debug("  rx_desc : %p\n", rx_desc);
 426                 pr_debug("    index : %Zu\n",
 427                         elem - c2_port->rx_ring.start);
 428                 pr_debug("    len   : %u\n", rx_desc->len);
 429                 pr_debug("  rxp_hdr : %p [PA %p]\n", rxp_hdr,
 430                         (void *) __pa((unsigned long) rxp_hdr));
 431                 pr_debug("    flags : 0x%x\n", rxp_hdr->flags);
 432                 pr_debug("    status: 0x%x\n", rxp_hdr->status);
 433                 pr_debug("    len   : %u\n", rxp_hdr->len);
 434                 pr_debug("    rsvd  : 0x%x\n", rxp_hdr->rsvd);
 435         }
 436
 437         /* Setup the skb for reuse since we're dropping this pkt */
 438         elem->skb->data = elem->skb->head;
 439         skb_reset_tail_pointer(elem->skb);
 440
 441         /* Zero out the rxp hdr in the sk_buff */
 442         memset(elem->skb->data, 0, sizeof(*rxp_hdr));
 443
 444         /* Write the descriptor to the adapter's rx ring */
 445         __raw_writew(0, elem->hw_desc + C2_RXP_STATUS);
 446         __raw_writew(0, elem->hw_desc + C2_RXP_COUNT);
 447         __raw_writew((__force u16) cpu_to_be16((u16) elem->maplen - sizeof(*rxp_hdr)),
 448                      elem->hw_desc + C2_RXP_LEN);
 449         __raw_writeq((__force u64) cpu_to_be64(elem->mapaddr),
 450                      elem->hw_desc + C2_RXP_ADDR);
 451         __raw_writew((__force u16) cpu_to_be16(RXP_HRXD_READY),
 452                      elem->hw_desc + C2_RXP_FLAGS);
 453
 454         pr_debug("packet dropped\n");
 455         c2_port->netdev->stats.rx_dropped++;
 456 }
 457
 458 static void c2_rx_interrupt(struct net_device *netdev)
 459 {
 460         struct c2_port *c2_port = netdev_priv(netdev);
 461         struct c2_dev *c2dev = c2_port->c2dev;
 462         struct c2_ring *rx_ring = &c2_port->rx_ring;
 463         struct c2_element *elem;
 464         struct c2_rx_desc *rx_desc;
 465         struct c2_rxp_hdr *rxp_hdr;
 466         struct sk_buff *skb;
 467         dma_addr_t mapaddr;
 468         u32 maplen, buflen;
 469         unsigned long flags;
 470
 471         spin_lock_irqsave(&c2dev->lock, flags);
 472
 473         /* Begin where we left off */
 474         rx_ring->to_clean = rx_ring->start + c2dev->cur_rx;
 475
 476         for (elem = rx_ring->to_clean; elem->next != rx_ring->to_clean;
 477              elem = elem->next) {
 478                 rx_desc = elem->ht_desc;
 479                 mapaddr = elem->mapaddr;
 480                 maplen = elem->maplen;
 481                 skb = elem->skb;
 482                 rxp_hdr = (struct c2_rxp_hdr *) skb->data;
 483
 484                 if (rxp_hdr->flags != RXP_HRXD_DONE)
 485                         break;
 486                 buflen = rxp_hdr->len;
 487
 488                 /* Sanity check the RXP header */
 489                 if (rxp_hdr->status != RXP_HRXD_OK ||
 490                     buflen > (rx_desc->len - sizeof(*rxp_hdr))) {
 491                         c2_rx_error(c2_port, elem);
 492                         continue;
 493                 }
 494
 495                 /*
 496                  * Allocate and map a new skb for replenishing the host
 497                  * RX desc
 498                  */
 499                 if (c2_rx_alloc(c2_port, elem)) {
 500                         c2_rx_error(c2_port, elem);
 501                         continue;
 502                 }
 503
 504                 /* Unmap the old skb */
 505                 pci_unmap_single(c2dev->pcidev, mapaddr, maplen,
 506                                  PCI_DMA_FROMDEVICE);
 507
 508                 prefetch(skb->data);
 509
 510                 /*
 511                  * Skip past the leading 8 bytes comprising of the
 512                  * "struct c2_rxp_hdr", prepended by the adapter
 513                  * to the usual Ethernet header ("struct ethhdr"),
 514                  * to the start of the raw Ethernet packet.
 515                  *
 516                  * Fix up the various fields in the sk_buff before
 517                  * passing it up to netif_rx(). The transfer size
 518                  * (in bytes) specified by the adapter len field of
 519                  * the "struct rxp_hdr_t" does NOT include the
 520                  * "sizeof(struct c2_rxp_hdr)".
 521                  */
 522                 skb->data += sizeof(*rxp_hdr);
 523                 skb_set_tail_pointer(skb, buflen);
 524                 skb->len = buflen;
 525                 skb->protocol = eth_type_trans(skb, netdev);
 526
 527                 netif_rx(skb);
 528
 529                 netdev->stats.rx_packets++;
 530                 netdev->stats.rx_bytes += buflen;
 531         }
 532
 533         /* Save where we left off */
 534         rx_ring->to_clean = elem;
 535         c2dev->cur_rx = elem - rx_ring->start;
 536         C2_SET_CUR_RX(c2dev, c2dev->cur_rx);
 537
 538         spin_unlock_irqrestore(&c2dev->lock, flags);
 539 }
 540
 541 /*
 542  * Handle netisr0 TX & RX interrupts.
 543  */
 544 static irqreturn_t c2_interrupt(int irq, void *dev_id)
 545 {
 546         unsigned int netisr0, dmaisr;
 547         int handled = 0;
 548         struct c2_dev *c2dev = dev_id;
 549
 550         /* Process CCILNET interrupts */
 551         netisr0 = readl(c2dev->regs + C2_NISR0);
 552         if (netisr0) {
 553
 554                 /*
 555                  * There is an issue with the firmware that always
 556                  * provides the status of RX for both TX & RX
 557                  * interrupts.  So process both queues here.
 558                  */
 559                 c2_rx_interrupt(c2dev->netdev);
 560                 c2_tx_interrupt(c2dev->netdev);
 561
 562                 /* Clear the interrupt */
 563                 writel(netisr0, c2dev->regs + C2_NISR0);
 564                 handled++;
 565         }
 566
 567         /* Process RNIC interrupts */
 568         dmaisr = readl(c2dev->regs + C2_DISR);
 569         if (dmaisr) {
 570                 writel(dmaisr, c2dev->regs + C2_DISR);
 571                 c2_rnic_interrupt(c2dev);
 572                 handled++;
 573         }
 574
 575         if (handled) {
 576                 return IRQ_HANDLED;
 577         } else {
 578                 return IRQ_NONE;
 579         }
 580 }
 581
 582 static int c2_up(struct net_device *netdev)
 583 {
 584         struct c2_port *c2_port = netdev_priv(netdev);
 585         struct c2_dev *c2dev = c2_port->c2dev;
 586         struct c2_element *elem;
 587         struct c2_rxp_hdr *rxp_hdr;
 588         struct in_device *in_dev;
 589         size_t rx_size, tx_size;
 590         int ret, i;
 591         unsigned int netimr0;
 592
 593         if (netif_msg_ifup(c2_port))
 594                 pr_debug("%s: enabling interface\n", netdev->name);
 595
 596         /* Set the Rx buffer size based on MTU */
 597         c2_set_rxbufsize(c2_port);
 598
 599         /* Allocate DMA'able memory for Tx/Rx host descriptor rings */
 600         rx_size = c2_port->rx_ring.count * sizeof(struct c2_rx_desc);
 601         tx_size = c2_port->tx_ring.count * sizeof(struct c2_tx_desc);
 602
 603         c2_port->mem_size = tx_size + rx_size;
 604         c2_port->mem = pci_zalloc_consistent(c2dev->pcidev, c2_port->mem_size,
 605                                              &c2_port->dma);
 606         if (c2_port->mem == NULL) {
 607                 pr_debug("Unable to allocate memory for "
 608                         "host descriptor rings\n");
 609                 return -ENOMEM;
 610         }
 611
 612         /* Create the Rx host descriptor ring */
 613         if ((ret =
 614              c2_rx_ring_alloc(&c2_port->rx_ring, c2_port->mem, c2_port->dma,
 615                               c2dev->mmio_rxp_ring))) {
 616                 pr_debug("Unable to create RX ring\n");
 617                 goto bail0;
 618         }
 619
 620         /* Allocate Rx buffers for the host descriptor ring */
 621         if (c2_rx_fill(c2_port)) {
 622                 pr_debug("Unable to fill RX ring\n");
 623                 goto bail1;
 624         }
 625
 626         /* Create the Tx host descriptor ring */
 627         if ((ret = c2_tx_ring_alloc(&c2_port->tx_ring, c2_port->mem + rx_size,
 628                                     c2_port->dma + rx_size,
 629                                     c2dev->mmio_txp_ring))) {
 630                 pr_debug("Unable to create TX ring\n");
 631                 goto bail1;
 632         }
 633
 634         /* Set the TX pointer to where we left off */
 635         c2_port->tx_avail = c2_port->tx_ring.count - 1;
 636         c2_port->tx_ring.to_use = c2_port->tx_ring.to_clean =
 637             c2_port->tx_ring.start + c2dev->cur_tx;
 638
 639         /* missing: Initialize MAC */
 640
 641         BUG_ON(c2_port->tx_ring.to_use != c2_port->tx_ring.to_clean);
 642
 643         /* Reset the adapter, ensures the driver is in sync with the RXP */
 644         c2_reset(c2_port);
 645
 646         /* Reset the READY bit in the sk_buff RXP headers & adapter HRXDQ */
 647         for (i = 0, elem = c2_port->rx_ring.start; i < c2_port->rx_ring.count;
 648              i++, elem++) {
 649                 rxp_hdr = (struct c2_rxp_hdr *) elem->skb->data;
 650                 rxp_hdr->flags = 0;
 651                 __raw_writew((__force u16) cpu_to_be16(RXP_HRXD_READY),
 652                              elem->hw_desc + C2_RXP_FLAGS);
 653         }
 654
 655         /* Enable network packets */
 656         netif_start_queue(netdev);
 657
 658         /* Enable IRQ */
 659         writel(0, c2dev->regs + C2_IDIS);
 660         netimr0 = readl(c2dev->regs + C2_NIMR0);
 661         netimr0 &= ~(C2_PCI_HTX_INT | C2_PCI_HRX_INT);
 662         writel(netimr0, c2dev->regs + C2_NIMR0);
 663
 664         /* Tell the stack to ignore arp requests for ipaddrs bound to
 665          * other interfaces.  This is needed to prevent the host stack
 666          * from responding to arp requests to the ipaddr bound on the
 667          * rdma interface.
 668          */
 669         in_dev = in_dev_get(netdev);
 670         IN_DEV_CONF_SET(in_dev, ARP_IGNORE, 1);
 671         in_dev_put(in_dev);
 672
 673         return 0;
 674
 675 bail1:
 676         c2_rx_clean(c2_port);
 677         kfree(c2_port->rx_ring.start);
 678
 679 bail0:
 680         pci_free_consistent(c2dev->pcidev, c2_port->mem_size, c2_port->mem,
 681                             c2_port->dma);
 682
 683         return ret;
 684 }
 685
 686 static int c2_down(struct net_device *netdev)
 687 {
 688         struct c2_port *c2_port = netdev_priv(netdev);
 689         struct c2_dev *c2dev = c2_port->c2dev;
 690
 691         if (netif_msg_ifdown(c2_port))
 692                 pr_debug("%s: disabling interface\n",
 693                         netdev->name);
 694
 695         /* Wait for all the queued packets to get sent */
 696         c2_tx_interrupt(netdev);
 697
 698         /* Disable network packets */
 699         netif_stop_queue(netdev);
 700
 701         /* Disable IRQs by clearing the interrupt mask */
 702         writel(1, c2dev->regs + C2_IDIS);
 703         writel(0, c2dev->regs + C2_NIMR0);
 704
 705         /* missing: Stop transmitter */
 706
 707         /* missing: Stop receiver */
 708
 709         /* Reset the adapter, ensures the driver is in sync with the RXP */
 710         c2_reset(c2_port);
 711
 712         /* missing: Turn off LEDs here */
 713
 714         /* Free all buffers in the host descriptor rings */
 715         c2_tx_clean(c2_port);
 716         c2_rx_clean(c2_port);
 717
 718         /* Free the host descriptor rings */
 719         kfree(c2_port->rx_ring.start);
 720         kfree(c2_port->tx_ring.start);
 721         pci_free_consistent(c2dev->pcidev, c2_port->mem_size, c2_port->mem,
 722                             c2_port->dma);
 723
 724         return 0;
 725 }
 726
 727 static void c2_reset(struct c2_port *c2_port)
 728 {
 729         struct c2_dev *c2dev = c2_port->c2dev;
 730         unsigned int cur_rx = c2dev->cur_rx;
 731
 732         /* Tell the hardware to quiesce */
 733         C2_SET_CUR_RX(c2dev, cur_rx | C2_PCI_HRX_QUI);
 734
 735         /*
 736          * The hardware will reset the C2_PCI_HRX_QUI bit once
 737          * the RXP is quiesced.  Wait 2 seconds for this.
 738          */
 739         ssleep(2);
 740
 741         cur_rx = C2_GET_CUR_RX(c2dev);
 742
 743         if (cur_rx & C2_PCI_HRX_QUI)
 744                 pr_debug("c2_reset: failed to quiesce the hardware!\n");
 745
 746         cur_rx &= ~C2_PCI_HRX_QUI;
 747
 748         c2dev->cur_rx = cur_rx;
 749
 750         pr_debug("Current RX: %u\n", c2dev->cur_rx);
 751 }
 752
 753 static int c2_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
 754 {
 755         struct c2_port *c2_port = netdev_priv(netdev);
 756         struct c2_dev *c2dev = c2_port->c2dev;
 757         struct c2_ring *tx_ring = &c2_port->tx_ring;
 758         struct c2_element *elem;
 759         dma_addr_t mapaddr;
 760         u32 maplen;
 761         unsigned long flags;
 762         unsigned int i;
 763
 764         spin_lock_irqsave(&c2_port->tx_lock, flags);
 765
 766         if (unlikely(c2_port->tx_avail < (skb_shinfo(skb)->nr_frags + 1))) {
 767                 netif_stop_queue(netdev);
 768                 spin_unlock_irqrestore(&c2_port->tx_lock, flags);
 769
 770                 pr_debug("%s: Tx ring full when queue awake!\n",
 771                         netdev->name);
 772                 return NETDEV_TX_BUSY;
 773         }
 774
 775         maplen = skb_headlen(skb);
 776         mapaddr =
 777             pci_map_single(c2dev->pcidev, skb->data, maplen, PCI_DMA_TODEVICE);
 778
 779         elem = tx_ring->to_use;
 780         elem->skb = skb;
 781         elem->mapaddr = mapaddr;
 782         elem->maplen = maplen;
 783
 784         /* Tell HW to xmit */
 785         __raw_writeq((__force u64) cpu_to_be64(mapaddr),
 786                      elem->hw_desc + C2_TXP_ADDR);
 787         __raw_writew((__force u16) cpu_to_be16(maplen),
 788                      elem->hw_desc + C2_TXP_LEN);
 789         __raw_writew((__force u16) cpu_to_be16(TXP_HTXD_READY),
 790                      elem->hw_desc + C2_TXP_FLAGS);
 791
 792         netdev->stats.tx_packets++;
 793         netdev->stats.tx_bytes += maplen;
 794
 795         /* Loop thru additional data fragments and queue them */
 796         if (skb_shinfo(skb)->nr_frags) {
 797                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
 798                         const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
 799                         maplen = skb_frag_size(frag);
 800                         mapaddr = skb_frag_dma_map(&c2dev->pcidev->dev, frag,
 801                                                    0, maplen, DMA_TO_DEVICE);
 802                         elem = elem->next;
 803                         elem->skb = NULL;
 804                         elem->mapaddr = mapaddr;
 805                         elem->maplen = maplen;
 806
 807                         /* Tell HW to xmit */
 808                         __raw_writeq((__force u64) cpu_to_be64(mapaddr),
 809                                      elem->hw_desc + C2_TXP_ADDR);
 810                         __raw_writew((__force u16) cpu_to_be16(maplen),
 811                                      elem->hw_desc + C2_TXP_LEN);
 812                         __raw_writew((__force u16) cpu_to_be16(TXP_HTXD_READY),
 813                                      elem->hw_desc + C2_TXP_FLAGS);
 814
 815                         netdev->stats.tx_packets++;
 816                         netdev->stats.tx_bytes += maplen;
 817                 }
 818         }
 819
 820         tx_ring->to_use = elem->next;
 821         c2_port->tx_avail -= (skb_shinfo(skb)->nr_frags + 1);
 822
 823         if (c2_port->tx_avail <= MAX_SKB_FRAGS + 1) {
 824                 netif_stop_queue(netdev);
 825                 if (netif_msg_tx_queued(c2_port))
 826                         pr_debug("%s: transmit queue full\n",
 827                                 netdev->name);
 828         }
 829
 830         spin_unlock_irqrestore(&c2_port->tx_lock, flags);
 831
 832         netdev->trans_start = jiffies;
 833
 834         return NETDEV_TX_OK;
 835 }
 836
 837 static void c2_tx_timeout(struct net_device *netdev)
 838 {
 839         struct c2_port *c2_port = netdev_priv(netdev);
 840
 841         if (netif_msg_timer(c2_port))
 842                 pr_debug("%s: tx timeout\n", netdev->name);
 843
 844         c2_tx_clean(c2_port);
 845 }
 846
 847 static int c2_change_mtu(struct net_device *netdev, int new_mtu)
 848 {
 849         int ret = 0;
 850
 851         if (new_mtu < ETH_ZLEN || new_mtu > ETH_JUMBO_MTU)
 852                 return -EINVAL;
 853
 854         netdev->mtu = new_mtu;
 855
 856         if (netif_running(netdev)) {
 857                 c2_down(netdev);
 858
 859                 c2_up(netdev);
 860         }
 861
 862         return ret;
 863 }
 864
 865 static const struct net_device_ops c2_netdev = {
 866         .ndo_open               = c2_up,
 867         .ndo_stop               = c2_down,
 868         .ndo_start_xmit         = c2_xmit_frame,
 869         .ndo_tx_timeout         = c2_tx_timeout,
 870         .ndo_change_mtu         = c2_change_mtu,
 871         .ndo_set_mac_address    = eth_mac_addr,
 872         .ndo_validate_addr      = eth_validate_addr,
 873 };
 874
 875 /* Initialize network device */
 876 static struct net_device *c2_devinit(struct c2_dev *c2dev,
 877                                      void __iomem * mmio_addr)
 878 {
 879         struct c2_port *c2_port = NULL;
 880         struct net_device *netdev = alloc_etherdev(sizeof(*c2_port));
 881
 882         if (!netdev) {
 883                 pr_debug("c2_port etherdev alloc failed");
 884                 return NULL;
 885         }
 886
 887         SET_NETDEV_DEV(netdev, &c2dev->pcidev->dev);
 888
 889         netdev->netdev_ops = &c2_netdev;
 890         netdev->watchdog_timeo = C2_TX_TIMEOUT;
 891         netdev->irq = c2dev->pcidev->irq;
 892
 893         c2_port = netdev_priv(netdev);
 894         c2_port->netdev = netdev;
 895         c2_port->c2dev = c2dev;
 896         c2_port->msg_enable = netif_msg_init(debug, default_msg);
 897         c2_port->tx_ring.count = C2_NUM_TX_DESC;
 898         c2_port->rx_ring.count = C2_NUM_RX_DESC;
 899
 900         spin_lock_init(&c2_port->tx_lock);
 901
 902         /* Copy our 48-bit ethernet hardware address */
 903         memcpy_fromio(netdev->dev_addr, mmio_addr + C2_REGS_ENADDR, 6);
 904
 905         /* Validate the MAC address */
 906         if (!is_valid_ether_addr(netdev->dev_addr)) {
 907                 pr_debug("Invalid MAC Address\n");
 908                 pr_debug("%s: MAC %pM, IRQ %u\n", netdev->name,
 909                          netdev->dev_addr, netdev->irq);
 910                 free_netdev(netdev);
 911                 return NULL;
 912         }
 913
 914         c2dev->netdev = netdev;
 915
 916         return netdev;
 917 }
 918
 919 static int c2_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
 920 {
 921         int ret = 0, i;
 922         unsigned long reg0_start, reg0_flags, reg0_len;
 923         unsigned long reg2_start, reg2_flags, reg2_len;
 924         unsigned long reg4_start, reg4_flags, reg4_len;
 925         unsigned kva_map_size;
 926         struct net_device *netdev = NULL;
 927         struct c2_dev *c2dev = NULL;
 928         void __iomem *mmio_regs = NULL;
 929
 930         printk(KERN_INFO PFX "AMSO1100 Gigabit Ethernet driver v%s loaded\n",
 931                 DRV_VERSION);
 932
 933         /* Enable PCI device */
 934         ret = pci_enable_device(pcidev);
 935         if (ret) {
 936                 printk(KERN_ERR PFX "%s: Unable to enable PCI device\n",
 937                         pci_name(pcidev));
 938                 goto bail0;
 939         }
 940
 941         reg0_start = pci_resource_start(pcidev, BAR_0);
 942         reg0_len = pci_resource_len(pcidev, BAR_0);
 943         reg0_flags = pci_resource_flags(pcidev, BAR_0);
 944
 945         reg2_start = pci_resource_start(pcidev, BAR_2);
 946         reg2_len = pci_resource_len(pcidev, BAR_2);
 947         reg2_flags = pci_resource_flags(pcidev, BAR_2);
 948
 949         reg4_start = pci_resource_start(pcidev, BAR_4);
 950         reg4_len = pci_resource_len(pcidev, BAR_4);
 951         reg4_flags = pci_resource_flags(pcidev, BAR_4);
 952
 953         pr_debug("BAR0 size = 0x%lX bytes\n", reg0_len);
 954         pr_debug("BAR2 size = 0x%lX bytes\n", reg2_len);
 955         pr_debug("BAR4 size = 0x%lX bytes\n", reg4_len);
 956
 957         /* Make sure PCI base addr are MMIO */
 958         if (!(reg0_flags & IORESOURCE_MEM) ||
 959             !(reg2_flags & IORESOURCE_MEM) || !(reg4_flags & IORESOURCE_MEM)) {
 960                 printk(KERN_ERR PFX "PCI regions not an MMIO resource\n");
 961                 ret = -ENODEV;
 962                 goto bail1;
 963         }
 964
 965         /* Check for weird/broken PCI region reporting */
 966         if ((reg0_len < C2_REG0_SIZE) ||
 967             (reg2_len < C2_REG2_SIZE) || (reg4_len < C2_REG4_SIZE)) {
 968                 printk(KERN_ERR PFX "Invalid PCI region sizes\n");
 969                 ret = -ENODEV;
 970                 goto bail1;
 971         }
 972
 973         /* Reserve PCI I/O and memory resources */
 974         ret = pci_request_regions(pcidev, DRV_NAME);
 975         if (ret) {
 976                 printk(KERN_ERR PFX "%s: Unable to request regions\n",
 977                         pci_name(pcidev));
 978                 goto bail1;
 979         }
 980
 981         if ((sizeof(dma_addr_t) > 4)) {
 982                 ret = pci_set_dma_mask(pcidev, DMA_BIT_MASK(64));
 983                 if (ret < 0) {
 984                         printk(KERN_ERR PFX "64b DMA configuration failed\n");
 985                         goto bail2;
 986                 }
 987         } else {
 988                 ret = pci_set_dma_mask(pcidev, DMA_BIT_MASK(32));
 989                 if (ret < 0) {
 990                         printk(KERN_ERR PFX "32b DMA configuration failed\n");
 991                         goto bail2;
 992                 }
 993         }
 994
 995         /* Enables bus-mastering on the device */
 996         pci_set_master(pcidev);
 997
 998         /* Remap the adapter PCI registers in BAR4 */
 999         mmio_regs = ioremap_nocache(reg4_start + C2_PCI_REGS_OFFSET,
1000                                     sizeof(struct c2_adapter_pci_regs));
1001         if (!mmio_regs) {
1002                 printk(KERN_ERR PFX
1003                         "Unable to remap adapter PCI registers in BAR4\n");
1004                 ret = -EIO;
1005                 goto bail2;
1006         }
1007
1008         /* Validate PCI regs magic */
1009         for (i = 0; i < sizeof(c2_magic); i++) {
1010                 if (c2_magic[i] != readb(mmio_regs + C2_REGS_MAGIC + i)) {
1011                         printk(KERN_ERR PFX "Downlevel Firmware boot loader "
1012                                 "[%d/%Zd: got 0x%x, exp 0x%x]. Use the cc_flash "
1013                                "utility to update your boot loader\n",
1014                                 i + 1, sizeof(c2_magic),
1015                                 readb(mmio_regs + C2_REGS_MAGIC + i),
1016                                 c2_magic[i]);
1017                         printk(KERN_ERR PFX "Adapter not claimed\n");
1018                         iounmap(mmio_regs);
1019                         ret = -EIO;
1020                         goto bail2;
1021                 }
1022         }
1023
1024         /* Validate the adapter version */
1025         if (be32_to_cpu((__force __be32) readl(mmio_regs + C2_REGS_VERS)) != C2_VERSION) {
1026                 printk(KERN_ERR PFX "Version mismatch "
1027                         "[fw=%u, c2=%u], Adapter not claimed\n",
1028                         be32_to_cpu((__force __be32) readl(mmio_regs + C2_REGS_VERS)),
1029                         C2_VERSION);
1030                 ret = -EINVAL;
1031                 iounmap(mmio_regs);
1032                 goto bail2;
1033         }
1034
1035         /* Validate the adapter IVN */
1036         if (be32_to_cpu((__force __be32) readl(mmio_regs + C2_REGS_IVN)) != C2_IVN) {
1037                 printk(KERN_ERR PFX "Downlevel FIrmware level. You should be using "
1038                        "the OpenIB device support kit. "
1039                        "[fw=0x%x, c2=0x%x], Adapter not claimed\n",
1040                        be32_to_cpu((__force __be32) readl(mmio_regs + C2_REGS_IVN)),
1041                        C2_IVN);
1042                 ret = -EINVAL;
1043                 iounmap(mmio_regs);
1044                 goto bail2;
1045         }
1046
1047         /* Allocate hardware structure */
1048         c2dev = (struct c2_dev *) ib_alloc_device(sizeof(*c2dev));
1049         if (!c2dev) {
1050                 printk(KERN_ERR PFX "%s: Unable to alloc hardware struct\n",
1051                         pci_name(pcidev));
1052                 ret = -ENOMEM;
1053                 iounmap(mmio_regs);
1054                 goto bail2;
1055         }
1056
1057         memset(c2dev, 0, sizeof(*c2dev));
1058         spin_lock_init(&c2dev->lock);
1059         c2dev->pcidev = pcidev;
1060         c2dev->cur_tx = 0;
1061
1062         /* Get the last RX index */
1063         c2dev->cur_rx =
1064             (be32_to_cpu((__force __be32) readl(mmio_regs + C2_REGS_HRX_CUR)) -
1065              0xffffc000) / sizeof(struct c2_rxp_desc);
1066
1067         /* Request an interrupt line for the driver */
1068         ret = request_irq(pcidev->irq, c2_interrupt, IRQF_SHARED, DRV_NAME, c2dev);
1069         if (ret) {
1070                 printk(KERN_ERR PFX "%s: requested IRQ %u is busy\n",
1071                         pci_name(pcidev), pcidev->irq);
1072                 iounmap(mmio_regs);
1073                 goto bail3;
1074         }
1075
1076         /* Set driver specific data */
1077         pci_set_drvdata(pcidev, c2dev);
1078
1079         /* Initialize network device */
1080         if ((netdev = c2_devinit(c2dev, mmio_regs)) == NULL) {
1081                 ret = -ENOMEM;
1082                 iounmap(mmio_regs);
1083                 goto bail4;
1084         }
1085
1086         /* Save off the actual size prior to unmapping mmio_regs */
1087         kva_map_size = be32_to_cpu((__force __be32) readl(mmio_regs + C2_REGS_PCI_WINSIZE));
1088
1089         /* Unmap the adapter PCI registers in BAR4 */
1090         iounmap(mmio_regs);
1091
1092         /* Register network device */
1093         ret = register_netdev(netdev);
1094         if (ret) {
1095                 printk(KERN_ERR PFX "Unable to register netdev, ret = %d\n",
1096                         ret);
1097                 goto bail5;
1098         }
1099
1100         /* Disable network packets */
1101         netif_stop_queue(netdev);
1102
1103         /* Remap the adapter HRXDQ PA space to kernel VA space */
1104         c2dev->mmio_rxp_ring = ioremap_nocache(reg4_start + C2_RXP_HRXDQ_OFFSET,
1105                                                C2_RXP_HRXDQ_SIZE);
1106         if (!c2dev->mmio_rxp_ring) {
1107                 printk(KERN_ERR PFX "Unable to remap MMIO HRXDQ region\n");
1108                 ret = -EIO;
1109                 goto bail6;
1110         }
1111
1112         /* Remap the adapter HTXDQ PA space to kernel VA space */
1113         c2dev->mmio_txp_ring = ioremap_nocache(reg4_start + C2_TXP_HTXDQ_OFFSET,
1114                                                C2_TXP_HTXDQ_SIZE);
1115         if (!c2dev->mmio_txp_ring) {
1116                 printk(KERN_ERR PFX "Unable to remap MMIO HTXDQ region\n");
1117                 ret = -EIO;
1118                 goto bail7;
1119         }
1120
1121         /* Save off the current RX index in the last 4 bytes of the TXP Ring */
1122         C2_SET_CUR_RX(c2dev, c2dev->cur_rx);
1123
1124         /* Remap the PCI registers in adapter BAR0 to kernel VA space */
1125         c2dev->regs = ioremap_nocache(reg0_start, reg0_len);
1126         if (!c2dev->regs) {
1127                 printk(KERN_ERR PFX "Unable to remap BAR0\n");
1128                 ret = -EIO;
1129                 goto bail8;
1130         }
1131
1132         /* Remap the PCI registers in adapter BAR4 to kernel VA space */
1133         c2dev->pa = reg4_start + C2_PCI_REGS_OFFSET;
1134         c2dev->kva = ioremap_nocache(reg4_start + C2_PCI_REGS_OFFSET,
1135                                      kva_map_size);
1136         if (!c2dev->kva) {
1137                 printk(KERN_ERR PFX "Unable to remap BAR4\n");
1138                 ret = -EIO;
1139                 goto bail9;
1140         }
1141
1142         /* Print out the MAC address */
1143         pr_debug("%s: MAC %pM, IRQ %u\n", netdev->name, netdev->dev_addr,
1144                  netdev->irq);
1145
1146         ret = c2_rnic_init(c2dev);
1147         if (ret) {
1148                 printk(KERN_ERR PFX "c2_rnic_init failed: %d\n", ret);
1149                 goto bail10;
1150         }
1151
1152         ret = c2_register_device(c2dev);
1153         if (ret)
1154                 goto bail10;
1155
1156         return 0;
1157
1158  bail10:
1159         iounmap(c2dev->kva);
1160
1161  bail9:
1162         iounmap(c2dev->regs);
1163
1164  bail8:
1165         iounmap(c2dev->mmio_txp_ring);
1166
1167  bail7:
1168         iounmap(c2dev->mmio_rxp_ring);
1169
1170  bail6:
1171         unregister_netdev(netdev);
1172
1173  bail5:
1174         free_netdev(netdev);
1175
1176  bail4:
1177         free_irq(pcidev->irq, c2dev);
1178
1179  bail3:
1180         ib_dealloc_device(&c2dev->ibdev);
1181
1182  bail2:
1183         pci_release_regions(pcidev);
1184
1185  bail1:
1186         pci_disable_device(pcidev);
1187
1188  bail0:
1189         return ret;
1190 }
1191
1192 static void c2_remove(struct pci_dev *pcidev)
1193 {
1194         struct c2_dev *c2dev = pci_get_drvdata(pcidev);
1195         struct net_device *netdev = c2dev->netdev;
1196
1197         /* Unregister with OpenIB */
1198         c2_unregister_device(c2dev);
1199
1200         /* Clean up the RNIC resources */
1201         c2_rnic_term(c2dev);
1202
1203         /* Remove network device from the kernel */
1204         unregister_netdev(netdev);
1205
1206         /* Free network device */
1207         free_netdev(netdev);
1208
1209         /* Free the interrupt line */
1210         free_irq(pcidev->irq, c2dev);
1211
1212         /* missing: Turn LEDs off here */
1213
1214         /* Unmap adapter PA space */
1215         iounmap(c2dev->kva);
1216         iounmap(c2dev->regs);
1217         iounmap(c2dev->mmio_txp_ring);
1218         iounmap(c2dev->mmio_rxp_ring);
1219
1220         /* Free the hardware structure */
1221         ib_dealloc_device(&c2dev->ibdev);
1222
1223         /* Release reserved PCI I/O and memory resources */
1224         pci_release_regions(pcidev);
1225
1226         /* Disable PCI device */
1227         pci_disable_device(pcidev);
1228
1229         /* Clear driver specific data */
1230         pci_set_drvdata(pcidev, NULL);
1231 }
1232
1233 static struct pci_driver c2_pci_driver = {
1234         .name = DRV_NAME,
1235         .id_table = c2_pci_table,
1236         .probe = c2_probe,
1237         .remove = c2_remove,
1238 };
1239
1240 module_pci_driver(c2_pci_driver);