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 tag 'scsi-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi

Pull SCSI fixes from James Bottomley:
"Twenty fixes all in drivers except the one zone storage revalidation
fix to sd.

The megaraid_sas fixes are more on the level of a driver update
(enabling crash dump and increasing lun number) but I thought you
could let this slide on -rc1 and the next most extensive update is a
load of fixes to mpi3mr"

* tag 'scsi-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi:
scsi: sd: Fix wrong zone_write_granularity value during revalidate
scsi: storvsc: Handle BlockSize change in Hyper-V VHD/VHDX file
scsi: megaraid_sas: Driver version update to 07.725.01.00-rc1
scsi: megaraid_sas: Add crash dump mode capability bit in MFI capabilities
scsi: megaraid_sas: Update max supported LD IDs to 240
scsi: mpi3mr: Bad drive in topology results kernel crash
scsi: mpi3mr: NVMe command size greater than 8K fails
scsi: mpi3mr: Return proper values for failures in firmware init path
scsi: mpi3mr: Wait for diagnostic save during controller init
scsi: mpi3mr: Driver unload crashes host when enhanced logging is enabled
scsi: mpi3mr: ioctl timeout when disabling/enabling interrupt
scsi: lpfc: Avoid usage of list iterator variable after loop
scsi: lpfc: Check kzalloc() in lpfc_sli4_cgn_params_read()
scsi: ufs: mcq: qcom: Clean the return path of ufs_qcom_mcq_config_resource()
scsi: ufs: mcq: qcom: Fix passing zero to PTR_ERR
scsi: ufs: ufs-qcom: Remove impossible check
scsi: ufs: core: Add soft dependency on governor_simpleondemand
scsi: hisi_sas: Check devm_add_action() return value
scsi: qla2xxx: Add option to disable FC2 Target support
scsi: target: iscsi: Fix an error message in iscsi_check_key()

Linus Torvalds ef5f68cc 40f879bd

+117 -50
+1 -2
drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
··· 2495 2495 hisi_hba->cq_nvecs = vectors - BASE_VECTORS_V3_HW; 2496 2496 shost->nr_hw_queues = hisi_hba->cq_nvecs; 2497 2497 2498 - devm_add_action(&pdev->dev, hisi_sas_v3_free_vectors, pdev); 2499 - return 0; 2498 + return devm_add_action(&pdev->dev, hisi_sas_v3_free_vectors, pdev); 2500 2499 } 2501 2500 2502 2501 static int interrupt_init_v3_hw(struct hisi_hba *hisi_hba)
+2
drivers/scsi/lpfc/lpfc_init.c
··· 7291 7291 /* Find out if the FW has a new set of congestion parameters. */ 7292 7292 len = sizeof(struct lpfc_cgn_param); 7293 7293 pdata = kzalloc(len, GFP_KERNEL); 7294 + if (!pdata) 7295 + return -ENOMEM; 7294 7296 ret = lpfc_read_object(phba, (char *)LPFC_PORT_CFG_NAME, 7295 7297 pdata, len); 7296 7298
+4 -8
drivers/scsi/lpfc/lpfc_sli.c
··· 21899 21899 static struct lpfc_io_buf * 21900 21900 lpfc_get_io_buf_from_expedite_pool(struct lpfc_hba *phba) 21901 21901 { 21902 - struct lpfc_io_buf *lpfc_ncmd; 21902 + struct lpfc_io_buf *lpfc_ncmd = NULL, *iter; 21903 21903 struct lpfc_io_buf *lpfc_ncmd_next; 21904 21904 unsigned long iflag; 21905 21905 struct lpfc_epd_pool *epd_pool; 21906 21906 21907 21907 epd_pool = &phba->epd_pool; 21908 - lpfc_ncmd = NULL; 21909 21908 21910 21909 spin_lock_irqsave(&epd_pool->lock, iflag); 21911 21910 if (epd_pool->count > 0) { 21912 - list_for_each_entry_safe(lpfc_ncmd, lpfc_ncmd_next, 21911 + list_for_each_entry_safe(iter, lpfc_ncmd_next, 21913 21912 &epd_pool->list, list) { 21914 - list_del(&lpfc_ncmd->list); 21913 + list_del(&iter->list); 21915 21914 epd_pool->count--; 21915 + lpfc_ncmd = iter; 21916 21916 break; 21917 21917 } 21918 21918 } ··· 22108 22108 union lpfc_sli4_cfg_shdr *shdr; 22109 22109 struct lpfc_dmabuf *pcmd; 22110 22110 u32 rd_object_name[LPFC_MBX_OBJECT_NAME_LEN_DW] = {0}; 22111 - 22112 - /* sanity check on queue memory */ 22113 - if (!datap) 22114 - return -ENODEV; 22115 22111 22116 22112 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 22117 22113 if (!mbox)
+8 -4
drivers/scsi/megaraid/megaraid_sas.h
··· 23 23 /* 24 24 * MegaRAID SAS Driver meta data 25 25 */ 26 - #define MEGASAS_VERSION "07.719.03.00-rc1" 27 - #define MEGASAS_RELDATE "Sep 29, 2021" 26 + #define MEGASAS_VERSION "07.725.01.00-rc1" 27 + #define MEGASAS_RELDATE "Mar 2, 2023" 28 28 29 29 #define MEGASAS_MSIX_NAME_LEN 32 30 30 ··· 1519 1519 #define MEGASAS_MAX_LD_IDS (MEGASAS_MAX_LD_CHANNELS * \ 1520 1520 MEGASAS_MAX_DEV_PER_CHANNEL) 1521 1521 1522 + #define MEGASAS_MAX_SUPPORTED_LD_IDS 240 1523 + 1522 1524 #define MEGASAS_MAX_SECTORS (2*1024) 1523 1525 #define MEGASAS_MAX_SECTORS_IEEE (2*128) 1524 1526 #define MEGASAS_DBG_LVL 1 ··· 1760 1758 typedef union _MFI_CAPABILITIES { 1761 1759 struct { 1762 1760 #if defined(__BIG_ENDIAN_BITFIELD) 1763 - u32 reserved:16; 1761 + u32 reserved:15; 1762 + u32 support_memdump:1; 1764 1763 u32 support_fw_exposed_dev_list:1; 1765 1764 u32 support_nvme_passthru:1; 1766 1765 u32 support_64bit_mode:1; ··· 1795 1792 u32 support_64bit_mode:1; 1796 1793 u32 support_nvme_passthru:1; 1797 1794 u32 support_fw_exposed_dev_list:1; 1798 - u32 reserved:16; 1795 + u32 support_memdump:1; 1796 + u32 reserved:15; 1799 1797 #endif 1800 1798 } mfi_capabilities; 1801 1799 __le32 reg;
+1 -1
drivers/scsi/megaraid/megaraid_sas_fp.c
··· 358 358 ld = MR_TargetIdToLdGet(i, drv_map); 359 359 360 360 /* For non existing VDs, iterate to next VD*/ 361 - if (ld >= (MAX_LOGICAL_DRIVES_EXT - 1)) 361 + if (ld >= MEGASAS_MAX_SUPPORTED_LD_IDS) 362 362 continue; 363 363 364 364 raid = MR_LdRaidGet(ld, drv_map);
+3
drivers/scsi/megaraid/megaraid_sas_fusion.c
··· 1201 1201 drv_ops->mfi_capabilities.support_nvme_passthru = 1; 1202 1202 drv_ops->mfi_capabilities.support_fw_exposed_dev_list = 1; 1203 1203 1204 + if (reset_devices) 1205 + drv_ops->mfi_capabilities.support_memdump = 1; 1206 + 1204 1207 if (instance->consistent_mask_64bit) 1205 1208 drv_ops->mfi_capabilities.support_64bit_mode = 1; 1206 1209
+3
drivers/scsi/mpi3mr/mpi3mr.h
··· 902 902 * @admin_reply_ephase:Admin reply queue expected phase 903 903 * @admin_reply_base: Admin reply queue base virtual address 904 904 * @admin_reply_dma: Admin reply queue base dma address 905 + * @admin_reply_q_in_use: Queue is handled by poll/ISR 905 906 * @ready_timeout: Controller ready timeout 906 907 * @intr_info: Interrupt cookie pointer 907 908 * @intr_info_count: Number of interrupt cookies ··· 1056 1055 u8 admin_reply_ephase; 1057 1056 void *admin_reply_base; 1058 1057 dma_addr_t admin_reply_dma; 1058 + atomic_t admin_reply_q_in_use; 1059 1059 1060 1060 u32 ready_timeout; 1061 1061 ··· 1392 1390 void mpi3mr_flush_drv_cmds(struct mpi3mr_ioc *mrioc); 1393 1391 void mpi3mr_flush_cmds_for_unrecovered_controller(struct mpi3mr_ioc *mrioc); 1394 1392 void mpi3mr_free_enclosure_list(struct mpi3mr_ioc *mrioc); 1393 + int mpi3mr_process_admin_reply_q(struct mpi3mr_ioc *mrioc); 1395 1394 #endif /*MPI3MR_H_INCLUDED*/
+2 -2
drivers/scsi/mpi3mr/mpi3mr_app.c
··· 886 886 * each time through the loop. 887 887 */ 888 888 *prp_entry = cpu_to_le64(dma_addr); 889 - if (*prp1_entry & sgemod_mask) { 889 + if (*prp_entry & sgemod_mask) { 890 890 dprint_bsg_err(mrioc, 891 891 "%s: PRP address collides with SGE modifier\n", 892 892 __func__); ··· 895 895 *prp_entry &= ~sgemod_mask; 896 896 *prp_entry |= sgemod_val; 897 897 prp_entry++; 898 - prp_entry_dma++; 898 + prp_entry_dma += prp_size; 899 899 } 900 900 901 901 /*
+37 -5
drivers/scsi/mpi3mr/mpi3mr_fw.c
··· 415 415 le64_to_cpu(scsi_reply->sense_data_buffer_address)); 416 416 } 417 417 418 - static int mpi3mr_process_admin_reply_q(struct mpi3mr_ioc *mrioc) 418 + int mpi3mr_process_admin_reply_q(struct mpi3mr_ioc *mrioc) 419 419 { 420 420 u32 exp_phase = mrioc->admin_reply_ephase; 421 421 u32 admin_reply_ci = mrioc->admin_reply_ci; ··· 423 423 u64 reply_dma = 0; 424 424 struct mpi3_default_reply_descriptor *reply_desc; 425 425 426 + if (!atomic_add_unless(&mrioc->admin_reply_q_in_use, 1, 1)) 427 + return 0; 428 + 426 429 reply_desc = (struct mpi3_default_reply_descriptor *)mrioc->admin_reply_base + 427 430 admin_reply_ci; 428 431 429 432 if ((le16_to_cpu(reply_desc->reply_flags) & 430 - MPI3_REPLY_DESCRIPT_FLAGS_PHASE_MASK) != exp_phase) 433 + MPI3_REPLY_DESCRIPT_FLAGS_PHASE_MASK) != exp_phase) { 434 + atomic_dec(&mrioc->admin_reply_q_in_use); 431 435 return 0; 436 + } 432 437 433 438 do { 434 439 if (mrioc->unrecoverable) ··· 459 454 writel(admin_reply_ci, &mrioc->sysif_regs->admin_reply_queue_ci); 460 455 mrioc->admin_reply_ci = admin_reply_ci; 461 456 mrioc->admin_reply_ephase = exp_phase; 457 + atomic_dec(&mrioc->admin_reply_q_in_use); 462 458 463 459 return num_admin_replies; 464 460 } ··· 1198 1192 */ 1199 1193 static int mpi3mr_bring_ioc_ready(struct mpi3mr_ioc *mrioc) 1200 1194 { 1201 - u32 ioc_config, ioc_status, timeout; 1195 + u32 ioc_config, ioc_status, timeout, host_diagnostic; 1202 1196 int retval = 0; 1203 1197 enum mpi3mr_iocstate ioc_state; 1204 1198 u64 base_info; ··· 1252 1246 retval, mpi3mr_iocstate_name(ioc_state)); 1253 1247 } 1254 1248 if (ioc_state != MRIOC_STATE_RESET) { 1249 + if (ioc_state == MRIOC_STATE_FAULT) { 1250 + timeout = MPI3_SYSIF_DIAG_SAVE_TIMEOUT * 10; 1251 + mpi3mr_print_fault_info(mrioc); 1252 + do { 1253 + host_diagnostic = 1254 + readl(&mrioc->sysif_regs->host_diagnostic); 1255 + if (!(host_diagnostic & 1256 + MPI3_SYSIF_HOST_DIAG_SAVE_IN_PROGRESS)) 1257 + break; 1258 + if (!pci_device_is_present(mrioc->pdev)) { 1259 + mrioc->unrecoverable = 1; 1260 + ioc_err(mrioc, "controller is not present at the bringup\n"); 1261 + goto out_device_not_present; 1262 + } 1263 + msleep(100); 1264 + } while (--timeout); 1265 + } 1255 1266 mpi3mr_print_fault_info(mrioc); 1256 1267 ioc_info(mrioc, "issuing soft reset to bring to reset state\n"); 1257 1268 retval = mpi3mr_issue_reset(mrioc, ··· 2628 2605 mrioc->admin_reply_ci = 0; 2629 2606 mrioc->admin_reply_ephase = 1; 2630 2607 mrioc->admin_reply_base = NULL; 2608 + atomic_set(&mrioc->admin_reply_q_in_use, 0); 2631 2609 2632 2610 if (!mrioc->admin_req_base) { 2633 2611 mrioc->admin_req_base = dma_alloc_coherent(&mrioc->pdev->dev, ··· 3840 3816 dprint_init(mrioc, "allocating config page buffers\n"); 3841 3817 mrioc->cfg_page = dma_alloc_coherent(&mrioc->pdev->dev, 3842 3818 MPI3MR_DEFAULT_CFG_PAGE_SZ, &mrioc->cfg_page_dma, GFP_KERNEL); 3843 - if (!mrioc->cfg_page) 3819 + if (!mrioc->cfg_page) { 3820 + retval = -1; 3844 3821 goto out_failed_noretry; 3822 + } 3845 3823 3846 3824 mrioc->cfg_page_sz = MPI3MR_DEFAULT_CFG_PAGE_SZ; 3847 3825 ··· 3905 3879 dprint_init(mrioc, "allocating memory for throttle groups\n"); 3906 3880 sz = sizeof(struct mpi3mr_throttle_group_info); 3907 3881 mrioc->throttle_groups = kcalloc(mrioc->num_io_throttle_group, sz, GFP_KERNEL); 3908 - if (!mrioc->throttle_groups) 3882 + if (!mrioc->throttle_groups) { 3883 + retval = -1; 3909 3884 goto out_failed_noretry; 3885 + } 3910 3886 } 3911 3887 3912 3888 retval = mpi3mr_enable_events(mrioc); ··· 3928 3900 mpi3mr_memset_buffers(mrioc); 3929 3901 goto retry_init; 3930 3902 } 3903 + retval = -1; 3931 3904 out_failed_noretry: 3932 3905 ioc_err(mrioc, "controller initialization failed\n"); 3933 3906 mpi3mr_issue_reset(mrioc, MPI3_SYSIF_HOST_DIAG_RESET_ACTION_DIAG_FAULT, ··· 4041 4012 ioc_err(mrioc, 4042 4013 "cannot create minimum number of operational queues expected:%d created:%d\n", 4043 4014 mrioc->shost->nr_hw_queues, mrioc->num_op_reply_q); 4015 + retval = -1; 4044 4016 goto out_failed_noretry; 4045 4017 } 4046 4018 ··· 4108 4078 mpi3mr_memset_buffers(mrioc); 4109 4079 goto retry_init; 4110 4080 } 4081 + retval = -1; 4111 4082 out_failed_noretry: 4112 4083 ioc_err(mrioc, "controller %s is failed\n", 4113 4084 (is_resume)?"resume":"re-initialization"); ··· 4186 4155 memset(mrioc->admin_req_base, 0, mrioc->admin_req_q_sz); 4187 4156 if (mrioc->admin_reply_base) 4188 4157 memset(mrioc->admin_reply_base, 0, mrioc->admin_reply_q_sz); 4158 + atomic_set(&mrioc->admin_reply_q_in_use, 0); 4189 4159 4190 4160 if (mrioc->init_cmds.reply) { 4191 4161 memset(mrioc->init_cmds.reply, 0, sizeof(*mrioc->init_cmds.reply));
+1
drivers/scsi/mpi3mr/mpi3mr_os.c
··· 3720 3720 mpi3mr_poll_pend_io_completions(mrioc); 3721 3721 mpi3mr_ioc_enable_intr(mrioc); 3722 3722 mpi3mr_poll_pend_io_completions(mrioc); 3723 + mpi3mr_process_admin_reply_q(mrioc); 3723 3724 } 3724 3725 switch (tm_type) { 3725 3726 case MPI3_SCSITASKMGMT_TASKTYPE_TARGET_RESET:
+9 -6
drivers/scsi/mpi3mr/mpi3mr_transport.c
··· 1552 1552 1553 1553 list_for_each_entry_safe(mr_sas_phy, next_phy, 1554 1554 &mr_sas_port->phy_list, port_siblings) { 1555 - if ((mrioc->logging_level & MPI3_DEBUG_TRANSPORT_INFO)) 1555 + if ((!mrioc->stop_drv_processing) && 1556 + (mrioc->logging_level & MPI3_DEBUG_TRANSPORT_INFO)) 1556 1557 dev_info(&mr_sas_port->port->dev, 1557 1558 "remove: sas_address(0x%016llx), phy(%d)\n", 1558 1559 (unsigned long long) ··· 2358 2357 tgtdev->host_exposed = 1; 2359 2358 if (!mpi3mr_sas_port_add(mrioc, tgtdev->dev_handle, 2360 2359 sas_address_parent, hba_port)) { 2361 - tgtdev->host_exposed = 0; 2362 2360 retval = -1; 2363 - } else if ((!tgtdev->starget)) { 2364 - if (!mrioc->is_driver_loading) 2361 + } else if ((!tgtdev->starget) && (!mrioc->is_driver_loading)) { 2365 2362 mpi3mr_sas_port_remove(mrioc, sas_address, 2366 2363 sas_address_parent, hba_port); 2367 - tgtdev->host_exposed = 0; 2368 2364 retval = -1; 2365 + } 2366 + if (retval) { 2367 + tgtdev->dev_spec.sas_sata_inf.hba_port = NULL; 2368 + tgtdev->host_exposed = 0; 2369 2369 } 2370 2370 return retval; 2371 2371 } ··· 2396 2394 mpi3mr_sas_port_remove(mrioc, sas_address, sas_address_parent, 2397 2395 hba_port); 2398 2396 tgtdev->host_exposed = 0; 2397 + tgtdev->dev_spec.sas_sata_inf.hba_port = NULL; 2399 2398 } 2400 2399 2401 2400 /** ··· 2453 2450 2454 2451 tgtdev = __mpi3mr_get_tgtdev_by_addr_and_rphy(mrioc, 2455 2452 rphy->identify.sas_address, rphy); 2456 - if (tgtdev) { 2453 + if (tgtdev && tgtdev->dev_spec.sas_sata_inf.hba_port) { 2457 2454 port_id = 2458 2455 tgtdev->dev_spec.sas_sata_inf.hba_port->port_id; 2459 2456 mpi3mr_tgtdev_put(tgtdev);
+1
drivers/scsi/qla2xxx/qla_gbl.h
··· 192 192 extern int ql2xenforce_iocb_limit; 193 193 extern int ql2xabts_wait_nvme; 194 194 extern u32 ql2xnvme_queues; 195 + extern int ql2xfc2target; 195 196 196 197 extern int qla2x00_loop_reset(scsi_qla_host_t *); 197 198 extern void qla2x00_abort_all_cmds(scsi_qla_host_t *, int);
+2 -1
drivers/scsi/qla2xxx/qla_init.c
··· 1840 1840 case RSCN_PORT_ADDR: 1841 1841 fcport = qla2x00_find_fcport_by_nportid(vha, &ea->id, 1); 1842 1842 if (fcport) { 1843 - if (fcport->flags & FCF_FCP2_DEVICE && 1843 + if (ql2xfc2target && 1844 + fcport->flags & FCF_FCP2_DEVICE && 1844 1845 atomic_read(&fcport->state) == FCS_ONLINE) { 1845 1846 ql_dbg(ql_dbg_disc, vha, 0x2115, 1846 1847 "Delaying session delete for FCP2 portid=%06x %8phC ",
+9 -1
drivers/scsi/qla2xxx/qla_os.c
··· 360 360 "1 - Minimum number of queues supported\n" 361 361 "8 - Default value"); 362 362 363 + int ql2xfc2target = 1; 364 + module_param(ql2xfc2target, int, 0444); 365 + MODULE_PARM_DESC(qla2xfc2target, 366 + "Enables FC2 Target support. " 367 + "0 - FC2 Target support is disabled. " 368 + "1 - FC2 Target support is enabled (default)."); 369 + 363 370 static struct scsi_transport_template *qla2xxx_transport_template = NULL; 364 371 struct scsi_transport_template *qla2xxx_transport_vport_template = NULL; 365 372 ··· 4092 4085 "Mark all dev lost\n"); 4093 4086 4094 4087 list_for_each_entry(fcport, &vha->vp_fcports, list) { 4095 - if (fcport->loop_id != FC_NO_LOOP_ID && 4088 + if (ql2xfc2target && 4089 + fcport->loop_id != FC_NO_LOOP_ID && 4096 4090 (fcport->flags & FCF_FCP2_DEVICE) && 4097 4091 fcport->port_type == FCT_TARGET && 4098 4092 !qla2x00_reset_active(vha)) {
+6 -1
drivers/scsi/sd.c
··· 2988 2988 } 2989 2989 2990 2990 if (sdkp->device->type == TYPE_ZBC) { 2991 - /* Host-managed */ 2991 + /* 2992 + * Host-managed: Per ZBC and ZAC specifications, writes in 2993 + * sequential write required zones of host-managed devices must 2994 + * be aligned to the device physical block size. 2995 + */ 2992 2996 disk_set_zoned(sdkp->disk, BLK_ZONED_HM); 2997 + blk_queue_zone_write_granularity(q, sdkp->physical_block_size); 2993 2998 } else { 2994 2999 sdkp->zoned = zoned; 2995 3000 if (sdkp->zoned == 1) {
-8
drivers/scsi/sd_zbc.c
··· 965 965 disk_set_max_active_zones(disk, 0); 966 966 nr_zones = round_up(sdkp->capacity, zone_blocks) >> ilog2(zone_blocks); 967 967 968 - /* 969 - * Per ZBC and ZAC specifications, writes in sequential write required 970 - * zones of host-managed devices must be aligned to the device physical 971 - * block size. 972 - */ 973 - if (blk_queue_zoned_model(q) == BLK_ZONED_HM) 974 - blk_queue_zone_write_granularity(q, sdkp->physical_block_size); 975 - 976 968 sdkp->early_zone_info.nr_zones = nr_zones; 977 969 sdkp->early_zone_info.zone_blocks = zone_blocks; 978 970
+16
drivers/scsi/storvsc_drv.c
··· 988 988 } 989 989 990 990 /* 991 + * Check for "Operating parameters have changed" 992 + * due to Hyper-V changing the VHD/VHDX BlockSize 993 + * when adding/removing a differencing disk. This 994 + * causes discard_granularity to change, so do a 995 + * rescan to pick up the new granularity. We don't 996 + * want scsi_report_sense() to output a message 997 + * that a sysadmin wouldn't know what to do with. 998 + */ 999 + if ((asc == 0x3f) && (ascq != 0x03) && 1000 + (ascq != 0x0e)) { 1001 + process_err_fn = storvsc_device_scan; 1002 + set_host_byte(scmnd, DID_REQUEUE); 1003 + goto do_work; 1004 + } 1005 + 1006 + /* 991 1007 * Otherwise, let upper layer deal with the 992 1008 * error when sense message is present 993 1009 */
+7 -5
drivers/target/iscsi/iscsi_target_parameters.c
··· 1262 1262 return param; 1263 1263 1264 1264 if (!(param->phase & phase)) { 1265 - pr_err("Key \"%s\" may not be negotiated during ", 1266 - param->name); 1265 + char *phase_name; 1266 + 1267 1267 switch (phase) { 1268 1268 case PHASE_SECURITY: 1269 - pr_debug("Security phase.\n"); 1269 + phase_name = "Security"; 1270 1270 break; 1271 1271 case PHASE_OPERATIONAL: 1272 - pr_debug("Operational phase.\n"); 1272 + phase_name = "Operational"; 1273 1273 break; 1274 1274 default: 1275 - pr_debug("Unknown phase.\n"); 1275 + phase_name = "Unknown"; 1276 1276 } 1277 + pr_err("Key \"%s\" may not be negotiated during %s phase.\n", 1278 + param->name, phase_name); 1277 1279 return NULL; 1278 1280 } 1279 1281
+1
drivers/ufs/core/ufshcd.c
··· 10512 10512 MODULE_AUTHOR("Santosh Yaragnavi <santosh.sy@samsung.com>"); 10513 10513 MODULE_AUTHOR("Vinayak Holikatti <h.vinayak@samsung.com>"); 10514 10514 MODULE_DESCRIPTION("Generic UFS host controller driver Core"); 10515 + MODULE_SOFTDEP("pre: governor_simpleondemand"); 10515 10516 MODULE_LICENSE("GPL");
+4 -6
drivers/ufs/host/ufs-qcom.c
··· 1177 1177 err = ufs_qcom_clk_scale_down_post_change(hba); 1178 1178 1179 1179 1180 - if (err || !dev_req_params) { 1180 + if (err) { 1181 1181 ufshcd_uic_hibern8_exit(hba); 1182 1182 return err; 1183 1183 } ··· 1451 1451 if (IS_ERR(res->base)) { 1452 1452 dev_err(hba->dev, "Failed to map res %s, err=%d\n", 1453 1453 res->name, (int)PTR_ERR(res->base)); 1454 - res->base = NULL; 1455 1454 ret = PTR_ERR(res->base); 1455 + res->base = NULL; 1456 1456 return ret; 1457 1457 } 1458 1458 } ··· 1466 1466 /* Explicitly allocate MCQ resource from ufs_mem */ 1467 1467 res_mcq = devm_kzalloc(hba->dev, sizeof(*res_mcq), GFP_KERNEL); 1468 1468 if (!res_mcq) 1469 - return ret; 1469 + return -ENOMEM; 1470 1470 1471 1471 res_mcq->start = res_mem->start + 1472 1472 MCQ_SQATTR_OFFSET(hba->mcq_capabilities); ··· 1478 1478 if (ret) { 1479 1479 dev_err(hba->dev, "Failed to insert MCQ resource, err=%d\n", 1480 1480 ret); 1481 - goto insert_res_err; 1481 + return ret; 1482 1482 } 1483 1483 1484 1484 res->base = devm_ioremap_resource(hba->dev, res_mcq); ··· 1495 1495 ioremap_err: 1496 1496 res->base = NULL; 1497 1497 remove_resource(res_mcq); 1498 - insert_res_err: 1499 - devm_kfree(hba->dev, res_mcq); 1500 1498 return ret; 1501 1499 } 1502 1500