drivers/misc/bcm-vk/bcm_vk_dev.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright 2018-2020 Broadcom.
   4  */
   5
   6 #include <linux/delay.h>
   7 #include <linux/dma-mapping.h>
   8 #include <linux/firmware.h>
   9 #include <linux/fs.h>
  10 #include <linux/idr.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/panic_notifier.h>
  13 #include <linux/kref.h>
  14 #include <linux/module.h>
  15 #include <linux/mutex.h>
  16 #include <linux/pci.h>
  17 #include <linux/pci_regs.h>
  18 #include <uapi/linux/misc/bcm_vk.h>
  19
  20 #include "bcm_vk.h"
  21
  22 #define PCI_DEVICE_ID_VALKYRIE  0x5e87
  23 #define PCI_DEVICE_ID_VIPER     0x5e88
  24
  25 static DEFINE_IDA(bcm_vk_ida);
  26
  27 enum soc_idx {
  28         VALKYRIE_A0 = 0,
  29         VALKYRIE_B0,
  30         VIPER,
  31         VK_IDX_INVALID
  32 };
  33
  34 enum img_idx {
  35         IMG_PRI = 0,
  36         IMG_SEC,
  37         IMG_PER_TYPE_MAX
  38 };
  39
  40 struct load_image_entry {
  41         const u32 image_type;
  42         const char *image_name[IMG_PER_TYPE_MAX];
  43 };
  44
  45 #define NUM_BOOT_STAGES 2
  46 /* default firmware images names */
  47 static const struct load_image_entry image_tab[][NUM_BOOT_STAGES] = {
  48         [VALKYRIE_A0] = {
  49                 {VK_IMAGE_TYPE_BOOT1, {"vk_a0-boot1.bin", "vk-boot1.bin"}},
  50                 {VK_IMAGE_TYPE_BOOT2, {"vk_a0-boot2.bin", "vk-boot2.bin"}}
  51         },
  52         [VALKYRIE_B0] = {
  53                 {VK_IMAGE_TYPE_BOOT1, {"vk_b0-boot1.bin", "vk-boot1.bin"}},
  54                 {VK_IMAGE_TYPE_BOOT2, {"vk_b0-boot2.bin", "vk-boot2.bin"}}
  55         },
  56
  57         [VIPER] = {
  58                 {VK_IMAGE_TYPE_BOOT1, {"vp-boot1.bin", ""}},
  59                 {VK_IMAGE_TYPE_BOOT2, {"vp-boot2.bin", ""}}
  60         },
  61 };
  62
  63 /* Location of memory base addresses of interest in BAR1 */
  64 /* Load Boot1 to start of ITCM */
  65 #define BAR1_CODEPUSH_BASE_BOOT1        0x100000
  66
  67 /* Allow minimum 1s for Load Image timeout responses */
  68 #define LOAD_IMAGE_TIMEOUT_MS           (1 * MSEC_PER_SEC)
  69
  70 /* Image startup timeouts */
  71 #define BOOT1_STARTUP_TIMEOUT_MS        (5 * MSEC_PER_SEC)
  72 #define BOOT2_STARTUP_TIMEOUT_MS        (10 * MSEC_PER_SEC)
  73
  74 /* 1ms wait for checking the transfer complete status */
  75 #define TXFR_COMPLETE_TIMEOUT_MS        1
  76
  77 /* MSIX usages */
  78 #define VK_MSIX_MSGQ_MAX                3
  79 #define VK_MSIX_NOTF_MAX                1
  80 #define VK_MSIX_TTY_MAX                 BCM_VK_NUM_TTY
  81 #define VK_MSIX_IRQ_MAX                 (VK_MSIX_MSGQ_MAX + VK_MSIX_NOTF_MAX + \
  82                                          VK_MSIX_TTY_MAX)
  83 #define VK_MSIX_IRQ_MIN_REQ             (VK_MSIX_MSGQ_MAX + VK_MSIX_NOTF_MAX)
  84
  85 /* Number of bits set in DMA mask*/
  86 #define BCM_VK_DMA_BITS                 64
  87
  88 /* Ucode boot wait time */
  89 #define BCM_VK_UCODE_BOOT_US            (100 * USEC_PER_MSEC)
  90 /* 50% margin */
  91 #define BCM_VK_UCODE_BOOT_MAX_US        ((BCM_VK_UCODE_BOOT_US * 3) >> 1)
  92
  93 /* deinit time for the card os after receiving doorbell */
  94 #define BCM_VK_DEINIT_TIME_MS           (2 * MSEC_PER_SEC)
  95
  96 /*
  97  * module parameters
  98  */
  99 static bool auto_load = true;
 100 module_param(auto_load, bool, 0444);
 101 MODULE_PARM_DESC(auto_load,
 102                  "Load images automatically at PCIe probe time.\n");
 103 static uint nr_scratch_pages = VK_BAR1_SCRATCH_DEF_NR_PAGES;
 104 module_param(nr_scratch_pages, uint, 0444);
 105 MODULE_PARM_DESC(nr_scratch_pages,
 106                  "Number of pre allocated DMAable coherent pages.\n");
 107 static uint nr_ib_sgl_blk = BCM_VK_DEF_IB_SGL_BLK_LEN;
 108 module_param(nr_ib_sgl_blk, uint, 0444);
 109 MODULE_PARM_DESC(nr_ib_sgl_blk,
 110                  "Number of in-band msg blks for short SGL.\n");
 111
 112 /*
 113  * alerts that could be generated from peer
 114  */
 115 const struct bcm_vk_entry bcm_vk_peer_err[BCM_VK_PEER_ERR_NUM] = {
 116         {ERR_LOG_UECC, ERR_LOG_UECC, "uecc"},
 117         {ERR_LOG_SSIM_BUSY, ERR_LOG_SSIM_BUSY, "ssim_busy"},
 118         {ERR_LOG_AFBC_BUSY, ERR_LOG_AFBC_BUSY, "afbc_busy"},
 119         {ERR_LOG_HIGH_TEMP_ERR, ERR_LOG_HIGH_TEMP_ERR, "high_temp"},
 120         {ERR_LOG_WDOG_TIMEOUT, ERR_LOG_WDOG_TIMEOUT, "wdog_timeout"},
 121         {ERR_LOG_SYS_FAULT, ERR_LOG_SYS_FAULT, "sys_fault"},
 122         {ERR_LOG_RAMDUMP, ERR_LOG_RAMDUMP, "ramdump"},
 123         {ERR_LOG_COP_WDOG_TIMEOUT, ERR_LOG_COP_WDOG_TIMEOUT,
 124          "cop_wdog_timeout"},
 125         {ERR_LOG_MEM_ALLOC_FAIL, ERR_LOG_MEM_ALLOC_FAIL, "malloc_fail warn"},
 126         {ERR_LOG_LOW_TEMP_WARN, ERR_LOG_LOW_TEMP_WARN, "low_temp warn"},
 127         {ERR_LOG_ECC, ERR_LOG_ECC, "ecc"},
 128         {ERR_LOG_IPC_DWN, ERR_LOG_IPC_DWN, "ipc_down"},
 129 };
 130
 131 /* alerts detected by the host */
 132 const struct bcm_vk_entry bcm_vk_host_err[BCM_VK_HOST_ERR_NUM] = {
 133         {ERR_LOG_HOST_PCIE_DWN, ERR_LOG_HOST_PCIE_DWN, "PCIe_down"},
 134         {ERR_LOG_HOST_HB_FAIL, ERR_LOG_HOST_HB_FAIL, "hb_fail"},
 135         {ERR_LOG_HOST_INTF_V_FAIL, ERR_LOG_HOST_INTF_V_FAIL, "intf_ver_fail"},
 136 };
 137
 138 irqreturn_t bcm_vk_notf_irqhandler(int irq, void *dev_id)
 139 {
 140         struct bcm_vk *vk = dev_id;
 141
 142         if (!bcm_vk_drv_access_ok(vk)) {
 143                 dev_err(&vk->pdev->dev,
 144                         "Interrupt %d received when msgq not inited\n", irq);
 145                 goto skip_schedule_work;
 146         }
 147
 148         /* if notification is not pending, set bit and schedule work */
 149         if (test_and_set_bit(BCM_VK_WQ_NOTF_PEND, vk->wq_offload) == 0)
 150                 queue_work(vk->wq_thread, &vk->wq_work);
 151
 152 skip_schedule_work:
 153         return IRQ_HANDLED;
 154 }
 155
 156 static int bcm_vk_intf_ver_chk(struct bcm_vk *vk)
 157 {
 158         struct device *dev = &vk->pdev->dev;
 159         u32 reg;
 160         u16 major, minor;
 161         int ret = 0;
 162
 163         /* read interface register */
 164         reg = vkread32(vk, BAR_0, BAR_INTF_VER);
 165         major = (reg >> BAR_INTF_VER_MAJOR_SHIFT) & BAR_INTF_VER_MASK;
 166         minor = reg & BAR_INTF_VER_MASK;
 167
 168         /*
 169          * if major number is 0, it is pre-release and it would be allowed
 170          * to continue, else, check versions accordingly
 171          */
 172         if (!major) {
 173                 dev_warn(dev, "Pre-release major.minor=%d.%d - drv %d.%d\n",
 174                          major, minor, SEMANTIC_MAJOR, SEMANTIC_MINOR);
 175         } else if (major != SEMANTIC_MAJOR) {
 176                 dev_err(dev,
 177                         "Intf major.minor=%d.%d rejected - drv %d.%d\n",
 178                         major, minor, SEMANTIC_MAJOR, SEMANTIC_MINOR);
 179                 bcm_vk_set_host_alert(vk, ERR_LOG_HOST_INTF_V_FAIL);
 180                 ret = -EPFNOSUPPORT;
 181         } else {
 182                 dev_dbg(dev,
 183                         "Intf major.minor=%d.%d passed - drv %d.%d\n",
 184                         major, minor, SEMANTIC_MAJOR, SEMANTIC_MINOR);
 185         }
 186         return ret;
 187 }
 188
 189 static void bcm_vk_log_notf(struct bcm_vk *vk,
 190                             struct bcm_vk_alert *alert,
 191                             struct bcm_vk_entry const *entry_tab,
 192                             const u32 table_size)
 193 {
 194         u32 i;
 195         u32 masked_val, latched_val;
 196         struct bcm_vk_entry const *entry;
 197         u32 reg;
 198         u16 ecc_mem_err, uecc_mem_err;
 199         struct device *dev = &vk->pdev->dev;
 200
 201         for (i = 0; i < table_size; i++) {
 202                 entry = &entry_tab[i];
 203                 masked_val = entry->mask & alert->notfs;
 204                 latched_val = entry->mask & alert->flags;
 205
 206                 if (masked_val == ERR_LOG_UECC) {
 207                         /*
 208                          * if there is difference between stored cnt and it
 209                          * is greater than threshold, log it.
 210                          */
 211                         reg = vkread32(vk, BAR_0, BAR_CARD_ERR_MEM);
 212                         BCM_VK_EXTRACT_FIELD(uecc_mem_err, reg,
 213                                              BCM_VK_MEM_ERR_FIELD_MASK,
 214                                              BCM_VK_UECC_MEM_ERR_SHIFT);
 215                         if ((uecc_mem_err != vk->alert_cnts.uecc) &&
 216                             (uecc_mem_err >= BCM_VK_UECC_THRESHOLD))
 217                                 dev_info(dev,
 218                                          "ALERT! %s.%d uecc RAISED - ErrCnt %d\n",
 219                                          DRV_MODULE_NAME, vk->devid,
 220                                          uecc_mem_err);
 221                         vk->alert_cnts.uecc = uecc_mem_err;
 222                 } else if (masked_val == ERR_LOG_ECC) {
 223                         reg = vkread32(vk, BAR_0, BAR_CARD_ERR_MEM);
 224                         BCM_VK_EXTRACT_FIELD(ecc_mem_err, reg,
 225                                              BCM_VK_MEM_ERR_FIELD_MASK,
 226                                              BCM_VK_ECC_MEM_ERR_SHIFT);
 227                         if ((ecc_mem_err != vk->alert_cnts.ecc) &&
 228                             (ecc_mem_err >= BCM_VK_ECC_THRESHOLD))
 229                                 dev_info(dev, "ALERT! %s.%d ecc RAISED - ErrCnt %d\n",
 230                                          DRV_MODULE_NAME, vk->devid,
 231                                          ecc_mem_err);
 232                         vk->alert_cnts.ecc = ecc_mem_err;
 233                 } else if (masked_val != latched_val) {
 234                         /* print a log as info */
 235                         dev_info(dev, "ALERT! %s.%d %s %s\n",
 236                                  DRV_MODULE_NAME, vk->devid, entry->str,
 237                                  masked_val ? "RAISED" : "CLEARED");
 238                 }
 239         }
 240 }
 241
 242 static void bcm_vk_dump_peer_log(struct bcm_vk *vk)
 243 {
 244         struct bcm_vk_peer_log log;
 245         struct bcm_vk_peer_log *log_info = &vk->peerlog_info;
 246         char loc_buf[BCM_VK_PEER_LOG_LINE_MAX];
 247         int cnt;
 248         struct device *dev = &vk->pdev->dev;
 249         unsigned int data_offset;
 250
 251         memcpy_fromio(&log, vk->bar[BAR_2] + vk->peerlog_off, sizeof(log));
 252
 253         dev_dbg(dev, "Peer PANIC: Size 0x%x(0x%x), [Rd Wr] = [%d %d]\n",
 254                 log.buf_size, log.mask, log.rd_idx, log.wr_idx);
 255
 256         if (!log_info->buf_size) {
 257                 dev_err(dev, "Peer log dump disabled - skipped!\n");
 258                 return;
 259         }
 260
 261         /* perform range checking for rd/wr idx */
 262         if ((log.rd_idx > log_info->mask) ||
 263             (log.wr_idx > log_info->mask) ||
 264             (log.buf_size != log_info->buf_size) ||
 265             (log.mask != log_info->mask)) {
 266                 dev_err(dev,
 267                         "Corrupted Ptrs: Size 0x%x(0x%x) Mask 0x%x(0x%x) [Rd Wr] = [%d %d], skip log dump.\n",
 268                         log_info->buf_size, log.buf_size,
 269                         log_info->mask, log.mask,
 270                         log.rd_idx, log.wr_idx);
 271                 return;
 272         }
 273
 274         cnt = 0;
 275         data_offset = vk->peerlog_off + sizeof(struct bcm_vk_peer_log);
 276         loc_buf[BCM_VK_PEER_LOG_LINE_MAX - 1] = '\0';
 277         while (log.rd_idx != log.wr_idx) {
 278                 loc_buf[cnt] = vkread8(vk, BAR_2, data_offset + log.rd_idx);
 279
 280                 if ((loc_buf[cnt] == '\0') ||
 281                     (cnt == (BCM_VK_PEER_LOG_LINE_MAX - 1))) {
 282                         dev_err(dev, "%s", loc_buf);
 283                         cnt = 0;
 284                 } else {
 285                         cnt++;
 286                 }
 287                 log.rd_idx = (log.rd_idx + 1) & log.mask;
 288         }
 289         /* update rd idx at the end */
 290         vkwrite32(vk, log.rd_idx, BAR_2,
 291                   vk->peerlog_off + offsetof(struct bcm_vk_peer_log, rd_idx));
 292 }
 293
 294 void bcm_vk_handle_notf(struct bcm_vk *vk)
 295 {
 296         u32 reg;
 297         struct bcm_vk_alert alert;
 298         bool intf_down;
 299         unsigned long flags;
 300
 301         /* handle peer alerts and then locally detected ones */
 302         reg = vkread32(vk, BAR_0, BAR_CARD_ERR_LOG);
 303         intf_down = BCM_VK_INTF_IS_DOWN(reg);
 304         if (!intf_down) {
 305                 vk->peer_alert.notfs = reg;
 306                 bcm_vk_log_notf(vk, &vk->peer_alert, bcm_vk_peer_err,
 307                                 ARRAY_SIZE(bcm_vk_peer_err));
 308                 vk->peer_alert.flags = vk->peer_alert.notfs;
 309         } else {
 310                 /* turn off access */
 311                 bcm_vk_blk_drv_access(vk);
 312         }
 313
 314         /* check and make copy of alert with lock and then free lock */
 315         spin_lock_irqsave(&vk->host_alert_lock, flags);
 316         if (intf_down)
 317                 vk->host_alert.notfs |= ERR_LOG_HOST_PCIE_DWN;
 318
 319         alert = vk->host_alert;
 320         vk->host_alert.flags = vk->host_alert.notfs;
 321         spin_unlock_irqrestore(&vk->host_alert_lock, flags);
 322
 323         /* call display with copy */
 324         bcm_vk_log_notf(vk, &alert, bcm_vk_host_err,
 325                         ARRAY_SIZE(bcm_vk_host_err));
 326
 327         /*
 328          * If it is a sys fault or heartbeat timeout, we would like extract
 329          * log msg from the card so that we would know what is the last fault
 330          */
 331         if (!intf_down &&
 332             ((vk->host_alert.flags & ERR_LOG_HOST_HB_FAIL) ||
 333              (vk->peer_alert.flags & ERR_LOG_SYS_FAULT)))
 334                 bcm_vk_dump_peer_log(vk);
 335 }
 336
 337 static inline int bcm_vk_wait(struct bcm_vk *vk, enum pci_barno bar,
 338                               u64 offset, u32 mask, u32 value,
 339                               unsigned long timeout_ms)
 340 {
 341         struct device *dev = &vk->pdev->dev;
 342         unsigned long start_time;
 343         unsigned long timeout;
 344         u32 rd_val, boot_status;
 345
 346         start_time = jiffies;
 347         timeout = start_time + msecs_to_jiffies(timeout_ms);
 348
 349         do {
 350                 rd_val = vkread32(vk, bar, offset);
 351                 dev_dbg(dev, "BAR%d Offset=0x%llx: 0x%x\n",
 352                         bar, offset, rd_val);
 353
 354                 /* check for any boot err condition */
 355                 boot_status = vkread32(vk, BAR_0, BAR_BOOT_STATUS);
 356                 if (boot_status & BOOT_ERR_MASK) {
 357                         dev_err(dev, "Boot Err 0x%x, progress 0x%x after %d ms\n",
 358                                 (boot_status & BOOT_ERR_MASK) >> BOOT_ERR_SHIFT,
 359                                 boot_status & BOOT_PROG_MASK,
 360                                 jiffies_to_msecs(jiffies - start_time));
 361                         return -EFAULT;
 362                 }
 363
 364                 if (time_after(jiffies, timeout))
 365                         return -ETIMEDOUT;
 366
 367                 cpu_relax();
 368                 cond_resched();
 369         } while ((rd_val & mask) != value);
 370
 371         return 0;
 372 }
 373
 374 static void bcm_vk_get_card_info(struct bcm_vk *vk)
 375 {
 376         struct device *dev = &vk->pdev->dev;
 377         u32 offset;
 378         int i;
 379         u8 *dst;
 380         struct bcm_vk_card_info *info = &vk->card_info;
 381
 382         /* first read the offset from spare register */
 383         offset = vkread32(vk, BAR_0, BAR_CARD_STATIC_INFO);
 384         offset &= (pci_resource_len(vk->pdev, BAR_2 * 2) - 1);
 385
 386         /* based on the offset, read info to internal card info structure */
 387         dst = (u8 *)info;
 388         for (i = 0; i < sizeof(*info); i++)
 389                 *dst++ = vkread8(vk, BAR_2, offset++);
 390
 391 #define CARD_INFO_LOG_FMT "version   : %x\n" \
 392                           "os_tag    : %s\n" \
 393                           "cmpt_tag  : %s\n" \
 394                           "cpu_freq  : %d MHz\n" \
 395                           "cpu_scale : %d full, %d lowest\n" \
 396                           "ddr_freq  : %d MHz\n" \
 397                           "ddr_size  : %d MB\n" \
 398                           "video_freq: %d MHz\n"
 399         dev_dbg(dev, CARD_INFO_LOG_FMT, info->version, info->os_tag,
 400                 info->cmpt_tag, info->cpu_freq_mhz, info->cpu_scale[0],
 401                 info->cpu_scale[MAX_OPP - 1], info->ddr_freq_mhz,
 402                 info->ddr_size_MB, info->video_core_freq_mhz);
 403
 404         /*
 405          * get the peer log pointer, only need the offset, and get record
 406          * of the log buffer information which would be used for checking
 407          * before dump, in case the BAR2 memory has been corrupted.
 408          */
 409         vk->peerlog_off = offset;
 410         memcpy_fromio(&vk->peerlog_info, vk->bar[BAR_2] + vk->peerlog_off,
 411                       sizeof(vk->peerlog_info));
 412
 413         /*
 414          * Do a range checking and if out of bound, the record will be zeroed
 415          * which guarantees that nothing would be dumped.  In other words,
 416          * peer dump is disabled.
 417          */
 418         if ((vk->peerlog_info.buf_size > BCM_VK_PEER_LOG_BUF_MAX) ||
 419             (vk->peerlog_info.mask != (vk->peerlog_info.buf_size - 1)) ||
 420             (vk->peerlog_info.rd_idx > vk->peerlog_info.mask) ||
 421             (vk->peerlog_info.wr_idx > vk->peerlog_info.mask)) {
 422                 dev_err(dev, "Peer log disabled - range error: Size 0x%x(0x%x), [Rd Wr] = [%d %d]\n",
 423                         vk->peerlog_info.buf_size,
 424                         vk->peerlog_info.mask,
 425                         vk->peerlog_info.rd_idx,
 426                         vk->peerlog_info.wr_idx);
 427                 memset(&vk->peerlog_info, 0, sizeof(vk->peerlog_info));
 428         } else {
 429                 dev_dbg(dev, "Peer log: Size 0x%x(0x%x), [Rd Wr] = [%d %d]\n",
 430                         vk->peerlog_info.buf_size,
 431                         vk->peerlog_info.mask,
 432                         vk->peerlog_info.rd_idx,
 433                         vk->peerlog_info.wr_idx);
 434         }
 435 }
 436
 437 static void bcm_vk_get_proc_mon_info(struct bcm_vk *vk)
 438 {
 439         struct device *dev = &vk->pdev->dev;
 440         struct bcm_vk_proc_mon_info *mon = &vk->proc_mon_info;
 441         u32 num, entry_size, offset, buf_size;
 442         u8 *dst;
 443
 444         /* calculate offset which is based on peerlog offset */
 445         buf_size = vkread32(vk, BAR_2,
 446                             vk->peerlog_off
 447                             + offsetof(struct bcm_vk_peer_log, buf_size));
 448         offset = vk->peerlog_off + sizeof(struct bcm_vk_peer_log)
 449                  + buf_size;
 450
 451         /* first read the num and entry size */
 452         num = vkread32(vk, BAR_2, offset);
 453         entry_size = vkread32(vk, BAR_2, offset + sizeof(num));
 454
 455         /* check for max allowed */
 456         if (num > BCM_VK_PROC_MON_MAX) {
 457                 dev_err(dev, "Processing monitoring entry %d exceeds max %d\n",
 458                         num, BCM_VK_PROC_MON_MAX);
 459                 return;
 460         }
 461         mon->num = num;
 462         mon->entry_size = entry_size;
 463
 464         vk->proc_mon_off = offset;
 465
 466         /* read it once that will capture those static info */
 467         dst = (u8 *)&mon->entries[0];
 468         offset += sizeof(num) + sizeof(entry_size);
 469         memcpy_fromio(dst, vk->bar[BAR_2] + offset, num * entry_size);
 470 }
 471
 472 static int bcm_vk_sync_card_info(struct bcm_vk *vk)
 473 {
 474         u32 rdy_marker = vkread32(vk, BAR_1, VK_BAR1_MSGQ_DEF_RDY);
 475
 476         /* check for marker, but allow diags mode to skip sync */
 477         if (!bcm_vk_msgq_marker_valid(vk))
 478                 return (rdy_marker == VK_BAR1_DIAG_RDY_MARKER ? 0 : -EINVAL);
 479
 480         /*
 481          * Write down scratch addr which is used for DMA. For
 482          * signed part, BAR1 is accessible only after boot2 has come
 483          * up
 484          */
 485         if (vk->tdma_addr) {
 486                 vkwrite32(vk, (u64)vk->tdma_addr >> 32, BAR_1,
 487                           VK_BAR1_SCRATCH_OFF_HI);
 488                 vkwrite32(vk, (u32)vk->tdma_addr, BAR_1,
 489                           VK_BAR1_SCRATCH_OFF_LO);
 490                 vkwrite32(vk, nr_scratch_pages * PAGE_SIZE, BAR_1,
 491                           VK_BAR1_SCRATCH_SZ_ADDR);
 492         }
 493
 494         /* get static card info, only need to read once */
 495         bcm_vk_get_card_info(vk);
 496
 497         /* get the proc mon info once */
 498         bcm_vk_get_proc_mon_info(vk);
 499
 500         return 0;
 501 }
 502
 503 void bcm_vk_blk_drv_access(struct bcm_vk *vk)
 504 {
 505         int i;
 506
 507         /*
 508          * kill all the apps except for the process that is resetting.
 509          * If not called during reset, reset_pid will be 0, and all will be
 510          * killed.
 511          */
 512         spin_lock(&vk->ctx_lock);
 513
 514         /* set msgq_inited to 0 so that all rd/wr will be blocked */
 515         atomic_set(&vk->msgq_inited, 0);
 516
 517         for (i = 0; i < VK_PID_HT_SZ; i++) {
 518                 struct bcm_vk_ctx *ctx;
 519
 520                 list_for_each_entry(ctx, &vk->pid_ht[i].head, node) {
 521                         if (ctx->pid != vk->reset_pid) {
 522                                 dev_dbg(&vk->pdev->dev,
 523                                         "Send kill signal to pid %d\n",
 524                                         ctx->pid);
 525                                 kill_pid(find_vpid(ctx->pid), SIGKILL, 1);
 526                         }
 527                 }
 528         }
 529         bcm_vk_tty_terminate_tty_user(vk);
 530         spin_unlock(&vk->ctx_lock);
 531 }
 532
 533 static void bcm_vk_buf_notify(struct bcm_vk *vk, void *bufp,
 534                               dma_addr_t host_buf_addr, u32 buf_size)
 535 {
 536         /* update the dma address to the card */
 537         vkwrite32(vk, (u64)host_buf_addr >> 32, BAR_1,
 538                   VK_BAR1_DMA_BUF_OFF_HI);
 539         vkwrite32(vk, (u32)host_buf_addr, BAR_1,
 540                   VK_BAR1_DMA_BUF_OFF_LO);
 541         vkwrite32(vk, buf_size, BAR_1, VK_BAR1_DMA_BUF_SZ);
 542 }
 543
 544 static int bcm_vk_load_image_by_type(struct bcm_vk *vk, u32 load_type,
 545                                      const char *filename)
 546 {
 547         struct device *dev = &vk->pdev->dev;
 548         const struct firmware *fw = NULL;
 549         void *bufp = NULL;
 550         size_t max_buf, offset;
 551         int ret;
 552         u64 offset_codepush;
 553         u32 codepush;
 554         u32 value;
 555         dma_addr_t boot_dma_addr;
 556         bool is_stdalone;
 557
 558         if (load_type == VK_IMAGE_TYPE_BOOT1) {
 559                 /*
 560                  * After POR, enable VK soft BOOTSRC so bootrom do not clear
 561                  * the pushed image (the TCM memories).
 562                  */
 563                 value = vkread32(vk, BAR_0, BAR_BOOTSRC_SELECT);
 564                 value |= BOOTSRC_SOFT_ENABLE;
 565                 vkwrite32(vk, value, BAR_0, BAR_BOOTSRC_SELECT);
 566
 567                 codepush = CODEPUSH_BOOTSTART + CODEPUSH_BOOT1_ENTRY;
 568                 offset_codepush = BAR_CODEPUSH_SBL;
 569
 570                 /* Write a 1 to request SRAM open bit */
 571                 vkwrite32(vk, CODEPUSH_BOOTSTART, BAR_0, offset_codepush);
 572
 573                 /* Wait for VK to respond */
 574                 ret = bcm_vk_wait(vk, BAR_0, BAR_BOOT_STATUS, SRAM_OPEN,
 575                                   SRAM_OPEN, LOAD_IMAGE_TIMEOUT_MS);
 576                 if (ret < 0) {
 577                         dev_err(dev, "boot1 wait SRAM err - ret(%d)\n", ret);
 578                         goto err_buf_out;
 579                 }
 580
 581                 max_buf = SZ_256K;
 582                 bufp = dma_alloc_coherent(dev,
 583                                           max_buf,
 584                                           &boot_dma_addr, GFP_KERNEL);
 585                 if (!bufp) {
 586                         dev_err(dev, "Error allocating 0x%zx\n", max_buf);
 587                         ret = -ENOMEM;
 588                         goto err_buf_out;
 589                 }
 590         } else if (load_type == VK_IMAGE_TYPE_BOOT2) {
 591                 codepush = CODEPUSH_BOOT2_ENTRY;
 592                 offset_codepush = BAR_CODEPUSH_SBI;
 593
 594                 /* Wait for VK to respond */
 595                 ret = bcm_vk_wait(vk, BAR_0, BAR_BOOT_STATUS, DDR_OPEN,
 596                                   DDR_OPEN, LOAD_IMAGE_TIMEOUT_MS);
 597                 if (ret < 0) {
 598                         dev_err(dev, "boot2 wait DDR open error - ret(%d)\n",
 599                                 ret);
 600                         goto err_buf_out;
 601                 }
 602
 603                 max_buf = SZ_4M;
 604                 bufp = dma_alloc_coherent(dev,
 605                                           max_buf,
 606                                           &boot_dma_addr, GFP_KERNEL);
 607                 if (!bufp) {
 608                         dev_err(dev, "Error allocating 0x%zx\n", max_buf);
 609                         ret = -ENOMEM;
 610                         goto err_buf_out;
 611                 }
 612
 613                 bcm_vk_buf_notify(vk, bufp, boot_dma_addr, max_buf);
 614         } else {
 615                 dev_err(dev, "Error invalid image type 0x%x\n", load_type);
 616                 ret = -EINVAL;
 617                 goto err_buf_out;
 618         }
 619
 620         offset = 0;
 621         ret = request_partial_firmware_into_buf(&fw, filename, dev,
 622                                                 bufp, max_buf, offset);
 623         if (ret) {
 624                 dev_err(dev, "Error %d requesting firmware file: %s\n",
 625                         ret, filename);
 626                 goto err_firmware_out;
 627         }
 628         dev_dbg(dev, "size=0x%zx\n", fw->size);
 629         if (load_type == VK_IMAGE_TYPE_BOOT1)
 630                 memcpy_toio(vk->bar[BAR_1] + BAR1_CODEPUSH_BASE_BOOT1,
 631                             bufp,
 632                             fw->size);
 633
 634         dev_dbg(dev, "Signaling 0x%x to 0x%llx\n", codepush, offset_codepush);
 635         vkwrite32(vk, codepush, BAR_0, offset_codepush);
 636
 637         if (load_type == VK_IMAGE_TYPE_BOOT1) {
 638                 u32 boot_status;
 639
 640                 /* wait until done */
 641                 ret = bcm_vk_wait(vk, BAR_0, BAR_BOOT_STATUS,
 642                                   BOOT1_RUNNING,
 643                                   BOOT1_RUNNING,
 644                                   BOOT1_STARTUP_TIMEOUT_MS);
 645
 646                 boot_status = vkread32(vk, BAR_0, BAR_BOOT_STATUS);
 647                 is_stdalone = !BCM_VK_INTF_IS_DOWN(boot_status) &&
 648                               (boot_status & BOOT_STDALONE_RUNNING);
 649                 if (ret && !is_stdalone) {
 650                         dev_err(dev,
 651                                 "Timeout %ld ms waiting for boot1 to come up - ret(%d)\n",
 652                                 BOOT1_STARTUP_TIMEOUT_MS, ret);
 653                         goto err_firmware_out;
 654                 } else if (is_stdalone) {
 655                         u32 reg;
 656
 657                         reg = vkread32(vk, BAR_0, BAR_BOOT1_STDALONE_PROGRESS);
 658                         if ((reg & BOOT1_STDALONE_PROGRESS_MASK) ==
 659                                      BOOT1_STDALONE_SUCCESS) {
 660                                 dev_info(dev, "Boot1 standalone success\n");
 661                                 ret = 0;
 662                         } else {
 663                                 dev_err(dev, "Timeout %ld ms - Boot1 standalone failure\n",
 664                                         BOOT1_STARTUP_TIMEOUT_MS);
 665                                 ret = -EINVAL;
 666                                 goto err_firmware_out;
 667                         }
 668                 }
 669         } else if (load_type == VK_IMAGE_TYPE_BOOT2) {
 670                 unsigned long timeout;
 671
 672                 timeout = jiffies + msecs_to_jiffies(LOAD_IMAGE_TIMEOUT_MS);
 673
 674                 /* To send more data to VK than max_buf allowed at a time */
 675                 do {
 676                         /*
 677                          * Check for ack from card. when Ack is received,
 678                          * it means all the data is received by card.
 679                          * Exit the loop after ack is received.
 680                          */
 681                         ret = bcm_vk_wait(vk, BAR_0, BAR_BOOT_STATUS,
 682                                           FW_LOADER_ACK_RCVD_ALL_DATA,
 683                                           FW_LOADER_ACK_RCVD_ALL_DATA,
 684                                           TXFR_COMPLETE_TIMEOUT_MS);
 685                         if (ret == 0) {
 686                                 dev_dbg(dev, "Exit boot2 download\n");
 687                                 break;
 688                         } else if (ret == -EFAULT) {
 689                                 dev_err(dev, "Error detected during ACK waiting");
 690                                 goto err_firmware_out;
 691                         }
 692
 693                         /* exit the loop, if there is no response from card */
 694                         if (time_after(jiffies, timeout)) {
 695                                 dev_err(dev, "Error. No reply from card\n");
 696                                 ret = -ETIMEDOUT;
 697                                 goto err_firmware_out;
 698                         }
 699
 700                         /* Wait for VK to open BAR space to copy new data */
 701                         ret = bcm_vk_wait(vk, BAR_0, offset_codepush,
 702                                           codepush, 0,
 703                                           TXFR_COMPLETE_TIMEOUT_MS);
 704                         if (ret == 0) {
 705                                 offset += max_buf;
 706                                 ret = request_partial_firmware_into_buf
 707                                                 (&fw,
 708                                                  filename,
 709                                                  dev, bufp,
 710                                                  max_buf,
 711                                                  offset);
 712                                 if (ret) {
 713                                         dev_err(dev,
 714                                                 "Error %d requesting firmware file: %s offset: 0x%zx\n",
 715                                                 ret, filename, offset);
 716                                         goto err_firmware_out;
 717                                 }
 718                                 dev_dbg(dev, "size=0x%zx\n", fw->size);
 719                                 dev_dbg(dev, "Signaling 0x%x to 0x%llx\n",
 720                                         codepush, offset_codepush);
 721                                 vkwrite32(vk, codepush, BAR_0, offset_codepush);
 722                                 /* reload timeout after every codepush */
 723                                 timeout = jiffies +
 724                                     msecs_to_jiffies(LOAD_IMAGE_TIMEOUT_MS);
 725                         } else if (ret == -EFAULT) {
 726                                 dev_err(dev, "Error detected waiting for transfer\n");
 727                                 goto err_firmware_out;
 728                         }
 729                 } while (1);
 730
 731                 /* wait for fw status bits to indicate app ready */
 732                 ret = bcm_vk_wait(vk, BAR_0, VK_BAR_FWSTS,
 733                                   VK_FWSTS_READY,
 734                                   VK_FWSTS_READY,
 735                                   BOOT2_STARTUP_TIMEOUT_MS);
 736                 if (ret < 0) {
 737                         dev_err(dev, "Boot2 not ready - ret(%d)\n", ret);
 738                         goto err_firmware_out;
 739                 }
 740
 741                 is_stdalone = vkread32(vk, BAR_0, BAR_BOOT_STATUS) &
 742                               BOOT_STDALONE_RUNNING;
 743                 if (!is_stdalone) {
 744                         ret = bcm_vk_intf_ver_chk(vk);
 745                         if (ret) {
 746                                 dev_err(dev, "failure in intf version check\n");
 747                                 goto err_firmware_out;
 748                         }
 749
 750                         /*
 751                          * Next, initialize Message Q if we are loading boot2.
 752                          * Do a force sync
 753                          */
 754                         ret = bcm_vk_sync_msgq(vk, true);
 755                         if (ret) {
 756                                 dev_err(dev, "Boot2 Error reading comm msg Q info\n");
 757                                 ret = -EIO;
 758                                 goto err_firmware_out;
 759                         }
 760
 761                         /* sync & channel other info */
 762                         ret = bcm_vk_sync_card_info(vk);
 763                         if (ret) {
 764                                 dev_err(dev, "Syncing Card Info failure\n");
 765                                 goto err_firmware_out;
 766                         }
 767                 }
 768         }
 769
 770 err_firmware_out:
 771         release_firmware(fw);
 772
 773 err_buf_out:
 774         if (bufp)
 775                 dma_free_coherent(dev, max_buf, bufp, boot_dma_addr);
 776
 777         return ret;
 778 }
 779
 780 static u32 bcm_vk_next_boot_image(struct bcm_vk *vk)
 781 {
 782         u32 boot_status;
 783         u32 fw_status;
 784         u32 load_type = 0;  /* default for unknown */
 785
 786         boot_status = vkread32(vk, BAR_0, BAR_BOOT_STATUS);
 787         fw_status = vkread32(vk, BAR_0, VK_BAR_FWSTS);
 788
 789         if (!BCM_VK_INTF_IS_DOWN(boot_status) && (boot_status & SRAM_OPEN))
 790                 load_type = VK_IMAGE_TYPE_BOOT1;
 791         else if (boot_status == BOOT1_RUNNING)
 792                 load_type = VK_IMAGE_TYPE_BOOT2;
 793
 794         /* Log status so that we know different stages */
 795         dev_info(&vk->pdev->dev,
 796                  "boot-status value for next image: 0x%x : fw-status 0x%x\n",
 797                  boot_status, fw_status);
 798
 799         return load_type;
 800 }
 801
 802 static enum soc_idx get_soc_idx(struct bcm_vk *vk)
 803 {
 804         struct pci_dev *pdev = vk->pdev;
 805         enum soc_idx idx = VK_IDX_INVALID;
 806         u32 rev;
 807         static enum soc_idx const vk_soc_tab[] = { VALKYRIE_A0, VALKYRIE_B0 };
 808
 809         switch (pdev->device) {
 810         case PCI_DEVICE_ID_VALKYRIE:
 811                 /* get the chip id to decide sub-class */
 812                 rev = MAJOR_SOC_REV(vkread32(vk, BAR_0, BAR_CHIP_ID));
 813                 if (rev < ARRAY_SIZE(vk_soc_tab)) {
 814                         idx = vk_soc_tab[rev];
 815                 } else {
 816                         /* Default to A0 firmware for all other chip revs */
 817                         idx = VALKYRIE_A0;
 818                         dev_warn(&pdev->dev,
 819                                  "Rev %d not in image lookup table, default to idx=%d\n",
 820                                  rev, idx);
 821                 }
 822                 break;
 823
 824         case PCI_DEVICE_ID_VIPER:
 825                 idx = VIPER;
 826                 break;
 827
 828         default:
 829                 dev_err(&pdev->dev, "no images for 0x%x\n", pdev->device);
 830         }
 831         return idx;
 832 }
 833
 834 static const char *get_load_fw_name(struct bcm_vk *vk,
 835                                     const struct load_image_entry *entry)
 836 {
 837         const struct firmware *fw;
 838         struct device *dev = &vk->pdev->dev;
 839         int ret;
 840         unsigned long dummy;
 841         int i;
 842
 843         for (i = 0; i < IMG_PER_TYPE_MAX; i++) {
 844                 fw = NULL;
 845                 ret = request_partial_firmware_into_buf(&fw,
 846                                                         entry->image_name[i],
 847                                                         dev, &dummy,
 848                                                         sizeof(dummy),
 849                                                         0);
 850                 release_firmware(fw);
 851                 if (!ret)
 852                         return entry->image_name[i];
 853         }
 854         return NULL;
 855 }
 856
 857 int bcm_vk_auto_load_all_images(struct bcm_vk *vk)
 858 {
 859         int i, ret = -1;
 860         enum soc_idx idx;
 861         struct device *dev = &vk->pdev->dev;
 862         u32 curr_type;
 863         const char *curr_name;
 864
 865         idx = get_soc_idx(vk);
 866         if (idx == VK_IDX_INVALID)
 867                 goto auto_load_all_exit;
 868
 869         /* log a message to know the relative loading order */
 870         dev_dbg(dev, "Load All for device %d\n", vk->devid);
 871
 872         for (i = 0; i < NUM_BOOT_STAGES; i++) {
 873                 curr_type = image_tab[idx][i].image_type;
 874                 if (bcm_vk_next_boot_image(vk) == curr_type) {
 875                         curr_name = get_load_fw_name(vk, &image_tab[idx][i]);
 876                         if (!curr_name) {
 877                                 dev_err(dev, "No suitable firmware exists for type %d",
 878                                         curr_type);
 879                                 ret = -ENOENT;
 880                                 goto auto_load_all_exit;
 881                         }
 882                         ret = bcm_vk_load_image_by_type(vk, curr_type,
 883                                                         curr_name);
 884                         dev_info(dev, "Auto load %s, ret %d\n",
 885                                  curr_name, ret);
 886
 887                         if (ret) {
 888                                 dev_err(dev, "Error loading default %s\n",
 889                                         curr_name);
 890                                 goto auto_load_all_exit;
 891                         }
 892                 }
 893         }
 894
 895 auto_load_all_exit:
 896         return ret;
 897 }
 898
 899 static int bcm_vk_trigger_autoload(struct bcm_vk *vk)
 900 {
 901         if (test_and_set_bit(BCM_VK_WQ_DWNLD_PEND, vk->wq_offload) != 0)
 902                 return -EPERM;
 903
 904         set_bit(BCM_VK_WQ_DWNLD_AUTO, vk->wq_offload);
 905         queue_work(vk->wq_thread, &vk->wq_work);
 906
 907         return 0;
 908 }
 909
 910 /*
 911  * deferred work queue for draining and auto download.
 912  */
 913 static void bcm_vk_wq_handler(struct work_struct *work)
 914 {
 915         struct bcm_vk *vk = container_of(work, struct bcm_vk, wq_work);
 916         struct device *dev = &vk->pdev->dev;
 917         s32 ret;
 918
 919         /* check wq offload bit map to perform various operations */
 920         if (test_bit(BCM_VK_WQ_NOTF_PEND, vk->wq_offload)) {
 921                 /* clear bit right the way for notification */
 922                 clear_bit(BCM_VK_WQ_NOTF_PEND, vk->wq_offload);
 923                 bcm_vk_handle_notf(vk);
 924         }
 925         if (test_bit(BCM_VK_WQ_DWNLD_AUTO, vk->wq_offload)) {
 926                 bcm_vk_auto_load_all_images(vk);
 927
 928                 /*
 929                  * at the end of operation, clear AUTO bit and pending
 930                  * bit
 931                  */
 932                 clear_bit(BCM_VK_WQ_DWNLD_AUTO, vk->wq_offload);
 933                 clear_bit(BCM_VK_WQ_DWNLD_PEND, vk->wq_offload);
 934         }
 935
 936         /* next, try to drain */
 937         ret = bcm_to_h_msg_dequeue(vk);
 938
 939         if (ret == 0)
 940                 dev_dbg(dev, "Spurious trigger for workqueue\n");
 941         else if (ret < 0)
 942                 bcm_vk_blk_drv_access(vk);
 943 }
 944
 945 static long bcm_vk_load_image(struct bcm_vk *vk,
 946                               const struct vk_image __user *arg)
 947 {
 948         struct device *dev = &vk->pdev->dev;
 949         const char *image_name;
 950         struct vk_image image;
 951         u32 next_loadable;
 952         enum soc_idx idx;
 953         int image_idx;
 954         int ret = -EPERM;
 955
 956         if (copy_from_user(&image, arg, sizeof(image)))
 957                 return -EACCES;
 958
 959         if ((image.type != VK_IMAGE_TYPE_BOOT1) &&
 960             (image.type != VK_IMAGE_TYPE_BOOT2)) {
 961                 dev_err(dev, "invalid image.type %u\n", image.type);
 962                 return ret;
 963         }
 964
 965         next_loadable = bcm_vk_next_boot_image(vk);
 966         if (next_loadable != image.type) {
 967                 dev_err(dev, "Next expected image %u, Loading %u\n",
 968                         next_loadable, image.type);
 969                 return ret;
 970         }
 971
 972         /*
 973          * if something is pending download already.  This could only happen
 974          * for now when the driver is being loaded, or if someone has issued
 975          * another download command in another shell.
 976          */
 977         if (test_and_set_bit(BCM_VK_WQ_DWNLD_PEND, vk->wq_offload) != 0) {
 978                 dev_err(dev, "Download operation already pending.\n");
 979                 return ret;
 980         }
 981
 982         image_name = image.filename;
 983         if (image_name[0] == '\0') {
 984                 /* Use default image name if NULL */
 985                 idx = get_soc_idx(vk);
 986                 if (idx == VK_IDX_INVALID)
 987                         goto err_idx;
 988
 989                 /* Image idx starts with boot1 */
 990                 image_idx = image.type - VK_IMAGE_TYPE_BOOT1;
 991                 image_name = get_load_fw_name(vk, &image_tab[idx][image_idx]);
 992                 if (!image_name) {
 993                         dev_err(dev, "No suitable image found for type %d",
 994                                 image.type);
 995                         ret = -ENOENT;
 996                         goto err_idx;
 997                 }
 998         } else {
 999                 /* Ensure filename is NULL terminated */
1000                 image.filename[sizeof(image.filename) - 1] = '\0';
1001         }
1002         ret = bcm_vk_load_image_by_type(vk, image.type, image_name);
1003         dev_info(dev, "Load %s, ret %d\n", image_name, ret);
1004 err_idx:
1005         clear_bit(BCM_VK_WQ_DWNLD_PEND, vk->wq_offload);
1006
1007         return ret;
1008 }
1009
1010 static int bcm_vk_reset_successful(struct bcm_vk *vk)
1011 {
1012         struct device *dev = &vk->pdev->dev;
1013         u32 fw_status, reset_reason;
1014         int ret = -EAGAIN;
1015
1016         /*
1017          * Reset could be triggered when the card in several state:
1018          *   i)   in bootROM
1019          *   ii)  after boot1
1020          *   iii) boot2 running
1021          *
1022          * i) & ii) - no status bits will be updated.  If vkboot1
1023          * runs automatically after reset, it  will update the reason
1024          * to be unknown reason
1025          * iii) - reboot reason match + deinit done.
1026          */
1027         fw_status = vkread32(vk, BAR_0, VK_BAR_FWSTS);
1028         /* immediate exit if interface goes down */
1029         if (BCM_VK_INTF_IS_DOWN(fw_status)) {
1030                 dev_err(dev, "PCIe Intf Down!\n");
1031                 goto reset_exit;
1032         }
1033
1034         reset_reason = (fw_status & VK_FWSTS_RESET_REASON_MASK);
1035         if ((reset_reason == VK_FWSTS_RESET_MBOX_DB) ||
1036             (reset_reason == VK_FWSTS_RESET_UNKNOWN))
1037                 ret = 0;
1038
1039         /*
1040          * if some of the deinit bits are set, but done
1041          * bit is not, this is a failure if triggered while boot2 is running
1042          */
1043         if ((fw_status & VK_FWSTS_DEINIT_TRIGGERED) &&
1044             !(fw_status & VK_FWSTS_RESET_DONE))
1045                 ret = -EAGAIN;
1046
1047 reset_exit:
1048         dev_dbg(dev, "FW status = 0x%x ret %d\n", fw_status, ret);
1049
1050         return ret;
1051 }
1052
1053 static void bcm_to_v_reset_doorbell(struct bcm_vk *vk, u32 db_val)
1054 {
1055         vkwrite32(vk, db_val, BAR_0, VK_BAR0_RESET_DB_BASE);
1056 }
1057
1058 static int bcm_vk_trigger_reset(struct bcm_vk *vk)
1059 {
1060         u32 i;
1061         u32 value, boot_status;
1062         bool is_stdalone, is_boot2;
1063         static const u32 bar0_reg_clr_list[] = { BAR_OS_UPTIME,
1064                                                  BAR_INTF_VER,
1065                                                  BAR_CARD_VOLTAGE,
1066                                                  BAR_CARD_TEMPERATURE,
1067                                                  BAR_CARD_PWR_AND_THRE };
1068
1069         /* clean up before pressing the door bell */
1070         bcm_vk_drain_msg_on_reset(vk);
1071         vkwrite32(vk, 0, BAR_1, VK_BAR1_MSGQ_DEF_RDY);
1072         /* make tag '\0' terminated */
1073         vkwrite32(vk, 0, BAR_1, VK_BAR1_BOOT1_VER_TAG);
1074
1075         for (i = 0; i < VK_BAR1_DAUTH_MAX; i++) {
1076                 vkwrite32(vk, 0, BAR_1, VK_BAR1_DAUTH_STORE_ADDR(i));
1077                 vkwrite32(vk, 0, BAR_1, VK_BAR1_DAUTH_VALID_ADDR(i));
1078         }
1079         for (i = 0; i < VK_BAR1_SOTP_REVID_MAX; i++)
1080                 vkwrite32(vk, 0, BAR_1, VK_BAR1_SOTP_REVID_ADDR(i));
1081
1082         memset(&vk->card_info, 0, sizeof(vk->card_info));
1083         memset(&vk->peerlog_info, 0, sizeof(vk->peerlog_info));
1084         memset(&vk->proc_mon_info, 0, sizeof(vk->proc_mon_info));
1085         memset(&vk->alert_cnts, 0, sizeof(vk->alert_cnts));
1086
1087         /*
1088          * When boot request fails, the CODE_PUSH_OFFSET stays persistent.
1089          * Allowing us to debug the failure. When we call reset,
1090          * we should clear CODE_PUSH_OFFSET so ROM does not execute
1091          * boot again (and fails again) and instead waits for a new
1092          * codepush.  And, if previous boot has encountered error, need
1093          * to clear the entry values
1094          */
1095         boot_status = vkread32(vk, BAR_0, BAR_BOOT_STATUS);
1096         if (boot_status & BOOT_ERR_MASK) {
1097                 dev_info(&vk->pdev->dev,
1098                          "Card in boot error 0x%x, clear CODEPUSH val\n",
1099                          boot_status);
1100                 value = 0;
1101         } else {
1102                 value = vkread32(vk, BAR_0, BAR_CODEPUSH_SBL);
1103                 value &= CODEPUSH_MASK;
1104         }
1105         vkwrite32(vk, value, BAR_0, BAR_CODEPUSH_SBL);
1106
1107         /* special reset handling */
1108         is_stdalone = boot_status & BOOT_STDALONE_RUNNING;
1109         is_boot2 = (boot_status & BOOT_STATE_MASK) == BOOT2_RUNNING;
1110         if (vk->peer_alert.flags & ERR_LOG_RAMDUMP) {
1111                 /*
1112                  * if card is in ramdump mode, it is hitting an error.  Don't
1113                  * reset the reboot reason as it will contain valid info that
1114                  * is important - simply use special reset
1115                  */
1116                 vkwrite32(vk, VK_BAR0_RESET_RAMPDUMP, BAR_0, VK_BAR_FWSTS);
1117                 return VK_BAR0_RESET_RAMPDUMP;
1118         } else if (is_stdalone && !is_boot2) {
1119                 dev_info(&vk->pdev->dev, "Hard reset on Standalone mode");
1120                 bcm_to_v_reset_doorbell(vk, VK_BAR0_RESET_DB_HARD);
1121                 return VK_BAR0_RESET_DB_HARD;
1122         }
1123
1124         /* reset fw_status with proper reason, and press db */
1125         vkwrite32(vk, VK_FWSTS_RESET_MBOX_DB, BAR_0, VK_BAR_FWSTS);
1126         bcm_to_v_reset_doorbell(vk, VK_BAR0_RESET_DB_SOFT);
1127
1128         /* clear other necessary registers and alert records */
1129         for (i = 0; i < ARRAY_SIZE(bar0_reg_clr_list); i++)
1130                 vkwrite32(vk, 0, BAR_0, bar0_reg_clr_list[i]);
1131         memset(&vk->host_alert, 0, sizeof(vk->host_alert));
1132         memset(&vk->peer_alert, 0, sizeof(vk->peer_alert));
1133         /* clear 4096 bits of bitmap */
1134         bitmap_clear(vk->bmap, 0, VK_MSG_ID_BITMAP_SIZE);
1135
1136         return 0;
1137 }
1138
1139 static long bcm_vk_reset(struct bcm_vk *vk, struct vk_reset __user *arg)
1140 {
1141         struct device *dev = &vk->pdev->dev;
1142         struct vk_reset reset;
1143         int ret = 0;
1144         u32 ramdump_reset;
1145         int special_reset;
1146
1147         if (copy_from_user(&reset, arg, sizeof(struct vk_reset)))
1148                 return -EFAULT;
1149
1150         /* check if any download is in-progress, if so return error */
1151         if (test_and_set_bit(BCM_VK_WQ_DWNLD_PEND, vk->wq_offload) != 0) {
1152                 dev_err(dev, "Download operation pending - skip reset.\n");
1153                 return -EPERM;
1154         }
1155
1156         ramdump_reset = vk->peer_alert.flags & ERR_LOG_RAMDUMP;
1157         dev_info(dev, "Issue Reset %s\n",
1158                  ramdump_reset ? "in ramdump mode" : "");
1159
1160         /*
1161          * The following is the sequence of reset:
1162          * - send card level graceful shut down
1163          * - wait enough time for VK to handle its business, stopping DMA etc
1164          * - kill host apps
1165          * - Trigger interrupt with DB
1166          */
1167         bcm_vk_send_shutdown_msg(vk, VK_SHUTDOWN_GRACEFUL, 0, 0);
1168
1169         spin_lock(&vk->ctx_lock);
1170         if (!vk->reset_pid) {
1171                 vk->reset_pid = task_pid_nr(current);
1172         } else {
1173                 dev_err(dev, "Reset already launched by process pid %d\n",
1174                         vk->reset_pid);
1175                 ret = -EACCES;
1176         }
1177         spin_unlock(&vk->ctx_lock);
1178         if (ret)
1179                 goto err_exit;
1180
1181         bcm_vk_blk_drv_access(vk);
1182         special_reset = bcm_vk_trigger_reset(vk);
1183
1184         /*
1185          * Wait enough time for card os to deinit
1186          * and populate the reset reason.
1187          */
1188         msleep(BCM_VK_DEINIT_TIME_MS);
1189
1190         if (special_reset) {
1191                 /* if it is special ramdump reset, return the type to user */
1192                 reset.arg2 = special_reset;
1193                 if (copy_to_user(arg, &reset, sizeof(reset)))
1194                         ret = -EFAULT;
1195         } else {
1196                 ret = bcm_vk_reset_successful(vk);
1197         }
1198
1199 err_exit:
1200         clear_bit(BCM_VK_WQ_DWNLD_PEND, vk->wq_offload);
1201         return ret;
1202 }
1203
1204 static int bcm_vk_mmap(struct file *file, struct vm_area_struct *vma)
1205 {
1206         struct bcm_vk_ctx *ctx = file->private_data;
1207         struct bcm_vk *vk = container_of(ctx->miscdev, struct bcm_vk, miscdev);
1208         unsigned long pg_size;
1209
1210         /* only BAR2 is mmap possible, which is bar num 4 due to 64bit */
1211 #define VK_MMAPABLE_BAR 4
1212
1213         pg_size = ((pci_resource_len(vk->pdev, VK_MMAPABLE_BAR) - 1)
1214                     >> PAGE_SHIFT) + 1;
1215         if (vma->vm_pgoff + vma_pages(vma) > pg_size)
1216                 return -EINVAL;
1217
1218         vma->vm_pgoff += (pci_resource_start(vk->pdev, VK_MMAPABLE_BAR)
1219                           >> PAGE_SHIFT);
1220         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1221
1222         return io_remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
1223                                   vma->vm_end - vma->vm_start,
1224                                   vma->vm_page_prot);
1225 }
1226
1227 static long bcm_vk_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1228 {
1229         long ret = -EINVAL;
1230         struct bcm_vk_ctx *ctx = file->private_data;
1231         struct bcm_vk *vk = container_of(ctx->miscdev, struct bcm_vk, miscdev);
1232         void __user *argp = (void __user *)arg;
1233
1234         dev_dbg(&vk->pdev->dev,
1235                 "ioctl, cmd=0x%02x, arg=0x%02lx\n",
1236                 cmd, arg);
1237
1238         mutex_lock(&vk->mutex);
1239
1240         switch (cmd) {
1241         case VK_IOCTL_LOAD_IMAGE:
1242                 ret = bcm_vk_load_image(vk, argp);
1243                 break;
1244
1245         case VK_IOCTL_RESET:
1246                 ret = bcm_vk_reset(vk, argp);
1247                 break;
1248
1249         default:
1250                 break;
1251         }
1252
1253         mutex_unlock(&vk->mutex);
1254
1255         return ret;
1256 }
1257
1258 static const struct file_operations bcm_vk_fops = {
1259         .owner = THIS_MODULE,
1260         .open = bcm_vk_open,
1261         .read = bcm_vk_read,
1262         .write = bcm_vk_write,
1263         .poll = bcm_vk_poll,
1264         .release = bcm_vk_release,
1265         .mmap = bcm_vk_mmap,
1266         .unlocked_ioctl = bcm_vk_ioctl,
1267 };
1268
1269 static int bcm_vk_on_panic(struct notifier_block *nb,
1270                            unsigned long e, void *p)
1271 {
1272         struct bcm_vk *vk = container_of(nb, struct bcm_vk, panic_nb);
1273
1274         bcm_to_v_reset_doorbell(vk, VK_BAR0_RESET_DB_HARD);
1275
1276         return 0;
1277 }
1278
1279 static int bcm_vk_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1280 {
1281         int err;
1282         int i;
1283         int id;
1284         int irq;
1285         char name[20];
1286         struct bcm_vk *vk;
1287         struct device *dev = &pdev->dev;
1288         struct miscdevice *misc_device;
1289         u32 boot_status;
1290
1291         /* allocate vk structure which is tied to kref for freeing */
1292         vk = kzalloc(sizeof(*vk), GFP_KERNEL);
1293         if (!vk)
1294                 return -ENOMEM;
1295
1296         kref_init(&vk->kref);
1297         if (nr_ib_sgl_blk > BCM_VK_IB_SGL_BLK_MAX) {
1298                 dev_warn(dev, "Inband SGL blk %d limited to max %d\n",
1299                          nr_ib_sgl_blk, BCM_VK_IB_SGL_BLK_MAX);
1300                 nr_ib_sgl_blk = BCM_VK_IB_SGL_BLK_MAX;
1301         }
1302         vk->ib_sgl_size = nr_ib_sgl_blk * VK_MSGQ_BLK_SIZE;
1303         mutex_init(&vk->mutex);
1304
1305         err = pci_enable_device(pdev);
1306         if (err) {
1307                 dev_err(dev, "Cannot enable PCI device\n");
1308                 goto err_free_exit;
1309         }
1310         vk->pdev = pci_dev_get(pdev);
1311
1312         err = pci_request_regions(pdev, DRV_MODULE_NAME);
1313         if (err) {
1314                 dev_err(dev, "Cannot obtain PCI resources\n");
1315                 goto err_disable_pdev;
1316         }
1317
1318         /* make sure DMA is good */
1319         err = dma_set_mask_and_coherent(&pdev->dev,
1320                                         DMA_BIT_MASK(BCM_VK_DMA_BITS));
1321         if (err) {
1322                 dev_err(dev, "failed to set DMA mask\n");
1323                 goto err_disable_pdev;
1324         }
1325
1326         /* The tdma is a scratch area for some DMA testings. */
1327         if (nr_scratch_pages) {
1328                 vk->tdma_vaddr = dma_alloc_coherent
1329                                         (dev,
1330                                          nr_scratch_pages * PAGE_SIZE,
1331                                          &vk->tdma_addr, GFP_KERNEL);
1332                 if (!vk->tdma_vaddr) {
1333                         err = -ENOMEM;
1334                         goto err_disable_pdev;
1335                 }
1336         }
1337
1338         pci_set_master(pdev);
1339         pci_set_drvdata(pdev, vk);
1340
1341         irq = pci_alloc_irq_vectors(pdev,
1342                                     VK_MSIX_IRQ_MIN_REQ,
1343                                     VK_MSIX_IRQ_MAX,
1344                                     PCI_IRQ_MSI | PCI_IRQ_MSIX);
1345
1346         if (irq < VK_MSIX_IRQ_MIN_REQ) {
1347                 dev_err(dev, "failed to get min %d MSIX interrupts, irq(%d)\n",
1348                         VK_MSIX_IRQ_MIN_REQ, irq);
1349                 err = (irq >= 0) ? -EINVAL : irq;
1350                 goto err_disable_pdev;
1351         }
1352
1353         if (irq != VK_MSIX_IRQ_MAX)
1354                 dev_warn(dev, "Number of IRQs %d allocated - requested(%d).\n",
1355                          irq, VK_MSIX_IRQ_MAX);
1356
1357         for (i = 0; i < MAX_BAR; i++) {
1358                 /* multiple by 2 for 64 bit BAR mapping */
1359                 vk->bar[i] = pci_ioremap_bar(pdev, i * 2);
1360                 if (!vk->bar[i]) {
1361                         dev_err(dev, "failed to remap BAR%d\n", i);
1362                         err = -ENOMEM;
1363                         goto err_iounmap;
1364                 }
1365         }
1366
1367         for (vk->num_irqs = 0;
1368              vk->num_irqs < VK_MSIX_MSGQ_MAX;
1369              vk->num_irqs++) {
1370                 err = devm_request_irq(dev, pci_irq_vector(pdev, vk->num_irqs),
1371                                        bcm_vk_msgq_irqhandler,
1372                                        IRQF_SHARED, DRV_MODULE_NAME, vk);
1373                 if (err) {
1374                         dev_err(dev, "failed to request msgq IRQ %d for MSIX %d\n",
1375                                 pdev->irq + vk->num_irqs, vk->num_irqs + 1);
1376                         goto err_irq;
1377                 }
1378         }
1379         /* one irq for notification from VK */
1380         err = devm_request_irq(dev, pci_irq_vector(pdev, vk->num_irqs),
1381                                bcm_vk_notf_irqhandler,
1382                                IRQF_SHARED, DRV_MODULE_NAME, vk);
1383         if (err) {
1384                 dev_err(dev, "failed to request notf IRQ %d for MSIX %d\n",
1385                         pdev->irq + vk->num_irqs, vk->num_irqs + 1);
1386                 goto err_irq;
1387         }
1388         vk->num_irqs++;
1389
1390         for (i = 0;
1391              (i < VK_MSIX_TTY_MAX) && (vk->num_irqs < irq);
1392              i++, vk->num_irqs++) {
1393                 err = devm_request_irq(dev, pci_irq_vector(pdev, vk->num_irqs),
1394                                        bcm_vk_tty_irqhandler,
1395                                        IRQF_SHARED, DRV_MODULE_NAME, vk);
1396                 if (err) {
1397                         dev_err(dev, "failed request tty IRQ %d for MSIX %d\n",
1398                                 pdev->irq + vk->num_irqs, vk->num_irqs + 1);
1399                         goto err_irq;
1400                 }
1401                 bcm_vk_tty_set_irq_enabled(vk, i);
1402         }
1403
1404         id = ida_alloc(&bcm_vk_ida, GFP_KERNEL);
1405         if (id < 0) {
1406                 err = id;
1407                 dev_err(dev, "unable to get id\n");
1408                 goto err_irq;
1409         }
1410
1411         vk->devid = id;
1412         snprintf(name, sizeof(name), DRV_MODULE_NAME ".%d", id);
1413         misc_device = &vk->miscdev;
1414         misc_device->minor = MISC_DYNAMIC_MINOR;
1415         misc_device->name = kstrdup(name, GFP_KERNEL);
1416         if (!misc_device->name) {
1417                 err = -ENOMEM;
1418                 goto err_ida_remove;
1419         }
1420         misc_device->fops = &bcm_vk_fops,
1421
1422         err = misc_register(misc_device);
1423         if (err) {
1424                 dev_err(dev, "failed to register device\n");
1425                 goto err_kfree_name;
1426         }
1427
1428         INIT_WORK(&vk->wq_work, bcm_vk_wq_handler);
1429
1430         /* create dedicated workqueue */
1431         vk->wq_thread = create_singlethread_workqueue(name);
1432         if (!vk->wq_thread) {
1433                 dev_err(dev, "Fail to create workqueue thread\n");
1434                 err = -ENOMEM;
1435                 goto err_misc_deregister;
1436         }
1437
1438         err = bcm_vk_msg_init(vk);
1439         if (err) {
1440                 dev_err(dev, "failed to init msg queue info\n");
1441                 goto err_destroy_workqueue;
1442         }
1443
1444         /* sync other info */
1445         bcm_vk_sync_card_info(vk);
1446
1447         /* register for panic notifier */
1448         vk->panic_nb.notifier_call = bcm_vk_on_panic;
1449         err = atomic_notifier_chain_register(&panic_notifier_list,
1450                                              &vk->panic_nb);
1451         if (err) {
1452                 dev_err(dev, "Fail to register panic notifier\n");
1453                 goto err_destroy_workqueue;
1454         }
1455
1456         snprintf(name, sizeof(name), KBUILD_MODNAME ".%d_ttyVK", id);
1457         err = bcm_vk_tty_init(vk, name);
1458         if (err)
1459                 goto err_unregister_panic_notifier;
1460
1461         /*
1462          * lets trigger an auto download.  We don't want to do it serially here
1463          * because at probing time, it is not supposed to block for a long time.
1464          */
1465         boot_status = vkread32(vk, BAR_0, BAR_BOOT_STATUS);
1466         if (auto_load) {
1467                 if ((boot_status & BOOT_STATE_MASK) == BROM_RUNNING) {
1468                         err = bcm_vk_trigger_autoload(vk);
1469                         if (err)
1470                                 goto err_bcm_vk_tty_exit;
1471                 } else {
1472                         dev_err(dev,
1473                                 "Auto-load skipped - BROM not in proper state (0x%x)\n",
1474                                 boot_status);
1475                 }
1476         }
1477
1478         /* enable hb */
1479         bcm_vk_hb_init(vk);
1480
1481         dev_dbg(dev, "BCM-VK:%u created\n", id);
1482
1483         return 0;
1484
1485 err_bcm_vk_tty_exit:
1486         bcm_vk_tty_exit(vk);
1487
1488 err_unregister_panic_notifier:
1489         atomic_notifier_chain_unregister(&panic_notifier_list,
1490                                          &vk->panic_nb);
1491
1492 err_destroy_workqueue:
1493         destroy_workqueue(vk->wq_thread);
1494
1495 err_misc_deregister:
1496         misc_deregister(misc_device);
1497
1498 err_kfree_name:
1499         kfree(misc_device->name);
1500         misc_device->name = NULL;
1501
1502 err_ida_remove:
1503         ida_free(&bcm_vk_ida, id);
1504
1505 err_irq:
1506         for (i = 0; i < vk->num_irqs; i++)
1507                 devm_free_irq(dev, pci_irq_vector(pdev, i), vk);
1508
1509         pci_disable_msix(pdev);
1510         pci_disable_msi(pdev);
1511
1512 err_iounmap:
1513         for (i = 0; i < MAX_BAR; i++) {
1514                 if (vk->bar[i])
1515                         pci_iounmap(pdev, vk->bar[i]);
1516         }
1517         pci_release_regions(pdev);
1518
1519 err_disable_pdev:
1520         if (vk->tdma_vaddr)
1521                 dma_free_coherent(&pdev->dev, nr_scratch_pages * PAGE_SIZE,
1522                                   vk->tdma_vaddr, vk->tdma_addr);
1523
1524         pci_free_irq_vectors(pdev);
1525         pci_disable_device(pdev);
1526         pci_dev_put(pdev);
1527
1528 err_free_exit:
1529         kfree(vk);
1530
1531         return err;
1532 }
1533
1534 void bcm_vk_release_data(struct kref *kref)
1535 {
1536         struct bcm_vk *vk = container_of(kref, struct bcm_vk, kref);
1537         struct pci_dev *pdev = vk->pdev;
1538
1539         dev_dbg(&pdev->dev, "BCM-VK:%d release data 0x%p\n", vk->devid, vk);
1540         pci_dev_put(pdev);
1541         kfree(vk);
1542 }
1543
1544 static void bcm_vk_remove(struct pci_dev *pdev)
1545 {
1546         int i;
1547         struct bcm_vk *vk = pci_get_drvdata(pdev);
1548         struct miscdevice *misc_device = &vk->miscdev;
1549
1550         bcm_vk_hb_deinit(vk);
1551
1552         /*
1553          * Trigger a reset to card and wait enough time for UCODE to rerun,
1554          * which re-initialize the card into its default state.
1555          * This ensures when driver is re-enumerated it will start from
1556          * a completely clean state.
1557          */
1558         bcm_vk_trigger_reset(vk);
1559         usleep_range(BCM_VK_UCODE_BOOT_US, BCM_VK_UCODE_BOOT_MAX_US);
1560
1561         /* unregister panic notifier */
1562         atomic_notifier_chain_unregister(&panic_notifier_list,
1563                                          &vk->panic_nb);
1564
1565         bcm_vk_msg_remove(vk);
1566         bcm_vk_tty_exit(vk);
1567
1568         if (vk->tdma_vaddr)
1569                 dma_free_coherent(&pdev->dev, nr_scratch_pages * PAGE_SIZE,
1570                                   vk->tdma_vaddr, vk->tdma_addr);
1571
1572         /* remove if name is set which means misc dev registered */
1573         if (misc_device->name) {
1574                 misc_deregister(misc_device);
1575                 kfree(misc_device->name);
1576                 ida_free(&bcm_vk_ida, vk->devid);
1577         }
1578         for (i = 0; i < vk->num_irqs; i++)
1579                 devm_free_irq(&pdev->dev, pci_irq_vector(pdev, i), vk);
1580
1581         pci_disable_msix(pdev);
1582         pci_disable_msi(pdev);
1583
1584         cancel_work_sync(&vk->wq_work);
1585         destroy_workqueue(vk->wq_thread);
1586         bcm_vk_tty_wq_exit(vk);
1587
1588         for (i = 0; i < MAX_BAR; i++) {
1589                 if (vk->bar[i])
1590                         pci_iounmap(pdev, vk->bar[i]);
1591         }
1592
1593         dev_dbg(&pdev->dev, "BCM-VK:%d released\n", vk->devid);
1594
1595         pci_release_regions(pdev);
1596         pci_free_irq_vectors(pdev);
1597         pci_disable_device(pdev);
1598
1599         kref_put(&vk->kref, bcm_vk_release_data);
1600 }
1601
1602 static void bcm_vk_shutdown(struct pci_dev *pdev)
1603 {
1604         struct bcm_vk *vk = pci_get_drvdata(pdev);
1605         u32 reg, boot_stat;
1606
1607         reg = vkread32(vk, BAR_0, BAR_BOOT_STATUS);
1608         boot_stat = reg & BOOT_STATE_MASK;
1609
1610         if (boot_stat == BOOT1_RUNNING) {
1611                 /* simply trigger a reset interrupt to park it */
1612                 bcm_vk_trigger_reset(vk);
1613         } else if (boot_stat == BROM_NOT_RUN) {
1614                 int err;
1615                 u16 lnksta;
1616
1617                 /*
1618                  * The boot status only reflects boot condition since last reset
1619                  * As ucode will run only once to configure pcie, if multiple
1620                  * resets happen, we lost track if ucode has run or not.
1621                  * Here, read the current link speed and use that to
1622                  * sync up the bootstatus properly so that on reboot-back-up,
1623                  * it has the proper state to start with autoload
1624                  */
1625                 err = pcie_capability_read_word(pdev, PCI_EXP_LNKSTA, &lnksta);
1626                 if (!err &&
1627                     (lnksta & PCI_EXP_LNKSTA_CLS) != PCI_EXP_LNKSTA_CLS_2_5GB) {
1628                         reg |= BROM_STATUS_COMPLETE;
1629                         vkwrite32(vk, reg, BAR_0, BAR_BOOT_STATUS);
1630                 }
1631         }
1632 }
1633
1634 static const struct pci_device_id bcm_vk_ids[] = {
1635         { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_VALKYRIE), },
1636         { }
1637 };
1638 MODULE_DEVICE_TABLE(pci, bcm_vk_ids);
1639
1640 static struct pci_driver pci_driver = {
1641         .name     = DRV_MODULE_NAME,
1642         .id_table = bcm_vk_ids,
1643         .probe    = bcm_vk_probe,
1644         .remove   = bcm_vk_remove,
1645         .shutdown = bcm_vk_shutdown,
1646 };
1647 module_pci_driver(pci_driver);
1648
1649 MODULE_DESCRIPTION("Broadcom VK Host Driver");
1650 MODULE_AUTHOR("Scott Branden <scott.branden@broadcom.com>");
1651 MODULE_LICENSE("GPL v2");
1652 MODULE_VERSION("1.0");