1 /* QLogic qed NIC Driver 2 * Copyright (c) 2015 QLogic Corporation 3 * 4 * This software is available under the terms of the GNU General Public License 5 * (GPL) Version 2, available from the file COPYING in the main directory of 6 * this source tree. 7 */ 8 9 #include <linux/types.h> 10 #include <linux/io.h> 11 #include <linux/delay.h> 12 #include <linux/dma-mapping.h> 13 #include <linux/errno.h> 14 #include <linux/kernel.h> 15 #include <linux/list.h> 16 #include <linux/mutex.h> 17 #include <linux/pci.h> 18 #include <linux/slab.h> 19 #include <linux/spinlock.h> 20 #include <linux/string.h> 21 #include <linux/qed/qed_chain.h> 22 #include "qed.h" 23 #include "qed_hsi.h" 24 #include "qed_hw.h" 25 #include "qed_reg_addr.h" 26 27 #define QED_BAR_ACQUIRE_TIMEOUT 1000 28 29 /* Invalid values */ 30 #define QED_BAR_INVALID_OFFSET (cpu_to_le32(-1)) 31 32 struct qed_ptt { 33 struct list_head list_entry; 34 unsigned int idx; 35 struct pxp_ptt_entry pxp; 36 }; 37 38 struct qed_ptt_pool { 39 struct list_head free_list; 40 spinlock_t lock; /* ptt synchronized access */ 41 struct qed_ptt ptts[PXP_EXTERNAL_BAR_PF_WINDOW_NUM]; 42 }; 43 44 int qed_ptt_pool_alloc(struct qed_hwfn *p_hwfn) 45 { 46 struct qed_ptt_pool *p_pool = kmalloc(sizeof(*p_pool), 47 GFP_KERNEL); 48 int i; 49 50 if (!p_pool) 51 return -ENOMEM; 52 53 INIT_LIST_HEAD(&p_pool->free_list); 54 for (i = 0; i < PXP_EXTERNAL_BAR_PF_WINDOW_NUM; i++) { 55 p_pool->ptts[i].idx = i; 56 p_pool->ptts[i].pxp.offset = QED_BAR_INVALID_OFFSET; 57 p_pool->ptts[i].pxp.pretend.control = 0; 58 if (i >= RESERVED_PTT_MAX) 59 list_add(&p_pool->ptts[i].list_entry, 60 &p_pool->free_list); 61 } 62 63 p_hwfn->p_ptt_pool = p_pool; 64 spin_lock_init(&p_pool->lock); 65 66 return 0; 67 } 68 69 void qed_ptt_invalidate(struct qed_hwfn *p_hwfn) 70 { 71 struct qed_ptt *p_ptt; 72 int i; 73 74 for (i = 0; i < PXP_EXTERNAL_BAR_PF_WINDOW_NUM; i++) { 75 p_ptt = &p_hwfn->p_ptt_pool->ptts[i]; 76 p_ptt->pxp.offset = QED_BAR_INVALID_OFFSET; 77 } 78 } 79 80 void qed_ptt_pool_free(struct qed_hwfn *p_hwfn) 81 { 82 kfree(p_hwfn->p_ptt_pool); 83 p_hwfn->p_ptt_pool = NULL; 84 } 85 86 struct qed_ptt *qed_ptt_acquire(struct qed_hwfn *p_hwfn) 87 { 88 struct qed_ptt *p_ptt; 89 unsigned int i; 90 91 /* Take the free PTT from the list */ 92 for (i = 0; i < QED_BAR_ACQUIRE_TIMEOUT; i++) { 93 spin_lock_bh(&p_hwfn->p_ptt_pool->lock); 94 95 if (!list_empty(&p_hwfn->p_ptt_pool->free_list)) { 96 p_ptt = list_first_entry(&p_hwfn->p_ptt_pool->free_list, 97 struct qed_ptt, list_entry); 98 list_del(&p_ptt->list_entry); 99 100 spin_unlock_bh(&p_hwfn->p_ptt_pool->lock); 101 102 DP_VERBOSE(p_hwfn, NETIF_MSG_HW, 103 "allocated ptt %d\n", p_ptt->idx); 104 return p_ptt; 105 } 106 107 spin_unlock_bh(&p_hwfn->p_ptt_pool->lock); 108 usleep_range(1000, 2000); 109 } 110 111 DP_NOTICE(p_hwfn, "PTT acquire timeout - failed to allocate PTT\n"); 112 return NULL; 113 } 114 115 void qed_ptt_release(struct qed_hwfn *p_hwfn, 116 struct qed_ptt *p_ptt) 117 { 118 spin_lock_bh(&p_hwfn->p_ptt_pool->lock); 119 list_add(&p_ptt->list_entry, &p_hwfn->p_ptt_pool->free_list); 120 spin_unlock_bh(&p_hwfn->p_ptt_pool->lock); 121 } 122 123 u32 qed_ptt_get_hw_addr(struct qed_hwfn *p_hwfn, 124 struct qed_ptt *p_ptt) 125 { 126 /* The HW is using DWORDS and we need to translate it to Bytes */ 127 return le32_to_cpu(p_ptt->pxp.offset) << 2; 128 } 129 130 static u32 qed_ptt_config_addr(struct qed_ptt *p_ptt) 131 { 132 return PXP_PF_WINDOW_ADMIN_PER_PF_START + 133 p_ptt->idx * sizeof(struct pxp_ptt_entry); 134 } 135 136 u32 qed_ptt_get_bar_addr(struct qed_ptt *p_ptt) 137 { 138 return PXP_EXTERNAL_BAR_PF_WINDOW_START + 139 p_ptt->idx * PXP_EXTERNAL_BAR_PF_WINDOW_SINGLE_SIZE; 140 } 141 142 void qed_ptt_set_win(struct qed_hwfn *p_hwfn, 143 struct qed_ptt *p_ptt, 144 u32 new_hw_addr) 145 { 146 u32 prev_hw_addr; 147 148 prev_hw_addr = qed_ptt_get_hw_addr(p_hwfn, p_ptt); 149 150 if (new_hw_addr == prev_hw_addr) 151 return; 152 153 /* Update PTT entery in admin window */ 154 DP_VERBOSE(p_hwfn, NETIF_MSG_HW, 155 "Updating PTT entry %d to offset 0x%x\n", 156 p_ptt->idx, new_hw_addr); 157 158 /* The HW is using DWORDS and the address is in Bytes */ 159 p_ptt->pxp.offset = cpu_to_le32(new_hw_addr >> 2); 160 161 REG_WR(p_hwfn, 162 qed_ptt_config_addr(p_ptt) + 163 offsetof(struct pxp_ptt_entry, offset), 164 le32_to_cpu(p_ptt->pxp.offset)); 165 } 166 167 static u32 qed_set_ptt(struct qed_hwfn *p_hwfn, 168 struct qed_ptt *p_ptt, 169 u32 hw_addr) 170 { 171 u32 win_hw_addr = qed_ptt_get_hw_addr(p_hwfn, p_ptt); 172 u32 offset; 173 174 offset = hw_addr - win_hw_addr; 175 176 /* Verify the address is within the window */ 177 if (hw_addr < win_hw_addr || 178 offset >= PXP_EXTERNAL_BAR_PF_WINDOW_SINGLE_SIZE) { 179 qed_ptt_set_win(p_hwfn, p_ptt, hw_addr); 180 offset = 0; 181 } 182 183 return qed_ptt_get_bar_addr(p_ptt) + offset; 184 } 185 186 struct qed_ptt *qed_get_reserved_ptt(struct qed_hwfn *p_hwfn, 187 enum reserved_ptts ptt_idx) 188 { 189 if (ptt_idx >= RESERVED_PTT_MAX) { 190 DP_NOTICE(p_hwfn, 191 "Requested PTT %d is out of range\n", ptt_idx); 192 return NULL; 193 } 194 195 return &p_hwfn->p_ptt_pool->ptts[ptt_idx]; 196 } 197 198 void qed_wr(struct qed_hwfn *p_hwfn, 199 struct qed_ptt *p_ptt, 200 u32 hw_addr, u32 val) 201 { 202 u32 bar_addr = qed_set_ptt(p_hwfn, p_ptt, hw_addr); 203 204 REG_WR(p_hwfn, bar_addr, val); 205 DP_VERBOSE(p_hwfn, NETIF_MSG_HW, 206 "bar_addr 0x%x, hw_addr 0x%x, val 0x%x\n", 207 bar_addr, hw_addr, val); 208 } 209 210 u32 qed_rd(struct qed_hwfn *p_hwfn, 211 struct qed_ptt *p_ptt, 212 u32 hw_addr) 213 { 214 u32 bar_addr = qed_set_ptt(p_hwfn, p_ptt, hw_addr); 215 u32 val = REG_RD(p_hwfn, bar_addr); 216 217 DP_VERBOSE(p_hwfn, NETIF_MSG_HW, 218 "bar_addr 0x%x, hw_addr 0x%x, val 0x%x\n", 219 bar_addr, hw_addr, val); 220 221 return val; 222 } 223 224 static void qed_memcpy_hw(struct qed_hwfn *p_hwfn, 225 struct qed_ptt *p_ptt, 226 void *addr, 227 u32 hw_addr, 228 size_t n, 229 bool to_device) 230 { 231 u32 dw_count, *host_addr, hw_offset; 232 size_t quota, done = 0; 233 u32 __iomem *reg_addr; 234 235 while (done < n) { 236 quota = min_t(size_t, n - done, 237 PXP_EXTERNAL_BAR_PF_WINDOW_SINGLE_SIZE); 238 239 qed_ptt_set_win(p_hwfn, p_ptt, hw_addr + done); 240 hw_offset = qed_ptt_get_bar_addr(p_ptt); 241 242 dw_count = quota / 4; 243 host_addr = (u32 *)((u8 *)addr + done); 244 reg_addr = (u32 __iomem *)REG_ADDR(p_hwfn, hw_offset); 245 if (to_device) 246 while (dw_count--) 247 DIRECT_REG_WR(reg_addr++, *host_addr++); 248 else 249 while (dw_count--) 250 *host_addr++ = DIRECT_REG_RD(reg_addr++); 251 252 done += quota; 253 } 254 } 255 256 void qed_memcpy_from(struct qed_hwfn *p_hwfn, 257 struct qed_ptt *p_ptt, 258 void *dest, u32 hw_addr, size_t n) 259 { 260 DP_VERBOSE(p_hwfn, NETIF_MSG_HW, 261 "hw_addr 0x%x, dest %p hw_addr 0x%x, size %lu\n", 262 hw_addr, dest, hw_addr, (unsigned long)n); 263 264 qed_memcpy_hw(p_hwfn, p_ptt, dest, hw_addr, n, false); 265 } 266 267 void qed_memcpy_to(struct qed_hwfn *p_hwfn, 268 struct qed_ptt *p_ptt, 269 u32 hw_addr, void *src, size_t n) 270 { 271 DP_VERBOSE(p_hwfn, NETIF_MSG_HW, 272 "hw_addr 0x%x, hw_addr 0x%x, src %p size %lu\n", 273 hw_addr, hw_addr, src, (unsigned long)n); 274 275 qed_memcpy_hw(p_hwfn, p_ptt, src, hw_addr, n, true); 276 } 277 278 void qed_fid_pretend(struct qed_hwfn *p_hwfn, 279 struct qed_ptt *p_ptt, 280 u16 fid) 281 { 282 u16 control = 0; 283 284 SET_FIELD(control, PXP_PRETEND_CMD_IS_CONCRETE, 1); 285 SET_FIELD(control, PXP_PRETEND_CMD_PRETEND_FUNCTION, 1); 286 287 /* Every pretend undos previous pretends, including 288 * previous port pretend. 289 */ 290 SET_FIELD(control, PXP_PRETEND_CMD_PORT, 0); 291 SET_FIELD(control, PXP_PRETEND_CMD_USE_PORT, 0); 292 SET_FIELD(control, PXP_PRETEND_CMD_PRETEND_PORT, 1); 293 294 if (!GET_FIELD(fid, PXP_CONCRETE_FID_VFVALID)) 295 fid = GET_FIELD(fid, PXP_CONCRETE_FID_PFID); 296 297 p_ptt->pxp.pretend.control = cpu_to_le16(control); 298 p_ptt->pxp.pretend.fid.concrete_fid.fid = cpu_to_le16(fid); 299 300 REG_WR(p_hwfn, 301 qed_ptt_config_addr(p_ptt) + 302 offsetof(struct pxp_ptt_entry, pretend), 303 *(u32 *)&p_ptt->pxp.pretend); 304 } 305 306 void qed_port_pretend(struct qed_hwfn *p_hwfn, 307 struct qed_ptt *p_ptt, 308 u8 port_id) 309 { 310 u16 control = 0; 311 312 SET_FIELD(control, PXP_PRETEND_CMD_PORT, port_id); 313 SET_FIELD(control, PXP_PRETEND_CMD_USE_PORT, 1); 314 SET_FIELD(control, PXP_PRETEND_CMD_PRETEND_PORT, 1); 315 316 p_ptt->pxp.pretend.control = cpu_to_le16(control); 317 318 REG_WR(p_hwfn, 319 qed_ptt_config_addr(p_ptt) + 320 offsetof(struct pxp_ptt_entry, pretend), 321 *(u32 *)&p_ptt->pxp.pretend); 322 } 323 324 void qed_port_unpretend(struct qed_hwfn *p_hwfn, 325 struct qed_ptt *p_ptt) 326 { 327 u16 control = 0; 328 329 SET_FIELD(control, PXP_PRETEND_CMD_PORT, 0); 330 SET_FIELD(control, PXP_PRETEND_CMD_USE_PORT, 0); 331 SET_FIELD(control, PXP_PRETEND_CMD_PRETEND_PORT, 1); 332 333 p_ptt->pxp.pretend.control = cpu_to_le16(control); 334 335 REG_WR(p_hwfn, 336 qed_ptt_config_addr(p_ptt) + 337 offsetof(struct pxp_ptt_entry, pretend), 338 *(u32 *)&p_ptt->pxp.pretend); 339 } 340 341 u32 qed_vfid_to_concrete(struct qed_hwfn *p_hwfn, u8 vfid) 342 { 343 u32 concrete_fid = 0; 344 345 SET_FIELD(concrete_fid, PXP_CONCRETE_FID_PFID, p_hwfn->rel_pf_id); 346 SET_FIELD(concrete_fid, PXP_CONCRETE_FID_VFID, vfid); 347 SET_FIELD(concrete_fid, PXP_CONCRETE_FID_VFVALID, 1); 348 349 return concrete_fid; 350 } 351 352 /* DMAE */ 353 static void qed_dmae_opcode(struct qed_hwfn *p_hwfn, 354 const u8 is_src_type_grc, 355 const u8 is_dst_type_grc, 356 struct qed_dmae_params *p_params) 357 { 358 u16 opcode_b = 0; 359 u32 opcode = 0; 360 361 /* Whether the source is the PCIe or the GRC. 362 * 0- The source is the PCIe 363 * 1- The source is the GRC. 364 */ 365 opcode |= (is_src_type_grc ? DMAE_CMD_SRC_MASK_GRC 366 : DMAE_CMD_SRC_MASK_PCIE) << 367 DMAE_CMD_SRC_SHIFT; 368 opcode |= ((p_hwfn->rel_pf_id & DMAE_CMD_SRC_PF_ID_MASK) << 369 DMAE_CMD_SRC_PF_ID_SHIFT); 370 371 /* The destination of the DMA can be: 0-None 1-PCIe 2-GRC 3-None */ 372 opcode |= (is_dst_type_grc ? DMAE_CMD_DST_MASK_GRC 373 : DMAE_CMD_DST_MASK_PCIE) << 374 DMAE_CMD_DST_SHIFT; 375 opcode |= ((p_hwfn->rel_pf_id & DMAE_CMD_DST_PF_ID_MASK) << 376 DMAE_CMD_DST_PF_ID_SHIFT); 377 378 /* Whether to write a completion word to the completion destination: 379 * 0-Do not write a completion word 380 * 1-Write the completion word 381 */ 382 opcode |= (DMAE_CMD_COMP_WORD_EN_MASK << DMAE_CMD_COMP_WORD_EN_SHIFT); 383 opcode |= (DMAE_CMD_SRC_ADDR_RESET_MASK << 384 DMAE_CMD_SRC_ADDR_RESET_SHIFT); 385 386 if (p_params->flags & QED_DMAE_FLAG_COMPLETION_DST) 387 opcode |= (1 << DMAE_CMD_COMP_FUNC_SHIFT); 388 389 opcode |= (DMAE_CMD_ENDIANITY << DMAE_CMD_ENDIANITY_MODE_SHIFT); 390 391 opcode |= ((p_hwfn->port_id) << DMAE_CMD_PORT_ID_SHIFT); 392 393 /* reset source address in next go */ 394 opcode |= (DMAE_CMD_SRC_ADDR_RESET_MASK << 395 DMAE_CMD_SRC_ADDR_RESET_SHIFT); 396 397 /* reset dest address in next go */ 398 opcode |= (DMAE_CMD_DST_ADDR_RESET_MASK << 399 DMAE_CMD_DST_ADDR_RESET_SHIFT); 400 401 /* SRC/DST VFID: all 1's - pf, otherwise VF id */ 402 if (p_params->flags & QED_DMAE_FLAG_VF_SRC) { 403 opcode |= 1 << DMAE_CMD_SRC_VF_ID_VALID_SHIFT; 404 opcode_b |= p_params->src_vfid << DMAE_CMD_SRC_VF_ID_SHIFT; 405 } else { 406 opcode_b |= DMAE_CMD_SRC_VF_ID_MASK << 407 DMAE_CMD_SRC_VF_ID_SHIFT; 408 } 409 410 if (p_params->flags & QED_DMAE_FLAG_VF_DST) { 411 opcode |= 1 << DMAE_CMD_DST_VF_ID_VALID_SHIFT; 412 opcode_b |= p_params->dst_vfid << DMAE_CMD_DST_VF_ID_SHIFT; 413 } else { 414 opcode_b |= DMAE_CMD_DST_VF_ID_MASK << DMAE_CMD_DST_VF_ID_SHIFT; 415 } 416 417 p_hwfn->dmae_info.p_dmae_cmd->opcode = cpu_to_le32(opcode); 418 p_hwfn->dmae_info.p_dmae_cmd->opcode_b = cpu_to_le16(opcode_b); 419 } 420 421 u32 qed_dmae_idx_to_go_cmd(u8 idx) 422 { 423 /* All the DMAE 'go' registers form an array in internal memory */ 424 return DMAE_REG_GO_C0 + (idx << 2); 425 } 426 427 static int 428 qed_dmae_post_command(struct qed_hwfn *p_hwfn, 429 struct qed_ptt *p_ptt) 430 { 431 struct dmae_cmd *command = p_hwfn->dmae_info.p_dmae_cmd; 432 u8 idx_cmd = p_hwfn->dmae_info.channel, i; 433 int qed_status = 0; 434 435 /* verify address is not NULL */ 436 if ((((command->dst_addr_lo == 0) && (command->dst_addr_hi == 0)) || 437 ((command->src_addr_lo == 0) && (command->src_addr_hi == 0)))) { 438 DP_NOTICE(p_hwfn, 439 "source or destination address 0 idx_cmd=%d\n" 440 "opcode = [0x%08x,0x%04x] len=0x%x src=0x%x:%x dst=0x%x:%x\n", 441 idx_cmd, 442 le32_to_cpu(command->opcode), 443 le16_to_cpu(command->opcode_b), 444 le16_to_cpu(command->length), 445 le32_to_cpu(command->src_addr_hi), 446 le32_to_cpu(command->src_addr_lo), 447 le32_to_cpu(command->dst_addr_hi), 448 le32_to_cpu(command->dst_addr_lo)); 449 450 return -EINVAL; 451 } 452 453 DP_VERBOSE(p_hwfn, 454 NETIF_MSG_HW, 455 "Posting DMAE command [idx %d]: opcode = [0x%08x,0x%04x] len=0x%x src=0x%x:%x dst=0x%x:%x\n", 456 idx_cmd, 457 le32_to_cpu(command->opcode), 458 le16_to_cpu(command->opcode_b), 459 le16_to_cpu(command->length), 460 le32_to_cpu(command->src_addr_hi), 461 le32_to_cpu(command->src_addr_lo), 462 le32_to_cpu(command->dst_addr_hi), 463 le32_to_cpu(command->dst_addr_lo)); 464 465 /* Copy the command to DMAE - need to do it before every call 466 * for source/dest address no reset. 467 * The first 9 DWs are the command registers, the 10 DW is the 468 * GO register, and the rest are result registers 469 * (which are read only by the client). 470 */ 471 for (i = 0; i < DMAE_CMD_SIZE; i++) { 472 u32 data = (i < DMAE_CMD_SIZE_TO_FILL) ? 473 *(((u32 *)command) + i) : 0; 474 475 qed_wr(p_hwfn, p_ptt, 476 DMAE_REG_CMD_MEM + 477 (idx_cmd * DMAE_CMD_SIZE * sizeof(u32)) + 478 (i * sizeof(u32)), data); 479 } 480 481 qed_wr(p_hwfn, p_ptt, 482 qed_dmae_idx_to_go_cmd(idx_cmd), 483 DMAE_GO_VALUE); 484 485 return qed_status; 486 } 487 488 int qed_dmae_info_alloc(struct qed_hwfn *p_hwfn) 489 { 490 dma_addr_t *p_addr = &p_hwfn->dmae_info.completion_word_phys_addr; 491 struct dmae_cmd **p_cmd = &p_hwfn->dmae_info.p_dmae_cmd; 492 u32 **p_buff = &p_hwfn->dmae_info.p_intermediate_buffer; 493 u32 **p_comp = &p_hwfn->dmae_info.p_completion_word; 494 495 *p_comp = dma_alloc_coherent(&p_hwfn->cdev->pdev->dev, 496 sizeof(u32), 497 p_addr, 498 GFP_KERNEL); 499 if (!*p_comp) { 500 DP_NOTICE(p_hwfn, "Failed to allocate `p_completion_word'\n"); 501 goto err; 502 } 503 504 p_addr = &p_hwfn->dmae_info.dmae_cmd_phys_addr; 505 *p_cmd = dma_alloc_coherent(&p_hwfn->cdev->pdev->dev, 506 sizeof(struct dmae_cmd), 507 p_addr, GFP_KERNEL); 508 if (!*p_cmd) { 509 DP_NOTICE(p_hwfn, "Failed to allocate `struct dmae_cmd'\n"); 510 goto err; 511 } 512 513 p_addr = &p_hwfn->dmae_info.intermediate_buffer_phys_addr; 514 *p_buff = dma_alloc_coherent(&p_hwfn->cdev->pdev->dev, 515 sizeof(u32) * DMAE_MAX_RW_SIZE, 516 p_addr, GFP_KERNEL); 517 if (!*p_buff) { 518 DP_NOTICE(p_hwfn, "Failed to allocate `intermediate_buffer'\n"); 519 goto err; 520 } 521 522 p_hwfn->dmae_info.channel = p_hwfn->rel_pf_id; 523 524 return 0; 525 err: 526 qed_dmae_info_free(p_hwfn); 527 return -ENOMEM; 528 } 529 530 void qed_dmae_info_free(struct qed_hwfn *p_hwfn) 531 { 532 dma_addr_t p_phys; 533 534 /* Just make sure no one is in the middle */ 535 mutex_lock(&p_hwfn->dmae_info.mutex); 536 537 if (p_hwfn->dmae_info.p_completion_word) { 538 p_phys = p_hwfn->dmae_info.completion_word_phys_addr; 539 dma_free_coherent(&p_hwfn->cdev->pdev->dev, 540 sizeof(u32), 541 p_hwfn->dmae_info.p_completion_word, 542 p_phys); 543 p_hwfn->dmae_info.p_completion_word = NULL; 544 } 545 546 if (p_hwfn->dmae_info.p_dmae_cmd) { 547 p_phys = p_hwfn->dmae_info.dmae_cmd_phys_addr; 548 dma_free_coherent(&p_hwfn->cdev->pdev->dev, 549 sizeof(struct dmae_cmd), 550 p_hwfn->dmae_info.p_dmae_cmd, 551 p_phys); 552 p_hwfn->dmae_info.p_dmae_cmd = NULL; 553 } 554 555 if (p_hwfn->dmae_info.p_intermediate_buffer) { 556 p_phys = p_hwfn->dmae_info.intermediate_buffer_phys_addr; 557 dma_free_coherent(&p_hwfn->cdev->pdev->dev, 558 sizeof(u32) * DMAE_MAX_RW_SIZE, 559 p_hwfn->dmae_info.p_intermediate_buffer, 560 p_phys); 561 p_hwfn->dmae_info.p_intermediate_buffer = NULL; 562 } 563 564 mutex_unlock(&p_hwfn->dmae_info.mutex); 565 } 566 567 static int qed_dmae_operation_wait(struct qed_hwfn *p_hwfn) 568 { 569 u32 wait_cnt = 0; 570 u32 wait_cnt_limit = 10000; 571 572 int qed_status = 0; 573 574 barrier(); 575 while (*p_hwfn->dmae_info.p_completion_word != DMAE_COMPLETION_VAL) { 576 udelay(DMAE_MIN_WAIT_TIME); 577 if (++wait_cnt > wait_cnt_limit) { 578 DP_NOTICE(p_hwfn->cdev, 579 "Timed-out waiting for operation to complete. Completion word is 0x%08x expected 0x%08x.\n", 580 *p_hwfn->dmae_info.p_completion_word, 581 DMAE_COMPLETION_VAL); 582 qed_status = -EBUSY; 583 break; 584 } 585 586 /* to sync the completion_word since we are not 587 * using the volatile keyword for p_completion_word 588 */ 589 barrier(); 590 } 591 592 if (qed_status == 0) 593 *p_hwfn->dmae_info.p_completion_word = 0; 594 595 return qed_status; 596 } 597 598 static int qed_dmae_execute_sub_operation(struct qed_hwfn *p_hwfn, 599 struct qed_ptt *p_ptt, 600 u64 src_addr, 601 u64 dst_addr, 602 u8 src_type, 603 u8 dst_type, 604 u32 length) 605 { 606 dma_addr_t phys = p_hwfn->dmae_info.intermediate_buffer_phys_addr; 607 struct dmae_cmd *cmd = p_hwfn->dmae_info.p_dmae_cmd; 608 int qed_status = 0; 609 610 switch (src_type) { 611 case QED_DMAE_ADDRESS_GRC: 612 case QED_DMAE_ADDRESS_HOST_PHYS: 613 cmd->src_addr_hi = cpu_to_le32(upper_32_bits(src_addr)); 614 cmd->src_addr_lo = cpu_to_le32(lower_32_bits(src_addr)); 615 break; 616 /* for virtual source addresses we use the intermediate buffer. */ 617 case QED_DMAE_ADDRESS_HOST_VIRT: 618 cmd->src_addr_hi = cpu_to_le32(upper_32_bits(phys)); 619 cmd->src_addr_lo = cpu_to_le32(lower_32_bits(phys)); 620 memcpy(&p_hwfn->dmae_info.p_intermediate_buffer[0], 621 (void *)(uintptr_t)src_addr, 622 length * sizeof(u32)); 623 break; 624 default: 625 return -EINVAL; 626 } 627 628 switch (dst_type) { 629 case QED_DMAE_ADDRESS_GRC: 630 case QED_DMAE_ADDRESS_HOST_PHYS: 631 cmd->dst_addr_hi = cpu_to_le32(upper_32_bits(dst_addr)); 632 cmd->dst_addr_lo = cpu_to_le32(lower_32_bits(dst_addr)); 633 break; 634 /* for virtual source addresses we use the intermediate buffer. */ 635 case QED_DMAE_ADDRESS_HOST_VIRT: 636 cmd->dst_addr_hi = cpu_to_le32(upper_32_bits(phys)); 637 cmd->dst_addr_lo = cpu_to_le32(lower_32_bits(phys)); 638 break; 639 default: 640 return -EINVAL; 641 } 642 643 cmd->length = cpu_to_le16((u16)length); 644 645 qed_dmae_post_command(p_hwfn, p_ptt); 646 647 qed_status = qed_dmae_operation_wait(p_hwfn); 648 649 if (qed_status) { 650 DP_NOTICE(p_hwfn, 651 "qed_dmae_host2grc: Wait Failed. source_addr 0x%llx, grc_addr 0x%llx, size_in_dwords 0x%x\n", 652 src_addr, 653 dst_addr, 654 length); 655 return qed_status; 656 } 657 658 if (dst_type == QED_DMAE_ADDRESS_HOST_VIRT) 659 memcpy((void *)(uintptr_t)(dst_addr), 660 &p_hwfn->dmae_info.p_intermediate_buffer[0], 661 length * sizeof(u32)); 662 663 return 0; 664 } 665 666 static int qed_dmae_execute_command(struct qed_hwfn *p_hwfn, 667 struct qed_ptt *p_ptt, 668 u64 src_addr, u64 dst_addr, 669 u8 src_type, u8 dst_type, 670 u32 size_in_dwords, 671 struct qed_dmae_params *p_params) 672 { 673 dma_addr_t phys = p_hwfn->dmae_info.completion_word_phys_addr; 674 u16 length_cur = 0, i = 0, cnt_split = 0, length_mod = 0; 675 struct dmae_cmd *cmd = p_hwfn->dmae_info.p_dmae_cmd; 676 u64 src_addr_split = 0, dst_addr_split = 0; 677 u16 length_limit = DMAE_MAX_RW_SIZE; 678 int qed_status = 0; 679 u32 offset = 0; 680 681 qed_dmae_opcode(p_hwfn, 682 (src_type == QED_DMAE_ADDRESS_GRC), 683 (dst_type == QED_DMAE_ADDRESS_GRC), 684 p_params); 685 686 cmd->comp_addr_lo = cpu_to_le32(lower_32_bits(phys)); 687 cmd->comp_addr_hi = cpu_to_le32(upper_32_bits(phys)); 688 cmd->comp_val = cpu_to_le32(DMAE_COMPLETION_VAL); 689 690 /* Check if the grc_addr is valid like < MAX_GRC_OFFSET */ 691 cnt_split = size_in_dwords / length_limit; 692 length_mod = size_in_dwords % length_limit; 693 694 src_addr_split = src_addr; 695 dst_addr_split = dst_addr; 696 697 for (i = 0; i <= cnt_split; i++) { 698 offset = length_limit * i; 699 700 if (!(p_params->flags & QED_DMAE_FLAG_RW_REPL_SRC)) { 701 if (src_type == QED_DMAE_ADDRESS_GRC) 702 src_addr_split = src_addr + offset; 703 else 704 src_addr_split = src_addr + (offset * 4); 705 } 706 707 if (dst_type == QED_DMAE_ADDRESS_GRC) 708 dst_addr_split = dst_addr + offset; 709 else 710 dst_addr_split = dst_addr + (offset * 4); 711 712 length_cur = (cnt_split == i) ? length_mod : length_limit; 713 714 /* might be zero on last iteration */ 715 if (!length_cur) 716 continue; 717 718 qed_status = qed_dmae_execute_sub_operation(p_hwfn, 719 p_ptt, 720 src_addr_split, 721 dst_addr_split, 722 src_type, 723 dst_type, 724 length_cur); 725 if (qed_status) { 726 DP_NOTICE(p_hwfn, 727 "qed_dmae_execute_sub_operation Failed with error 0x%x. source_addr 0x%llx, destination addr 0x%llx, size_in_dwords 0x%x\n", 728 qed_status, 729 src_addr, 730 dst_addr, 731 length_cur); 732 break; 733 } 734 } 735 736 return qed_status; 737 } 738 739 int qed_dmae_host2grc(struct qed_hwfn *p_hwfn, 740 struct qed_ptt *p_ptt, 741 u64 source_addr, 742 u32 grc_addr, 743 u32 size_in_dwords, 744 u32 flags) 745 { 746 u32 grc_addr_in_dw = grc_addr / sizeof(u32); 747 struct qed_dmae_params params; 748 int rc; 749 750 memset(¶ms, 0, sizeof(struct qed_dmae_params)); 751 params.flags = flags; 752 753 mutex_lock(&p_hwfn->dmae_info.mutex); 754 755 rc = qed_dmae_execute_command(p_hwfn, p_ptt, source_addr, 756 grc_addr_in_dw, 757 QED_DMAE_ADDRESS_HOST_VIRT, 758 QED_DMAE_ADDRESS_GRC, 759 size_in_dwords, ¶ms); 760 761 mutex_unlock(&p_hwfn->dmae_info.mutex); 762 763 return rc; 764 } 765 766 int 767 qed_dmae_host2host(struct qed_hwfn *p_hwfn, 768 struct qed_ptt *p_ptt, 769 dma_addr_t source_addr, 770 dma_addr_t dest_addr, 771 u32 size_in_dwords, struct qed_dmae_params *p_params) 772 { 773 int rc; 774 775 mutex_lock(&(p_hwfn->dmae_info.mutex)); 776 777 rc = qed_dmae_execute_command(p_hwfn, p_ptt, source_addr, 778 dest_addr, 779 QED_DMAE_ADDRESS_HOST_PHYS, 780 QED_DMAE_ADDRESS_HOST_PHYS, 781 size_in_dwords, p_params); 782 783 mutex_unlock(&(p_hwfn->dmae_info.mutex)); 784 785 return rc; 786 } 787 788 u16 qed_get_qm_pq(struct qed_hwfn *p_hwfn, 789 enum protocol_type proto, 790 union qed_qm_pq_params *p_params) 791 { 792 u16 pq_id = 0; 793 794 if ((proto == PROTOCOLID_CORE || proto == PROTOCOLID_ETH) && 795 !p_params) { 796 DP_NOTICE(p_hwfn, 797 "Protocol %d received NULL PQ params\n", 798 proto); 799 return 0; 800 } 801 802 switch (proto) { 803 case PROTOCOLID_CORE: 804 if (p_params->core.tc == LB_TC) 805 pq_id = p_hwfn->qm_info.pure_lb_pq; 806 else 807 pq_id = p_hwfn->qm_info.offload_pq; 808 break; 809 case PROTOCOLID_ETH: 810 pq_id = p_params->eth.tc; 811 break; 812 default: 813 pq_id = 0; 814 } 815 816 pq_id = CM_TX_PQ_BASE + pq_id + RESC_START(p_hwfn, QED_PQ); 817 818 return pq_id; 819 } 820