drivers/scsi/fnic/vnic_dev.c

   1 /*
   2  * Copyright 2008 Cisco Systems, Inc.  All rights reserved.
   3  * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
   4  *
   5  * This program is free software; you may redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; version 2 of the License.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  10  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  11  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  12  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  13  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  14  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  15  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  16  * SOFTWARE.
  17  */
  18
  19 #include <linux/kernel.h>
  20 #include <linux/errno.h>
  21 #include <linux/types.h>
  22 #include <linux/pci.h>
  23 #include <linux/delay.h>
  24 #include <linux/if_ether.h>
  25 #include <linux/slab.h>
  26 #include "vnic_resource.h"
  27 #include "vnic_devcmd.h"
  28 #include "vnic_dev.h"
  29 #include "vnic_stats.h"
  30
  31 struct vnic_res {
  32         void __iomem *vaddr;
  33         unsigned int count;
  34 };
  35
  36 struct vnic_dev {
  37         void *priv;
  38         struct pci_dev *pdev;
  39         struct vnic_res res[RES_TYPE_MAX];
  40         enum vnic_dev_intr_mode intr_mode;
  41         struct vnic_devcmd __iomem *devcmd;
  42         struct vnic_devcmd_notify *notify;
  43         struct vnic_devcmd_notify notify_copy;
  44         dma_addr_t notify_pa;
  45         u32 *linkstatus;
  46         dma_addr_t linkstatus_pa;
  47         struct vnic_stats *stats;
  48         dma_addr_t stats_pa;
  49         struct vnic_devcmd_fw_info *fw_info;
  50         dma_addr_t fw_info_pa;
  51 };
  52
  53 #define VNIC_MAX_RES_HDR_SIZE \
  54         (sizeof(struct vnic_resource_header) + \
  55         sizeof(struct vnic_resource) * RES_TYPE_MAX)
  56 #define VNIC_RES_STRIDE 128
  57
  58 void *vnic_dev_priv(struct vnic_dev *vdev)
  59 {
  60         return vdev->priv;
  61 }
  62
  63 static int vnic_dev_discover_res(struct vnic_dev *vdev,
  64         struct vnic_dev_bar *bar)
  65 {
  66         struct vnic_resource_header __iomem *rh;
  67         struct vnic_resource __iomem *r;
  68         u8 type;
  69
  70         if (bar->len < VNIC_MAX_RES_HDR_SIZE) {
  71                 printk(KERN_ERR "vNIC BAR0 res hdr length error\n");
  72                 return -EINVAL;
  73         }
  74
  75         rh = bar->vaddr;
  76         if (!rh) {
  77                 printk(KERN_ERR "vNIC BAR0 res hdr not mem-mapped\n");
  78                 return -EINVAL;
  79         }
  80
  81         if (ioread32(&rh->magic) != VNIC_RES_MAGIC ||
  82             ioread32(&rh->version) != VNIC_RES_VERSION) {
  83                 printk(KERN_ERR "vNIC BAR0 res magic/version error "
  84                         "exp (%lx/%lx) curr (%x/%x)\n",
  85                         VNIC_RES_MAGIC, VNIC_RES_VERSION,
  86                         ioread32(&rh->magic), ioread32(&rh->version));
  87                 return -EINVAL;
  88         }
  89
  90         r = (struct vnic_resource __iomem *)(rh + 1);
  91
  92         while ((type = ioread8(&r->type)) != RES_TYPE_EOL) {
  93
  94                 u8 bar_num = ioread8(&r->bar);
  95                 u32 bar_offset = ioread32(&r->bar_offset);
  96                 u32 count = ioread32(&r->count);
  97                 u32 len;
  98
  99                 r++;
 100
 101                 if (bar_num != 0)  /* only mapping in BAR0 resources */
 102                         continue;
 103
 104                 switch (type) {
 105                 case RES_TYPE_WQ:
 106                 case RES_TYPE_RQ:
 107                 case RES_TYPE_CQ:
 108                 case RES_TYPE_INTR_CTRL:
 109                         /* each count is stride bytes long */
 110                         len = count * VNIC_RES_STRIDE;
 111                         if (len + bar_offset > bar->len) {
 112                                 printk(KERN_ERR "vNIC BAR0 resource %d "
 113                                         "out-of-bounds, offset 0x%x + "
 114                                         "size 0x%x > bar len 0x%lx\n",
 115                                         type, bar_offset,
 116                                         len,
 117                                         bar->len);
 118                                 return -EINVAL;
 119                         }
 120                         break;
 121                 case RES_TYPE_INTR_PBA_LEGACY:
 122                 case RES_TYPE_DEVCMD:
 123                         len = count;
 124                         break;
 125                 default:
 126                         continue;
 127                 }
 128
 129                 vdev->res[type].count = count;
 130                 vdev->res[type].vaddr = (char __iomem *)bar->vaddr + bar_offset;
 131         }
 132
 133         return 0;
 134 }
 135
 136 unsigned int vnic_dev_get_res_count(struct vnic_dev *vdev,
 137         enum vnic_res_type type)
 138 {
 139         return vdev->res[type].count;
 140 }
 141
 142 void __iomem *vnic_dev_get_res(struct vnic_dev *vdev, enum vnic_res_type type,
 143         unsigned int index)
 144 {
 145         if (!vdev->res[type].vaddr)
 146                 return NULL;
 147
 148         switch (type) {
 149         case RES_TYPE_WQ:
 150         case RES_TYPE_RQ:
 151         case RES_TYPE_CQ:
 152         case RES_TYPE_INTR_CTRL:
 153                 return (char __iomem *)vdev->res[type].vaddr +
 154                                         index * VNIC_RES_STRIDE;
 155         default:
 156                 return (char __iomem *)vdev->res[type].vaddr;
 157         }
 158 }
 159
 160 unsigned int vnic_dev_desc_ring_size(struct vnic_dev_ring *ring,
 161                                      unsigned int desc_count,
 162                                      unsigned int desc_size)
 163 {
 164         /* The base address of the desc rings must be 512 byte aligned.
 165          * Descriptor count is aligned to groups of 32 descriptors.  A
 166          * count of 0 means the maximum 4096 descriptors.  Descriptor
 167          * size is aligned to 16 bytes.
 168          */
 169
 170         unsigned int count_align = 32;
 171         unsigned int desc_align = 16;
 172
 173         ring->base_align = 512;
 174
 175         if (desc_count == 0)
 176                 desc_count = 4096;
 177
 178         ring->desc_count = ALIGN(desc_count, count_align);
 179
 180         ring->desc_size = ALIGN(desc_size, desc_align);
 181
 182         ring->size = ring->desc_count * ring->desc_size;
 183         ring->size_unaligned = ring->size + ring->base_align;
 184
 185         return ring->size_unaligned;
 186 }
 187
 188 void vnic_dev_clear_desc_ring(struct vnic_dev_ring *ring)
 189 {
 190         memset(ring->descs, 0, ring->size);
 191 }
 192
 193 int vnic_dev_alloc_desc_ring(struct vnic_dev *vdev, struct vnic_dev_ring *ring,
 194         unsigned int desc_count, unsigned int desc_size)
 195 {
 196         vnic_dev_desc_ring_size(ring, desc_count, desc_size);
 197
 198         ring->descs_unaligned = dma_alloc_coherent(&vdev->pdev->dev,
 199                 ring->size_unaligned,
 200                 &ring->base_addr_unaligned, GFP_KERNEL);
 201
 202         if (!ring->descs_unaligned) {
 203                 printk(KERN_ERR
 204                   "Failed to allocate ring (size=%d), aborting\n",
 205                         (int)ring->size);
 206                 return -ENOMEM;
 207         }
 208
 209         ring->base_addr = ALIGN(ring->base_addr_unaligned,
 210                 ring->base_align);
 211         ring->descs = (u8 *)ring->descs_unaligned +
 212                 (ring->base_addr - ring->base_addr_unaligned);
 213
 214         vnic_dev_clear_desc_ring(ring);
 215
 216         ring->desc_avail = ring->desc_count - 1;
 217
 218         return 0;
 219 }
 220
 221 void vnic_dev_free_desc_ring(struct vnic_dev *vdev, struct vnic_dev_ring *ring)
 222 {
 223         if (ring->descs) {
 224                 dma_free_coherent(&vdev->pdev->dev,
 225                         ring->size_unaligned,
 226                         ring->descs_unaligned,
 227                         ring->base_addr_unaligned);
 228                 ring->descs = NULL;
 229         }
 230 }
 231
 232 int vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
 233         u64 *a0, u64 *a1, int wait)
 234 {
 235         struct vnic_devcmd __iomem *devcmd = vdev->devcmd;
 236         int delay;
 237         u32 status;
 238         int dev_cmd_err[] = {
 239                 /* convert from fw's version of error.h to host's version */
 240                 0,      /* ERR_SUCCESS */
 241                 EINVAL, /* ERR_EINVAL */
 242                 EFAULT, /* ERR_EFAULT */
 243                 EPERM,  /* ERR_EPERM */
 244                 EBUSY,  /* ERR_EBUSY */
 245         };
 246         int err;
 247
 248         status = ioread32(&devcmd->status);
 249         if (status & STAT_BUSY) {
 250                 printk(KERN_ERR "Busy devcmd %d\n", _CMD_N(cmd));
 251                 return -EBUSY;
 252         }
 253
 254         if (_CMD_DIR(cmd) & _CMD_DIR_WRITE) {
 255                 writeq(*a0, &devcmd->args[0]);
 256                 writeq(*a1, &devcmd->args[1]);
 257                 wmb();
 258         }
 259
 260         iowrite32(cmd, &devcmd->cmd);
 261
 262         if ((_CMD_FLAGS(cmd) & _CMD_FLAGS_NOWAIT))
 263                         return 0;
 264
 265         for (delay = 0; delay < wait; delay++) {
 266
 267                 udelay(100);
 268
 269                 status = ioread32(&devcmd->status);
 270                 if (!(status & STAT_BUSY)) {
 271
 272                         if (status & STAT_ERROR) {
 273                                 err = dev_cmd_err[(int)readq(&devcmd->args[0])];
 274                                 printk(KERN_ERR "Error %d devcmd %d\n",
 275                                         err, _CMD_N(cmd));
 276                                 return -err;
 277                         }
 278
 279                         if (_CMD_DIR(cmd) & _CMD_DIR_READ) {
 280                                 rmb();
 281                                 *a0 = readq(&devcmd->args[0]);
 282                                 *a1 = readq(&devcmd->args[1]);
 283                         }
 284
 285                         return 0;
 286                 }
 287         }
 288
 289         printk(KERN_ERR "Timedout devcmd %d\n", _CMD_N(cmd));
 290         return -ETIMEDOUT;
 291 }
 292
 293 int vnic_dev_fw_info(struct vnic_dev *vdev,
 294         struct vnic_devcmd_fw_info **fw_info)
 295 {
 296         u64 a0, a1 = 0;
 297         int wait = 1000;
 298         int err = 0;
 299
 300         if (!vdev->fw_info) {
 301                 vdev->fw_info = dma_alloc_coherent(&vdev->pdev->dev,
 302                         sizeof(struct vnic_devcmd_fw_info),
 303                         &vdev->fw_info_pa, GFP_KERNEL);
 304                 if (!vdev->fw_info)
 305                         return -ENOMEM;
 306
 307                 a0 = vdev->fw_info_pa;
 308
 309                 /* only get fw_info once and cache it */
 310                 err = vnic_dev_cmd(vdev, CMD_MCPU_FW_INFO, &a0, &a1, wait);
 311         }
 312
 313         *fw_info = vdev->fw_info;
 314
 315         return err;
 316 }
 317
 318 int vnic_dev_spec(struct vnic_dev *vdev, unsigned int offset, unsigned int size,
 319         void *value)
 320 {
 321         u64 a0, a1;
 322         int wait = 1000;
 323         int err;
 324
 325         a0 = offset;
 326         a1 = size;
 327
 328         err = vnic_dev_cmd(vdev, CMD_DEV_SPEC, &a0, &a1, wait);
 329
 330         switch (size) {
 331         case 1:
 332                 *(u8 *)value = (u8)a0;
 333                 break;
 334         case 2:
 335                 *(u16 *)value = (u16)a0;
 336                 break;
 337         case 4:
 338                 *(u32 *)value = (u32)a0;
 339                 break;
 340         case 8:
 341                 *(u64 *)value = a0;
 342                 break;
 343         default:
 344                 BUG();
 345                 break;
 346         }
 347
 348         return err;
 349 }
 350
 351 int vnic_dev_stats_clear(struct vnic_dev *vdev)
 352 {
 353         u64 a0 = 0, a1 = 0;
 354         int wait = 1000;
 355         return vnic_dev_cmd(vdev, CMD_STATS_CLEAR, &a0, &a1, wait);
 356 }
 357
 358 int vnic_dev_stats_dump(struct vnic_dev *vdev, struct vnic_stats **stats)
 359 {
 360         u64 a0, a1;
 361         int wait = 1000;
 362
 363         if (!vdev->stats) {
 364                 vdev->stats = dma_alloc_coherent(&vdev->pdev->dev,
 365                         sizeof(struct vnic_stats), &vdev->stats_pa, GFP_KERNEL);
 366                 if (!vdev->stats)
 367                         return -ENOMEM;
 368         }
 369
 370         *stats = vdev->stats;
 371         a0 = vdev->stats_pa;
 372         a1 = sizeof(struct vnic_stats);
 373
 374         return vnic_dev_cmd(vdev, CMD_STATS_DUMP, &a0, &a1, wait);
 375 }
 376
 377 int vnic_dev_close(struct vnic_dev *vdev)
 378 {
 379         u64 a0 = 0, a1 = 0;
 380         int wait = 1000;
 381         return vnic_dev_cmd(vdev, CMD_CLOSE, &a0, &a1, wait);
 382 }
 383
 384 int vnic_dev_enable(struct vnic_dev *vdev)
 385 {
 386         u64 a0 = 0, a1 = 0;
 387         int wait = 1000;
 388         return vnic_dev_cmd(vdev, CMD_ENABLE, &a0, &a1, wait);
 389 }
 390
 391 int vnic_dev_disable(struct vnic_dev *vdev)
 392 {
 393         u64 a0 = 0, a1 = 0;
 394         int wait = 1000;
 395         return vnic_dev_cmd(vdev, CMD_DISABLE, &a0, &a1, wait);
 396 }
 397
 398 int vnic_dev_open(struct vnic_dev *vdev, int arg)
 399 {
 400         u64 a0 = (u32)arg, a1 = 0;
 401         int wait = 1000;
 402         return vnic_dev_cmd(vdev, CMD_OPEN, &a0, &a1, wait);
 403 }
 404
 405 int vnic_dev_open_done(struct vnic_dev *vdev, int *done)
 406 {
 407         u64 a0 = 0, a1 = 0;
 408         int wait = 1000;
 409         int err;
 410
 411         *done = 0;
 412
 413         err = vnic_dev_cmd(vdev, CMD_OPEN_STATUS, &a0, &a1, wait);
 414         if (err)
 415                 return err;
 416
 417         *done = (a0 == 0);
 418
 419         return 0;
 420 }
 421
 422 int vnic_dev_soft_reset(struct vnic_dev *vdev, int arg)
 423 {
 424         u64 a0 = (u32)arg, a1 = 0;
 425         int wait = 1000;
 426         return vnic_dev_cmd(vdev, CMD_SOFT_RESET, &a0, &a1, wait);
 427 }
 428
 429 int vnic_dev_soft_reset_done(struct vnic_dev *vdev, int *done)
 430 {
 431         u64 a0 = 0, a1 = 0;
 432         int wait = 1000;
 433         int err;
 434
 435         *done = 0;
 436
 437         err = vnic_dev_cmd(vdev, CMD_SOFT_RESET_STATUS, &a0, &a1, wait);
 438         if (err)
 439                 return err;
 440
 441         *done = (a0 == 0);
 442
 443         return 0;
 444 }
 445
 446 int vnic_dev_hang_notify(struct vnic_dev *vdev)
 447 {
 448         u64 a0, a1;
 449         int wait = 1000;
 450         return vnic_dev_cmd(vdev, CMD_HANG_NOTIFY, &a0, &a1, wait);
 451 }
 452
 453 int vnic_dev_mac_addr(struct vnic_dev *vdev, u8 *mac_addr)
 454 {
 455         u64 a0, a1;
 456         int wait = 1000;
 457         int err, i;
 458
 459         for (i = 0; i < ETH_ALEN; i++)
 460                 mac_addr[i] = 0;
 461
 462         err = vnic_dev_cmd(vdev, CMD_MAC_ADDR, &a0, &a1, wait);
 463         if (err)
 464                 return err;
 465
 466         for (i = 0; i < ETH_ALEN; i++)
 467                 mac_addr[i] = ((u8 *)&a0)[i];
 468
 469         return 0;
 470 }
 471
 472 void vnic_dev_packet_filter(struct vnic_dev *vdev, int directed, int multicast,
 473         int broadcast, int promisc, int allmulti)
 474 {
 475         u64 a0, a1 = 0;
 476         int wait = 1000;
 477         int err;
 478
 479         a0 = (directed ? CMD_PFILTER_DIRECTED : 0) |
 480              (multicast ? CMD_PFILTER_MULTICAST : 0) |
 481              (broadcast ? CMD_PFILTER_BROADCAST : 0) |
 482              (promisc ? CMD_PFILTER_PROMISCUOUS : 0) |
 483              (allmulti ? CMD_PFILTER_ALL_MULTICAST : 0);
 484
 485         err = vnic_dev_cmd(vdev, CMD_PACKET_FILTER, &a0, &a1, wait);
 486         if (err)
 487                 printk(KERN_ERR "Can't set packet filter\n");
 488 }
 489
 490 void vnic_dev_add_addr(struct vnic_dev *vdev, u8 *addr)
 491 {
 492         u64 a0 = 0, a1 = 0;
 493         int wait = 1000;
 494         int err;
 495         int i;
 496
 497         for (i = 0; i < ETH_ALEN; i++)
 498                 ((u8 *)&a0)[i] = addr[i];
 499
 500         err = vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a0, &a1, wait);
 501         if (err)
 502                 pr_err("Can't add addr [%pM], %d\n", addr, err);
 503 }
 504
 505 void vnic_dev_del_addr(struct vnic_dev *vdev, u8 *addr)
 506 {
 507         u64 a0 = 0, a1 = 0;
 508         int wait = 1000;
 509         int err;
 510         int i;
 511
 512         for (i = 0; i < ETH_ALEN; i++)
 513                 ((u8 *)&a0)[i] = addr[i];
 514
 515         err = vnic_dev_cmd(vdev, CMD_ADDR_DEL, &a0, &a1, wait);
 516         if (err)
 517                 pr_err("Can't del addr [%pM], %d\n", addr, err);
 518 }
 519
 520 int vnic_dev_notify_set(struct vnic_dev *vdev, u16 intr)
 521 {
 522         u64 a0, a1;
 523         int wait = 1000;
 524
 525         if (!vdev->notify) {
 526                 vdev->notify = dma_alloc_coherent(&vdev->pdev->dev,
 527                         sizeof(struct vnic_devcmd_notify),
 528                         &vdev->notify_pa, GFP_KERNEL);
 529                 if (!vdev->notify)
 530                         return -ENOMEM;
 531         }
 532
 533         a0 = vdev->notify_pa;
 534         a1 = ((u64)intr << 32) & 0x0000ffff00000000ULL;
 535         a1 += sizeof(struct vnic_devcmd_notify);
 536
 537         return vnic_dev_cmd(vdev, CMD_NOTIFY, &a0, &a1, wait);
 538 }
 539
 540 void vnic_dev_notify_unset(struct vnic_dev *vdev)
 541 {
 542         u64 a0, a1;
 543         int wait = 1000;
 544
 545         a0 = 0;  /* paddr = 0 to unset notify buffer */
 546         a1 = 0x0000ffff00000000ULL; /* intr num = -1 to unreg for intr */
 547         a1 += sizeof(struct vnic_devcmd_notify);
 548
 549         vnic_dev_cmd(vdev, CMD_NOTIFY, &a0, &a1, wait);
 550 }
 551
 552 static int vnic_dev_notify_ready(struct vnic_dev *vdev)
 553 {
 554         u32 *words;
 555         unsigned int nwords = sizeof(struct vnic_devcmd_notify) / 4;
 556         unsigned int i;
 557         u32 csum;
 558
 559         if (!vdev->notify)
 560                 return 0;
 561
 562         do {
 563                 csum = 0;
 564                 memcpy(&vdev->notify_copy, vdev->notify,
 565                         sizeof(struct vnic_devcmd_notify));
 566                 words = (u32 *)&vdev->notify_copy;
 567                 for (i = 1; i < nwords; i++)
 568                         csum += words[i];
 569         } while (csum != words[0]);
 570
 571         return 1;
 572 }
 573
 574 int vnic_dev_init(struct vnic_dev *vdev, int arg)
 575 {
 576         u64 a0 = (u32)arg, a1 = 0;
 577         int wait = 1000;
 578         return vnic_dev_cmd(vdev, CMD_INIT, &a0, &a1, wait);
 579 }
 580
 581 u16 vnic_dev_set_default_vlan(struct vnic_dev *vdev, u16 new_default_vlan)
 582 {
 583         u64 a0 = new_default_vlan, a1 = 0;
 584         int wait = 1000;
 585         int old_vlan = 0;
 586
 587         old_vlan = vnic_dev_cmd(vdev, CMD_SET_DEFAULT_VLAN, &a0, &a1, wait);
 588         return (u16)old_vlan;
 589 }
 590
 591 int vnic_dev_link_status(struct vnic_dev *vdev)
 592 {
 593         if (vdev->linkstatus)
 594                 return *vdev->linkstatus;
 595
 596         if (!vnic_dev_notify_ready(vdev))
 597                 return 0;
 598
 599         return vdev->notify_copy.link_state;
 600 }
 601
 602 u32 vnic_dev_port_speed(struct vnic_dev *vdev)
 603 {
 604         if (!vnic_dev_notify_ready(vdev))
 605                 return 0;
 606
 607         return vdev->notify_copy.port_speed;
 608 }
 609
 610 u32 vnic_dev_msg_lvl(struct vnic_dev *vdev)
 611 {
 612         if (!vnic_dev_notify_ready(vdev))
 613                 return 0;
 614
 615         return vdev->notify_copy.msglvl;
 616 }
 617
 618 u32 vnic_dev_mtu(struct vnic_dev *vdev)
 619 {
 620         if (!vnic_dev_notify_ready(vdev))
 621                 return 0;
 622
 623         return vdev->notify_copy.mtu;
 624 }
 625
 626 u32 vnic_dev_link_down_cnt(struct vnic_dev *vdev)
 627 {
 628         if (!vnic_dev_notify_ready(vdev))
 629                 return 0;
 630
 631         return vdev->notify_copy.link_down_cnt;
 632 }
 633
 634 void vnic_dev_set_intr_mode(struct vnic_dev *vdev,
 635         enum vnic_dev_intr_mode intr_mode)
 636 {
 637         vdev->intr_mode = intr_mode;
 638 }
 639
 640 enum vnic_dev_intr_mode vnic_dev_get_intr_mode(
 641         struct vnic_dev *vdev)
 642 {
 643         return vdev->intr_mode;
 644 }
 645
 646 void vnic_dev_unregister(struct vnic_dev *vdev)
 647 {
 648         if (vdev) {
 649                 if (vdev->notify)
 650                         dma_free_coherent(&vdev->pdev->dev,
 651                                 sizeof(struct vnic_devcmd_notify),
 652                                 vdev->notify,
 653                                 vdev->notify_pa);
 654                 if (vdev->linkstatus)
 655                         dma_free_coherent(&vdev->pdev->dev,
 656                                 sizeof(u32),
 657                                 vdev->linkstatus,
 658                                 vdev->linkstatus_pa);
 659                 if (vdev->stats)
 660                         dma_free_coherent(&vdev->pdev->dev,
 661                                 sizeof(struct vnic_stats),
 662                                 vdev->stats, vdev->stats_pa);
 663                 if (vdev->fw_info)
 664                         dma_free_coherent(&vdev->pdev->dev,
 665                                 sizeof(struct vnic_devcmd_fw_info),
 666                                 vdev->fw_info, vdev->fw_info_pa);
 667                 kfree(vdev);
 668         }
 669 }
 670
 671 struct vnic_dev *vnic_dev_register(struct vnic_dev *vdev,
 672         void *priv, struct pci_dev *pdev, struct vnic_dev_bar *bar)
 673 {
 674         if (!vdev) {
 675                 vdev = kzalloc(sizeof(struct vnic_dev), GFP_KERNEL);
 676                 if (!vdev)
 677                         return NULL;
 678         }
 679
 680         vdev->priv = priv;
 681         vdev->pdev = pdev;
 682
 683         if (vnic_dev_discover_res(vdev, bar))
 684                 goto err_out;
 685
 686         vdev->devcmd = vnic_dev_get_res(vdev, RES_TYPE_DEVCMD, 0);
 687         if (!vdev->devcmd)
 688                 goto err_out;
 689
 690         return vdev;
 691
 692 err_out:
 693         vnic_dev_unregister(vdev);
 694         return NULL;
 695 }