1 /* Copyright (c) 2015-2017, The Linux Foundation. All rights reserved.
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 and
5 * only version 2 as published by the Free Software Foundation.
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
13 #define pr_fmt(fmt) "CAM-SOC %s:%d " fmt, __func__, __LINE__
14 #define NO_SET_RATE -1
17 #ifdef CONFIG_CAM_SOC_API_DBG
18 #define CDBG(fmt, args...) pr_err(fmt, ##args)
20 #define CDBG(fmt, args...) pr_debug(fmt, ##args)
23 #include <linux/delay.h>
24 #include <linux/module.h>
25 #include <linux/of_platform.h>
26 #include <linux/msm-bus.h>
27 #include <linux/clk/msm-clk.h>
28 #include "cam_soc_api.h"
30 struct msm_cam_bus_pscale_data {
31 struct msm_bus_scale_pdata *pdata;
33 uint32_t num_usecases;
35 unsigned int vector_index;
40 struct msm_cam_bus_pscale_data g_cv[CAM_BUS_CLIENT_MAX];
43 /* Get all clocks from DT */
44 static int msm_camera_get_clk_info_internal(struct device *dev,
45 struct msm_cam_clk_info **clk_info,
46 struct clk ***clk_ptr,
51 uint32_t *rates, i = 0;
52 const char *clk_ctl = NULL;
53 bool clock_cntl_support = false;
54 struct device_node *of_node;
56 of_node = dev->of_node;
58 cnt = of_property_count_strings(of_node, "clock-names");
60 pr_err("err: No clocks found in DT=%zu\n", cnt);
64 tmp = of_property_count_u32_elems(of_node, "qcom,clock-rates");
66 pr_err("err: No clk rates device tree, count=%zu", tmp);
71 pr_err("err: clk name/rates mismatch, strings=%zu, rates=%zu\n",
76 if (of_property_read_bool(of_node, "qcom,clock-cntl-support")) {
77 tmp = of_property_count_strings(of_node,
78 "qcom,clock-control");
80 pr_err("err: control strings not found in DT count=%zu",
85 pr_err("err: controls mismatch, strings=%zu, ctl=%zu\n",
89 clock_cntl_support = true;
94 *clk_info = devm_kcalloc(dev, cnt,
95 sizeof(struct msm_cam_clk_info), GFP_KERNEL);
99 *clk_ptr = devm_kcalloc(dev, cnt, sizeof(struct clk *),
106 rates = devm_kcalloc(dev, cnt, sizeof(long), GFP_KERNEL);
112 rc = of_property_read_u32_array(of_node, "qcom,clock-rates",
115 pr_err("err: failed reading clock rates\n");
120 for (i = 0; i < cnt; i++) {
121 rc = of_property_read_string_index(of_node, "clock-names",
122 i, &((*clk_info)[i].clk_name));
124 pr_err("%s reading clock-name failed index %d\n",
130 CDBG("dbg: clk-name[%d] = %s\n", i, (*clk_info)[i].clk_name);
131 if (clock_cntl_support) {
132 rc = of_property_read_string_index(of_node,
133 "qcom,clock-control", i, &clk_ctl);
135 pr_err("%s reading clock-control failed index %d\n",
141 if (!strcmp(clk_ctl, "NO_SET_RATE"))
142 (*clk_info)[i].clk_rate = NO_SET_RATE;
143 else if (!strcmp(clk_ctl, "INIT_RATE"))
144 (*clk_info)[i].clk_rate = INIT_RATE;
145 else if (!strcmp(clk_ctl, "SET_RATE"))
146 (*clk_info)[i].clk_rate = rates[i];
148 pr_err("%s: error: clock control has invalid value\n",
154 (*clk_info)[i].clk_rate =
155 (rates[i] == 0) ? (long)-1 : rates[i];
157 CDBG("dbg: clk-rate[%d] = rate: %ld\n",
158 i, (*clk_info)[i].clk_rate);
161 devm_clk_get(dev, (*clk_info)[i].clk_name);
162 if (IS_ERR((*clk_ptr)[i])) {
163 rc = PTR_ERR((*clk_ptr)[i]);
166 CDBG("clk ptr[%d] :%pK\n", i, (*clk_ptr)[i]);
169 devm_kfree(dev, rates);
173 for (--i; i >= 0; i--)
174 devm_clk_put(dev, (*clk_ptr)[i]);
176 devm_kfree(dev, rates);
178 devm_kfree(dev, *clk_ptr);
180 devm_kfree(dev, *clk_info);
184 /* Get all clocks from DT for I2C devices */
185 int msm_camera_i2c_dev_get_clk_info(struct device *dev,
186 struct msm_cam_clk_info **clk_info,
187 struct clk ***clk_ptr,
192 if (!dev || !clk_info || !clk_ptr || !num_clk)
195 rc = msm_camera_get_clk_info_internal(dev, clk_info, clk_ptr, num_clk);
198 EXPORT_SYMBOL(msm_camera_i2c_dev_get_clk_info);
200 /* Get all clocks from DT for platform devices */
201 int msm_camera_get_clk_info(struct platform_device *pdev,
202 struct msm_cam_clk_info **clk_info,
203 struct clk ***clk_ptr,
208 if (!pdev || !&pdev->dev || !clk_info || !clk_ptr || !num_clk)
211 rc = msm_camera_get_clk_info_internal(&pdev->dev,
212 clk_info, clk_ptr, num_clk);
215 EXPORT_SYMBOL(msm_camera_get_clk_info);
217 /* Get all clocks and multiple rates from DT */
218 int msm_camera_get_clk_info_and_rates(
219 struct platform_device *pdev,
220 struct msm_cam_clk_info **pclk_info,
222 uint32_t ***pclk_rates,
226 int rc = 0, tmp_var, cnt, tmp;
227 uint32_t i = 0, j = 0;
228 struct device_node *of_node;
231 struct msm_cam_clk_info *clk_info;
233 if (!pdev || !pclk_info || !num_clk
234 || !pclk_rates || !pclks || !num_set)
237 of_node = pdev->dev.of_node;
239 cnt = of_property_count_strings(of_node, "clock-names");
241 pr_err("err: No clocks found in DT=%d\n", cnt);
245 tmp = of_property_count_u32_elems(of_node, "qcom,clock-rates");
247 pr_err("err: No clk rates device tree, count=%d\n", tmp);
251 if ((tmp % cnt) != 0) {
252 pr_err("err: clk name/rates mismatch, strings=%d, rates=%d\n",
258 *num_set = (tmp / cnt);
260 clk_info = devm_kcalloc(&pdev->dev, cnt,
261 sizeof(struct msm_cam_clk_info), GFP_KERNEL);
265 clks = devm_kcalloc(&pdev->dev, cnt, sizeof(struct clk *),
272 rates = devm_kcalloc(&pdev->dev, *num_set,
273 sizeof(uint32_t *), GFP_KERNEL);
279 for (i = 0; i < *num_set; i++) {
280 rates[i] = devm_kcalloc(&pdev->dev, *num_clk,
281 sizeof(uint32_t), GFP_KERNEL);
284 for (--i; i >= 0; i--)
285 devm_kfree(&pdev->dev, rates[i]);
291 for (i = 0; i < *num_set; i++) {
292 for (j = 0; j < *num_clk; j++) {
293 rc = of_property_read_u32_index(of_node,
294 "qcom,clock-rates", tmp_var++, &rates[i][j]);
296 pr_err("err: failed reading clock rates\n");
300 CDBG("Clock rate idx %d idx %d value %d\n",
304 for (i = 0; i < *num_clk; i++) {
305 rc = of_property_read_string_index(of_node, "clock-names",
306 i, &clk_info[i].clk_name);
308 pr_err("%s reading clock-name failed index %d\n",
314 CDBG("dbg: clk-name[%d] = %s\n", i, clk_info[i].clk_name);
317 devm_clk_get(&pdev->dev, clk_info[i].clk_name);
318 if (IS_ERR(clks[i])) {
319 rc = PTR_ERR(clks[i]);
322 CDBG("clk ptr[%d] :%pK\n", i, clks[i]);
324 *pclk_info = clk_info;
331 for (--i; i >= 0; i--)
332 devm_clk_put(&pdev->dev, clks[i]);
334 for (i = 0; i < *num_set; i++)
335 devm_kfree(&pdev->dev, rates[i]);
337 devm_kfree(&pdev->dev, rates);
339 devm_kfree(&pdev->dev, clks);
341 devm_kfree(&pdev->dev, clk_info);
344 EXPORT_SYMBOL(msm_camera_get_clk_info_and_rates);
346 /* Enable/Disable all clocks */
347 int msm_camera_clk_enable(struct device *dev,
348 struct msm_cam_clk_info *clk_info,
349 struct clk **clk_ptr, int num_clk, int enable)
356 for (i = 0; i < num_clk; i++) {
357 CDBG("enable %s\n", clk_info[i].clk_name);
358 if (clk_info[i].clk_rate > 0) {
359 clk_rate = clk_round_rate(clk_ptr[i],
360 clk_info[i].clk_rate);
362 pr_err("%s round failed\n",
363 clk_info[i].clk_name);
364 goto cam_clk_set_err;
366 rc = clk_set_rate(clk_ptr[i],
369 pr_err("%s set failed\n",
370 clk_info[i].clk_name);
371 goto cam_clk_set_err;
374 } else if (clk_info[i].clk_rate == INIT_RATE) {
375 clk_rate = clk_get_rate(clk_ptr[i]);
378 clk_round_rate(clk_ptr[i], 0);
380 pr_err("%s round rate failed\n",
381 clk_info[i].clk_name);
382 goto cam_clk_set_err;
385 rc = clk_set_rate(clk_ptr[i], clk_rate);
387 pr_err("%s set rate failed\n",
388 clk_info[i].clk_name);
389 goto cam_clk_set_err;
392 rc = clk_prepare_enable(clk_ptr[i]);
394 pr_err("%s enable failed\n",
395 clk_info[i].clk_name);
396 goto cam_clk_enable_err;
398 if (clk_info[i].delay > 20) {
399 msleep(clk_info[i].delay);
400 } else if (clk_info[i].delay) {
401 usleep_range(clk_info[i].delay * 1000,
402 (clk_info[i].delay * 1000) + 1000);
406 for (i = num_clk - 1; i >= 0; i--) {
407 if (clk_ptr[i] != NULL) {
408 CDBG("%s disable %s\n", __func__,
409 clk_info[i].clk_name);
410 clk_disable_unprepare(clk_ptr[i]);
418 for (i--; i >= 0; i--) {
419 if (clk_ptr[i] != NULL)
420 clk_disable_unprepare(clk_ptr[i]);
424 EXPORT_SYMBOL(msm_camera_clk_enable);
426 /* Set rate on a specific clock */
427 long msm_camera_clk_set_rate(struct device *dev,
434 if (!dev || !clk || (clk_rate < 0))
437 CDBG("clk : %pK, enable : %ld\n", clk, clk_rate);
440 rate = clk_round_rate(clk, clk_rate);
442 pr_err("round rate failed\n");
446 rc = clk_set_rate(clk, rate);
448 pr_err("set rate failed\n");
455 EXPORT_SYMBOL(msm_camera_clk_set_rate);
457 int msm_camera_set_clk_flags(struct clk *clk, unsigned long flags)
462 CDBG("clk : %pK, flags : %ld\n", clk, flags);
464 return clk_set_flags(clk, flags);
466 EXPORT_SYMBOL(msm_camera_set_clk_flags);
468 /* release memory allocated for clocks */
469 static int msm_camera_put_clk_info_internal(struct device *dev,
470 struct msm_cam_clk_info **clk_info,
471 struct clk ***clk_ptr, int cnt)
475 for (i = cnt - 1; i >= 0; i--) {
476 if (clk_ptr[i] != NULL)
477 devm_clk_put(dev, (*clk_ptr)[i]);
479 CDBG("clk ptr[%d] :%pK\n", i, (*clk_ptr)[i]);
481 devm_kfree(dev, *clk_info);
482 devm_kfree(dev, *clk_ptr);
488 /* release memory allocated for clocks for i2c devices */
489 int msm_camera_i2c_dev_put_clk_info(struct device *dev,
490 struct msm_cam_clk_info **clk_info,
491 struct clk ***clk_ptr, int cnt)
495 if (!dev || !clk_info || !clk_ptr)
498 rc = msm_camera_put_clk_info_internal(dev, clk_info, clk_ptr, cnt);
501 EXPORT_SYMBOL(msm_camera_i2c_dev_put_clk_info);
503 /* release memory allocated for clocks for platform devices */
504 int msm_camera_put_clk_info(struct platform_device *pdev,
505 struct msm_cam_clk_info **clk_info,
506 struct clk ***clk_ptr, int cnt)
510 if (!pdev || !&pdev->dev || !clk_info || !clk_ptr)
513 rc = msm_camera_put_clk_info_internal(&pdev->dev,
514 clk_info, clk_ptr, cnt);
517 EXPORT_SYMBOL(msm_camera_put_clk_info);
519 int msm_camera_put_clk_info_and_rates(struct platform_device *pdev,
520 struct msm_cam_clk_info **clk_info,
521 struct clk ***clk_ptr, uint32_t ***clk_rates,
522 size_t set, size_t cnt)
526 for (i = set - 1; i >= 0; i--)
527 devm_kfree(&pdev->dev, (*clk_rates)[i]);
529 devm_kfree(&pdev->dev, *clk_rates);
530 for (i = cnt - 1; i >= 0; i--) {
531 if (clk_ptr[i] != NULL)
532 devm_clk_put(&pdev->dev, (*clk_ptr)[i]);
533 CDBG("clk ptr[%d] :%pK\n", i, (*clk_ptr)[i]);
535 devm_kfree(&pdev->dev, *clk_info);
536 devm_kfree(&pdev->dev, *clk_ptr);
542 EXPORT_SYMBOL(msm_camera_put_clk_info_and_rates);
544 /* Get reset info from DT */
545 int msm_camera_get_reset_info(struct platform_device *pdev,
546 struct reset_control **micro_iface_reset)
548 if (!pdev || !micro_iface_reset)
551 if (of_property_match_string(pdev->dev.of_node, "reset-names",
552 "micro_iface_reset")) {
553 pr_err("err: Reset property not found\n");
557 *micro_iface_reset = devm_reset_control_get
558 (&pdev->dev, "micro_iface_reset");
559 if (IS_ERR(*micro_iface_reset))
560 return PTR_ERR(*micro_iface_reset);
564 EXPORT_SYMBOL(msm_camera_get_reset_info);
566 /* Get regulators from DT */
567 int msm_camera_get_regulator_info(struct platform_device *pdev,
568 struct msm_cam_regulator **vdd_info,
573 struct device_node *of_node;
575 struct msm_cam_regulator *tmp_reg;
577 if (!pdev || !vdd_info || !num_reg)
580 of_node = pdev->dev.of_node;
582 if (!of_get_property(of_node, "qcom,vdd-names", NULL)) {
583 pr_err("err: Regulators property not found\n");
587 cnt = of_property_count_strings(of_node, "qcom,vdd-names");
589 pr_err("err: no regulators found in device tree, count=%d",
594 tmp_reg = devm_kcalloc(&pdev->dev, cnt,
595 sizeof(struct msm_cam_regulator), GFP_KERNEL);
599 for (i = 0; i < cnt; i++) {
600 rc = of_property_read_string_index(of_node,
601 "qcom,vdd-names", i, &tmp_reg[i].name);
603 pr_err("Fail to fetch regulators: %d\n", i);
608 CDBG("regulator-names[%d] = %s\n", i, tmp_reg[i].name);
610 snprintf(prop_name, 32, "%s-supply", tmp_reg[i].name);
612 if (of_get_property(of_node, prop_name, NULL)) {
614 devm_regulator_get(&pdev->dev, tmp_reg[i].name);
615 if (IS_ERR(tmp_reg[i].vdd)) {
617 pr_err("Fail to get regulator :%d\n", i);
621 pr_err("Regulator phandle not found :%s\n",
626 CDBG("vdd ptr[%d] :%pK\n", i, tmp_reg[i].vdd);
635 for (--i; i >= 0; i--)
636 devm_regulator_put(tmp_reg[i].vdd);
637 devm_kfree(&pdev->dev, tmp_reg);
640 EXPORT_SYMBOL(msm_camera_get_regulator_info);
643 /* Enable/Disable regulators */
644 int msm_camera_regulator_enable(struct msm_cam_regulator *vdd_info,
649 struct msm_cam_regulator *tmp = vdd_info;
652 pr_err("Invalid params");
655 CDBG("cnt : %d\n", cnt);
657 for (i = 0; i < cnt; i++) {
658 if (tmp && !IS_ERR_OR_NULL(tmp->vdd)) {
659 CDBG("name : %s, enable : %d\n", tmp->name, enable);
661 rc = regulator_enable(tmp->vdd);
663 pr_err("regulator enable failed %d\n",
668 rc = regulator_disable(tmp->vdd);
670 pr_err("regulator disable failed %d\n",
679 for (--i; i > 0; i--) {
681 if (!IS_ERR_OR_NULL(tmp->vdd))
682 regulator_disable(tmp->vdd);
686 EXPORT_SYMBOL(msm_camera_regulator_enable);
688 /* set regulator mode */
689 int msm_camera_regulator_set_mode(struct msm_cam_regulator *vdd_info,
694 struct msm_cam_regulator *tmp = vdd_info;
697 pr_err("Invalid params");
700 CDBG("cnt : %d\n", cnt);
702 for (i = 0; i < cnt; i++) {
703 if (tmp && !IS_ERR_OR_NULL(tmp->vdd)) {
704 CDBG("name : %s, enable : %d\n", tmp->name, mode);
706 rc = regulator_set_mode(tmp->vdd,
707 REGULATOR_MODE_FAST);
709 pr_err("regulator enable failed %d\n",
714 rc = regulator_set_mode(tmp->vdd,
715 REGULATOR_MODE_NORMAL);
717 pr_err("regulator disable failed %d\n",
729 EXPORT_SYMBOL(msm_camera_regulator_set_mode);
732 /* Put regulators regulators */
733 void msm_camera_put_regulators(struct platform_device *pdev,
734 struct msm_cam_regulator **vdd_info, int cnt)
738 if (!vdd_info || !*vdd_info) {
739 pr_err("Invalid params\n");
743 for (i = cnt - 1; i >= 0; i--) {
744 if (vdd_info[i] && !IS_ERR_OR_NULL(vdd_info[i]->vdd))
745 devm_regulator_put(vdd_info[i]->vdd);
746 CDBG("vdd ptr[%d] :%pK\n", i, vdd_info[i]->vdd);
749 devm_kfree(&pdev->dev, *vdd_info);
752 EXPORT_SYMBOL(msm_camera_put_regulators);
754 struct resource *msm_camera_get_irq(struct platform_device *pdev,
757 if (!pdev || !irq_name) {
758 pr_err("Invalid params\n");
762 CDBG("Get irq for %s\n", irq_name);
763 return platform_get_resource_byname(pdev, IORESOURCE_IRQ, irq_name);
765 EXPORT_SYMBOL(msm_camera_get_irq);
767 int msm_camera_register_irq(struct platform_device *pdev,
768 struct resource *irq, irq_handler_t handler,
769 unsigned long irqflags, char *irq_name, void *dev_id)
773 if (!pdev || !irq || !handler || !irq_name || !dev_id) {
774 pr_err("Invalid params\n");
778 rc = devm_request_irq(&pdev->dev, irq->start, handler,
779 irqflags, irq_name, dev_id);
781 pr_err("irq request fail\n");
785 CDBG("Registered irq for %s[resource - %pK]\n", irq_name, irq);
789 EXPORT_SYMBOL(msm_camera_register_irq);
791 int msm_camera_register_threaded_irq(struct platform_device *pdev,
792 struct resource *irq, irq_handler_t handler_fn,
793 irq_handler_t thread_fn, unsigned long irqflags,
794 const char *irq_name, void *dev_id)
798 if (!pdev || !irq || !irq_name || !dev_id) {
799 pr_err("Invalid params\n");
803 rc = devm_request_threaded_irq(&pdev->dev, irq->start, handler_fn,
804 thread_fn, irqflags, irq_name, dev_id);
806 pr_err("irq request fail\n");
810 CDBG("Registered irq for %s[resource - %pK]\n", irq_name, irq);
814 EXPORT_SYMBOL(msm_camera_register_threaded_irq);
816 int msm_camera_enable_irq(struct resource *irq, int enable)
819 pr_err("Invalid params\n");
823 CDBG("irq Enable %d\n", enable);
825 enable_irq(irq->start);
827 disable_irq(irq->start);
831 EXPORT_SYMBOL(msm_camera_enable_irq);
833 int msm_camera_unregister_irq(struct platform_device *pdev,
834 struct resource *irq, void *dev_id)
837 if (!pdev || !irq || !dev_id) {
838 pr_err("Invalid params\n");
842 CDBG("Un Registering irq for [resource - %pK]\n", irq);
843 devm_free_irq(&pdev->dev, irq->start, dev_id);
847 EXPORT_SYMBOL(msm_camera_unregister_irq);
849 void __iomem *msm_camera_get_reg_base(struct platform_device *pdev,
850 char *device_name, int reserve_mem)
852 struct resource *mem;
855 if (!pdev || !device_name) {
856 pr_err("Invalid params\n");
860 CDBG("device name :%s\n", device_name);
861 mem = platform_get_resource_byname(pdev,
862 IORESOURCE_MEM, device_name);
864 pr_err("err: mem resource %s not found\n", device_name);
869 CDBG("device:%pK, mem : %pK, size : %d\n",
870 &pdev->dev, mem, (int)resource_size(mem));
871 if (!devm_request_mem_region(&pdev->dev, mem->start,
874 pr_err("err: no valid mem region for device:%s\n",
880 base = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
882 devm_release_mem_region(&pdev->dev, mem->start,
884 pr_err("err: ioremap failed: %s\n", device_name);
888 CDBG("base : %pK\n", base);
891 EXPORT_SYMBOL(msm_camera_get_reg_base);
893 uint32_t msm_camera_get_res_size(struct platform_device *pdev,
896 struct resource *mem;
898 if (!pdev || !device_name) {
899 pr_err("Invalid params\n");
903 CDBG("device name :%s\n", device_name);
904 mem = platform_get_resource_byname(pdev,
905 IORESOURCE_MEM, device_name);
907 pr_err("err: mem resource %s not found\n", device_name);
910 return resource_size(mem);
912 EXPORT_SYMBOL(msm_camera_get_res_size);
915 int msm_camera_put_reg_base(struct platform_device *pdev,
916 void __iomem *base, char *device_name, int reserve_mem)
918 struct resource *mem;
920 if (!pdev || !base || !device_name) {
921 pr_err("Invalid params\n");
925 CDBG("device name :%s\n", device_name);
926 mem = platform_get_resource_byname(pdev,
927 IORESOURCE_MEM, device_name);
929 pr_err("err: mem resource %s not found\n", device_name);
932 CDBG("mem : %pK, size : %d\n", mem, (int)resource_size(mem));
934 devm_iounmap(&pdev->dev, base);
936 devm_release_mem_region(&pdev->dev,
937 mem->start, resource_size(mem));
941 EXPORT_SYMBOL(msm_camera_put_reg_base);
943 /* Register the bus client */
944 uint32_t msm_camera_register_bus_client(struct platform_device *pdev,
945 enum cam_bus_client id)
948 uint32_t bus_client, num_usecases, num_paths;
949 struct msm_bus_scale_pdata *pdata;
950 struct device_node *of_node;
952 CDBG("Register client ID: %d\n", id);
954 if (id >= CAM_BUS_CLIENT_MAX || !pdev) {
955 pr_err("Invalid params");
959 of_node = pdev->dev.of_node;
961 if (!g_cv[id].pdata) {
962 rc = of_property_read_u32(of_node, "qcom,msm-bus,num-cases",
965 pr_err("num-usecases not found\n");
968 rc = of_property_read_u32(of_node, "qcom,msm-bus,num-paths",
971 pr_err("num-usecases not found\n");
975 if (num_paths != 1) {
976 pr_err("Exceeds number of paths\n");
980 if (of_property_read_bool(of_node,
981 "qcom,msm-bus-vector-dyn-vote")) {
982 if (num_usecases != 2) {
983 pr_err("Excess or less vectors\n");
986 g_cv[id].dyn_vote = true;
989 pdata = msm_bus_cl_get_pdata(pdev);
991 pr_err("failed get_pdata client_id :%d\n", id);
994 bus_client = msm_bus_scale_register_client(pdata);
996 pr_err("Unable to register bus client :%d\n", id);
1000 pr_err("vector already setup client_id : %d\n", id);
1004 g_cv[id].pdata = pdata;
1005 g_cv[id].bus_client = bus_client;
1006 g_cv[id].vector_index = 0;
1007 g_cv[id].num_usecases = num_usecases;
1008 g_cv[id].num_paths = num_paths;
1009 mutex_init(&g_cv[id].lock);
1010 CDBG("Exit Client ID: %d\n", id);
1013 EXPORT_SYMBOL(msm_camera_register_bus_client);
1015 /* Update the bus bandwidth */
1016 uint32_t msm_camera_update_bus_bw(int id, uint64_t ab, uint64_t ib)
1018 struct msm_bus_paths *path;
1019 struct msm_bus_scale_pdata *pdata;
1022 if (id >= CAM_BUS_CLIENT_MAX) {
1023 pr_err("Invalid params");
1026 if (g_cv[id].num_usecases != 2 ||
1027 g_cv[id].num_paths != 1 ||
1028 g_cv[id].dyn_vote != true) {
1029 pr_err("dynamic update not allowed\n");
1033 mutex_lock(&g_cv[id].lock);
1034 idx = g_cv[id].vector_index;
1036 g_cv[id].vector_index = idx;
1037 mutex_unlock(&g_cv[id].lock);
1039 pdata = g_cv[id].pdata;
1040 path = &(pdata->usecase[idx]);
1041 path->vectors[0].ab = ab;
1042 path->vectors[0].ib = ib;
1044 CDBG("Register client ID : %d [ab : %llx, ib : %llx], update :%d\n",
1046 msm_bus_scale_client_update_request(g_cv[id].bus_client, idx);
1050 EXPORT_SYMBOL(msm_camera_update_bus_bw);
1052 /* Update the bus vector */
1053 uint32_t msm_camera_update_bus_vector(enum cam_bus_client id,
1056 if (id >= CAM_BUS_CLIENT_MAX || g_cv[id].dyn_vote == true) {
1057 pr_err("Invalid params");
1061 if (vector_index < 0 || vector_index > g_cv[id].num_usecases) {
1062 pr_err("Invalid params");
1066 CDBG("Register client ID : %d vector idx: %d,\n", id, vector_index);
1067 msm_bus_scale_client_update_request(g_cv[id].bus_client,
1072 EXPORT_SYMBOL(msm_camera_update_bus_vector);
1074 /* Unregister the bus client */
1075 uint32_t msm_camera_unregister_bus_client(enum cam_bus_client id)
1077 if (id >= CAM_BUS_CLIENT_MAX) {
1078 pr_err("Invalid params");
1082 CDBG("UnRegister client ID: %d\n", id);
1084 mutex_destroy(&g_cv[id].lock);
1085 msm_bus_scale_unregister_client(g_cv[id].bus_client);
1086 g_cv[id].bus_client = 0;
1087 g_cv[id].num_usecases = 0;
1088 g_cv[id].num_paths = 0;
1089 g_cv[id].vector_index = 0;
1090 g_cv[id].dyn_vote = 0;
1094 EXPORT_SYMBOL(msm_camera_unregister_bus_client);