[FAQ22659] [Android Q] Camera Sensor Regulator Restricting voltage 的处理...

admin

[DESCRIPTION]

Linux regulator framework允许针对某个LDO取得多个consumer regulator instance，并且会纪录该LDO使用的consumer list，安全起见会使用该list中电压设值最小的来供电，因此当不同regulator instance设定为不同电压时就会出现Restricting voltage这样的错误log：
关键log为 "Restricting voltage"：

01-01 00:05:54.771655   517   517 E [  124.722793].(0)[517:camerahalserver][name:core&]vcamd: Restricting voltage, 1200000-1100000uV


[SOLUTION]

Power off时一并释放regulator（Call regulator_put（）），然后于power on时重新取得regulator。用这个做法时，需要注意确保thread safe，regulator取得与释放时需要互斥锁定。
当前的FAQ中提供了Android Q下MT6873和MT6765平台上的修改方案，其他平台可参考修改。
Android P下该问题的解决办法可以参考FAQ20676 [Android P] Camera Sensor Regulator Restricting voltage 的处理方法。

MT6873

1.   diff --git a/drivers/misc/mediatek/imgsensor/src/mt6873/camera_hw/regulator/regulator.c b/drivers/misc/mediatek/imgsensor/src/mt6873/camera_hw/regulator/regulator.c
   
2. index 2132cc748f08..9de92138cd66
   
3. --- a/drivers/misc/mediatek/imgsensor/src/mt6873/camera_hw/regulator/regulator.c
   
4. +++ b/drivers/misc/mediatek/imgsensor/src/mt6873/camera_hw/regulator/regulator.c
   
5. @@ -13,7 +13,17 @@
   
6. 
   
7. #include "regulator.h"
   
8. 
   
9. +static bool regulator_status[IMGSENSOR_SENSOR_IDX_MAX_NUM][
   
10. + REGULATOR_TYPE_MAX_NUM] = {{false}};
    
11. +static void check_for_regulator_get(struct REGULATOR *preg,
    
12. + struct device *pdevice, unsigned int sensor_index,
    
13. + unsigned int regulator_index);
    
14. +static void check_for_regulator_put(struct REGULATOR *preg,
    
15. + unsigned int sensor_index, unsigned int regulator_index);
    
16. +static struct device_node *of_node_record;
    
17. +static struct IMGSENSOR_HW_DEVICE_COMMON *ghw_device_common;
    
18. 
    
19. +static DEFINE_MUTEX(g_regulator_state_mutex);
    
20. static const int regulator_voltage[] = {
    
21. REGULATOR_VOLTAGE_0,
    
22. REGULATOR_VOLTAGE_1000,
    
23. @@ -43,7 +53,10 @@ static enum IMGSENSOR_RETURN regulator_init(
    
24. struct REGULATOR *preg = (struct REGULATOR *)pinstance;
    
25. int type, idx;
    
26. char str_regulator_name[LENGTH_FOR_SNPRINTF];
    
27. -
    
28. +
    
29. + ghw_device_common = pcommon;
    
30. + of_node_record = pcommon->pplatform_device->dev.of_node;
    
31. +
    
32. for (idx = IMGSENSOR_SENSOR_IDX_MIN_NUM;
    
33. idx < IMGSENSOR_SENSOR_IDX_MAX_NUM;
    
34. idx++) {
    
35. @@ -113,7 +126,11 @@ static enum IMGSENSOR_RETURN regulator_set(
    
36. return IMGSENSOR_RETURN_ERROR;
    
37. 
    
38. reg_type_offset = REGULATOR_TYPE_VCAMA;
    
39. -
    
40. +
    
41. + if (ghw_device_common)
    
42. + check_for_regulator_get(preg, &ghw_device_common->pplatform_device->dev, sensor_idx,
    
43. + (reg_type_offset + pin - IMGSENSOR_HW_PIN_AVDD));
    
44. +
    
45. pregulator =
    
46. preg->pregulator[sensor_idx][
    
47. reg_type_offset + pin - IMGSENSOR_HW_PIN_AVDD];
    
48. @@ -142,6 +159,10 @@ static enum IMGSENSOR_RETURN regulator_set(
    
49. pin,
    
50. regulator_voltage[
    
51. pin_state - IMGSENSOR_HW_PIN_STATE_LEVEL_0]);
    
52. +
    
53. + check_for_regulator_put(preg, sensor_idx,
    
54. + (reg_type_offset + pin - IMGSENSOR_HW_PIN_AVDD));
    
55. +
    
56. return IMGSENSOR_RETURN_ERROR;
    
57. }
    
58. atomic_inc(enable_cnt);
    
59. @@ -153,8 +174,16 @@ static enum IMGSENSOR_RETURN regulator_set(
    
60. PK_PR_ERR(
    
61. "[regulator]fail to regulator_disable, powertype: %d\n",
    
62. pin);
    
63. +
    
64. + check_for_regulator_put(preg, sensor_idx,
    
65. + (reg_type_offset + pin - IMGSENSOR_HW_PIN_AVDD));
    
66. +
    
67. return IMGSENSOR_RETURN_ERROR;
    
68. }
    
69. +
    
70. + check_for_regulator_put(preg, sensor_idx,
    
71. + (reg_type_offset + pin - IMGSENSOR_HW_PIN_AVDD));
    
72. +
    
73. atomic_dec(enable_cnt);
    
74. }
    
75. } else {
    
76. @@ -166,7 +195,77 @@ static enum IMGSENSOR_RETURN regulator_set(
    
77. 
    
78. return IMGSENSOR_RETURN_SUCCESS;
    
79. }
    
80. +static void check_for_regulator_get(struct REGULATOR *preg,
    
81. + struct device *pdevice, unsigned int sensor_index,
    
82. + unsigned int regulator_index)
    
83. +{
    
84. + struct device_node *pof_node = NULL;
    
85. + char str_regulator_name[LENGTH_FOR_SNPRINTF];
    
86. +
    
87. + if (!preg || !pdevice) {
    
88. + pr_err("Fatal: Null ptr.preg:%pK,pdevice:%pK\n", preg, pdevice);
    
89. + return;
    
90. + }
    
91. +
    
92. + if (sensor_index >= IMGSENSOR_SENSOR_IDX_MAX_NUM ||
    
93. + regulator_index >= REGULATOR_TYPE_MAX_NUM ) {
    
94. + pr_err("[%s]Invalid sensor_idx:%d regulator_idx: %d\n",
    
95. + __func__, sensor_index, regulator_index);
    
96. + return;
    
97. + }
    
98. +
    
99. + mutex_lock(&g_regulator_state_mutex);
    
100. +
     
101. + if (regulator_status[sensor_index][regulator_index] == false) {
     
102. + pof_node = pdevice->of_node;
     
103. + pdevice->of_node = of_node_record;
     
104. +
     
105. + snprintf(str_regulator_name,
     
106. + sizeof(str_regulator_name),
     
107. + "cam%d_%s",
     
108. + sensor_index,
     
109. + regulator_control[regulator_index].pregulator_type);
     
110. + preg->pregulator[sensor_index][regulator_index] =
     
111. + regulator_get(pdevice, str_regulator_name);
     
112. +
     
113. + if (preg != NULL)
     
114. + regulator_status[sensor_index][regulator_index] = true;
     
115. + else
     
116. + pr_err("get regulator failed.\n");
     
117. + pdevice->of_node = pof_node;
     
118. + }
     
119. +
     
120. + mutex_unlock(&g_regulator_state_mutex);
     
121. 
     
122. + return;
     
123. +}
     
124. +
     
125. +static void check_for_regulator_put(struct REGULATOR *preg,
     
126. + unsigned int sensor_index, unsigned int regulator_index)
     
127. +{
     
128. + if (!preg) {
     
129. + pr_err("Fatal: Null ptr.\n");
     
130. + return;
     
131. + }
     
132. +
     
133. + if (sensor_index >= IMGSENSOR_SENSOR_IDX_MAX_NUM ||
     
134. + regulator_index >= REGULATOR_TYPE_MAX_NUM ) {
     
135. + pr_err("[%s]Invalid sensor_idx:%d regulator_idx: %d\n",
     
136. + __func__, sensor_index, regulator_index);
     
137. + return;
     
138. + }
     
139. +
     
140. + mutex_lock(&g_regulator_state_mutex);
     
141. +
     
142. + if (regulator_status[sensor_index][regulator_index] == true) {
     
143. + regulator_put(preg->pregulator[sensor_index][regulator_index]);
     
144. + preg->pregulator[sensor_index][regulator_index] = NULL;
     
145. + regulator_status[sensor_index][regulator_index] = false;
     
146. + }
     
147. +
     
148. + mutex_unlock(&g_regulator_state_mutex);
     
149. +
     
150. + return;
     
151. +}
     
152. static enum IMGSENSOR_RETURN regulator_dump(void *pinstance)
     
153. {
     
154. struct REGULATOR *preg = (struct REGULATOR *)pinstance;
     

复制代码

MT6765

1. +static bool regulator_status[IMGSENSOR_SENSOR_IDX_MAX_NUM][
   
2. + REGULATOR_TYPE_MAX_NUM] = {false};
   
3. +static void check_for_regulator_get(struct REGULATOR *preg,
   
4. + struct device *pdevice, unsigned int sensor_index,
   
5. + unsigned int regulator_index);
   
6. +static void check_for_regulator_put(struct REGULATOR *preg,
   
7. + unsigned int sensor_index, unsigned int regulator_index);
   
8. +static struct device_node *of_node_record = NULL;
   
9. +
   
10. +static DEFINE_MUTEX(g_regulator_state_mutex);
    
11. +
    
12. static const int regulator_voltage[] = {
    
13. REGULATOR_VOLTAGE_0,
    
14. REGULATOR_VOLTAGE_1000,
    
15. @@ -183,12 +194,12 @@
    
16. pof_node = pdevice->of_node;
    
17. pdevice->of_node =
    
18. of_find_compatible_node(NULL, NULL, "mediatek,camera_hw");
    
19. -
    
20. if (pdevice->of_node == NULL) {
    
21. pr_err("regulator get cust camera node failed!\n");
    
22. pdevice->of_node = pof_node;
    
23. return IMGSENSOR_RETURN_ERROR;
    
24. }
    
25. + of_node_record = pdevice->of_node;
    
26. 
    
27. for (j = IMGSENSOR_SENSOR_IDX_MIN_NUM;
    
28. j < IMGSENSOR_SENSOR_IDX_MAX_NUM;
    
29. @@ -207,6 +218,7 @@
    
30. j, i, str_regulator_name);
    
31. 
    
32. atomic_set(&preg->enable_cnt[j][i], 0);
    
33. + regulator_status[j][i] = true;
    
34. }
    
35. }
    
36. pdevice->of_node = pof_node;
    
37. @@ -257,7 +269,8 @@
    
38. return IMGSENSOR_RETURN_ERROR;
    
39. 
    
40. reg_type_offset = REGULATOR_TYPE_VCAMA;
    
41. -
    
42. + check_for_regulator_get(preg, gimgsensor_device, sensor_idx,
    
43. + (reg_type_offset + pin - IMGSENSOR_HW_PIN_AVDD));
    
44. pregulator =
    
45. preg->pregulator[sensor_idx][
    
46. reg_type_offset + pin - IMGSENSOR_HW_PIN_AVDD];
    
47. @@ -300,7 +313,8 @@
    
48. pin,
    
49. regulator_voltage[
    
50. pin_state - IMGSENSOR_HW_PIN_STATE_LEVEL_0]);
    
51. -
    
52. + check_for_regulator_put(preg, sensor_idx,
    
53. + (reg_type_offset + pin - IMGSENSOR_HW_PIN_AVDD));
    
54. return IMGSENSOR_RETURN_ERROR;
    
55. }
    
56. atomic_inc(enable_cnt);
    
57. @@ -312,9 +326,13 @@
    
58. pr_err(
    
59. "[regulator]fail to regulator_disable, powertype: %d\n",
    
60. pin);
    
61. + check_for_regulator_put(preg, sensor_idx,
    
62. + (reg_type_offset + pin - IMGSENSOR_HW_PIN_AVDD));
    
63. return IMGSENSOR_RETURN_ERROR;
    
64. }
    
65. }
    
66. + check_for_regulator_put(preg, sensor_idx,
    
67. + (reg_type_offset + pin - IMGSENSOR_HW_PIN_AVDD));
    
68. atomic_dec(enable_cnt);
    
69. }
    
70. } else {
    
71. @@ -327,6 +345,78 @@
    
72. return IMGSENSOR_RETURN_SUCCESS;
    
73. }
    
74. 
    
75. +static void check_for_regulator_get(struct REGULATOR *preg,
    
76. + struct device *pdevice, unsigned int sensor_index,
    
77. + unsigned int regulator_index)
    
78. +{
    
79. + struct device_node *pof_node = NULL;
    
80. + char str_regulator_name[LENGTH_FOR_SNPRINTF];
    
81. +
    
82. + if (!preg || !pdevice) {
    
83. + pr_err("Fatal: Null ptr.preg:%pK,pdevice:%pK\n", preg, pdevice);
    
84. + return;
    
85. + }
    
86. +
    
87. + if (sensor_index >= IMGSENSOR_SENSOR_IDX_MAX_NUM ||
    
88. + regulator_index >= REGULATOR_TYPE_MAX_NUM ) {
    
89. + pr_err("[%s]Invalid sensor_idx:%d regulator_idx: %d\n",
    
90. + __func__, sensor_index, regulator_index);
    
91. + return;
    
92. + }
    
93. +
    
94. + mutex_lock(&g_regulator_state_mutex);
    
95. +
    
96. + if (regulator_status[sensor_index][regulator_index] == false) {
    
97. + pof_node = pdevice->of_node;
    
98. + pdevice->of_node = of_node_record;
    
99. +
    
100. + snprintf(str_regulator_name,
     
101. + sizeof(str_regulator_name),
     
102. + "cam%d_%s",
     
103. + sensor_index,
     
104. + regulator_control[regulator_index].pregulator_type);
     
105. + preg->pregulator[sensor_index][regulator_index] =
     
106. + regulator_get(pdevice, str_regulator_name);
     
107. +
     
108. + if (preg != NULL)
     
109. + regulator_status[sensor_index][regulator_index] = true;
     
110. + else
     
111. + pr_err("get regulator failed.\n");
     
112. + pdevice->of_node = pof_node;
     
113. + }
     
114. +
     
115. + mutex_unlock(&g_regulator_state_mutex);
     
116. +
     
117. + return;
     
118. +}
     
119. +
     
120. +static void check_for_regulator_put(struct REGULATOR *preg,
     
121. + unsigned int sensor_index, unsigned int regulator_index)
     
122. +{
     
123. + if (!preg) {
     
124. + pr_err("Fatal: Null ptr.\n");
     
125. + return;
     
126. + }
     
127. +
     
128. + if (sensor_index >= IMGSENSOR_SENSOR_IDX_MAX_NUM ||
     
129. + regulator_index >= REGULATOR_TYPE_MAX_NUM ) {
     
130. + pr_err("[%s]Invalid sensor_idx:%d regulator_idx: %d\n",
     
131. + __func__, sensor_index, regulator_index);
     
132. + return;
     
133. + }
     
134. +
     
135. + mutex_lock(&g_regulator_state_mutex);
     
136. +
     
137. + if (regulator_status[sensor_index][regulator_index] == true) {
     
138. + regulator_put(preg->pregulator[sensor_index][regulator_index]);
     
139. + preg->pregulator[sensor_index][regulator_index] = NULL;
     
140. + regulator_status[sensor_index][regulator_index] = false;
     
141. + }
     
142. +
     
143. + mutex_unlock(&g_regulator_state_mutex);
     
144. +
     
145. + return;
     
146. +}
     
147. +
     
148. static struct IMGSENSOR_HW_DEVICE device = {
     
149. .pinstance = (void *)&reg_instance,
     
150. .init = regulator_init,
     

复制代码