Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright 2018-2020 Broadcom.
0004  */
0005 
0006 #include <linux/delay.h>
0007 #include <linux/dma-mapping.h>
0008 #include <linux/firmware.h>
0009 #include <linux/fs.h>
0010 #include <linux/idr.h>
0011 #include <linux/interrupt.h>
0012 #include <linux/panic_notifier.h>
0013 #include <linux/kref.h>
0014 #include <linux/module.h>
0015 #include <linux/mutex.h>
0016 #include <linux/pci.h>
0017 #include <linux/pci_regs.h>
0018 #include <uapi/linux/misc/bcm_vk.h>
0019 
0020 #include "bcm_vk.h"
0021 
0022 #define PCI_DEVICE_ID_VALKYRIE  0x5e87
0023 #define PCI_DEVICE_ID_VIPER 0x5e88
0024 
0025 static DEFINE_IDA(bcm_vk_ida);
0026 
0027 enum soc_idx {
0028     VALKYRIE_A0 = 0,
0029     VALKYRIE_B0,
0030     VIPER,
0031     VK_IDX_INVALID
0032 };
0033 
0034 enum img_idx {
0035     IMG_PRI = 0,
0036     IMG_SEC,
0037     IMG_PER_TYPE_MAX
0038 };
0039 
0040 struct load_image_entry {
0041     const u32 image_type;
0042     const char *image_name[IMG_PER_TYPE_MAX];
0043 };
0044 
0045 #define NUM_BOOT_STAGES 2
0046 /* default firmware images names */
0047 static const struct load_image_entry image_tab[][NUM_BOOT_STAGES] = {
0048     [VALKYRIE_A0] = {
0049         {VK_IMAGE_TYPE_BOOT1, {"vk_a0-boot1.bin", "vk-boot1.bin"}},
0050         {VK_IMAGE_TYPE_BOOT2, {"vk_a0-boot2.bin", "vk-boot2.bin"}}
0051     },
0052     [VALKYRIE_B0] = {
0053         {VK_IMAGE_TYPE_BOOT1, {"vk_b0-boot1.bin", "vk-boot1.bin"}},
0054         {VK_IMAGE_TYPE_BOOT2, {"vk_b0-boot2.bin", "vk-boot2.bin"}}
0055     },
0056 
0057     [VIPER] = {
0058         {VK_IMAGE_TYPE_BOOT1, {"vp-boot1.bin", ""}},
0059         {VK_IMAGE_TYPE_BOOT2, {"vp-boot2.bin", ""}}
0060     },
0061 };
0062 
0063 /* Location of memory base addresses of interest in BAR1 */
0064 /* Load Boot1 to start of ITCM */
0065 #define BAR1_CODEPUSH_BASE_BOOT1    0x100000
0066 
0067 /* Allow minimum 1s for Load Image timeout responses */
0068 #define LOAD_IMAGE_TIMEOUT_MS       (1 * MSEC_PER_SEC)
0069 
0070 /* Image startup timeouts */
0071 #define BOOT1_STARTUP_TIMEOUT_MS    (5 * MSEC_PER_SEC)
0072 #define BOOT2_STARTUP_TIMEOUT_MS    (10 * MSEC_PER_SEC)
0073 
0074 /* 1ms wait for checking the transfer complete status */
0075 #define TXFR_COMPLETE_TIMEOUT_MS    1
0076 
0077 /* MSIX usages */
0078 #define VK_MSIX_MSGQ_MAX        3
0079 #define VK_MSIX_NOTF_MAX        1
0080 #define VK_MSIX_TTY_MAX         BCM_VK_NUM_TTY
0081 #define VK_MSIX_IRQ_MAX         (VK_MSIX_MSGQ_MAX + VK_MSIX_NOTF_MAX + \
0082                      VK_MSIX_TTY_MAX)
0083 #define VK_MSIX_IRQ_MIN_REQ             (VK_MSIX_MSGQ_MAX + VK_MSIX_NOTF_MAX)
0084 
0085 /* Number of bits set in DMA mask*/
0086 #define BCM_VK_DMA_BITS         64
0087 
0088 /* Ucode boot wait time */
0089 #define BCM_VK_UCODE_BOOT_US            (100 * USEC_PER_MSEC)
0090 /* 50% margin */
0091 #define BCM_VK_UCODE_BOOT_MAX_US        ((BCM_VK_UCODE_BOOT_US * 3) >> 1)
0092 
0093 /* deinit time for the card os after receiving doorbell */
0094 #define BCM_VK_DEINIT_TIME_MS       (2 * MSEC_PER_SEC)
0095 
0096 /*
0097  * module parameters
0098  */
0099 static bool auto_load = true;
0100 module_param(auto_load, bool, 0444);
0101 MODULE_PARM_DESC(auto_load,
0102          "Load images automatically at PCIe probe time.\n");
0103 static uint nr_scratch_pages = VK_BAR1_SCRATCH_DEF_NR_PAGES;
0104 module_param(nr_scratch_pages, uint, 0444);
0105 MODULE_PARM_DESC(nr_scratch_pages,
0106          "Number of pre allocated DMAable coherent pages.\n");
0107 static uint nr_ib_sgl_blk = BCM_VK_DEF_IB_SGL_BLK_LEN;
0108 module_param(nr_ib_sgl_blk, uint, 0444);
0109 MODULE_PARM_DESC(nr_ib_sgl_blk,
0110          "Number of in-band msg blks for short SGL.\n");
0111 
0112 /*
0113  * alerts that could be generated from peer
0114  */
0115 const struct bcm_vk_entry bcm_vk_peer_err[BCM_VK_PEER_ERR_NUM] = {
0116     {ERR_LOG_UECC, ERR_LOG_UECC, "uecc"},
0117     {ERR_LOG_SSIM_BUSY, ERR_LOG_SSIM_BUSY, "ssim_busy"},
0118     {ERR_LOG_AFBC_BUSY, ERR_LOG_AFBC_BUSY, "afbc_busy"},
0119     {ERR_LOG_HIGH_TEMP_ERR, ERR_LOG_HIGH_TEMP_ERR, "high_temp"},
0120     {ERR_LOG_WDOG_TIMEOUT, ERR_LOG_WDOG_TIMEOUT, "wdog_timeout"},
0121     {ERR_LOG_SYS_FAULT, ERR_LOG_SYS_FAULT, "sys_fault"},
0122     {ERR_LOG_RAMDUMP, ERR_LOG_RAMDUMP, "ramdump"},
0123     {ERR_LOG_COP_WDOG_TIMEOUT, ERR_LOG_COP_WDOG_TIMEOUT,
0124      "cop_wdog_timeout"},
0125     {ERR_LOG_MEM_ALLOC_FAIL, ERR_LOG_MEM_ALLOC_FAIL, "malloc_fail warn"},
0126     {ERR_LOG_LOW_TEMP_WARN, ERR_LOG_LOW_TEMP_WARN, "low_temp warn"},
0127     {ERR_LOG_ECC, ERR_LOG_ECC, "ecc"},
0128     {ERR_LOG_IPC_DWN, ERR_LOG_IPC_DWN, "ipc_down"},
0129 };
0130 
0131 /* alerts detected by the host */
0132 const struct bcm_vk_entry bcm_vk_host_err[BCM_VK_HOST_ERR_NUM] = {
0133     {ERR_LOG_HOST_PCIE_DWN, ERR_LOG_HOST_PCIE_DWN, "PCIe_down"},
0134     {ERR_LOG_HOST_HB_FAIL, ERR_LOG_HOST_HB_FAIL, "hb_fail"},
0135     {ERR_LOG_HOST_INTF_V_FAIL, ERR_LOG_HOST_INTF_V_FAIL, "intf_ver_fail"},
0136 };
0137 
0138 irqreturn_t bcm_vk_notf_irqhandler(int irq, void *dev_id)
0139 {
0140     struct bcm_vk *vk = dev_id;
0141 
0142     if (!bcm_vk_drv_access_ok(vk)) {
0143         dev_err(&vk->pdev->dev,
0144             "Interrupt %d received when msgq not inited\n", irq);
0145         goto skip_schedule_work;
0146     }
0147 
0148     /* if notification is not pending, set bit and schedule work */
0149     if (test_and_set_bit(BCM_VK_WQ_NOTF_PEND, vk->wq_offload) == 0)
0150         queue_work(vk->wq_thread, &vk->wq_work);
0151 
0152 skip_schedule_work:
0153     return IRQ_HANDLED;
0154 }
0155 
0156 static int bcm_vk_intf_ver_chk(struct bcm_vk *vk)
0157 {
0158     struct device *dev = &vk->pdev->dev;
0159     u32 reg;
0160     u16 major, minor;
0161     int ret = 0;
0162 
0163     /* read interface register */
0164     reg = vkread32(vk, BAR_0, BAR_INTF_VER);
0165     major = (reg >> BAR_INTF_VER_MAJOR_SHIFT) & BAR_INTF_VER_MASK;
0166     minor = reg & BAR_INTF_VER_MASK;
0167 
0168     /*
0169      * if major number is 0, it is pre-release and it would be allowed
0170      * to continue, else, check versions accordingly
0171      */
0172     if (!major) {
0173         dev_warn(dev, "Pre-release major.minor=%d.%d - drv %d.%d\n",
0174              major, minor, SEMANTIC_MAJOR, SEMANTIC_MINOR);
0175     } else if (major != SEMANTIC_MAJOR) {
0176         dev_err(dev,
0177             "Intf major.minor=%d.%d rejected - drv %d.%d\n",
0178             major, minor, SEMANTIC_MAJOR, SEMANTIC_MINOR);
0179         bcm_vk_set_host_alert(vk, ERR_LOG_HOST_INTF_V_FAIL);
0180         ret = -EPFNOSUPPORT;
0181     } else {
0182         dev_dbg(dev,
0183             "Intf major.minor=%d.%d passed - drv %d.%d\n",
0184             major, minor, SEMANTIC_MAJOR, SEMANTIC_MINOR);
0185     }
0186     return ret;
0187 }
0188 
0189 static void bcm_vk_log_notf(struct bcm_vk *vk,
0190                 struct bcm_vk_alert *alert,
0191                 struct bcm_vk_entry const *entry_tab,
0192                 const u32 table_size)
0193 {
0194     u32 i;
0195     u32 masked_val, latched_val;
0196     struct bcm_vk_entry const *entry;
0197     u32 reg;
0198     u16 ecc_mem_err, uecc_mem_err;
0199     struct device *dev = &vk->pdev->dev;
0200 
0201     for (i = 0; i < table_size; i++) {
0202         entry = &entry_tab[i];
0203         masked_val = entry->mask & alert->notfs;
0204         latched_val = entry->mask & alert->flags;
0205 
0206         if (masked_val == ERR_LOG_UECC) {
0207             /*
0208              * if there is difference between stored cnt and it
0209              * is greater than threshold, log it.
0210              */
0211             reg = vkread32(vk, BAR_0, BAR_CARD_ERR_MEM);
0212             BCM_VK_EXTRACT_FIELD(uecc_mem_err, reg,
0213                          BCM_VK_MEM_ERR_FIELD_MASK,
0214                          BCM_VK_UECC_MEM_ERR_SHIFT);
0215             if ((uecc_mem_err != vk->alert_cnts.uecc) &&
0216                 (uecc_mem_err >= BCM_VK_UECC_THRESHOLD))
0217                 dev_info(dev,
0218                      "ALERT! %s.%d uecc RAISED - ErrCnt %d\n",
0219                      DRV_MODULE_NAME, vk->devid,
0220                      uecc_mem_err);
0221             vk->alert_cnts.uecc = uecc_mem_err;
0222         } else if (masked_val == ERR_LOG_ECC) {
0223             reg = vkread32(vk, BAR_0, BAR_CARD_ERR_MEM);
0224             BCM_VK_EXTRACT_FIELD(ecc_mem_err, reg,
0225                          BCM_VK_MEM_ERR_FIELD_MASK,
0226                          BCM_VK_ECC_MEM_ERR_SHIFT);
0227             if ((ecc_mem_err != vk->alert_cnts.ecc) &&
0228                 (ecc_mem_err >= BCM_VK_ECC_THRESHOLD))
0229                 dev_info(dev, "ALERT! %s.%d ecc RAISED - ErrCnt %d\n",
0230                      DRV_MODULE_NAME, vk->devid,
0231                      ecc_mem_err);
0232             vk->alert_cnts.ecc = ecc_mem_err;
0233         } else if (masked_val != latched_val) {
0234             /* print a log as info */
0235             dev_info(dev, "ALERT! %s.%d %s %s\n",
0236                  DRV_MODULE_NAME, vk->devid, entry->str,
0237                  masked_val ? "RAISED" : "CLEARED");
0238         }
0239     }
0240 }
0241 
0242 static void bcm_vk_dump_peer_log(struct bcm_vk *vk)
0243 {
0244     struct bcm_vk_peer_log log;
0245     struct bcm_vk_peer_log *log_info = &vk->peerlog_info;
0246     char loc_buf[BCM_VK_PEER_LOG_LINE_MAX];
0247     int cnt;
0248     struct device *dev = &vk->pdev->dev;
0249     unsigned int data_offset;
0250 
0251     memcpy_fromio(&log, vk->bar[BAR_2] + vk->peerlog_off, sizeof(log));
0252 
0253     dev_dbg(dev, "Peer PANIC: Size 0x%x(0x%x), [Rd Wr] = [%d %d]\n",
0254         log.buf_size, log.mask, log.rd_idx, log.wr_idx);
0255 
0256     if (!log_info->buf_size) {
0257         dev_err(dev, "Peer log dump disabled - skipped!\n");
0258         return;
0259     }
0260 
0261     /* perform range checking for rd/wr idx */
0262     if ((log.rd_idx > log_info->mask) ||
0263         (log.wr_idx > log_info->mask) ||
0264         (log.buf_size != log_info->buf_size) ||
0265         (log.mask != log_info->mask)) {
0266         dev_err(dev,
0267             "Corrupted Ptrs: Size 0x%x(0x%x) Mask 0x%x(0x%x) [Rd Wr] = [%d %d], skip log dump.\n",
0268             log_info->buf_size, log.buf_size,
0269             log_info->mask, log.mask,
0270             log.rd_idx, log.wr_idx);
0271         return;
0272     }
0273 
0274     cnt = 0;
0275     data_offset = vk->peerlog_off + sizeof(struct bcm_vk_peer_log);
0276     loc_buf[BCM_VK_PEER_LOG_LINE_MAX - 1] = '\0';
0277     while (log.rd_idx != log.wr_idx) {
0278         loc_buf[cnt] = vkread8(vk, BAR_2, data_offset + log.rd_idx);
0279 
0280         if ((loc_buf[cnt] == '\0') ||
0281             (cnt == (BCM_VK_PEER_LOG_LINE_MAX - 1))) {
0282             dev_err(dev, "%s", loc_buf);
0283             cnt = 0;
0284         } else {
0285             cnt++;
0286         }
0287         log.rd_idx = (log.rd_idx + 1) & log.mask;
0288     }
0289     /* update rd idx at the end */
0290     vkwrite32(vk, log.rd_idx, BAR_2,
0291           vk->peerlog_off + offsetof(struct bcm_vk_peer_log, rd_idx));
0292 }
0293 
0294 void bcm_vk_handle_notf(struct bcm_vk *vk)
0295 {
0296     u32 reg;
0297     struct bcm_vk_alert alert;
0298     bool intf_down;
0299     unsigned long flags;
0300 
0301     /* handle peer alerts and then locally detected ones */
0302     reg = vkread32(vk, BAR_0, BAR_CARD_ERR_LOG);
0303     intf_down = BCM_VK_INTF_IS_DOWN(reg);
0304     if (!intf_down) {
0305         vk->peer_alert.notfs = reg;
0306         bcm_vk_log_notf(vk, &vk->peer_alert, bcm_vk_peer_err,
0307                 ARRAY_SIZE(bcm_vk_peer_err));
0308         vk->peer_alert.flags = vk->peer_alert.notfs;
0309     } else {
0310         /* turn off access */
0311         bcm_vk_blk_drv_access(vk);
0312     }
0313 
0314     /* check and make copy of alert with lock and then free lock */
0315     spin_lock_irqsave(&vk->host_alert_lock, flags);
0316     if (intf_down)
0317         vk->host_alert.notfs |= ERR_LOG_HOST_PCIE_DWN;
0318 
0319     alert = vk->host_alert;
0320     vk->host_alert.flags = vk->host_alert.notfs;
0321     spin_unlock_irqrestore(&vk->host_alert_lock, flags);
0322 
0323     /* call display with copy */
0324     bcm_vk_log_notf(vk, &alert, bcm_vk_host_err,
0325             ARRAY_SIZE(bcm_vk_host_err));
0326 
0327     /*
0328      * If it is a sys fault or heartbeat timeout, we would like extract
0329      * log msg from the card so that we would know what is the last fault
0330      */
0331     if (!intf_down &&
0332         ((vk->host_alert.flags & ERR_LOG_HOST_HB_FAIL) ||
0333          (vk->peer_alert.flags & ERR_LOG_SYS_FAULT)))
0334         bcm_vk_dump_peer_log(vk);
0335 }
0336 
0337 static inline int bcm_vk_wait(struct bcm_vk *vk, enum pci_barno bar,
0338                   u64 offset, u32 mask, u32 value,
0339                   unsigned long timeout_ms)
0340 {
0341     struct device *dev = &vk->pdev->dev;
0342     unsigned long start_time;
0343     unsigned long timeout;
0344     u32 rd_val, boot_status;
0345 
0346     start_time = jiffies;
0347     timeout = start_time + msecs_to_jiffies(timeout_ms);
0348 
0349     do {
0350         rd_val = vkread32(vk, bar, offset);
0351         dev_dbg(dev, "BAR%d Offset=0x%llx: 0x%x\n",
0352             bar, offset, rd_val);
0353 
0354         /* check for any boot err condition */
0355         boot_status = vkread32(vk, BAR_0, BAR_BOOT_STATUS);
0356         if (boot_status & BOOT_ERR_MASK) {
0357             dev_err(dev, "Boot Err 0x%x, progress 0x%x after %d ms\n",
0358                 (boot_status & BOOT_ERR_MASK) >> BOOT_ERR_SHIFT,
0359                 boot_status & BOOT_PROG_MASK,
0360                 jiffies_to_msecs(jiffies - start_time));
0361             return -EFAULT;
0362         }
0363 
0364         if (time_after(jiffies, timeout))
0365             return -ETIMEDOUT;
0366 
0367         cpu_relax();
0368         cond_resched();
0369     } while ((rd_val & mask) != value);
0370 
0371     return 0;
0372 }
0373 
0374 static void bcm_vk_get_card_info(struct bcm_vk *vk)
0375 {
0376     struct device *dev = &vk->pdev->dev;
0377     u32 offset;
0378     int i;
0379     u8 *dst;
0380     struct bcm_vk_card_info *info = &vk->card_info;
0381 
0382     /* first read the offset from spare register */
0383     offset = vkread32(vk, BAR_0, BAR_CARD_STATIC_INFO);
0384     offset &= (pci_resource_len(vk->pdev, BAR_2 * 2) - 1);
0385 
0386     /* based on the offset, read info to internal card info structure */
0387     dst = (u8 *)info;
0388     for (i = 0; i < sizeof(*info); i++)
0389         *dst++ = vkread8(vk, BAR_2, offset++);
0390 
0391 #define CARD_INFO_LOG_FMT "version   : %x\n" \
0392               "os_tag    : %s\n" \
0393               "cmpt_tag  : %s\n" \
0394               "cpu_freq  : %d MHz\n" \
0395               "cpu_scale : %d full, %d lowest\n" \
0396               "ddr_freq  : %d MHz\n" \
0397               "ddr_size  : %d MB\n" \
0398               "video_freq: %d MHz\n"
0399     dev_dbg(dev, CARD_INFO_LOG_FMT, info->version, info->os_tag,
0400         info->cmpt_tag, info->cpu_freq_mhz, info->cpu_scale[0],
0401         info->cpu_scale[MAX_OPP - 1], info->ddr_freq_mhz,
0402         info->ddr_size_MB, info->video_core_freq_mhz);
0403 
0404     /*
0405      * get the peer log pointer, only need the offset, and get record
0406      * of the log buffer information which would be used for checking
0407      * before dump, in case the BAR2 memory has been corrupted.
0408      */
0409     vk->peerlog_off = offset;
0410     memcpy_fromio(&vk->peerlog_info, vk->bar[BAR_2] + vk->peerlog_off,
0411               sizeof(vk->peerlog_info));
0412 
0413     /*
0414      * Do a range checking and if out of bound, the record will be zeroed
0415      * which guarantees that nothing would be dumped.  In other words,
0416      * peer dump is disabled.
0417      */
0418     if ((vk->peerlog_info.buf_size > BCM_VK_PEER_LOG_BUF_MAX) ||
0419         (vk->peerlog_info.mask != (vk->peerlog_info.buf_size - 1)) ||
0420         (vk->peerlog_info.rd_idx > vk->peerlog_info.mask) ||
0421         (vk->peerlog_info.wr_idx > vk->peerlog_info.mask)) {
0422         dev_err(dev, "Peer log disabled - range error: Size 0x%x(0x%x), [Rd Wr] = [%d %d]\n",
0423             vk->peerlog_info.buf_size,
0424             vk->peerlog_info.mask,
0425             vk->peerlog_info.rd_idx,
0426             vk->peerlog_info.wr_idx);
0427         memset(&vk->peerlog_info, 0, sizeof(vk->peerlog_info));
0428     } else {
0429         dev_dbg(dev, "Peer log: Size 0x%x(0x%x), [Rd Wr] = [%d %d]\n",
0430             vk->peerlog_info.buf_size,
0431             vk->peerlog_info.mask,
0432             vk->peerlog_info.rd_idx,
0433             vk->peerlog_info.wr_idx);
0434     }
0435 }
0436 
0437 static void bcm_vk_get_proc_mon_info(struct bcm_vk *vk)
0438 {
0439     struct device *dev = &vk->pdev->dev;
0440     struct bcm_vk_proc_mon_info *mon = &vk->proc_mon_info;
0441     u32 num, entry_size, offset, buf_size;
0442     u8 *dst;
0443 
0444     /* calculate offset which is based on peerlog offset */
0445     buf_size = vkread32(vk, BAR_2,
0446                 vk->peerlog_off
0447                 + offsetof(struct bcm_vk_peer_log, buf_size));
0448     offset = vk->peerlog_off + sizeof(struct bcm_vk_peer_log)
0449          + buf_size;
0450 
0451     /* first read the num and entry size */
0452     num = vkread32(vk, BAR_2, offset);
0453     entry_size = vkread32(vk, BAR_2, offset + sizeof(num));
0454 
0455     /* check for max allowed */
0456     if (num > BCM_VK_PROC_MON_MAX) {
0457         dev_err(dev, "Processing monitoring entry %d exceeds max %d\n",
0458             num, BCM_VK_PROC_MON_MAX);
0459         return;
0460     }
0461     mon->num = num;
0462     mon->entry_size = entry_size;
0463 
0464     vk->proc_mon_off = offset;
0465 
0466     /* read it once that will capture those static info */
0467     dst = (u8 *)&mon->entries[0];
0468     offset += sizeof(num) + sizeof(entry_size);
0469     memcpy_fromio(dst, vk->bar[BAR_2] + offset, num * entry_size);
0470 }
0471 
0472 static int bcm_vk_sync_card_info(struct bcm_vk *vk)
0473 {
0474     u32 rdy_marker = vkread32(vk, BAR_1, VK_BAR1_MSGQ_DEF_RDY);
0475 
0476     /* check for marker, but allow diags mode to skip sync */
0477     if (!bcm_vk_msgq_marker_valid(vk))
0478         return (rdy_marker == VK_BAR1_DIAG_RDY_MARKER ? 0 : -EINVAL);
0479 
0480     /*
0481      * Write down scratch addr which is used for DMA. For
0482      * signed part, BAR1 is accessible only after boot2 has come
0483      * up
0484      */
0485     if (vk->tdma_addr) {
0486         vkwrite32(vk, (u64)vk->tdma_addr >> 32, BAR_1,
0487               VK_BAR1_SCRATCH_OFF_HI);
0488         vkwrite32(vk, (u32)vk->tdma_addr, BAR_1,
0489               VK_BAR1_SCRATCH_OFF_LO);
0490         vkwrite32(vk, nr_scratch_pages * PAGE_SIZE, BAR_1,
0491               VK_BAR1_SCRATCH_SZ_ADDR);
0492     }
0493 
0494     /* get static card info, only need to read once */
0495     bcm_vk_get_card_info(vk);
0496 
0497     /* get the proc mon info once */
0498     bcm_vk_get_proc_mon_info(vk);
0499 
0500     return 0;
0501 }
0502 
0503 void bcm_vk_blk_drv_access(struct bcm_vk *vk)
0504 {
0505     int i;
0506 
0507     /*
0508      * kill all the apps except for the process that is resetting.
0509      * If not called during reset, reset_pid will be 0, and all will be
0510      * killed.
0511      */
0512     spin_lock(&vk->ctx_lock);
0513 
0514     /* set msgq_inited to 0 so that all rd/wr will be blocked */
0515     atomic_set(&vk->msgq_inited, 0);
0516 
0517     for (i = 0; i < VK_PID_HT_SZ; i++) {
0518         struct bcm_vk_ctx *ctx;
0519 
0520         list_for_each_entry(ctx, &vk->pid_ht[i].head, node) {
0521             if (ctx->pid != vk->reset_pid) {
0522                 dev_dbg(&vk->pdev->dev,
0523                     "Send kill signal to pid %d\n",
0524                     ctx->pid);
0525                 kill_pid(find_vpid(ctx->pid), SIGKILL, 1);
0526             }
0527         }
0528     }
0529     bcm_vk_tty_terminate_tty_user(vk);
0530     spin_unlock(&vk->ctx_lock);
0531 }
0532 
0533 static void bcm_vk_buf_notify(struct bcm_vk *vk, void *bufp,
0534                   dma_addr_t host_buf_addr, u32 buf_size)
0535 {
0536     /* update the dma address to the card */
0537     vkwrite32(vk, (u64)host_buf_addr >> 32, BAR_1,
0538           VK_BAR1_DMA_BUF_OFF_HI);
0539     vkwrite32(vk, (u32)host_buf_addr, BAR_1,
0540           VK_BAR1_DMA_BUF_OFF_LO);
0541     vkwrite32(vk, buf_size, BAR_1, VK_BAR1_DMA_BUF_SZ);
0542 }
0543 
0544 static int bcm_vk_load_image_by_type(struct bcm_vk *vk, u32 load_type,
0545                      const char *filename)
0546 {
0547     struct device *dev = &vk->pdev->dev;
0548     const struct firmware *fw = NULL;
0549     void *bufp = NULL;
0550     size_t max_buf, offset;
0551     int ret;
0552     u64 offset_codepush;
0553     u32 codepush;
0554     u32 value;
0555     dma_addr_t boot_dma_addr;
0556     bool is_stdalone;
0557 
0558     if (load_type == VK_IMAGE_TYPE_BOOT1) {
0559         /*
0560          * After POR, enable VK soft BOOTSRC so bootrom do not clear
0561          * the pushed image (the TCM memories).
0562          */
0563         value = vkread32(vk, BAR_0, BAR_BOOTSRC_SELECT);
0564         value |= BOOTSRC_SOFT_ENABLE;
0565         vkwrite32(vk, value, BAR_0, BAR_BOOTSRC_SELECT);
0566 
0567         codepush = CODEPUSH_BOOTSTART + CODEPUSH_BOOT1_ENTRY;
0568         offset_codepush = BAR_CODEPUSH_SBL;
0569 
0570         /* Write a 1 to request SRAM open bit */
0571         vkwrite32(vk, CODEPUSH_BOOTSTART, BAR_0, offset_codepush);
0572 
0573         /* Wait for VK to respond */
0574         ret = bcm_vk_wait(vk, BAR_0, BAR_BOOT_STATUS, SRAM_OPEN,
0575                   SRAM_OPEN, LOAD_IMAGE_TIMEOUT_MS);
0576         if (ret < 0) {
0577             dev_err(dev, "boot1 wait SRAM err - ret(%d)\n", ret);
0578             goto err_buf_out;
0579         }
0580 
0581         max_buf = SZ_256K;
0582         bufp = dma_alloc_coherent(dev,
0583                       max_buf,
0584                       &boot_dma_addr, GFP_KERNEL);
0585         if (!bufp) {
0586             dev_err(dev, "Error allocating 0x%zx\n", max_buf);
0587             ret = -ENOMEM;
0588             goto err_buf_out;
0589         }
0590     } else if (load_type == VK_IMAGE_TYPE_BOOT2) {
0591         codepush = CODEPUSH_BOOT2_ENTRY;
0592         offset_codepush = BAR_CODEPUSH_SBI;
0593 
0594         /* Wait for VK to respond */
0595         ret = bcm_vk_wait(vk, BAR_0, BAR_BOOT_STATUS, DDR_OPEN,
0596                   DDR_OPEN, LOAD_IMAGE_TIMEOUT_MS);
0597         if (ret < 0) {
0598             dev_err(dev, "boot2 wait DDR open error - ret(%d)\n",
0599                 ret);
0600             goto err_buf_out;
0601         }
0602 
0603         max_buf = SZ_4M;
0604         bufp = dma_alloc_coherent(dev,
0605                       max_buf,
0606                       &boot_dma_addr, GFP_KERNEL);
0607         if (!bufp) {
0608             dev_err(dev, "Error allocating 0x%zx\n", max_buf);
0609             ret = -ENOMEM;
0610             goto err_buf_out;
0611         }
0612 
0613         bcm_vk_buf_notify(vk, bufp, boot_dma_addr, max_buf);
0614     } else {
0615         dev_err(dev, "Error invalid image type 0x%x\n", load_type);
0616         ret = -EINVAL;
0617         goto err_buf_out;
0618     }
0619 
0620     offset = 0;
0621     ret = request_partial_firmware_into_buf(&fw, filename, dev,
0622                         bufp, max_buf, offset);
0623     if (ret) {
0624         dev_err(dev, "Error %d requesting firmware file: %s\n",
0625             ret, filename);
0626         goto err_firmware_out;
0627     }
0628     dev_dbg(dev, "size=0x%zx\n", fw->size);
0629     if (load_type == VK_IMAGE_TYPE_BOOT1)
0630         memcpy_toio(vk->bar[BAR_1] + BAR1_CODEPUSH_BASE_BOOT1,
0631                 bufp,
0632                 fw->size);
0633 
0634     dev_dbg(dev, "Signaling 0x%x to 0x%llx\n", codepush, offset_codepush);
0635     vkwrite32(vk, codepush, BAR_0, offset_codepush);
0636 
0637     if (load_type == VK_IMAGE_TYPE_BOOT1) {
0638         u32 boot_status;
0639 
0640         /* wait until done */
0641         ret = bcm_vk_wait(vk, BAR_0, BAR_BOOT_STATUS,
0642                   BOOT1_RUNNING,
0643                   BOOT1_RUNNING,
0644                   BOOT1_STARTUP_TIMEOUT_MS);
0645 
0646         boot_status = vkread32(vk, BAR_0, BAR_BOOT_STATUS);
0647         is_stdalone = !BCM_VK_INTF_IS_DOWN(boot_status) &&
0648                   (boot_status & BOOT_STDALONE_RUNNING);
0649         if (ret && !is_stdalone) {
0650             dev_err(dev,
0651                 "Timeout %ld ms waiting for boot1 to come up - ret(%d)\n",
0652                 BOOT1_STARTUP_TIMEOUT_MS, ret);
0653             goto err_firmware_out;
0654         } else if (is_stdalone) {
0655             u32 reg;
0656 
0657             reg = vkread32(vk, BAR_0, BAR_BOOT1_STDALONE_PROGRESS);
0658             if ((reg & BOOT1_STDALONE_PROGRESS_MASK) ==
0659                      BOOT1_STDALONE_SUCCESS) {
0660                 dev_info(dev, "Boot1 standalone success\n");
0661                 ret = 0;
0662             } else {
0663                 dev_err(dev, "Timeout %ld ms - Boot1 standalone failure\n",
0664                     BOOT1_STARTUP_TIMEOUT_MS);
0665                 ret = -EINVAL;
0666                 goto err_firmware_out;
0667             }
0668         }
0669     } else if (load_type == VK_IMAGE_TYPE_BOOT2) {
0670         unsigned long timeout;
0671 
0672         timeout = jiffies + msecs_to_jiffies(LOAD_IMAGE_TIMEOUT_MS);
0673 
0674         /* To send more data to VK than max_buf allowed at a time */
0675         do {
0676             /*
0677              * Check for ack from card. when Ack is received,
0678              * it means all the data is received by card.
0679              * Exit the loop after ack is received.
0680              */
0681             ret = bcm_vk_wait(vk, BAR_0, BAR_BOOT_STATUS,
0682                       FW_LOADER_ACK_RCVD_ALL_DATA,
0683                       FW_LOADER_ACK_RCVD_ALL_DATA,
0684                       TXFR_COMPLETE_TIMEOUT_MS);
0685             if (ret == 0) {
0686                 dev_dbg(dev, "Exit boot2 download\n");
0687                 break;
0688             } else if (ret == -EFAULT) {
0689                 dev_err(dev, "Error detected during ACK waiting");
0690                 goto err_firmware_out;
0691             }
0692 
0693             /* exit the loop, if there is no response from card */
0694             if (time_after(jiffies, timeout)) {
0695                 dev_err(dev, "Error. No reply from card\n");
0696                 ret = -ETIMEDOUT;
0697                 goto err_firmware_out;
0698             }
0699 
0700             /* Wait for VK to open BAR space to copy new data */
0701             ret = bcm_vk_wait(vk, BAR_0, offset_codepush,
0702                       codepush, 0,
0703                       TXFR_COMPLETE_TIMEOUT_MS);
0704             if (ret == 0) {
0705                 offset += max_buf;
0706                 ret = request_partial_firmware_into_buf
0707                         (&fw,
0708                          filename,
0709                          dev, bufp,
0710                          max_buf,
0711                          offset);
0712                 if (ret) {
0713                     dev_err(dev,
0714                         "Error %d requesting firmware file: %s offset: 0x%zx\n",
0715                         ret, filename, offset);
0716                     goto err_firmware_out;
0717                 }
0718                 dev_dbg(dev, "size=0x%zx\n", fw->size);
0719                 dev_dbg(dev, "Signaling 0x%x to 0x%llx\n",
0720                     codepush, offset_codepush);
0721                 vkwrite32(vk, codepush, BAR_0, offset_codepush);
0722                 /* reload timeout after every codepush */
0723                 timeout = jiffies +
0724                     msecs_to_jiffies(LOAD_IMAGE_TIMEOUT_MS);
0725             } else if (ret == -EFAULT) {
0726                 dev_err(dev, "Error detected waiting for transfer\n");
0727                 goto err_firmware_out;
0728             }
0729         } while (1);
0730 
0731         /* wait for fw status bits to indicate app ready */
0732         ret = bcm_vk_wait(vk, BAR_0, VK_BAR_FWSTS,
0733                   VK_FWSTS_READY,
0734                   VK_FWSTS_READY,
0735                   BOOT2_STARTUP_TIMEOUT_MS);
0736         if (ret < 0) {
0737             dev_err(dev, "Boot2 not ready - ret(%d)\n", ret);
0738             goto err_firmware_out;
0739         }
0740 
0741         is_stdalone = vkread32(vk, BAR_0, BAR_BOOT_STATUS) &
0742                   BOOT_STDALONE_RUNNING;
0743         if (!is_stdalone) {
0744             ret = bcm_vk_intf_ver_chk(vk);
0745             if (ret) {
0746                 dev_err(dev, "failure in intf version check\n");
0747                 goto err_firmware_out;
0748             }
0749 
0750             /*
0751              * Next, initialize Message Q if we are loading boot2.
0752              * Do a force sync
0753              */
0754             ret = bcm_vk_sync_msgq(vk, true);
0755             if (ret) {
0756                 dev_err(dev, "Boot2 Error reading comm msg Q info\n");
0757                 ret = -EIO;
0758                 goto err_firmware_out;
0759             }
0760 
0761             /* sync & channel other info */
0762             ret = bcm_vk_sync_card_info(vk);
0763             if (ret) {
0764                 dev_err(dev, "Syncing Card Info failure\n");
0765                 goto err_firmware_out;
0766             }
0767         }
0768     }
0769 
0770 err_firmware_out:
0771     release_firmware(fw);
0772 
0773 err_buf_out:
0774     if (bufp)
0775         dma_free_coherent(dev, max_buf, bufp, boot_dma_addr);
0776 
0777     return ret;
0778 }
0779 
0780 static u32 bcm_vk_next_boot_image(struct bcm_vk *vk)
0781 {
0782     u32 boot_status;
0783     u32 fw_status;
0784     u32 load_type = 0;  /* default for unknown */
0785 
0786     boot_status = vkread32(vk, BAR_0, BAR_BOOT_STATUS);
0787     fw_status = vkread32(vk, BAR_0, VK_BAR_FWSTS);
0788 
0789     if (!BCM_VK_INTF_IS_DOWN(boot_status) && (boot_status & SRAM_OPEN))
0790         load_type = VK_IMAGE_TYPE_BOOT1;
0791     else if (boot_status == BOOT1_RUNNING)
0792         load_type = VK_IMAGE_TYPE_BOOT2;
0793 
0794     /* Log status so that we know different stages */
0795     dev_info(&vk->pdev->dev,
0796          "boot-status value for next image: 0x%x : fw-status 0x%x\n",
0797          boot_status, fw_status);
0798 
0799     return load_type;
0800 }
0801 
0802 static enum soc_idx get_soc_idx(struct bcm_vk *vk)
0803 {
0804     struct pci_dev *pdev = vk->pdev;
0805     enum soc_idx idx = VK_IDX_INVALID;
0806     u32 rev;
0807     static enum soc_idx const vk_soc_tab[] = { VALKYRIE_A0, VALKYRIE_B0 };
0808 
0809     switch (pdev->device) {
0810     case PCI_DEVICE_ID_VALKYRIE:
0811         /* get the chip id to decide sub-class */
0812         rev = MAJOR_SOC_REV(vkread32(vk, BAR_0, BAR_CHIP_ID));
0813         if (rev < ARRAY_SIZE(vk_soc_tab)) {
0814             idx = vk_soc_tab[rev];
0815         } else {
0816             /* Default to A0 firmware for all other chip revs */
0817             idx = VALKYRIE_A0;
0818             dev_warn(&pdev->dev,
0819                  "Rev %d not in image lookup table, default to idx=%d\n",
0820                  rev, idx);
0821         }
0822         break;
0823 
0824     case PCI_DEVICE_ID_VIPER:
0825         idx = VIPER;
0826         break;
0827 
0828     default:
0829         dev_err(&pdev->dev, "no images for 0x%x\n", pdev->device);
0830     }
0831     return idx;
0832 }
0833 
0834 static const char *get_load_fw_name(struct bcm_vk *vk,
0835                     const struct load_image_entry *entry)
0836 {
0837     const struct firmware *fw;
0838     struct device *dev = &vk->pdev->dev;
0839     int ret;
0840     unsigned long dummy;
0841     int i;
0842 
0843     for (i = 0; i < IMG_PER_TYPE_MAX; i++) {
0844         fw = NULL;
0845         ret = request_partial_firmware_into_buf(&fw,
0846                             entry->image_name[i],
0847                             dev, &dummy,
0848                             sizeof(dummy),
0849                             0);
0850         release_firmware(fw);
0851         if (!ret)
0852             return entry->image_name[i];
0853     }
0854     return NULL;
0855 }
0856 
0857 int bcm_vk_auto_load_all_images(struct bcm_vk *vk)
0858 {
0859     int i, ret = -1;
0860     enum soc_idx idx;
0861     struct device *dev = &vk->pdev->dev;
0862     u32 curr_type;
0863     const char *curr_name;
0864 
0865     idx = get_soc_idx(vk);
0866     if (idx == VK_IDX_INVALID)
0867         goto auto_load_all_exit;
0868 
0869     /* log a message to know the relative loading order */
0870     dev_dbg(dev, "Load All for device %d\n", vk->devid);
0871 
0872     for (i = 0; i < NUM_BOOT_STAGES; i++) {
0873         curr_type = image_tab[idx][i].image_type;
0874         if (bcm_vk_next_boot_image(vk) == curr_type) {
0875             curr_name = get_load_fw_name(vk, &image_tab[idx][i]);
0876             if (!curr_name) {
0877                 dev_err(dev, "No suitable firmware exists for type %d",
0878                     curr_type);
0879                 ret = -ENOENT;
0880                 goto auto_load_all_exit;
0881             }
0882             ret = bcm_vk_load_image_by_type(vk, curr_type,
0883                             curr_name);
0884             dev_info(dev, "Auto load %s, ret %d\n",
0885                  curr_name, ret);
0886 
0887             if (ret) {
0888                 dev_err(dev, "Error loading default %s\n",
0889                     curr_name);
0890                 goto auto_load_all_exit;
0891             }
0892         }
0893     }
0894 
0895 auto_load_all_exit:
0896     return ret;
0897 }
0898 
0899 static int bcm_vk_trigger_autoload(struct bcm_vk *vk)
0900 {
0901     if (test_and_set_bit(BCM_VK_WQ_DWNLD_PEND, vk->wq_offload) != 0)
0902         return -EPERM;
0903 
0904     set_bit(BCM_VK_WQ_DWNLD_AUTO, vk->wq_offload);
0905     queue_work(vk->wq_thread, &vk->wq_work);
0906 
0907     return 0;
0908 }
0909 
0910 /*
0911  * deferred work queue for draining and auto download.
0912  */
0913 static void bcm_vk_wq_handler(struct work_struct *work)
0914 {
0915     struct bcm_vk *vk = container_of(work, struct bcm_vk, wq_work);
0916     struct device *dev = &vk->pdev->dev;
0917     s32 ret;
0918 
0919     /* check wq offload bit map to perform various operations */
0920     if (test_bit(BCM_VK_WQ_NOTF_PEND, vk->wq_offload)) {
0921         /* clear bit right the way for notification */
0922         clear_bit(BCM_VK_WQ_NOTF_PEND, vk->wq_offload);
0923         bcm_vk_handle_notf(vk);
0924     }
0925     if (test_bit(BCM_VK_WQ_DWNLD_AUTO, vk->wq_offload)) {
0926         bcm_vk_auto_load_all_images(vk);
0927 
0928         /*
0929          * at the end of operation, clear AUTO bit and pending
0930          * bit
0931          */
0932         clear_bit(BCM_VK_WQ_DWNLD_AUTO, vk->wq_offload);
0933         clear_bit(BCM_VK_WQ_DWNLD_PEND, vk->wq_offload);
0934     }
0935 
0936     /* next, try to drain */
0937     ret = bcm_to_h_msg_dequeue(vk);
0938 
0939     if (ret == 0)
0940         dev_dbg(dev, "Spurious trigger for workqueue\n");
0941     else if (ret < 0)
0942         bcm_vk_blk_drv_access(vk);
0943 }
0944 
0945 static long bcm_vk_load_image(struct bcm_vk *vk,
0946                   const struct vk_image __user *arg)
0947 {
0948     struct device *dev = &vk->pdev->dev;
0949     const char *image_name;
0950     struct vk_image image;
0951     u32 next_loadable;
0952     enum soc_idx idx;
0953     int image_idx;
0954     int ret = -EPERM;
0955 
0956     if (copy_from_user(&image, arg, sizeof(image)))
0957         return -EACCES;
0958 
0959     if ((image.type != VK_IMAGE_TYPE_BOOT1) &&
0960         (image.type != VK_IMAGE_TYPE_BOOT2)) {
0961         dev_err(dev, "invalid image.type %u\n", image.type);
0962         return ret;
0963     }
0964 
0965     next_loadable = bcm_vk_next_boot_image(vk);
0966     if (next_loadable != image.type) {
0967         dev_err(dev, "Next expected image %u, Loading %u\n",
0968             next_loadable, image.type);
0969         return ret;
0970     }
0971 
0972     /*
0973      * if something is pending download already.  This could only happen
0974      * for now when the driver is being loaded, or if someone has issued
0975      * another download command in another shell.
0976      */
0977     if (test_and_set_bit(BCM_VK_WQ_DWNLD_PEND, vk->wq_offload) != 0) {
0978         dev_err(dev, "Download operation already pending.\n");
0979         return ret;
0980     }
0981 
0982     image_name = image.filename;
0983     if (image_name[0] == '\0') {
0984         /* Use default image name if NULL */
0985         idx = get_soc_idx(vk);
0986         if (idx == VK_IDX_INVALID)
0987             goto err_idx;
0988 
0989         /* Image idx starts with boot1 */
0990         image_idx = image.type - VK_IMAGE_TYPE_BOOT1;
0991         image_name = get_load_fw_name(vk, &image_tab[idx][image_idx]);
0992         if (!image_name) {
0993             dev_err(dev, "No suitable image found for type %d",
0994                 image.type);
0995             ret = -ENOENT;
0996             goto err_idx;
0997         }
0998     } else {
0999         /* 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                     1,
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_simple_get(&bcm_vk_ida, 0, 0, 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_simple_remove(&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_simple_remove(&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");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!