static int ath6kl_hsic_remove(struct platform_device *pdev) { struct ath6kl_platform_data *pdata = platform_get_drvdata(pdev); if (machine_is_apq8064_dma()) { ath6kl_toggle_radio(pdev->dev.platform_data, 0); } else { msm_bus_scale_client_update_request(bus_perf_client, 1); if (bus_perf_client) msm_bus_scale_unregister_client(bus_perf_client); if (pdata->wifi_chip_pwd != NULL) { int ret; ret = ath6kl_platform_power(pdata, 0); if (pdata->wifi_chip_pwd->reg) regulator_put(pdata->wifi_chip_pwd->reg); if (pdata->wifi_vddpa != NULL && pdata->wifi_vddpa->reg) regulator_put(pdata->wifi_vddpa->reg); if (pdata->wifi_vddio != NULL && pdata->wifi_vddio->reg) regulator_put(pdata->wifi_vddio->reg); if (ret == 0 && ath6kl_bt_on == 0) ath6kl_hsic_bind(0); } } return 0; }
void msm_isp_deinit_bandwidth_mgr(enum msm_isp_hw_client client) { mutex_lock(&bandwidth_mgr_mutex); memset(&isp_bandwidth_mgr.client_info[client], 0, sizeof(struct msm_isp_bandwidth_info)); if (--isp_bandwidth_mgr.use_count) { mutex_unlock(&bandwidth_mgr_mutex); return; } if (!isp_bandwidth_mgr.bus_client) { /*QCT_PATCH S, fix lockup when start camera with 13M resolution, 2013-10-31, [email protected] */ pr_err("%s:%d error: bus client invalid\n", __func__, __LINE__); mutex_unlock(&bandwidth_mgr_mutex); /*QCT_PATCH E, fix lockup when start camera with 13M resolution, 2013-10-31, [email protected] */ return; /*QCT_PATCH S, fix lockup when start camera with 13M resolution, 2013-10-31, [email protected] */ } /*QCT_PATCH E, fix lockup when start camera with 13M resolution, 2013-10-31, [email protected] */ msm_bus_scale_client_update_request( isp_bandwidth_mgr.bus_client, 0); msm_bus_scale_unregister_client(isp_bandwidth_mgr.bus_client); isp_bandwidth_mgr.bus_client = 0; mutex_unlock(&bandwidth_mgr_mutex); }
static void bs_fini(struct msm_gpu *gpu) { if (gpu->bsc) { msm_bus_scale_unregister_client(gpu->bsc); gpu->bsc = 0; } }
static int broadcast_tdmb_fc8080_remove(struct spi_device *spi) { printk("broadcast_tdmb_fc8080_remove \n"); #ifdef FEATURE_DMB_USE_WORKQUEUE if (fc8080_ctrl_info.spi_wq) { flush_workqueue(fc8080_ctrl_info.spi_wq); destroy_workqueue(fc8080_ctrl_info.spi_wq); } #endif #ifdef FEATURE_DMB_USE_BUS_SCALE msm_bus_scale_unregister_client(fc8080_ctrl_info.bus_scale_client_id); #endif free_irq(spi->irq, &fc8080_ctrl_info); mutex_destroy(&fc8080_ctrl_info.mutex); wake_lock_destroy(&fc8080_ctrl_info.wake_lock); #ifdef FEATURE_DMB_USE_PM_QOS pm_qos_remove_request(&fc8080_ctrl_info.pm_req_list); #endif memset((unsigned char*)&fc8080_ctrl_info, 0x0, sizeof(struct tdmb_fc8080_ctrl_blk)); return 0; }
static void stop_monitoring(void) { global_mon_enable(false); mon_disable(0); mon_disable(1); set_l2_indirect_reg(L2PMINTENCLR, BIT(0)); set_l2_indirect_reg(L2PMINTENCLR, BIT(1)); disable_irq(MON_INT); free_irq(MON_INT, mon_intr_handler); cancel_delayed_work_sync(&bw_sample); destroy_workqueue(bw_sample_wq); bw_levels[0].vectors[0].ib = 0; bw_levels[0].vectors[0].ab = 0; bw_levels[0].vectors[1].ib = 0; bw_levels[0].vectors[1].ab = 0; bw_levels[1].vectors[0].ib = 0; bw_levels[1].vectors[0].ab = 0; bw_levels[1].vectors[1].ib = 0; bw_levels[1].vectors[1].ab = 0; msm_bus_scale_unregister_client(bus_client); }
static void bs_fini(struct mdp5_cmd_encoder *mdp5_cmd_enc) { if (mdp5_cmd_enc->bsc) { msm_bus_scale_unregister_client(mdp5_cmd_enc->bsc); mdp5_cmd_enc->bsc = 0; } }
static void mdss_mdp_bus_scale_unregister(struct mdss_data_type *mdata) { pr_debug("unregister bus_hdl=%x\n", mdata->bus_hdl); if (mdata->bus_hdl) msm_bus_scale_unregister_client(mdata->bus_hdl); }
static void mdss_mdp_bus_scale_unregister(void) { pr_debug("unregister bus_hdl=%x\n", mdss_res->bus_hdl); if (mdss_res->bus_hdl) msm_bus_scale_unregister_client(mdss_res->bus_hdl); }
int devfreq_remove_devbw(struct device *dev) { struct dev_data *d = dev_get_drvdata(dev); msm_bus_scale_unregister_client(d->bus_client); devfreq_remove_device(d->df); return 0; }
void msm_camera_bus_scale_cfg(uint32_t bus_perf_client, enum msm_bus_perf_setting perf_setting) { int rc = 0; if (!bus_perf_client) { pr_err("%s: Bus Client NOT Registered!!!\n", __func__); return; } switch (perf_setting) { case S_EXIT: rc = msm_bus_scale_client_update_request(bus_perf_client, 1); msm_bus_scale_unregister_client(bus_perf_client); break; case S_PREVIEW: rc = msm_bus_scale_client_update_request(bus_perf_client, 1); break; case S_VIDEO: rc = msm_bus_scale_client_update_request(bus_perf_client, 2); break; case S_CAPTURE: rc = msm_bus_scale_client_update_request(bus_perf_client, 3); break; case S_ZSL: rc = msm_bus_scale_client_update_request(bus_perf_client, 4); break; case S_LIVESHOT: rc = msm_bus_scale_client_update_request(bus_perf_client, 5); break; case S_DEFAULT: break; default: pr_err("%s: INVALID CASE\n", __func__); } }
int vcap_enable(struct vcap_dev *dev, struct device *ddev) { int rc; rc = vcap_reg_powerup(dev); if (rc < 0) goto reg_failed; rc = vcap_clk_powerup(dev, ddev); if (rc < 0) goto clk_failed; rc = vcap_get_bus_client_handle(dev); if (rc < 0) goto bus_r_failed; config_gpios(1, dev->vcap_pdata); if (rc < 0) goto gpio_failed; return 0; gpio_failed: msm_bus_scale_unregister_client(dev->bus_client_handle); dev->bus_client_handle = 0; bus_r_failed: vcap_clk_powerdown(dev); clk_failed: vcap_reg_powerdown(dev); reg_failed: return rc; }
static void bs_fini(struct mdp4_lcdc_encoder *mdp4_lcdc_encoder) { if (mdp4_lcdc_encoder->bsc) { msm_bus_scale_unregister_client(mdp4_lcdc_encoder->bsc); mdp4_lcdc_encoder->bsc = 0; } }
static int remove(struct platform_device *pdev) { struct spdm_data *data = 0; data = platform_get_drvdata(pdev); spdm_remove_debugfs(data); if (data->devfreq) devfreq_remove_device(data->devfreq); if (data->profile) devm_kfree(&pdev->dev, data->profile); if (data->bus_scale_client_id) msm_bus_scale_unregister_client(data->bus_scale_client_id); if (data->config_data.ports) devm_kfree(&pdev->dev, data->config_data.ports); devm_kfree(&pdev->dev, data); platform_set_drvdata(pdev, NULL); if (spdm_ipc_log_ctxt) ipc_log_context_destroy(spdm_ipc_log_ctxt); return 0; }
void vpu_bus_deinit(void) { struct vpu_bus_ctrl *ctrl = &g_vpu_bus_ctrl; if (ctrl->bus_client) { msm_bus_scale_unregister_client(ctrl->bus_client); ctrl->bus_client = 0; } }
int vcap_disable(struct vcap_dev *dev) { config_gpios(0, dev->vcap_pdata); msm_bus_scale_unregister_client(dev->bus_client_handle); dev->bus_client_handle = 0; vcap_clk_powerdown(dev); vcap_reg_powerdown(dev); return 0; }
u32 res_trk_power_down(void) { VCDRES_MSG_LOW("clk_regime_rail_disable"); #ifdef CONFIG_MSM_BUS_SCALING msm_bus_scale_client_update_request(resource_context.pcl, 0); msm_bus_scale_unregister_client(resource_context.pcl); #endif VCDRES_MSG_MED("res_trk_power_down():: Calling " "res_trk_shutdown_vidc()\n"); return res_trk_shutdown_vidc(); }
void msm_camio_set_perf_lvl(enum msm_bus_perf_setting perf_setting) { static uint32_t bus_perf_client; int rc = 0; switch (perf_setting) { case S_INIT: bus_perf_client = msm_bus_scale_register_client(&cam_bus_client_pdata); if (!bus_perf_client) { pr_err("%s: Registration Failed!!!\n", __func__); bus_perf_client = 0; return; } pr_info("%s: S_INIT rc = %u\n", __func__, bus_perf_client); break; case S_EXIT: if (bus_perf_client) { pr_info("%s: S_EXIT\n", __func__); msm_bus_scale_unregister_client(bus_perf_client); } else pr_err("%s: Bus Client NOT Registered!!!\n", __func__); break; case S_PREVIEW: if (bus_perf_client) { rc = msm_bus_scale_client_update_request( bus_perf_client, 1); pr_info("%s: S_PREVIEW rc = %d\n", __func__, rc); } else pr_err("%s: Bus Client NOT Registered!!!\n", __func__); break; case S_VIDEO: if (bus_perf_client) { rc = msm_bus_scale_client_update_request( bus_perf_client, 2); pr_info("%s: S_VIDEO rc = %d\n", __func__, rc); } else pr_err("%s: Bus Client NOT Registered!!!\n", __func__); break; case S_CAPTURE: if (bus_perf_client) { rc = msm_bus_scale_client_update_request( bus_perf_client, 3); pr_info("%s: S_CAPTURE rc = %d\n", __func__, rc); } else pr_err("%s: Bus Client NOT Registered!!!\n", __func__); break; case S_DEFAULT: break; default: pr_info("%s: INVALID CASE\n", __func__); } }
static int dtv_remove(struct platform_device *pdev) { #ifdef CONFIG_MSM_BUS_SCALING if (dtv_pdata && dtv_pdata->bus_scale_table && dtv_bus_scale_handle > 0) msm_bus_scale_unregister_client(dtv_bus_scale_handle); #else if (ebi1_clk) clk_put(ebi1_clk); #endif pm_runtime_disable(&pdev->dev); return 0; }
static int msm_rng_remove(struct platform_device *pdev) { struct msm_rng_device *msm_rng_dev = platform_get_drvdata(pdev); unregister_chrdev(QRNG_IOC_MAGIC, DRIVER_NAME); hwrng_unregister(&msm_rng); clk_put(msm_rng_dev->prng_clk); iounmap(msm_rng_dev->base); platform_set_drvdata(pdev, NULL); if (msm_rng_dev->qrng_perf_client) msm_bus_scale_unregister_client(msm_rng_dev->qrng_perf_client); kfree(msm_rng_dev); return 0; }
static int mxhci_hsic_remove(struct platform_device *pdev) { struct usb_hcd *hcd = platform_get_drvdata(pdev); struct xhci_hcd *xhci = hcd_to_xhci(hcd); struct mxhci_hsic_hcd *mxhci = hcd_to_hsic(hcd); u32 reg; /* disable STROBE_PAD_CTL */ reg = readl_relaxed(TLMM_GPIO_HSIC_STROBE_PAD_CTL); writel_relaxed(reg & 0xfdffffff, TLMM_GPIO_HSIC_STROBE_PAD_CTL); /* disable DATA_PAD_CTL */ reg = readl_relaxed(TLMM_GPIO_HSIC_DATA_PAD_CTL); writel_relaxed(reg & 0xfdffffff, TLMM_GPIO_HSIC_DATA_PAD_CTL); mb(); device_remove_file(&pdev->dev, &dev_attr_config_imod); /* If the device was removed no need to call pm_runtime_disable */ if (pdev->dev.power.power_state.event != PM_EVENT_INVALID) pm_runtime_disable(&pdev->dev); pm_runtime_set_suspended(&pdev->dev); usb_remove_hcd(xhci->shared_hcd); usb_put_hcd(xhci->shared_hcd); usb_remove_hcd(hcd); if (mxhci->wakeup_irq_enabled) disable_irq_wake(mxhci->wakeup_irq); mxhci->bus_vote = false; cancel_work_sync(&mxhci->bus_vote_w); if (mxhci->bus_perf_client) msm_bus_scale_unregister_client(mxhci->bus_perf_client); destroy_workqueue(mxhci->wq); device_init_wakeup(&pdev->dev, 0); mxhci_hsic_init_vddcx(mxhci, 0); mxhci_hsic_init_clocks(mxhci, 0); mxhci_msm_config_gdsc(mxhci, 0); wakeup_source_trash(&mxhci->ws); usb_put_hcd(hcd); return 0; }
static int tvenc_remove(struct platform_device *pdev) { struct msm_fb_data_type *mfd; mfd = platform_get_drvdata(pdev); #ifdef CONFIG_MSM_BUS_SCALING if (tvenc_pdata && tvenc_pdata->bus_scale_table && tvenc_bus_scale_handle > 0) msm_bus_scale_unregister_client(tvenc_bus_scale_handle); #else clk_put(mfd->ebi1_clk); #endif pm_runtime_disable(&pdev->dev); return 0; }
static int __devexit ehci_hsic_msm_remove(struct platform_device *pdev) { struct usb_hcd *hcd = platform_get_drvdata(pdev); struct msm_hsic_hcd *mehci = hcd_to_hsic(hcd); struct msm_hsic_host_platform_data *pdata = mehci->dev->platform_data; if (pdata && pdata->swfi_latency) pm_qos_remove_request(&mehci->pm_qos_req_dma); if (mehci->peripheral_status_irq) free_irq(mehci->peripheral_status_irq, mehci); if (mehci->wakeup_irq) { if (mehci->wakeup_irq_enabled) disable_irq_wake(mehci->wakeup_irq); free_irq(mehci->wakeup_irq, mehci); } /* * If the update request is called after unregister, the request will * fail. Results are undefined if unregister is called in the middle of * update request. */ mehci->bus_vote = false; cancel_work_sync(&mehci->bus_vote_w); if (mehci->bus_perf_client) msm_bus_scale_unregister_client(mehci->bus_perf_client); ehci_hsic_msm_debugfs_cleanup(); device_init_wakeup(&pdev->dev, 0); pm_runtime_set_suspended(&pdev->dev); destroy_workqueue(ehci_wq); usb_remove_hcd(hcd); msm_hsic_config_gpios(mehci, 0); msm_hsic_init_vddcx(mehci, 0); msm_hsic_init_clocks(mehci, 0); wake_lock_destroy(&mehci->wlock); iounmap(hcd->regs); usb_put_hcd(hcd); return 0; }
int msm_jpeg_platform_release(struct resource *mem, void *base, int irq, void *context) { int result = 0; int i = 0; struct msm_jpeg_device *pgmn_dev = (struct msm_jpeg_device *) context; free_irq(irq, context); #ifdef CONFIG_MSM_IOMMU for (i = 0; i < pgmn_dev->iommu_cnt; i++) { iommu_detach_device(pgmn_dev->domain, pgmn_dev->iommu_ctx_arr[i]); JPEG_DBG("%s:%d]", __func__, __LINE__); } #endif if (pgmn_dev->jpeg_bus_client) { msm_bus_scale_client_update_request( pgmn_dev->jpeg_bus_client, 0); msm_bus_scale_unregister_client(pgmn_dev->jpeg_bus_client); } msm_cam_clk_enable(&pgmn_dev->pdev->dev, jpeg_8x_clk_info, pgmn_dev->jpeg_clk, ARRAY_SIZE(jpeg_8x_clk_info), 0); JPEG_DBG("%s:%d] clock disbale done", __func__, __LINE__); if (pgmn_dev->jpeg_fs) { result = regulator_disable(pgmn_dev->jpeg_fs); if (!result) regulator_put(pgmn_dev->jpeg_fs); else JPEG_PR_ERR("%s:%d] regulator disable failed %d", __func__, __LINE__, result); pgmn_dev->jpeg_fs = NULL; } iounmap(pgmn_dev->jpeg_vbif); iounmap(base); release_mem_region(mem->start, resource_size(mem)); ion_client_destroy(pgmn_dev->jpeg_client); pgmn_dev->state = MSM_JPEG_IDLE; JPEG_DBG("%s:%d] success\n", __func__, __LINE__); return result; }
void kgsl_pwrctrl_close(struct kgsl_device *device) { struct kgsl_pwrctrl *pwr = &device->pwrctrl; KGSL_DRV_INFO("close device %d\n", device->id); if (pwr->interrupt_num > 0) { if (pwr->have_irq) { free_irq(pwr->interrupt_num, NULL); pwr->have_irq = 0; } pwr->interrupt_num = 0; } clk_put(pwr->ebi1_clk); if (pwr->pcl) msm_bus_scale_unregister_client(pwr->pcl); pwr->pcl = 0; if (pwr->gpu_reg) { regulator_put(pwr->gpu_reg); pwr->gpu_reg = NULL; } if (pwr->grp_pclk) { clk_put(pwr->grp_pclk); pwr->grp_pclk = NULL; } if (pwr->grp_clk) { clk_put(pwr->grp_clk); pwr->grp_clk = NULL; } if (pwr->imem_clk != NULL) { clk_put(pwr->imem_clk); pwr->imem_clk = NULL; } pwr->grp_src_clk = NULL; pwr->power_flags = 0; }
void msm_isp_deinit_bandwidth_mgr(enum msm_isp_hw_client client) { mutex_lock(&bandwidth_mgr_mutex); memset(&isp_bandwidth_mgr.client_info[client], 0, sizeof(struct msm_isp_bandwidth_info)); if (--isp_bandwidth_mgr.use_count) { mutex_unlock(&bandwidth_mgr_mutex); return; } if (!isp_bandwidth_mgr.bus_client) return; msm_bus_scale_client_update_request( isp_bandwidth_mgr.bus_client, 0); msm_bus_scale_unregister_client(isp_bandwidth_mgr.bus_client); isp_bandwidth_mgr.bus_client = 0; mutex_unlock(&bandwidth_mgr_mutex); }
int msm_jpeg_platform_release(struct resource *mem, void *base, int irq, void *context) { int result = 0; struct msm_jpeg_device *pgmn_dev = (struct msm_jpeg_device *) context; free_irq(irq, context); msm_jpeg_detach_iommu(pgmn_dev); if (pgmn_dev->jpeg_bus_client) { msm_bus_scale_client_update_request( pgmn_dev->jpeg_bus_client, 0); msm_bus_scale_unregister_client(pgmn_dev->jpeg_bus_client); } msm_cam_clk_enable(&pgmn_dev->pdev->dev, pgmn_dev->jpeg_clk_info, pgmn_dev->jpeg_clk, pgmn_dev->num_clk, 0); JPEG_DBG("%s:%d] clock disbale done", __func__, __LINE__); if (pgmn_dev->jpeg_fs) { result = regulator_disable(pgmn_dev->jpeg_fs); if (!result) regulator_put(pgmn_dev->jpeg_fs); else JPEG_PR_ERR("%s:%d] regulator disable failed %d", __func__, __LINE__, result); pgmn_dev->jpeg_fs = NULL; } iounmap(pgmn_dev->jpeg_vbif); iounmap(base); release_mem_region(mem->start, resource_size(mem)); ion_client_destroy(pgmn_dev->jpeg_client); pgmn_dev->state = MSM_JPEG_IDLE; JPEG_DBG("%s:%d] success\n", __func__, __LINE__); return result; }
void msm_isp_deinit_bandwidth_mgr(enum msm_isp_hw_client client) { mutex_lock(&bandwidth_mgr_mutex); memset(&isp_bandwidth_mgr.client_info[client], 0, sizeof(struct msm_isp_bandwidth_info)); if (--isp_bandwidth_mgr.use_count) { mutex_unlock(&bandwidth_mgr_mutex); return; } if (!isp_bandwidth_mgr.bus_client) { pr_err("%s:%d error: bus client invalid\n", __func__, __LINE__); mutex_unlock(&bandwidth_mgr_mutex); return; } msm_bus_scale_client_update_request( isp_bandwidth_mgr.bus_client, 0); msm_bus_scale_unregister_client(isp_bandwidth_mgr.bus_client); isp_bandwidth_mgr.bus_client = 0; mutex_unlock(&bandwidth_mgr_mutex); }
void kgsl_pwrctrl_close(struct kgsl_device *device) { struct kgsl_pwrctrl *pwr = &device->pwrctrl; int i; KGSL_PWR_INFO(device, "close device %d\n", device->id); unregister_early_suspend(&device->display_off); if (pwr->interrupt_num > 0) { if (pwr->have_irq) { free_irq(pwr->interrupt_num, NULL); pwr->have_irq = 0; } pwr->interrupt_num = 0; } clk_put(pwr->ebi1_clk); if (pwr->pcl) msm_bus_scale_unregister_client(pwr->pcl); pwr->pcl = 0; if (pwr->gpu_reg) { regulator_put(pwr->gpu_reg); pwr->gpu_reg = NULL; } for (i = 1; i < KGSL_MAX_CLKS; i++) if (pwr->grp_clks[i]) { clk_put(pwr->grp_clks[i]); pwr->grp_clks[i] = NULL; } pwr->grp_clks[0] = NULL; pwr->power_flags = 0; }
static int __devexit ehci_hsic_msm_remove(struct platform_device *pdev) { struct usb_hcd *hcd = platform_get_drvdata(pdev); struct msm_hsic_hcd *mehci = hcd_to_hsic(hcd); struct msm_hsic_host_platform_data *pdata = mehci->dev->platform_data; if (pdata && pdata->swfi_latency) pm_qos_remove_request(&mehci->pm_qos_req_dma); if (mehci->peripheral_status_irq) free_irq(mehci->peripheral_status_irq, mehci); if (mehci->wakeup_irq) { if (mehci->wakeup_irq_enabled) disable_irq_wake(mehci->wakeup_irq); free_irq(mehci->wakeup_irq, mehci); } if (mehci->bus_perf_client) msm_bus_scale_unregister_client(mehci->bus_perf_client); ehci_hsic_msm_debugfs_cleanup(); device_init_wakeup(&pdev->dev, 0); pm_runtime_set_suspended(&pdev->dev); usb_remove_hcd(hcd); msm_hsic_config_gpios(mehci, 0); msm_hsic_init_vddcx(mehci, 0); msm_hsic_init_clocks(mehci, 0); wake_lock_destroy(&mehci->wlock); iounmap(hcd->regs); usb_put_hcd(hcd); return 0; }
void msm_camio_bus_scale_cfg(struct msm_bus_scale_pdata *cam_bus_scale_table, enum msm_bus_perf_setting perf_setting) { static uint32_t bus_perf_client; int rc = 0; switch (perf_setting) { case S_INIT: bus_perf_client = msm_bus_scale_register_client(cam_bus_scale_table); if (!bus_perf_client) { CDBG("%s: Registration Failed!!!\n", __func__); bus_perf_client = 0; return; } CDBG("%s: S_INIT rc = %u\n", __func__, bus_perf_client); break; case S_EXIT: if (bus_perf_client) { CDBG("%s: S_EXIT\n", __func__); msm_bus_scale_unregister_client(bus_perf_client); } else CDBG("%s: Bus Client NOT Registered!!!\n", __func__); break; case S_PREVIEW: if (bus_perf_client) { rc = msm_bus_scale_client_update_request( bus_perf_client, 1); CDBG("%s: S_PREVIEW rc = %d\n", __func__, rc); } else CDBG("%s: Bus Client NOT Registered!!!\n", __func__); break; case S_VIDEO: if (bus_perf_client) { rc = msm_bus_scale_client_update_request( bus_perf_client, 2); CDBG("%s: S_VIDEO rc = %d\n", __func__, rc); } else CDBG("%s: Bus Client NOT Registered!!!\n", __func__); break; case S_CAPTURE: if (bus_perf_client) { rc = msm_bus_scale_client_update_request( bus_perf_client, 3); CDBG("%s: S_CAPTURE rc = %d\n", __func__, rc); } else CDBG("%s: Bus Client NOT Registered!!!\n", __func__); break; case S_ZSL: if (bus_perf_client) { rc = msm_bus_scale_client_update_request( bus_perf_client, 4); CDBG("%s: S_ZSL rc = %d\n", __func__, rc); } else CDBG("%s: Bus Client NOT Registered!!!\n", __func__); break; case S_DEFAULT: break; default: pr_warning("%s: INVALID CASE\n", __func__); } }