tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge patch series "qla2xxx: Misc feature and bug fixes"

Nilesh Javali <njavali@marvell.com> says:

Hello Martin,

Please apply the qla2xxx driver load flash FW mailbox support
along with miscellaneous bug fixes to the scsi tree at your
earliest convenience.

Link: https://patch.msgid.link/20251210101604.431868-1-njavali@marvell.com
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

Martin K. Petersen 8334f930 0f9c4be7

+559 -56
+136 -11
drivers/scsi/qla2xxx/qla_bsg.c
··· 11 11 #include <linux/delay.h> 12 12 #include <linux/bsg-lib.h> 13 13 14 + static int qla28xx_validate_flash_image(struct bsg_job *bsg_job); 15 + 14 16 static void qla2xxx_free_fcport_work(struct work_struct *work) 15 17 { 16 18 struct fc_port *fcport = container_of(work, typeof(*fcport), ··· 1548 1546 ha->optrom_buffer = NULL; 1549 1547 ha->optrom_state = QLA_SWAITING; 1550 1548 mutex_unlock(&ha->optrom_mutex); 1551 - bsg_job_done(bsg_job, bsg_reply->result, 1552 - bsg_reply->reply_payload_rcv_len); 1549 + if (!rval) 1550 + bsg_job_done(bsg_job, bsg_reply->result, 1551 + bsg_reply->reply_payload_rcv_len); 1553 1552 return rval; 1554 1553 } 1555 1554 ··· 2553 2550 } 2554 2551 2555 2552 static int 2553 + qla2x00_get_drv_attr(struct bsg_job *bsg_job) 2554 + { 2555 + struct qla_drv_attr drv_attr; 2556 + struct fc_bsg_reply *bsg_reply = bsg_job->reply; 2557 + 2558 + memset(&drv_attr, 0, sizeof(struct qla_drv_attr)); 2559 + drv_attr.ext_attributes |= QLA_IMG_SET_VALID_SUPPORT; 2560 + 2561 + 2562 + sg_copy_from_buffer(bsg_job->reply_payload.sg_list, 2563 + bsg_job->reply_payload.sg_cnt, &drv_attr, 2564 + sizeof(struct qla_drv_attr)); 2565 + 2566 + bsg_reply->reply_payload_rcv_len = sizeof(struct qla_drv_attr); 2567 + bsg_reply->reply_data.vendor_reply.vendor_rsp[0] = EXT_STATUS_OK; 2568 + 2569 + bsg_job->reply_len = sizeof(struct fc_bsg_reply); 2570 + bsg_reply->result = DID_OK << 16; 2571 + bsg_job_done(bsg_job, bsg_reply->result, bsg_reply->reply_payload_rcv_len); 2572 + 2573 + return 0; 2574 + } 2575 + 2576 + static int 2556 2577 qla2x00_manage_host_stats(struct bsg_job *bsg_job) 2557 2578 { 2558 2579 scsi_qla_host_t *vha = shost_priv(fc_bsg_to_shost(bsg_job)); ··· 2639 2612 sizeof(struct ql_vnd_mng_host_stats_resp)); 2640 2613 2641 2614 bsg_reply->result = DID_OK; 2642 - bsg_job_done(bsg_job, bsg_reply->result, 2643 - bsg_reply->reply_payload_rcv_len); 2615 + if (!ret) 2616 + bsg_job_done(bsg_job, bsg_reply->result, 2617 + bsg_reply->reply_payload_rcv_len); 2644 2618 2645 2619 return ret; 2646 2620 } ··· 2730 2702 bsg_job->reply_payload.sg_cnt, 2731 2703 data, response_len); 2732 2704 bsg_reply->result = DID_OK; 2733 - bsg_job_done(bsg_job, bsg_reply->result, 2734 - bsg_reply->reply_payload_rcv_len); 2705 + if (!ret) 2706 + bsg_job_done(bsg_job, bsg_reply->result, 2707 + bsg_reply->reply_payload_rcv_len); 2735 2708 2736 2709 kfree(data); 2737 2710 host_stat_out: ··· 2831 2802 bsg_job->reply_payload.sg_cnt, data, 2832 2803 response_len); 2833 2804 bsg_reply->result = DID_OK; 2834 - bsg_job_done(bsg_job, bsg_reply->result, 2835 - bsg_reply->reply_payload_rcv_len); 2805 + if (!ret) 2806 + bsg_job_done(bsg_job, bsg_reply->result, 2807 + bsg_reply->reply_payload_rcv_len); 2836 2808 2837 2809 tgt_stat_out: 2838 2810 kfree(data); ··· 2894 2864 bsg_job->reply_payload.sg_cnt, &rsp_data, 2895 2865 sizeof(struct ql_vnd_mng_host_port_resp)); 2896 2866 bsg_reply->result = DID_OK; 2897 - bsg_job_done(bsg_job, bsg_reply->result, 2898 - bsg_reply->reply_payload_rcv_len); 2867 + if (!ret) 2868 + bsg_job_done(bsg_job, bsg_reply->result, 2869 + bsg_reply->reply_payload_rcv_len); 2899 2870 2900 2871 return ret; 2901 2872 } ··· 2963 2932 2964 2933 case QL_VND_GET_FLASH_UPDATE_CAPS: 2965 2934 return qla27xx_get_flash_upd_cap(bsg_job); 2935 + 2936 + case QL_VND_GET_DRV_ATTR: 2937 + return qla2x00_get_drv_attr(bsg_job); 2938 + 2939 + case QL_VND_IMG_SET_VALID: 2940 + return qla28xx_validate_flash_image(bsg_job); 2966 2941 2967 2942 case QL_VND_SET_FLASH_UPDATE_CAPS: 2968 2943 return qla27xx_set_flash_upd_cap(bsg_job); ··· 3277 3240 3278 3241 bsg_job->reply_len = sizeof(*bsg_job->reply); 3279 3242 bsg_reply->result = DID_OK << 16; 3280 - bsg_job_done(bsg_job, bsg_reply->result, bsg_reply->reply_payload_rcv_len); 3243 + if (!ret) 3244 + bsg_job_done(bsg_job, bsg_reply->result, bsg_reply->reply_payload_rcv_len); 3281 3245 3282 3246 kfree(req_data); 3283 3247 3284 3248 return ret; 3249 + } 3250 + 3251 + static int 3252 + qla28xx_do_validate_flash_image(struct bsg_job *bsg_job, uint16_t *state) 3253 + { 3254 + struct fc_bsg_request *bsg_request = bsg_job->request; 3255 + scsi_qla_host_t *vha = shost_priv(fc_bsg_to_shost(bsg_job)); 3256 + uint16_t mstate[16]; 3257 + uint16_t mpi_state = 0; 3258 + uint16_t img_idx; 3259 + int rval = QLA_SUCCESS; 3260 + 3261 + memset(mstate, 0, sizeof(mstate)); 3262 + 3263 + rval = qla2x00_get_firmware_state(vha, mstate); 3264 + if (rval != QLA_SUCCESS) { 3265 + ql_log(ql_log_warn, vha, 0xffff, 3266 + "MBC to get MPI state failed (%d)\n", rval); 3267 + rval = -EINVAL; 3268 + goto exit_flash_img; 3269 + } 3270 + 3271 + mpi_state = mstate[11]; 3272 + 3273 + if (!(mpi_state & BIT_9 && mpi_state & BIT_8 && mpi_state & BIT_15)) { 3274 + ql_log(ql_log_warn, vha, 0xffff, 3275 + "MPI firmware state failed (0x%02x)\n", mpi_state); 3276 + rval = -EINVAL; 3277 + goto exit_flash_img; 3278 + } 3279 + 3280 + rval = qla81xx_fac_semaphore_access(vha, FAC_SEMAPHORE_LOCK); 3281 + if (rval != QLA_SUCCESS) { 3282 + ql_log(ql_log_warn, vha, 0xffff, 3283 + "Unable to lock flash semaphore."); 3284 + goto exit_flash_img; 3285 + } 3286 + 3287 + img_idx = bsg_request->rqst_data.h_vendor.vendor_cmd[1]; 3288 + 3289 + rval = qla_mpipt_validate_fw(vha, img_idx, state); 3290 + if (rval != QLA_SUCCESS) { 3291 + ql_log(ql_log_warn, vha, 0xffff, 3292 + "Failed to validate Firmware image index [0x%x].\n", 3293 + img_idx); 3294 + } 3295 + 3296 + qla81xx_fac_semaphore_access(vha, FAC_SEMAPHORE_UNLOCK); 3297 + 3298 + exit_flash_img: 3299 + return rval; 3300 + } 3301 + 3302 + static int qla28xx_validate_flash_image(struct bsg_job *bsg_job) 3303 + { 3304 + scsi_qla_host_t *vha = shost_priv(fc_bsg_to_shost(bsg_job)); 3305 + struct fc_bsg_reply *bsg_reply = bsg_job->reply; 3306 + struct qla_hw_data *ha = vha->hw; 3307 + uint16_t state = 0; 3308 + int rval = 0; 3309 + 3310 + if (!IS_QLA28XX(ha) || vha->vp_idx != 0) 3311 + return -EPERM; 3312 + 3313 + mutex_lock(&ha->optrom_mutex); 3314 + rval = qla28xx_do_validate_flash_image(bsg_job, &state); 3315 + if (rval) 3316 + rval = -EINVAL; 3317 + mutex_unlock(&ha->optrom_mutex); 3318 + 3319 + bsg_job->reply_len = sizeof(struct fc_bsg_reply); 3320 + 3321 + if (rval) 3322 + bsg_reply->reply_data.vendor_reply.vendor_rsp[0] = 3323 + (state == 39) ? EXT_STATUS_IMG_SET_VALID_ERR : 3324 + EXT_STATUS_IMG_SET_CONFIG_ERR; 3325 + else 3326 + bsg_reply->reply_data.vendor_reply.vendor_rsp[0] = EXT_STATUS_OK; 3327 + 3328 + bsg_reply->result = DID_OK << 16; 3329 + bsg_reply->reply_payload_rcv_len = 0; 3330 + bsg_job->reply_len = sizeof(struct fc_bsg_reply); 3331 + if (!rval) 3332 + bsg_job_done(bsg_job, bsg_reply->result, 3333 + bsg_reply->reply_payload_rcv_len); 3334 + 3335 + return QLA_SUCCESS; 3285 3336 }
+12
drivers/scsi/qla2xxx/qla_bsg.h
··· 32 32 #define QL_VND_GET_PRIV_STATS_EX 0x1A 33 33 #define QL_VND_SS_GET_FLASH_IMAGE_STATUS 0x1E 34 34 #define QL_VND_EDIF_MGMT 0X1F 35 + #define QL_VND_GET_DRV_ATTR 0x22 35 36 #define QL_VND_MANAGE_HOST_STATS 0x23 36 37 #define QL_VND_GET_HOST_STATS 0x24 37 38 #define QL_VND_GET_TGT_STATS 0x25 38 39 #define QL_VND_MANAGE_HOST_PORT 0x26 39 40 #define QL_VND_MBX_PASSTHRU 0x2B 40 41 #define QL_VND_DPORT_DIAGNOSTICS_V2 0x2C 42 + #define QL_VND_IMG_SET_VALID 0x30 41 43 42 44 /* BSG Vendor specific subcode returns */ 43 45 #define EXT_STATUS_OK 0 ··· 52 50 #define EXT_STATUS_BUFFER_TOO_SMALL 16 53 51 #define EXT_STATUS_NO_MEMORY 17 54 52 #define EXT_STATUS_DEVICE_OFFLINE 22 53 + #define EXT_STATUS_IMG_SET_VALID_ERR 47 54 + #define EXT_STATUS_IMG_SET_CONFIG_ERR 48 55 55 56 56 /* 57 57 * To support bidirectional iocb ··· 320 316 uint8_t npiv_config_2_3; 321 317 uint8_t nvme_params; 322 318 uint8_t reserved[31]; 319 + } __packed; 320 + 321 + struct qla_drv_attr { 322 + uint32_t attributes; 323 + u32 ext_attributes; 324 + #define QLA_IMG_SET_VALID_SUPPORT BIT_4 325 + u32 status_flags; 326 + uint8_t reserved[20]; 323 327 } __packed; 324 328 325 329 #include "qla_edif_bsg.h"
+28 -2
drivers/scsi/qla2xxx/qla_def.h
··· 1270 1270 */ 1271 1271 #define MBC_LOAD_RAM 1 /* Load RAM. */ 1272 1272 #define MBC_EXECUTE_FIRMWARE 2 /* Execute firmware. */ 1273 + #define MBC_LOAD_FLASH_FIRMWARE 3 /* Load flash firmware. */ 1273 1274 #define MBC_READ_RAM_WORD 5 /* Read RAM word. */ 1274 1275 #define MBC_MAILBOX_REGISTER_TEST 6 /* Wrap incoming mailboxes */ 1275 1276 #define MBC_VERIFY_CHECKSUM 7 /* Verify checksum. */ ··· 1385 1384 #define MBC_SET_GET_ETH_SERDES_REG 0x150 1386 1385 #define HCS_WRITE_SERDES 0x3 1387 1386 #define HCS_READ_SERDES 0x4 1387 + 1388 + /* 1389 + * ISP2[7|8]xx mailbox commands. 1390 + */ 1391 + #define MBC_MPI_PASSTHROUGH 0x200 1392 + 1393 + /* MBC_MPI_PASSTHROUGH */ 1394 + #define MPIPT_REQ_V1 1 1395 + enum { 1396 + MPIPT_SUBCMD_GET_SUP_CMD = 0x10, 1397 + MPIPT_SUBCMD_GET_SUP_FEATURE, 1398 + MPIPT_SUBCMD_GET_STATUS, 1399 + MPIPT_SUBCMD_VALIDATE_FW, 1400 + }; 1401 + 1402 + enum { 1403 + MPIPT_MPI_STATUS = 1, 1404 + MPIPT_FCORE_STATUS, 1405 + MPIPT_LOCKDOWN_STATUS, 1406 + }; 1388 1407 1389 1408 /* Firmware return data sizes */ 1390 1409 #define FCAL_MAP_SIZE 128 ··· 4170 4149 uint32_t eeh_flush:2; 4171 4150 #define EEH_FLUSH_RDY 1 4172 4151 #define EEH_FLUSH_DONE 2 4152 + uint32_t secure_mcu:1; 4173 4153 } flags; 4174 4154 4175 4155 uint16_t max_exchg; ··· 4435 4413 #define IS_ZIO_THRESHOLD_CAPABLE(ha) \ 4436 4414 ((IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha)) &&\ 4437 4415 (ha->zio_mode == QLA_ZIO_MODE_6)) 4416 + 4417 + #define IS_QLA28XX_SECURED(ha) (IS_QLA28XX(ha) && ha->flags.secure_mcu) 4438 4418 4439 4419 /* HBA serial number */ 4440 4420 uint8_t serial0; ··· 5392 5368 struct list_head next; 5393 5369 }; 5394 5370 5395 - /* Refer to SNIA SFF 8247 */ 5371 + /* Refer to SNIA SFF 8472 */ 5396 5372 struct sff_8247_a0 { 5397 5373 u8 txid; /* transceiver id */ 5398 5374 u8 ext_txid; ··· 5436 5412 #define FC_SP_32 BIT_3 5437 5413 #define FC_SP_2 BIT_2 5438 5414 #define FC_SP_1 BIT_0 5415 + #define FC_SPEED_2 BIT_1 5439 5416 u8 fc_sp_cc10; 5440 5417 u8 encode; 5441 5418 u8 bitrate; ··· 5455 5430 u8 vendor_pn[SFF_PART_NAME_LEN]; /* part number */ 5456 5431 u8 vendor_rev[4]; 5457 5432 u8 wavelength[2]; 5458 - u8 resv; 5433 + #define FC_SP_64 BIT_0 5434 + u8 fiber_channel_speed2; 5459 5435 u8 cc_base; 5460 5436 u8 options[2]; /* offset 64 */ 5461 5437 u8 br_max;
+5
drivers/scsi/qla2xxx/qla_gbl.h
··· 345 345 qla2x00_execute_fw(scsi_qla_host_t *, uint32_t); 346 346 347 347 extern int 348 + qla28xx_load_flash_firmware(scsi_qla_host_t *vha); 349 + 350 + extern int 348 351 qla2x00_get_fw_version(scsi_qla_host_t *); 349 352 350 353 extern int ··· 841 838 /* Mailbox related functions */ 842 839 extern int qla82xx_abort_isp(scsi_qla_host_t *); 843 840 extern int qla82xx_restart_isp(scsi_qla_host_t *); 841 + 842 + extern int qla_mpipt_validate_fw(scsi_qla_host_t *vha, u16 img_idx, u16 *state); 844 843 845 844 /* IOCB related functions */ 846 845 extern int qla82xx_start_scsi(srb_t *);
+20 -21
drivers/scsi/qla2xxx/qla_gs.c
··· 3266 3266 atomic_read(&fcport->state) == FCS_ONLINE) || 3267 3267 do_delete) { 3268 3268 if (fcport->loop_id != FC_NO_LOOP_ID) { 3269 - if (fcport->flags & FCF_FCP2_DEVICE) 3270 - continue; 3271 - 3272 3269 ql_log(ql_log_warn, vha, 0x20f0, 3273 3270 "%s %d %8phC post del sess\n", 3274 3271 __func__, __LINE__, ··· 3532 3535 if (vha->scan.scan_flags & SF_SCANNING) { 3533 3536 spin_unlock_irqrestore(&vha->work_lock, flags); 3534 3537 ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0x2012, 3535 - "%s: scan active\n", __func__); 3536 - return rval; 3538 + "%s: scan active for sp:%p\n", __func__, sp); 3539 + goto done_free_sp; 3537 3540 } 3538 3541 vha->scan.scan_flags |= SF_SCANNING; 3539 3542 if (!sp) ··· 3698 3701 return rval; 3699 3702 3700 3703 done_free_sp: 3701 - if (sp->u.iocb_cmd.u.ctarg.req) { 3702 - dma_free_coherent(&vha->hw->pdev->dev, 3703 - sp->u.iocb_cmd.u.ctarg.req_allocated_size, 3704 - sp->u.iocb_cmd.u.ctarg.req, 3705 - sp->u.iocb_cmd.u.ctarg.req_dma); 3706 - sp->u.iocb_cmd.u.ctarg.req = NULL; 3707 - } 3708 - if (sp->u.iocb_cmd.u.ctarg.rsp) { 3709 - dma_free_coherent(&vha->hw->pdev->dev, 3710 - sp->u.iocb_cmd.u.ctarg.rsp_allocated_size, 3711 - sp->u.iocb_cmd.u.ctarg.rsp, 3712 - sp->u.iocb_cmd.u.ctarg.rsp_dma); 3713 - sp->u.iocb_cmd.u.ctarg.rsp = NULL; 3714 - } 3704 + if (sp) { 3705 + if (sp->u.iocb_cmd.u.ctarg.req) { 3706 + dma_free_coherent(&vha->hw->pdev->dev, 3707 + sp->u.iocb_cmd.u.ctarg.req_allocated_size, 3708 + sp->u.iocb_cmd.u.ctarg.req, 3709 + sp->u.iocb_cmd.u.ctarg.req_dma); 3710 + sp->u.iocb_cmd.u.ctarg.req = NULL; 3711 + } 3712 + if (sp->u.iocb_cmd.u.ctarg.rsp) { 3713 + dma_free_coherent(&vha->hw->pdev->dev, 3714 + sp->u.iocb_cmd.u.ctarg.rsp_allocated_size, 3715 + sp->u.iocb_cmd.u.ctarg.rsp, 3716 + sp->u.iocb_cmd.u.ctarg.rsp_dma); 3717 + sp->u.iocb_cmd.u.ctarg.rsp = NULL; 3718 + } 3715 3719 3716 - /* ref: INIT */ 3717 - kref_put(&sp->cmd_kref, qla2x00_sp_release); 3720 + /* ref: INIT */ 3721 + kref_put(&sp->cmd_kref, qla2x00_sp_release); 3722 + } 3718 3723 3719 3724 spin_lock_irqsave(&vha->work_lock, flags); 3720 3725 vha->scan.scan_flags &= ~SF_SCANNING;
+217 -15
drivers/scsi/qla2xxx/qla_init.c
··· 1859 1859 case RSCN_PORT_ADDR: 1860 1860 fcport = qla2x00_find_fcport_by_nportid(vha, &ea->id, 1); 1861 1861 if (fcport) { 1862 - if (ql2xfc2target && 1863 - fcport->flags & FCF_FCP2_DEVICE && 1864 - atomic_read(&fcport->state) == FCS_ONLINE) { 1865 - ql_dbg(ql_dbg_disc, vha, 0x2115, 1866 - "Delaying session delete for FCP2 portid=%06x %8phC ", 1867 - fcport->d_id.b24, fcport->port_name); 1868 - return; 1869 - } 1870 - 1871 1862 if (vha->hw->flags.edif_enabled && DBELL_ACTIVE(vha)) { 1872 1863 /* 1873 1864 * On ipsec start by remote port, Target port ··· 2462 2471 ea->sp->gen1, fcport->rscn_gen, 2463 2472 ea->data[0], ea->data[1], ea->iop[0], ea->iop[1]); 2464 2473 2465 - if ((fcport->fw_login_state == DSC_LS_PLOGI_PEND) || 2466 - (fcport->fw_login_state == DSC_LS_PRLI_PEND)) { 2474 + if (fcport->fw_login_state == DSC_LS_PLOGI_PEND) { 2475 + ql_dbg(ql_dbg_disc, vha, 0x20ea, 2476 + "%s %d %8phC Remote is trying to login\n", 2477 + __func__, __LINE__, fcport->port_name); 2478 + /* 2479 + * If we get here, there is port thats already logged in, 2480 + * but it's state has not moved ahead. Recheck with FW on 2481 + * what state it is in and proceed ahead 2482 + */ 2483 + if (!N2N_TOPO(vha->hw)) { 2484 + fcport->fw_login_state = DSC_LS_PRLI_COMP; 2485 + qla24xx_post_gpdb_work(vha, fcport, 0); 2486 + } 2487 + return; 2488 + } 2489 + 2490 + if (fcport->fw_login_state == DSC_LS_PRLI_PEND) { 2467 2491 ql_dbg(ql_dbg_disc, vha, 0x20ea, 2468 2492 "%s %d %8phC Remote is trying to login\n", 2469 2493 __func__, __LINE__, fcport->port_name); ··· 4079 4073 struct sff_8247_a0 *a0 = (struct sff_8247_a0 *)vha->hw->sfp_data; 4080 4074 u8 str[STR_LEN], *ptr, p; 4081 4075 int leftover, len; 4076 + 4077 + ql_dbg(ql_dbg_init, vha, 0x015a, 4078 + "SFP: %.*s -> %.*s ->%s%s%s%s%s%s%s\n", 4079 + (int)sizeof(a0->vendor_name), a0->vendor_name, 4080 + (int)sizeof(a0->vendor_pn), a0->vendor_pn, 4081 + a0->fc_sp_cc10 & FC_SP_2 ? a0->fiber_channel_speed2 & FC_SP_64 ? 4082 + " 64G" : "" : "", 4083 + a0->fc_sp_cc10 & FC_SP_32 ? " 32G" : "", 4084 + a0->fc_sp_cc10 & FC_SP_16 ? " 16G" : "", 4085 + a0->fc_sp_cc10 & FC_SP_8 ? " 8G" : "", 4086 + a0->fc_sp_cc10 & FC_SP_4 ? " 4G" : "", 4087 + a0->fc_sp_cc10 & FC_SP_2 ? " 2G" : "", 4088 + a0->fc_sp_cc10 & FC_SP_1 ? " 1G" : ""); 4089 + 4090 + if (!(ql2xextended_error_logging & ql_dbg_verbose)) 4091 + return; 4082 4092 4083 4093 memset(str, 0, STR_LEN); 4084 4094 snprintf(str, SFF_VEN_NAME_LEN+1, a0->vendor_name); ··· 8465 8443 } 8466 8444 8467 8445 static int 8446 + qla28xx_get_srisc_addr(scsi_qla_host_t *vha, uint32_t *srisc_addr, 8447 + uint32_t faddr) 8448 + { 8449 + struct qla_hw_data *ha = vha->hw; 8450 + struct req_que *req = ha->req_q_map[0]; 8451 + uint32_t *dcode; 8452 + int rval; 8453 + 8454 + *srisc_addr = 0; 8455 + dcode = (uint32_t *)req->ring; 8456 + 8457 + rval = qla24xx_read_flash_data(vha, dcode, faddr, 10); 8458 + if (rval) { 8459 + ql_log(ql_log_fatal, vha, 0x01aa, 8460 + "-> Failed to read flash addr + size .\n"); 8461 + return QLA_FUNCTION_FAILED; 8462 + } 8463 + 8464 + *srisc_addr = be32_to_cpu((__force __be32)dcode[2]); 8465 + return QLA_SUCCESS; 8466 + } 8467 + 8468 + static int 8469 + qla28xx_load_fw_template(scsi_qla_host_t *vha, uint32_t faddr) 8470 + { 8471 + struct qla_hw_data *ha = vha->hw; 8472 + struct fwdt *fwdt = ha->fwdt; 8473 + struct req_que *req = ha->req_q_map[0]; 8474 + uint32_t risc_size, risc_attr = 0; 8475 + uint templates, segments, fragment; 8476 + uint32_t *dcode; 8477 + ulong dlen; 8478 + int rval; 8479 + uint j; 8480 + 8481 + dcode = (uint32_t *)req->ring; 8482 + segments = FA_RISC_CODE_SEGMENTS; 8483 + 8484 + for (j = 0; j < segments; j++) { 8485 + rval = qla24xx_read_flash_data(vha, dcode, faddr, 10); 8486 + if (rval) { 8487 + ql_log(ql_log_fatal, vha, 0x01a1, 8488 + "-> Failed to read flash addr + size .\n"); 8489 + return QLA_FUNCTION_FAILED; 8490 + } 8491 + 8492 + risc_size = be32_to_cpu((__force __be32)dcode[3]); 8493 + 8494 + if (risc_attr == 0) 8495 + risc_attr = be32_to_cpu((__force __be32)dcode[9]); 8496 + 8497 + dlen = ha->fw_transfer_size >> 2; 8498 + for (fragment = 0; fragment < risc_size; fragment++) { 8499 + if (dlen > risc_size) 8500 + dlen = risc_size; 8501 + 8502 + faddr += dlen; 8503 + risc_size -= dlen; 8504 + } 8505 + } 8506 + 8507 + templates = (risc_attr & BIT_9) ? 2 : 1; 8508 + 8509 + ql_dbg(ql_dbg_init, vha, 0x01a1, "-> templates = %u\n", templates); 8510 + 8511 + for (j = 0; j < templates; j++, fwdt++) { 8512 + vfree(fwdt->template); 8513 + fwdt->template = NULL; 8514 + fwdt->length = 0; 8515 + 8516 + dcode = (uint32_t *)req->ring; 8517 + 8518 + rval = qla24xx_read_flash_data(vha, dcode, faddr, 7); 8519 + if (rval) { 8520 + ql_log(ql_log_fatal, vha, 0x01a2, 8521 + "-> Unable to read template size.\n"); 8522 + goto failed; 8523 + } 8524 + 8525 + risc_size = be32_to_cpu((__force __be32)dcode[2]); 8526 + ql_dbg(ql_dbg_init, vha, 0x01a3, 8527 + "-> fwdt%u template array at %#x (%#x dwords)\n", 8528 + j, faddr, risc_size); 8529 + if (!risc_size || !~risc_size) { 8530 + ql_dbg(ql_dbg_init, vha, 0x01a4, 8531 + "-> fwdt%u failed to read array\n", j); 8532 + goto failed; 8533 + } 8534 + 8535 + /* skip header and ignore checksum */ 8536 + faddr += 7; 8537 + risc_size -= 8; 8538 + 8539 + ql_dbg(ql_dbg_init, vha, 0x01a5, 8540 + "-> fwdt%u template allocate template %#x words...\n", 8541 + j, risc_size); 8542 + fwdt->template = vmalloc(risc_size * sizeof(*dcode)); 8543 + if (!fwdt->template) { 8544 + ql_log(ql_log_warn, vha, 0x01a6, 8545 + "-> fwdt%u failed allocate template.\n", j); 8546 + goto failed; 8547 + } 8548 + 8549 + dcode = fwdt->template; 8550 + rval = qla24xx_read_flash_data(vha, dcode, faddr, risc_size); 8551 + 8552 + if (rval || !qla27xx_fwdt_template_valid(dcode)) { 8553 + ql_log(ql_log_warn, vha, 0x01a7, 8554 + "-> fwdt%u failed template validate (rval %x)\n", 8555 + j, rval); 8556 + goto failed; 8557 + } 8558 + 8559 + dlen = qla27xx_fwdt_template_size(dcode); 8560 + ql_dbg(ql_dbg_init, vha, 0x01a7, 8561 + "-> fwdt%u template size %#lx bytes (%#lx words)\n", 8562 + j, dlen, dlen / sizeof(*dcode)); 8563 + if (dlen > risc_size * sizeof(*dcode)) { 8564 + ql_log(ql_log_warn, vha, 0x01a8, 8565 + "-> fwdt%u template exceeds array (%-lu bytes)\n", 8566 + j, dlen - risc_size * sizeof(*dcode)); 8567 + goto failed; 8568 + } 8569 + 8570 + fwdt->length = dlen; 8571 + ql_dbg(ql_dbg_init, vha, 0x01a9, 8572 + "-> fwdt%u loaded template ok\n", j); 8573 + 8574 + faddr += risc_size + 1; 8575 + } 8576 + 8577 + return QLA_SUCCESS; 8578 + 8579 + failed: 8580 + vfree(fwdt->template); 8581 + fwdt->template = NULL; 8582 + fwdt->length = 0; 8583 + 8584 + return QLA_SUCCESS; 8585 + } 8586 + 8587 + static int 8468 8588 qla24xx_load_risc_flash(scsi_qla_host_t *vha, uint32_t *srisc_addr, 8469 8589 uint32_t faddr) 8470 8590 { ··· 9045 8881 qla81xx_load_risc(scsi_qla_host_t *vha, uint32_t *srisc_addr) 9046 8882 { 9047 8883 int rval; 8884 + uint32_t f_region = 0; 9048 8885 struct qla_hw_data *ha = vha->hw; 9049 8886 struct active_regions active_regions = { }; 9050 8887 9051 - if (ql2xfwloadbin == 2) 8888 + if (ql2xfwloadbin == 2 && !IS_QLA28XX(ha)) 9052 8889 goto try_blob_fw; 9053 8890 9054 8891 /* FW Load priority: 9055 - * 1) Firmware residing in flash. 9056 - * 2) Firmware via request-firmware interface (.bin file). 9057 - * 3) Golden-Firmware residing in flash -- (limited operation). 8892 + * 1) If 28xxx, ROM cmd to load flash firmware. 8893 + * 2) Firmware residing in flash. 8894 + * 3) Firmware via request-firmware interface (.bin file). 8895 + * 4) Golden-Firmware residing in flash -- (limited operation). 9058 8896 */ 9059 8897 9060 8898 if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha)) 9061 8899 goto try_primary_fw; 9062 8900 9063 8901 qla27xx_get_active_image(vha, &active_regions); 8902 + 8903 + /* For 28XXX, always load the flash firmware using rom mbx */ 8904 + if (IS_QLA28XX_SECURED(ha)) { 8905 + rval = qla28xx_load_flash_firmware(vha); 8906 + if (rval != QLA_SUCCESS) { 8907 + ql_log(ql_log_fatal, vha, 0x019e, 8908 + "Failed to load flash firmware.\n"); 8909 + goto exit_load_risc; 8910 + } 8911 + 8912 + f_region = 8913 + (active_regions.global != QLA27XX_SECONDARY_IMAGE) ? 8914 + ha->flt_region_fw : ha->flt_region_fw_sec; 8915 + 8916 + ql_log(ql_log_info, vha, 0x019f, 8917 + "Load flash firmware successful (%s).\n", 8918 + ((active_regions.global != QLA27XX_SECONDARY_IMAGE) ? 8919 + "Primary" : "Secondary")); 8920 + 8921 + rval = qla28xx_get_srisc_addr(vha, srisc_addr, f_region); 8922 + if (rval != QLA_SUCCESS) { 8923 + ql_log(ql_log_warn, vha, 0x019f, 8924 + "failed to read srisc address\n"); 8925 + goto exit_load_risc; 8926 + } 8927 + 8928 + rval = qla28xx_load_fw_template(vha, f_region); 8929 + if (rval != QLA_SUCCESS) { 8930 + ql_log(ql_log_warn, vha, 0x01a0, 8931 + "failed to read firmware template\n"); 8932 + } 8933 + 8934 + goto exit_load_risc; 8935 + } 9064 8936 9065 8937 if (active_regions.global != QLA27XX_SECONDARY_IMAGE) 9066 8938 goto try_primary_fw; ··· 9127 8927 9128 8928 ql_log(ql_log_info, vha, 0x009a, "Need firmware flash update.\n"); 9129 8929 ha->flags.running_gold_fw = 1; 8930 + 8931 + exit_load_risc: 9130 8932 return rval; 9131 8933 } 9132 8934
+17 -2
drivers/scsi/qla2xxx/qla_isr.c
··· 1669 1669 1670 1670 /* Port logout */ 1671 1671 fcport = qla2x00_find_fcport_by_loopid(vha, mb[1]); 1672 - if (!fcport) 1672 + if (!fcport) { 1673 + ql_dbg(ql_dbg_async, vha, 0x5011, 1674 + "Could not find fcport:%04x %04x %04x\n", 1675 + mb[1], mb[2], mb[3]); 1673 1676 break; 1674 - if (atomic_read(&fcport->state) != FCS_ONLINE) 1677 + } 1678 + 1679 + if (atomic_read(&fcport->state) != FCS_ONLINE) { 1680 + ql_dbg(ql_dbg_async, vha, 0x5012, 1681 + "Port state is not online State:0x%x \n", 1682 + atomic_read(&fcport->state)); 1683 + ql_dbg(ql_dbg_async, vha, 0x5012, 1684 + "Scheduling session for deletion \n"); 1685 + fcport->logout_on_delete = 0; 1686 + qlt_schedule_sess_for_deletion(fcport); 1675 1687 break; 1688 + } 1689 + 1676 1690 ql_dbg(ql_dbg_async, vha, 0x508a, 1677 1691 "Marking port lost loopid=%04x portid=%06x.\n", 1678 1692 fcport->loop_id, fcport->d_id.b24); 1693 + 1679 1694 if (qla_ini_mode_enabled(vha)) { 1680 1695 fcport->logout_on_delete = 0; 1681 1696 qlt_schedule_sess_for_deletion(fcport);
+88
drivers/scsi/qla2xxx/qla_mbx.c
··· 43 43 } rom_cmds[] = { 44 44 { MBC_LOAD_RAM }, 45 45 { MBC_EXECUTE_FIRMWARE }, 46 + { MBC_LOAD_FLASH_FIRMWARE }, 46 47 { MBC_READ_RAM_WORD }, 47 48 { MBC_MAILBOX_REGISTER_TEST }, 48 49 { MBC_VERIFY_CHECKSUM }, ··· 824 823 825 824 return rval; 826 825 } 826 + 827 + /* 828 + * qla2x00_load_flash_firmware 829 + * Load firmware from flash. 830 + * 831 + * Input: 832 + * vha = adapter block pointer. 833 + * 834 + * Returns: 835 + * qla28xx local function return status code. 836 + * 837 + * Context: 838 + * Kernel context. 839 + */ 840 + int 841 + qla28xx_load_flash_firmware(scsi_qla_host_t *vha) 842 + { 843 + struct qla_hw_data *ha = vha->hw; 844 + int rval = QLA_COMMAND_ERROR; 845 + mbx_cmd_t mc; 846 + mbx_cmd_t *mcp = &mc; 847 + 848 + if (!IS_QLA28XX(ha)) 849 + return rval; 850 + 851 + ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x11a6, 852 + "Entered %s.\n", __func__); 853 + 854 + mcp->mb[0] = MBC_LOAD_FLASH_FIRMWARE; 855 + mcp->out_mb = MBX_2 | MBX_1 | MBX_0; 856 + mcp->in_mb = MBX_0; 857 + mcp->tov = MBX_TOV_SECONDS; 858 + mcp->flags = 0; 859 + rval = qla2x00_mailbox_command(vha, mcp); 860 + 861 + if (rval != QLA_SUCCESS) { 862 + ql_dbg(ql_log_info, vha, 0x11a7, 863 + "Failed=%x cmd error=%x img error=%x.\n", 864 + rval, mcp->mb[1], mcp->mb[2]); 865 + } else { 866 + ql_dbg(ql_log_info, vha, 0x11a8, 867 + "Done %s.\n", __func__); 868 + } 869 + 870 + return rval; 871 + } 872 + 827 873 828 874 /* 829 875 * qla_get_exlogin_status ··· 7201 7153 __func__); 7202 7154 /* passing all 32 register's contents */ 7203 7155 memcpy(mbx_out, &mcp->mb, 32 * sizeof(uint16_t)); 7156 + } 7157 + 7158 + return rval; 7159 + } 7160 + 7161 + int qla_mpipt_validate_fw(scsi_qla_host_t *vha, u16 img_idx, uint16_t *state) 7162 + { 7163 + struct qla_hw_data *ha = vha->hw; 7164 + mbx_cmd_t mc; 7165 + mbx_cmd_t *mcp = &mc; 7166 + int rval; 7167 + 7168 + if (!IS_QLA28XX(ha)) { 7169 + ql_dbg(ql_dbg_mbx, vha, 0xffff, "%s %d\n", __func__, __LINE__); 7170 + return QLA_FUNCTION_FAILED; 7171 + } 7172 + 7173 + if (img_idx > 1) { 7174 + ql_log(ql_log_info, vha, 0xffff, 7175 + "%s %d Invalid flash image index [%d]\n", 7176 + __func__, __LINE__, img_idx); 7177 + return QLA_INVALID_COMMAND; 7178 + } 7179 + 7180 + memset(&mc, 0, sizeof(mc)); 7181 + mcp->mb[0] = MBC_MPI_PASSTHROUGH; 7182 + mcp->mb[1] = MPIPT_SUBCMD_VALIDATE_FW; 7183 + mcp->mb[2] = img_idx; 7184 + mcp->out_mb = MBX_1|MBX_0; 7185 + mcp->in_mb = MBX_2|MBX_1|MBX_0; 7186 + 7187 + /* send mb via iocb */ 7188 + rval = qla24xx_send_mb_cmd(vha, &mc); 7189 + if (rval) { 7190 + ql_log(ql_log_info, vha, 0xffff, "%s:Failed %x (mb=%x,%x)\n", 7191 + __func__, rval, mcp->mb[0], mcp->mb[1]); 7192 + *state = mcp->mb[1]; 7193 + } else { 7194 + ql_log(ql_log_info, vha, 0xffff, "%s: mb=%x,%x,%x\n", __func__, 7195 + mcp->mb[0], mcp->mb[1], mcp->mb[2]); 7204 7196 } 7205 7197 7206 7198 return rval;
+1
drivers/scsi/qla2xxx/qla_nx.h
··· 892 892 #define FA_VPD_SIZE_82XX 0x400 893 893 894 894 #define FA_FLASH_LAYOUT_ADDR_82 0xFC400 895 + #define FA_FLASH_MCU_OFF 0x13000 895 896 896 897 /****************************************************************************** 897 898 *
+2 -1
drivers/scsi/qla2xxx/qla_os.c
··· 1183 1183 while ((qla2x00_reset_active(vha) || ha->dpc_active || 1184 1184 ha->flags.mbox_busy) || 1185 1185 test_bit(FX00_RESET_RECOVERY, &vha->dpc_flags) || 1186 - test_bit(FX00_TARGET_SCAN, &vha->dpc_flags)) { 1186 + test_bit(FX00_TARGET_SCAN, &vha->dpc_flags) || 1187 + (vha->scan.scan_flags & SF_SCANNING)) { 1187 1188 if (test_bit(UNLOADING, &base_vha->dpc_flags)) 1188 1189 break; 1189 1190 msleep(1000);
+29
drivers/scsi/qla2xxx/qla_sup.c
··· 1084 1084 return; 1085 1085 } 1086 1086 1087 + static int qla28xx_validate_mcu_signature(scsi_qla_host_t *vha) 1088 + { 1089 + struct qla_hw_data *ha = vha->hw; 1090 + struct req_que *req = ha->req_q_map[0]; 1091 + uint32_t *dcode = (uint32_t *)req->ring; 1092 + uint32_t signature[2] = {0x000c0000, 0x00050000}; 1093 + int ret = QLA_SUCCESS; 1094 + 1095 + ret = qla24xx_read_flash_data(vha, dcode, FA_FLASH_MCU_OFF >> 2, 2); 1096 + if (ret) { 1097 + ql_log(ql_log_fatal, vha, 0x01ab, 1098 + "-> Failed to read flash mcu signature.\n"); 1099 + ret = QLA_FUNCTION_FAILED; 1100 + goto done; 1101 + } 1102 + 1103 + ql_dbg(ql_dbg_init, vha, 0x01ac, 1104 + "Flash data 0x%08x 0x%08x.\n", dcode[0], dcode[1]); 1105 + 1106 + if (!(dcode[0] == signature[0] && dcode[1] == signature[1])) 1107 + ret = QLA_FUNCTION_FAILED; 1108 + 1109 + done: 1110 + return ret; 1111 + } 1112 + 1087 1113 int 1088 1114 qla2xxx_get_flash_info(scsi_qla_host_t *vha) 1089 1115 { ··· 1121 1095 !IS_CNA_CAPABLE(ha) && !IS_QLA2031(ha) && 1122 1096 !IS_QLA27XX(ha) && !IS_QLA28XX(ha)) 1123 1097 return QLA_SUCCESS; 1098 + 1099 + if (IS_QLA28XX(ha) && !qla28xx_validate_mcu_signature(vha)) 1100 + ha->flags.secure_mcu = 1; 1124 1101 1125 1102 ret = qla2xxx_find_flt_start(vha, &flt_addr); 1126 1103 if (ret != QLA_SUCCESS)
+4 -4
drivers/scsi/qla2xxx/qla_version.h
··· 6 6 /* 7 7 * Driver version 8 8 */ 9 - #define QLA2XXX_VERSION "10.02.09.400-k" 9 + #define QLA2XXX_VERSION "10.02.10.100-k" 10 10 11 11 #define QLA_DRIVER_MAJOR_VER 10 12 - #define QLA_DRIVER_MINOR_VER 2 13 - #define QLA_DRIVER_PATCH_VER 9 14 - #define QLA_DRIVER_BETA_VER 400 12 + #define QLA_DRIVER_MINOR_VER 02 13 + #define QLA_DRIVER_PATCH_VER 10 14 + #define QLA_DRIVER_BETA_VER 100