1653 lines · c
1// SPDX-License-Identifier: GPL-2.02/*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 0x5e8723#define PCI_DEVICE_ID_VIPER 0x5e8824 25static DEFINE_IDA(bcm_vk_ida);26 27enum soc_idx {28 VALKYRIE_A0 = 0,29 VALKYRIE_B0,30 VIPER,31 VK_IDX_INVALID32};33 34enum img_idx {35 IMG_PRI = 0,36 IMG_SEC,37 IMG_PER_TYPE_MAX38};39 40struct load_image_entry {41 const u32 image_type;42 const char *image_name[IMG_PER_TYPE_MAX];43};44 45#define NUM_BOOT_STAGES 246/* default firmware images names */47static 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 0x10000066 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 176 77/* MSIX usages */78#define VK_MSIX_MSGQ_MAX 379#define VK_MSIX_NOTF_MAX 180#define VK_MSIX_TTY_MAX BCM_VK_NUM_TTY81#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 6487 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 parameters98 */99static bool auto_load = true;100module_param(auto_load, bool, 0444);101MODULE_PARM_DESC(auto_load,102 "Load images automatically at PCIe probe time.\n");103static uint nr_scratch_pages = VK_BAR1_SCRATCH_DEF_NR_PAGES;104module_param(nr_scratch_pages, uint, 0444);105MODULE_PARM_DESC(nr_scratch_pages,106 "Number of pre allocated DMAable coherent pages.\n");107static uint nr_ib_sgl_blk = BCM_VK_DEF_IB_SGL_BLK_LEN;108module_param(nr_ib_sgl_blk, uint, 0444);109MODULE_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 peer114 */115const 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 */132const 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 138irqreturn_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 152skip_schedule_work:153 return IRQ_HANDLED;154}155 156static 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 allowed170 * to continue, else, check versions accordingly171 */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 189static 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 it209 * 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 242static 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 294void 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 extract329 * log msg from the card so that we would know what is the last fault330 */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 337static 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 374static 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 record406 * of the log buffer information which would be used for checking407 * 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 zeroed415 * 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 437static 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_off447 + 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 472static 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. For482 * signed part, BAR1 is accessible only after boot2 has come483 * up484 */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 503void 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 be510 * 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 533static 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 544static 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 clear561 * 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_buf707 (&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 sync753 */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 770err_firmware_out:771 release_firmware(fw);772 773err_buf_out:774 if (bufp)775 dma_free_coherent(dev, max_buf, bufp, boot_dma_addr);776 777 return ret;778}779 780static 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 802static 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 834static 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 857int 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 895auto_load_all_exit:896 return ret;897}898 899static 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 */913static 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 pending930 * bit931 */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 945static 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 happen974 * for now when the driver is being loaded, or if someone has issued975 * 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);1004err_idx:1005 clear_bit(BCM_VK_WQ_DWNLD_PEND, vk->wq_offload);1006 1007 return ret;1008}1009 1010static 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 bootROM1019 * ii) after boot11020 * iii) boot2 running1021 *1022 * i) & ii) - no status bits will be updated. If vkboot11023 * runs automatically after reset, it will update the reason1024 * to be unknown reason1025 * 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 done1041 * bit is not, this is a failure if triggered while boot2 is running1042 */1043 if ((fw_status & VK_FWSTS_DEINIT_TRIGGERED) &&1044 !(fw_status & VK_FWSTS_RESET_DONE))1045 ret = -EAGAIN;1046 1047reset_exit:1048 dev_dbg(dev, "FW status = 0x%x ret %d\n", fw_status, ret);1049 1050 return ret;1051}1052 1053static 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 1058static 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 execute1091 * boot again (and fails again) and instead waits for a new1092 * codepush. And, if previous boot has encountered error, need1093 * to clear the entry values1094 */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't1113 * reset the reboot reason as it will contain valid info that1114 * is important - simply use special reset1115 */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 1139static 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 down1163 * - wait enough time for VK to handle its business, stopping DMA etc1164 * - kill host apps1165 * - Trigger interrupt with DB1166 */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 deinit1186 * 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 1199err_exit:1200 clear_bit(BCM_VK_WQ_DWNLD_PEND, vk->wq_offload);1201 return ret;1202}1203 1204static 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 41212 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 1227static 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 1258static 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 1269static 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 1279static 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_coherent1329 (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 here1463 * 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 1485err_bcm_vk_tty_exit:1486 bcm_vk_tty_exit(vk);1487 1488err_unregister_panic_notifier:1489 atomic_notifier_chain_unregister(&panic_notifier_list,1490 &vk->panic_nb);1491 1492err_destroy_workqueue:1493 destroy_workqueue(vk->wq_thread);1494 1495err_misc_deregister:1496 misc_deregister(misc_device);1497 1498err_kfree_name:1499 kfree(misc_device->name);1500 misc_device->name = NULL;1501 1502err_ida_remove:1503 ida_free(&bcm_vk_ida, id);1504 1505err_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 1512err_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 1519err_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 1528err_free_exit:1529 kfree(vk);1530 1531 return err;1532}1533 1534void 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 1544static 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 from1556 * 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 1602static 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 reset1619 * As ucode will run only once to configure pcie, if multiple1620 * resets happen, we lost track if ucode has run or not.1621 * Here, read the current link speed and use that to1622 * sync up the bootstatus properly so that on reboot-back-up,1623 * it has the proper state to start with autoload1624 */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 1634static const struct pci_device_id bcm_vk_ids[] = {1635 { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_VALKYRIE), },1636 { }1637};1638MODULE_DEVICE_TABLE(pci, bcm_vk_ids);1639 1640static 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};1647module_pci_driver(pci_driver);1648 1649MODULE_DESCRIPTION("Broadcom VK Host Driver");1650MODULE_AUTHOR("Scott Branden <scott.branden@broadcom.com>");1651MODULE_LICENSE("GPL v2");1652MODULE_VERSION("1.0");1653