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:
"24 fixes, all in drivers. The lion's share (16) are qla2xxx and the
rest are iscsi (3), ufs (2), smarpqi, lpfc and libsas"

* tag 'scsi-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi: (24 commits)
scsi: iscsi: Avoid potential deadlock in iscsi_if_rx func
scsi: iscsi: Fix a potential deadlock in the timeout handler
scsi: smartpqi: Update attribute name to `driver_version`
scsi: libsas: stop discovering if oob mode is disconnected
scsi: ufs: Disable autohibern8 feature in Cadence UFS
scsi: iscsi: qla4xxx: fix double free in probe
scsi: ufs: Give an unique ID to each ufs-bsg
scsi: qla2xxx: Add debug dump of LOGO payload and ELS IOCB
scsi: qla2xxx: Ignore PORT UPDATE after N2N PLOGI
scsi: qla2xxx: Don't defer relogin unconditonally
scsi: qla2xxx: Send Notify ACK after N2N PLOGI
scsi: qla2xxx: Configure local loop for N2N target
scsi: qla2xxx: Fix PLOGI payload and ELS IOCB dump length
scsi: qla2xxx: Don't call qlt_async_event twice
scsi: qla2xxx: Allow PLOGI in target mode
scsi: qla2xxx: Change discovery state before PLOGI
scsi: qla2xxx: Drop superfluous INIT_WORK of del_work
scsi: qla2xxx: Initialize free_work before flushing it
scsi: qla2xxx: Use explicit LOGO in target mode
scsi: qla2xxx: Ignore NULL pointer in tcm_qla2xxx_free_mcmd
...

Linus Torvalds 07c4b9e9 f61cf8de

+111 -46
+1 -1
Documentation/scsi/smartpqi.txt
··· 29 29 smartpqi host attributes: 30 30 ------------------------- 31 31 /sys/class/scsi_host/host*/rescan 32 - /sys/class/scsi_host/host*/version 32 + /sys/class/scsi_host/host*/driver_version 33 33 34 34 The host rescan attribute is a write only attribute. Writing to this 35 35 attribute will trigger the driver to scan for new, changed, or removed
+2 -2
drivers/scsi/libiscsi.c
··· 1945 1945 1946 1946 ISCSI_DBG_EH(session, "scsi cmd %p timedout\n", sc); 1947 1947 1948 - spin_lock(&session->frwd_lock); 1948 + spin_lock_bh(&session->frwd_lock); 1949 1949 task = (struct iscsi_task *)sc->SCp.ptr; 1950 1950 if (!task) { 1951 1951 /* ··· 2072 2072 done: 2073 2073 if (task) 2074 2074 task->last_timeout = jiffies; 2075 - spin_unlock(&session->frwd_lock); 2075 + spin_unlock_bh(&session->frwd_lock); 2076 2076 ISCSI_DBG_EH(session, "return %s\n", rc == BLK_EH_RESET_TIMER ? 2077 2077 "timer reset" : "shutdown or nh"); 2078 2078 return rc;
+10 -1
drivers/scsi/libsas/sas_discover.c
··· 81 81 else 82 82 dev->dev_type = SAS_SATA_DEV; 83 83 dev->tproto = SAS_PROTOCOL_SATA; 84 - } else { 84 + } else if (port->oob_mode == SAS_OOB_MODE) { 85 85 struct sas_identify_frame *id = 86 86 (struct sas_identify_frame *) dev->frame_rcvd; 87 87 dev->dev_type = id->dev_type; 88 88 dev->iproto = id->initiator_bits; 89 89 dev->tproto = id->target_bits; 90 + } else { 91 + /* If the oob mode is OOB_NOT_CONNECTED, the port is 92 + * disconnected due to race with PHY down. We cannot 93 + * continue to discover this port 94 + */ 95 + sas_put_device(dev); 96 + pr_warn("Port %016llx is disconnected when discovering\n", 97 + SAS_ADDR(port->attached_sas_addr)); 98 + return -ENODEV; 90 99 } 91 100 92 101 sas_init_dev(dev);
+9 -6
drivers/scsi/lpfc/lpfc_bsg.c
··· 4489 4489 phba->mbox_ext_buf_ctx.seqNum++; 4490 4490 nemb_tp = phba->mbox_ext_buf_ctx.nembType; 4491 4491 4492 - dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL); 4493 - if (!dd_data) { 4494 - rc = -ENOMEM; 4495 - goto job_error; 4496 - } 4497 - 4498 4492 pbuf = (uint8_t *)dmabuf->virt; 4499 4493 size = job->request_payload.payload_len; 4500 4494 sg_copy_to_buffer(job->request_payload.sg_list, ··· 4525 4531 "2968 SLI_CONFIG ext-buffer wr all %d " 4526 4532 "ebuffers received\n", 4527 4533 phba->mbox_ext_buf_ctx.numBuf); 4534 + 4535 + dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL); 4536 + if (!dd_data) { 4537 + rc = -ENOMEM; 4538 + goto job_error; 4539 + } 4540 + 4528 4541 /* mailbox command structure for base driver */ 4529 4542 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 4530 4543 if (!pmboxq) { ··· 4580 4579 return SLI_CONFIG_HANDLED; 4581 4580 4582 4581 job_error: 4582 + if (pmboxq) 4583 + mempool_free(pmboxq, phba->mbox_mem_pool); 4583 4584 lpfc_bsg_dma_page_free(phba, dmabuf); 4584 4585 kfree(dd_data); 4585 4586
+1
drivers/scsi/qla2xxx/qla_attr.c
··· 178 178 179 179 faddr = ha->flt_region_nvram; 180 180 if (IS_QLA28XX(ha)) { 181 + qla28xx_get_aux_images(vha, &active_regions); 181 182 if (active_regions.aux.vpd_nvram == QLA27XX_SECONDARY_IMAGE) 182 183 faddr = ha->flt_region_nvram_sec; 183 184 }
+1 -1
drivers/scsi/qla2xxx/qla_bsg.c
··· 2399 2399 struct qla_active_regions regions = { }; 2400 2400 struct active_regions active_regions = { }; 2401 2401 2402 - qla28xx_get_aux_images(vha, &active_regions); 2402 + qla27xx_get_active_image(vha, &active_regions); 2403 2403 regions.global_image = active_regions.global; 2404 2404 2405 2405 if (IS_QLA28XX(ha)) {
+1
drivers/scsi/qla2xxx/qla_def.h
··· 2401 2401 unsigned int id_changed:1; 2402 2402 unsigned int scan_needed:1; 2403 2403 unsigned int n2n_flag:1; 2404 + unsigned int explicit_logout:1; 2404 2405 2405 2406 struct completion nvme_del_done; 2406 2407 uint32_t nvme_prli_service_param;
+4
drivers/scsi/qla2xxx/qla_fw.h
··· 1523 1523 #define FLT_REG_NVRAM_SEC_28XX_1 0x10F 1524 1524 #define FLT_REG_NVRAM_SEC_28XX_2 0x111 1525 1525 #define FLT_REG_NVRAM_SEC_28XX_3 0x113 1526 + #define FLT_REG_MPI_PRI_28XX 0xD3 1527 + #define FLT_REG_MPI_SEC_28XX 0xF0 1528 + #define FLT_REG_PEP_PRI_28XX 0xD1 1529 + #define FLT_REG_PEP_SEC_28XX 0xF1 1526 1530 1527 1531 struct qla_flt_region { 1528 1532 uint16_t code;
+10 -11
drivers/scsi/qla2xxx/qla_init.c
··· 533 533 534 534 e->u.fcport.fcport = fcport; 535 535 fcport->flags |= FCF_ASYNC_ACTIVE; 536 + fcport->disc_state = DSC_LOGIN_PEND; 536 537 return qla2x00_post_work(vha, e); 537 538 } 538 539 ··· 1527 1526 } 1528 1527 } 1529 1528 1530 - /* for pure Target Mode. Login will not be initiated */ 1531 - if (vha->host->active_mode == MODE_TARGET) 1529 + /* Target won't initiate port login if fabric is present */ 1530 + if (vha->host->active_mode == MODE_TARGET && !N2N_TOPO(vha->hw)) 1532 1531 return 0; 1533 1532 1534 1533 if (fcport->flags & FCF_ASYNC_SENT) { ··· 1720 1719 void qla_handle_els_plogi_done(scsi_qla_host_t *vha, 1721 1720 struct event_arg *ea) 1722 1721 { 1722 + /* for pure Target Mode, PRLI will not be initiated */ 1723 + if (vha->host->active_mode == MODE_TARGET) 1724 + return; 1725 + 1723 1726 ql_dbg(ql_dbg_disc, vha, 0x2118, 1724 1727 "%s %d %8phC post PRLI\n", 1725 1728 __func__, __LINE__, ea->fcport->port_name); ··· 4857 4852 } 4858 4853 4859 4854 INIT_WORK(&fcport->del_work, qla24xx_delete_sess_fn); 4855 + INIT_WORK(&fcport->free_work, qlt_free_session_done); 4860 4856 INIT_WORK(&fcport->reg_work, qla_register_fcport_fn); 4861 4857 INIT_LIST_HEAD(&fcport->gnl_entry); 4862 4858 INIT_LIST_HEAD(&fcport->list); ··· 4936 4930 set_bit(RSCN_UPDATE, &flags); 4937 4931 clear_bit(LOCAL_LOOP_UPDATE, &flags); 4938 4932 4939 - } else if (ha->current_topology == ISP_CFG_N) { 4940 - clear_bit(RSCN_UPDATE, &flags); 4941 - if (qla_tgt_mode_enabled(vha)) { 4942 - /* allow the other side to start the login */ 4943 - clear_bit(LOCAL_LOOP_UPDATE, &flags); 4944 - set_bit(RELOGIN_NEEDED, &vha->dpc_flags); 4945 - } 4946 - } else if (ha->current_topology == ISP_CFG_NL) { 4933 + } else if (ha->current_topology == ISP_CFG_NL || 4934 + ha->current_topology == ISP_CFG_N) { 4947 4935 clear_bit(RSCN_UPDATE, &flags); 4948 4936 set_bit(LOCAL_LOOP_UPDATE, &flags); 4949 4937 } else if (!vha->flags.online || ··· 5054 5054 memcpy(&ha->plogi_els_payld.data, 5055 5055 (void *)ha->init_cb, 5056 5056 sizeof(ha->plogi_els_payld.data)); 5057 - set_bit(RELOGIN_NEEDED, &vha->dpc_flags); 5058 5057 } else { 5059 5058 ql_dbg(ql_dbg_init, vha, 0x00d1, 5060 5059 "PLOGI ELS param read fail.\n");
+25 -6
drivers/scsi/qla2xxx/qla_iocb.c
··· 2405 2405 static void 2406 2406 qla24xx_logout_iocb(srb_t *sp, struct logio_entry_24xx *logio) 2407 2407 { 2408 + u16 control_flags = LCF_COMMAND_LOGO; 2408 2409 logio->entry_type = LOGINOUT_PORT_IOCB_TYPE; 2409 - logio->control_flags = 2410 - cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO); 2411 - if (!sp->fcport->keep_nport_handle) 2412 - logio->control_flags |= cpu_to_le16(LCF_FREE_NPORT); 2410 + 2411 + if (sp->fcport->explicit_logout) { 2412 + control_flags |= LCF_EXPL_LOGO|LCF_FREE_NPORT; 2413 + } else { 2414 + control_flags |= LCF_IMPL_LOGO; 2415 + 2416 + if (!sp->fcport->keep_nport_handle) 2417 + control_flags |= LCF_FREE_NPORT; 2418 + } 2419 + 2420 + logio->control_flags = cpu_to_le16(control_flags); 2413 2421 logio->nport_handle = cpu_to_le16(sp->fcport->loop_id); 2414 2422 logio->port_id[0] = sp->fcport->d_id.b.al_pa; 2415 2423 logio->port_id[1] = sp->fcport->d_id.b.area; ··· 2625 2617 2626 2618 memcpy(elsio->u.els_logo.els_logo_pyld, &logo_pyld, 2627 2619 sizeof(struct els_logo_payload)); 2620 + ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x3075, "LOGO buffer:"); 2621 + ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x010a, 2622 + elsio->u.els_logo.els_logo_pyld, 2623 + sizeof(*elsio->u.els_logo.els_logo_pyld)); 2628 2624 2629 2625 rval = qla2x00_start_sp(sp); 2630 2626 if (rval != QLA_SUCCESS) { ··· 2688 2676 ql_dbg(ql_dbg_io + ql_dbg_buffer, vha, 0x3073, 2689 2677 "PLOGI ELS IOCB:\n"); 2690 2678 ql_dump_buffer(ql_log_info, vha, 0x0109, 2691 - (uint8_t *)els_iocb, 0x70); 2679 + (uint8_t *)els_iocb, 2680 + sizeof(*els_iocb)); 2692 2681 } else { 2693 2682 els_iocb->control_flags = 1 << 13; 2694 2683 els_iocb->tx_byte_count = ··· 2701 2688 els_iocb->rx_byte_count = 0; 2702 2689 els_iocb->rx_address = 0; 2703 2690 els_iocb->rx_len = 0; 2691 + ql_dbg(ql_dbg_io + ql_dbg_buffer, vha, 0x3076, 2692 + "LOGO ELS IOCB:"); 2693 + ql_dump_buffer(ql_log_info, vha, 0x010b, 2694 + els_iocb, 2695 + sizeof(*els_iocb)); 2704 2696 } 2705 2697 2706 2698 sp->vha->qla_stats.control_requests++; ··· 2952 2934 2953 2935 ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x3073, "PLOGI buffer:\n"); 2954 2936 ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x0109, 2955 - (uint8_t *)elsio->u.els_plogi.els_plogi_pyld, 0x70); 2937 + (uint8_t *)elsio->u.els_plogi.els_plogi_pyld, 2938 + sizeof(*elsio->u.els_plogi.els_plogi_pyld)); 2956 2939 2957 2940 rval = qla2x00_start_sp(sp); 2958 2941 if (rval != QLA_SUCCESS) {
-4
drivers/scsi/qla2xxx/qla_isr.c
··· 1061 1061 ql_dbg(ql_dbg_async, vha, 0x5011, 1062 1062 "Asynchronous PORT UPDATE ignored %04x/%04x/%04x.\n", 1063 1063 mb[1], mb[2], mb[3]); 1064 - 1065 - qlt_async_event(mb[0], vha, mb); 1066 1064 break; 1067 1065 } 1068 1066 ··· 1077 1079 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags); 1078 1080 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags); 1079 1081 set_bit(VP_CONFIG_OK, &vha->vp_flags); 1080 - 1081 - qlt_async_event(mb[0], vha, mb); 1082 1082 break; 1083 1083 1084 1084 case MBA_RSCN_UPDATE: /* State Change Registration */
+2 -1
drivers/scsi/qla2xxx/qla_mbx.c
··· 3921 3921 vha->d_id.b24 = 0; 3922 3922 vha->d_id.b.al_pa = 1; 3923 3923 ha->flags.n2n_bigger = 1; 3924 + ha->flags.n2n_ae = 0; 3924 3925 3925 3926 id.b.al_pa = 2; 3926 3927 ql_dbg(ql_dbg_async, vha, 0x5075, ··· 3932 3931 "Format 1: Remote login - Waiting for WWPN %8phC.\n", 3933 3932 rptid_entry->u.f1.port_name); 3934 3933 ha->flags.n2n_bigger = 0; 3934 + ha->flags.n2n_ae = 1; 3935 3935 } 3936 3936 qla24xx_post_newsess_work(vha, &id, 3937 3937 rptid_entry->u.f1.port_name, ··· 3944 3942 /* if our portname is higher then initiate N2N login */ 3945 3943 3946 3944 set_bit(N2N_LOGIN_NEEDED, &vha->dpc_flags); 3947 - ha->flags.n2n_ae = 1; 3948 3945 return; 3949 3946 break; 3950 3947 case TOPO_FL:
+26 -9
drivers/scsi/qla2xxx/qla_sup.c
··· 847 847 ha->flt_region_img_status_pri = start; 848 848 break; 849 849 case FLT_REG_IMG_SEC_27XX: 850 - if (IS_QLA27XX(ha) && !IS_QLA28XX(ha)) 850 + if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) 851 851 ha->flt_region_img_status_sec = start; 852 852 break; 853 853 case FLT_REG_FW_SEC_27XX: 854 - if (IS_QLA27XX(ha) && !IS_QLA28XX(ha)) 854 + if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) 855 855 ha->flt_region_fw_sec = start; 856 856 break; 857 857 case FLT_REG_BOOTLOAD_SEC_27XX: 858 - if (IS_QLA27XX(ha) && !IS_QLA28XX(ha)) 858 + if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) 859 859 ha->flt_region_boot_sec = start; 860 860 break; 861 861 case FLT_REG_AUX_IMG_PRI_28XX: ··· 2725 2725 ql_log(ql_log_warn + ql_dbg_verbose, vha, 0xffff, 2726 2726 "Region %x is secure\n", region.code); 2727 2727 2728 - if (region.code == FLT_REG_FW || 2729 - region.code == FLT_REG_FW_SEC_27XX) { 2728 + switch (region.code) { 2729 + case FLT_REG_FW: 2730 + case FLT_REG_FW_SEC_27XX: 2731 + case FLT_REG_MPI_PRI_28XX: 2732 + case FLT_REG_MPI_SEC_28XX: 2730 2733 fw_array = dwptr; 2731 2734 2732 2735 /* 1st fw array */ ··· 2760 2757 buf_size_without_sfub += risc_size; 2761 2758 fw_array += risc_size; 2762 2759 } 2763 - } else { 2764 - ql_log(ql_log_warn + ql_dbg_verbose, vha, 0xffff, 2765 - "Secure region %x not supported\n", 2760 + break; 2761 + 2762 + case FLT_REG_PEP_PRI_28XX: 2763 + case FLT_REG_PEP_SEC_28XX: 2764 + fw_array = dwptr; 2765 + 2766 + /* 1st fw array */ 2767 + risc_size = be32_to_cpu(fw_array[3]); 2768 + risc_attr = be32_to_cpu(fw_array[9]); 2769 + 2770 + buf_size_without_sfub = risc_size; 2771 + fw_array += risc_size; 2772 + break; 2773 + 2774 + default: 2775 + ql_log(ql_log_warn + ql_dbg_verbose, vha, 2776 + 0xffff, "Secure region %x not supported\n", 2766 2777 region.code); 2767 2778 rval = QLA_COMMAND_ERROR; 2768 2779 goto done; ··· 2897 2880 "Sending Secure Flash MB Cmd\n"); 2898 2881 rval = qla28xx_secure_flash_update(vha, 0, region.code, 2899 2882 buf_size_without_sfub, sfub_dma, 2900 - sizeof(struct secure_flash_update_block)); 2883 + sizeof(struct secure_flash_update_block) >> 2); 2901 2884 if (rval != QLA_SUCCESS) { 2902 2885 ql_log(ql_log_warn, vha, 0xffff, 2903 2886 "Secure Flash MB Cmd failed %x.", rval);
+2 -2
drivers/scsi/qla2xxx/qla_target.c
··· 1104 1104 } 1105 1105 } 1106 1106 1107 + sess->explicit_logout = 0; 1107 1108 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags); 1108 1109 sess->free_pending = 0; 1109 1110 ··· 1161 1160 sess->last_rscn_gen = sess->rscn_gen; 1162 1161 sess->last_login_gen = sess->login_gen; 1163 1162 1164 - INIT_WORK(&sess->free_work, qlt_free_session_done); 1165 1163 queue_work(sess->vha->hw->wq, &sess->free_work); 1166 1164 } 1167 1165 EXPORT_SYMBOL(qlt_unreg_sess); ··· 1265 1265 "Scheduling sess %p for deletion %8phC\n", 1266 1266 sess, sess->port_name); 1267 1267 1268 - INIT_WORK(&sess->del_work, qla24xx_delete_sess_fn); 1269 1268 WARN_ON(!queue_work(sess->vha->hw->wq, &sess->del_work)); 1270 1269 } 1271 1270 ··· 4803 4804 4804 4805 switch (sess->disc_state) { 4805 4806 case DSC_DELETED: 4807 + case DSC_LOGIN_PEND: 4806 4808 qlt_plogi_ack_unref(vha, pla); 4807 4809 break; 4808 4810
+3
drivers/scsi/qla2xxx/tcm_qla2xxx.c
··· 246 246 */ 247 247 static void tcm_qla2xxx_free_mcmd(struct qla_tgt_mgmt_cmd *mcmd) 248 248 { 249 + if (!mcmd) 250 + return; 249 251 INIT_WORK(&mcmd->free_work, tcm_qla2xxx_complete_mcmd); 250 252 queue_work(tcm_qla2xxx_free_wq, &mcmd->free_work); 251 253 } ··· 350 348 target_sess_cmd_list_set_waiting(se_sess); 351 349 spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags); 352 350 351 + sess->explicit_logout = 1; 353 352 tcm_qla2xxx_put_sess(sess); 354 353 } 355 354
-1
drivers/scsi/qla4xxx/ql4_os.c
··· 4275 4275 return QLA_SUCCESS; 4276 4276 4277 4277 mem_alloc_error_exit: 4278 - qla4xxx_mem_free(ha); 4279 4278 return QLA_ERROR; 4280 4279 } 4281 4280
+7
drivers/scsi/scsi_transport_iscsi.c
··· 24 24 25 25 #define ISCSI_TRANSPORT_VERSION "2.0-870" 26 26 27 + #define ISCSI_SEND_MAX_ALLOWED 10 28 + 27 29 #define CREATE_TRACE_POINTS 28 30 #include <trace/events/iscsi.h> 29 31 ··· 3684 3682 struct nlmsghdr *nlh; 3685 3683 struct iscsi_uevent *ev; 3686 3684 uint32_t group; 3685 + int retries = ISCSI_SEND_MAX_ALLOWED; 3687 3686 3688 3687 nlh = nlmsg_hdr(skb); 3689 3688 if (nlh->nlmsg_len < sizeof(*nlh) + sizeof(*ev) || ··· 3715 3712 break; 3716 3713 err = iscsi_if_send_reply(portid, nlh->nlmsg_type, 3717 3714 ev, sizeof(*ev)); 3715 + if (err == -EAGAIN && --retries < 0) { 3716 + printk(KERN_WARNING "Send reply failed, error %d\n", err); 3717 + break; 3718 + } 3718 3719 } while (err < 0 && err != -ECONNREFUSED && err != -ESRCH); 3719 3720 skb_pull(skb, rlen); 3720 3721 }
+6
drivers/scsi/ufs/cdns-pltfrm.c
··· 99 99 */ 100 100 ufshcd_dme_set(hba, UIC_ARG_MIB(PA_LOCAL_TX_LCC_ENABLE), 0); 101 101 102 + /* 103 + * Disabling Autohibern8 feature in cadence UFS 104 + * to mask unexpected interrupt trigger. 105 + */ 106 + hba->ahit = 0; 107 + 102 108 return 0; 103 109 } 104 110
+1 -1
drivers/scsi/ufs/ufs_bsg.c
··· 203 203 bsg_dev->parent = get_device(parent); 204 204 bsg_dev->release = ufs_bsg_node_release; 205 205 206 - dev_set_name(bsg_dev, "ufs-bsg"); 206 + dev_set_name(bsg_dev, "ufs-bsg%u", shost->host_no); 207 207 208 208 ret = device_add(bsg_dev); 209 209 if (ret)