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