1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (c) 2020 Rockchip Electronics Co., Ltd.
3 /*
4 * otp_eeprom driver
5 *
6 * V0.0X01.0X01
7 * 1. fix table_size.
8 * 2. fix ioctl return value.
9 * 3. add version control.
10 * V0.0X01.0X02
11 * 1. fix otp info null issue.
12 * V0.0X01.0X03
13 * 1. add buf read optimize otp read speed.
14 * 2. add mutex for otp read.
15 */
16 //#define DEBUG
17 #include <linux/delay.h>
18 #include <linux/i2c.h>
19 #include <linux/module.h>
20 #include <linux/pm_runtime.h>
21 #include <linux/proc_fs.h>
22 #include <linux/rk-camera-module.h>
23 #include <linux/sem.h>
24 #include <linux/seq_file.h>
25 #include <media/v4l2-ctrls.h>
26 #include <media/v4l2-device.h>
27 #include <linux/version.h>
28 #include "otp_eeprom.h"
29
30 #define DRIVER_VERSION KERNEL_VERSION(0, 0x01, 0x03)
31 #define DEVICE_NAME "otp_eeprom"
32
33 static inline struct eeprom_device
sd_to_eeprom(struct v4l2_subdev * subdev)34 *sd_to_eeprom(struct v4l2_subdev *subdev)
35 {
36 return container_of(subdev, struct eeprom_device, sd);
37 }
38
39 /* Read registers up to 4 at a time */
read_reg_otp(struct i2c_client * client,u16 reg,unsigned int len,u32 * val)40 static int read_reg_otp(struct i2c_client *client, u16 reg,
41 unsigned int len, u32 *val)
42 {
43 struct i2c_msg msgs[2];
44 u8 *data_be_p;
45 __be32 data_be = 0;
46 __be16 reg_addr_be = cpu_to_be16(reg);
47 int ret;
48
49 if (len > 4 || !len)
50 return -EINVAL;
51
52 data_be_p = (u8 *)&data_be;
53 /* Write register address */
54 msgs[0].addr = client->addr;
55 msgs[0].flags = 0;
56 msgs[0].len = 2;
57 msgs[0].buf = (u8 *)®_addr_be;
58
59 /* Read data from register */
60 msgs[1].addr = client->addr;
61 msgs[1].flags = I2C_M_RD;
62 msgs[1].len = len;
63 msgs[1].buf = &data_be_p[4 - len];
64
65 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
66 if (ret != ARRAY_SIZE(msgs))
67 return -EIO;
68
69 *val = be32_to_cpu(data_be);
70
71 return 0;
72 }
73
74 /* Read registers buffers at a time */
read_reg_otp_buf(struct i2c_client * client,u16 reg,unsigned int len,u8 * buf)75 static int read_reg_otp_buf(struct i2c_client *client, u16 reg,
76 unsigned int len, u8 *buf)
77 {
78 struct i2c_msg msgs[2];
79 __be16 reg_addr_be = cpu_to_be16(reg);
80 int ret;
81
82 /* Write register address */
83 msgs[0].addr = client->addr;
84 msgs[0].flags = 0;
85 msgs[0].len = 2;
86 msgs[0].buf = (u8 *)®_addr_be;
87
88 /* Read data from register */
89 msgs[1].addr = client->addr;
90 msgs[1].flags = I2C_M_RD;
91 msgs[1].len = len;
92 msgs[1].buf = buf;
93
94 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
95 if (ret != ARRAY_SIZE(msgs))
96 return -EIO;
97
98 return 0;
99 }
100
get_vendor_flag(struct i2c_client * client)101 static u8 get_vendor_flag(struct i2c_client *client)
102 {
103 u8 vendor_flag = 0;
104 u8 vendor[9];
105 int i = 0;
106 u32 temp = 0;
107
108 for (i = 0; i < 8; i++) {
109 read_reg_otp(client, INFO_FLAG_REG + i, 1, &temp);
110 vendor[i] = (u8)temp;
111 }
112 vendor[8] = 0;
113 if (strcmp(vendor, "ROCKCHIP") == 0)
114 vendor_flag |= 0x40;
115 else
116 vendor_flag |= 0x80;
117 return vendor_flag;
118 }
119
otp_read_data(struct eeprom_device * eeprom_dev)120 static int otp_read_data(struct eeprom_device *eeprom_dev)
121 {
122 struct i2c_client *client = eeprom_dev->client;
123 int i;
124 struct otp_info *otp_ptr;
125 struct device *dev = &eeprom_dev->client->dev;
126 int ret = 0;
127 u32 temp = 0;
128
129 otp_ptr = kzalloc(sizeof(*otp_ptr), GFP_KERNEL);
130 if (!otp_ptr)
131 return -ENOMEM;
132 /* OTP base information*/
133 ret = read_reg_otp(client, INFO_FLAG_REG,
134 1, &otp_ptr->basic_data.flag);
135 if (otp_ptr->basic_data.flag == 0x01) {
136 ret |= read_reg_otp(client, INFO_ID_REG,
137 1, &otp_ptr->basic_data.id.supplier_id);
138 ret |= read_reg_otp(client, INFO_ID_REG + 1,
139 1, &otp_ptr->basic_data.id.year);
140 ret |= read_reg_otp(client, INFO_ID_REG + 2,
141 1, &otp_ptr->basic_data.id.month);
142 ret |= read_reg_otp(client, INFO_ID_REG + 3,
143 1, &otp_ptr->basic_data.id.day);
144 ret |= read_reg_otp(client, INFO_ID_REG + 4,
145 1, &otp_ptr->basic_data.id.sensor_id);
146 ret |= read_reg_otp(client, INFO_ID_REG + 5,
147 1, &otp_ptr->basic_data.id.lens_id);
148 ret |= read_reg_otp(client, INFO_ID_REG + 6,
149 1, &otp_ptr->basic_data.id.vcm_id);
150 ret |= read_reg_otp(client, INFO_ID_REG + 7,
151 1, &otp_ptr->basic_data.id.driver_ic_id);
152 ret |= read_reg_otp(client, INFO_ID_REG + 8,
153 1, &otp_ptr->basic_data.id.color_temperature_id);
154 for (i = 0; i < SMARTISAN_PN_SIZE; i++) {
155 ret |= read_reg_otp(client, SMARTISAN_PN_REG + i,
156 1, &temp);
157 otp_ptr->basic_data.smartisan_pn[i] = temp;
158 }
159 for (i = 0; i < MOUDLE_ID_SIZE; i++) {
160 ret |= read_reg_otp(client, MOUDLE_ID_REG + i,
161 1, &temp);
162 otp_ptr->basic_data.modul_id[i] = temp;
163 }
164 ret |= read_reg_otp(client, MIRROR_FLIP_REG,
165 1, &otp_ptr->basic_data.mirror_flip);
166 ret |= read_reg_otp(client, FULL_SIZE_WIGHT_REG,
167 2, &temp);
168 otp_ptr->basic_data.size.width = temp;
169 ret |= read_reg_otp(client, FULL_SIZE_HEIGHT_REG,
170 2, &temp);
171 otp_ptr->basic_data.size.height = temp;
172 ret |= read_reg_otp(client, INFO_CHECKSUM_REG,
173 1, &otp_ptr->basic_data.checksum);
174
175 dev_dbg(dev, "fasic info: supplier_id(0x%x) lens(0x%x) time(%d_%d_%d)\n",
176 otp_ptr->basic_data.id.supplier_id,
177 otp_ptr->basic_data.id.lens_id,
178 otp_ptr->basic_data.id.year,
179 otp_ptr->basic_data.id.month,
180 otp_ptr->basic_data.id.day);
181 if (ret)
182 goto err;
183 }
184
185 /* OTP WB calibration data */
186 ret = read_reg_otp(client, AWB_FLAG_REG,
187 1, &otp_ptr->awb_data.flag);
188 if (otp_ptr->awb_data.flag == 0x01) {
189 ret |= read_reg_otp(client, AWB_VERSION_REG,
190 1, &otp_ptr->awb_data.version);
191 ret |= read_reg_otp(client, CUR_R_REG,
192 2, &otp_ptr->awb_data.r_ratio);
193 ret |= read_reg_otp(client, CUR_B_REG,
194 2, &otp_ptr->awb_data.b_ratio);
195 ret |= read_reg_otp(client, CUR_G_REG,
196 2, &otp_ptr->awb_data.g_ratio);
197 ret |= read_reg_otp(client, GOLDEN_R_REG,
198 2, &otp_ptr->awb_data.r_golden);
199 ret |= read_reg_otp(client, GOLDEN_B_REG,
200 2, &otp_ptr->awb_data.b_golden);
201 ret |= read_reg_otp(client, GOLDEN_G_REG,
202 2, &otp_ptr->awb_data.g_golden);
203 ret |= read_reg_otp(client, AWB_CHECKSUM_REG,
204 1, &otp_ptr->awb_data.checksum);
205
206 dev_dbg(dev, "awb version:0x%x\n",
207 otp_ptr->awb_data.version);
208 if (ret)
209 goto err;
210 }
211
212 /* OTP LSC calibration data */
213 ret = read_reg_otp(client, LSC_FLAG_REG,
214 1, &otp_ptr->lsc_data.flag);
215 if (otp_ptr->lsc_data.flag == 0x01) {
216 ret |= read_reg_otp(client, LSC_VERSION_REG,
217 1, &otp_ptr->lsc_data.version);
218 ret |= read_reg_otp(client, LSC_TABLE_SIZE_REG,
219 2, &temp);
220 otp_ptr->lsc_data.table_size = temp;
221 for (i = 0; i < LSC_DATA_SIZE; i++) {
222 ret |= read_reg_otp(client, LSC_DATA_START_REG + i,
223 1, &temp);
224 otp_ptr->lsc_data.data[i] = temp;
225 }
226 ret |= read_reg_otp(client, LSC_CHECKSUM_REG,
227 1, &otp_ptr->lsc_data.checksum);
228 dev_dbg(dev, "lsc cur:(version 0x%x, table_size 0x%x checksum 0x%x)\n",
229 otp_ptr->lsc_data.version,
230 otp_ptr->lsc_data.table_size,
231 otp_ptr->lsc_data.checksum);
232 if (ret)
233 goto err;
234 }
235
236 /* OTP sfr calibration data */
237 ret = read_reg_otp(client, LSC_FLAG_REG,
238 1, &otp_ptr->sfr_otp_data.flag);
239 if (otp_ptr->sfr_otp_data.flag == 0x01) {
240 ret |= read_reg_otp(client, SFR_EQUIQ_NUM_REG,
241 1, &otp_ptr->sfr_otp_data.equip_num);
242 ret |= read_reg_otp(client, SFR_C_HOR_REG,
243 2, &otp_ptr->sfr_otp_data.center_horizontal);
244 ret |= read_reg_otp(client, SFR_C_VER_REG,
245 2, &otp_ptr->sfr_otp_data.center_vertical);
246 for (i = 0; i < 3; i++) {
247 ret |= read_reg_otp(client, SFR_TOP_L_HOR_REG + 16 * i,
248 2, &otp_ptr->sfr_otp_data.data[i].top_l_horizontal);
249 ret |= read_reg_otp(client, SFR_TOP_L_VER_REG + 16 * i,
250 2, &otp_ptr->sfr_otp_data.data[i].top_l_vertical);
251 ret |= read_reg_otp(client, SFR_TOP_R_HOR_REG + 16 * i,
252 2, &otp_ptr->sfr_otp_data.data[i].top_r_horizontal);
253 ret |= read_reg_otp(client, SFR_TOP_R_VER_REG + 16 * i,
254 2, &otp_ptr->sfr_otp_data.data[i].top_r_vertical);
255 ret |= read_reg_otp(client, SFR_BOTTOM_L_HOR_REG + 16 * i,
256 2, &otp_ptr->sfr_otp_data.data[i].bottom_l_horizontal);
257 ret |= read_reg_otp(client, SFR_BOTTOM_L_VER_REG + 16 * i,
258 2, &otp_ptr->sfr_otp_data.data[i].bottom_l_vertical);
259 ret |= read_reg_otp(client, SFR_BOTTOM_R_HOR_REG + 16 * i,
260 2, &otp_ptr->sfr_otp_data.data[i].bottom_r_horizontal);
261 ret |= read_reg_otp(client, SFR_BOTTOM_R_VER_REG + 16 * i,
262 2, &otp_ptr->sfr_otp_data.data[i].bottom_r_vertical);
263 }
264
265 ret |= read_reg_otp(client, SFR_CHECKSUM_REG,
266 1, &otp_ptr->sfr_otp_data.checksum);
267 if (ret)
268 goto err;
269 }
270
271 ret = read_reg_otp(client, TOTAL_CHECKSUM_REG,
272 1, &otp_ptr->total_checksum);
273 if (ret)
274 goto err;
275
276 if (otp_ptr->total_checksum) {
277 eeprom_dev->otp = otp_ptr;
278 dev_info(dev, "get otp successful\n");
279 } else {
280 eeprom_dev->otp = NULL;
281 kfree(otp_ptr);
282 dev_warn(&client->dev, "otp is NULL!\n");
283 }
284
285 return 0;
286 err:
287 eeprom_dev->otp = NULL;
288 kfree(otp_ptr);
289 dev_warn(&client->dev, "@%s read otp err!\n", __func__);
290 return -EINVAL;
291 }
292
rkotp_read_module_info(struct eeprom_device * eeprom_dev,struct otp_info * otp_ptr,u32 base_addr)293 static void rkotp_read_module_info(struct eeprom_device *eeprom_dev,
294 struct otp_info *otp_ptr,
295 u32 base_addr)
296 {
297 struct i2c_client *client = eeprom_dev->client;
298 struct device *dev = &eeprom_dev->client->dev;
299 int i = 0;
300 u32 temp = 0;
301 u32 checksum = 0;
302 int ret = 0;
303
304 ret |= read_reg_otp(client, base_addr,
305 4, &otp_ptr->basic_data.module_size);
306 checksum += otp_ptr->basic_data.module_size;
307 base_addr += 4;
308 ret |= read_reg_otp(client, base_addr,
309 2, &otp_ptr->basic_data.version);
310 checksum += otp_ptr->basic_data.version;
311 base_addr += 2;
312 ret |= read_reg_otp(client, base_addr,
313 1, &otp_ptr->basic_data.id.supplier_id);
314 checksum += otp_ptr->basic_data.id.supplier_id;
315 base_addr += 1;
316 ret |= read_reg_otp(client, base_addr,
317 1, &otp_ptr->basic_data.id.year);
318 checksum += otp_ptr->basic_data.id.year;
319 base_addr += 1;
320 ret |= read_reg_otp(client, base_addr,
321 1, &otp_ptr->basic_data.id.month);
322 checksum += otp_ptr->basic_data.id.month;
323 base_addr += 1;
324 ret |= read_reg_otp(client, base_addr,
325 1, &otp_ptr->basic_data.id.day);
326 checksum += otp_ptr->basic_data.id.day;
327 base_addr += 1;
328 ret |= read_reg_otp(client, base_addr,
329 1, &otp_ptr->basic_data.id.sensor_id);
330 checksum += otp_ptr->basic_data.id.sensor_id;
331 base_addr += 1;
332 ret |= read_reg_otp(client, base_addr,
333 1, &otp_ptr->basic_data.id.lens_id);
334 checksum += otp_ptr->basic_data.id.lens_id;
335 base_addr += 1;
336 ret |= read_reg_otp(client, base_addr,
337 1, &otp_ptr->basic_data.id.vcm_id);
338 checksum += otp_ptr->basic_data.id.vcm_id;
339 base_addr += 1;
340 ret |= read_reg_otp(client, base_addr,
341 1, &otp_ptr->basic_data.id.driver_ic_id);
342 checksum += otp_ptr->basic_data.id.driver_ic_id;
343 base_addr += 1;
344 for (i = 0; i < RKMOUDLE_ID_SIZE; i++) {
345 ret |= read_reg_otp(client, base_addr,
346 1, &temp);
347 otp_ptr->basic_data.modul_id[i] = temp;
348 checksum += temp;
349 base_addr += 1;
350 }
351 ret |= read_reg_otp(client, base_addr,
352 1, &otp_ptr->basic_data.mirror_flip);
353 checksum += otp_ptr->basic_data.mirror_flip;
354 base_addr += 1;
355 ret |= read_reg_otp(client, base_addr,
356 2, &temp);
357 checksum += temp;
358 otp_ptr->basic_data.size.width = temp;
359 base_addr += 2;
360 ret |= read_reg_otp(client, base_addr,
361 2, &temp);
362 checksum += temp;
363 otp_ptr->basic_data.size.height = temp;
364 base_addr += 2;
365 for (i = 0; i < RK_INFO_RESERVED_SIZE; i++) {
366 ret |= read_reg_otp(client, base_addr,
367 1, &temp);
368 checksum += temp;
369 base_addr += 1;
370 }
371 ret |= read_reg_otp(client, base_addr,
372 1, &otp_ptr->basic_data.checksum);
373 if ((checksum % 255 + 1) == otp_ptr->basic_data.checksum && (!ret)) {
374 otp_ptr->basic_data.flag = 0x01;
375 otp_ptr->flag++;
376 dev_info(dev, "fasic info: supplier_id(0x%x) lens(0x%x) time(%d_%d_%d) module id %x\n",
377 otp_ptr->basic_data.id.supplier_id,
378 otp_ptr->basic_data.id.lens_id,
379 otp_ptr->basic_data.id.year,
380 otp_ptr->basic_data.id.month,
381 otp_ptr->basic_data.id.day,
382 (u32)(*otp_ptr->basic_data.modul_id));
383 } else {
384 otp_ptr->basic_data.flag = 0;
385 dev_info(dev, "fasic info: checksum err, checksum %d, reg_checksum %d\n",
386 (int)(checksum % 255 + 1),
387 (int)otp_ptr->basic_data.checksum);
388 dev_info(dev, "fasic info: supplier_id(0x%x) lens(0x%x) time(%d_%d_%d)\n",
389 otp_ptr->basic_data.id.supplier_id,
390 otp_ptr->basic_data.id.lens_id,
391 otp_ptr->basic_data.id.year,
392 otp_ptr->basic_data.id.month,
393 otp_ptr->basic_data.id.day);
394 dev_info(dev, "fasic info: full size, width(%d) height(%d) flip(0x%x)\n",
395 otp_ptr->basic_data.size.width,
396 otp_ptr->basic_data.size.height,
397 otp_ptr->basic_data.mirror_flip);
398 }
399 }
400
rkotp_read_awb(struct eeprom_device * eeprom_dev,struct otp_info * otp_ptr,u32 base_addr)401 static void rkotp_read_awb(struct eeprom_device *eeprom_dev,
402 struct otp_info *otp_ptr,
403 u32 base_addr)
404 {
405 struct i2c_client *client = eeprom_dev->client;
406 struct device *dev = &eeprom_dev->client->dev;
407 u32 checksum = 0;
408 u32 temp = 0;
409 int i = 0;
410 int ret = 0;
411
412 ret = read_reg_otp(client, base_addr,
413 4, &otp_ptr->awb_data.size);
414 checksum += otp_ptr->awb_data.size;
415 base_addr += 4;
416 ret |= read_reg_otp(client, base_addr,
417 2, &otp_ptr->awb_data.version);
418 checksum += otp_ptr->awb_data.version;
419 base_addr += 2;
420 ret |= read_reg_otp(client, base_addr,
421 2, &otp_ptr->awb_data.r_ratio);
422 checksum += otp_ptr->awb_data.r_ratio;
423 base_addr += 2;
424 ret |= read_reg_otp(client, base_addr,
425 2, &otp_ptr->awb_data.b_ratio);
426 checksum += otp_ptr->awb_data.b_ratio;
427 base_addr += 2;
428 ret |= read_reg_otp(client, base_addr,
429 2, &otp_ptr->awb_data.g_ratio);
430 checksum += otp_ptr->awb_data.g_ratio;
431 base_addr += 2;
432 ret |= read_reg_otp(client, base_addr,
433 2, &otp_ptr->awb_data.r_golden);
434 checksum += otp_ptr->awb_data.r_golden;
435 base_addr += 2;
436 ret |= read_reg_otp(client, base_addr,
437 2, &otp_ptr->awb_data.b_golden);
438 checksum += otp_ptr->awb_data.b_golden;
439 base_addr += 2;
440 ret |= read_reg_otp(client, base_addr,
441 2, &otp_ptr->awb_data.g_golden);
442 checksum += otp_ptr->awb_data.g_golden;
443 base_addr += 2;
444 for (i = 0; i < RK_AWB_RESERVED_SIZE; i++) {
445 ret |= read_reg_otp(client, base_addr,
446 1, &temp);
447 checksum += temp;
448 base_addr += 1;
449 }
450 ret |= read_reg_otp(client, base_addr,
451 1, &otp_ptr->awb_data.checksum);
452
453 if ((checksum % 255 + 1) == otp_ptr->awb_data.checksum && (!ret)) {
454 otp_ptr->awb_data.flag = 0x01;
455 otp_ptr->flag++;
456 dev_info(dev, "awb version:0x%x\n",
457 otp_ptr->awb_data.version);
458 dev_info(dev, "awb cur:(r 0x%x, b 0x%x, g 0x%x)\n",
459 otp_ptr->awb_data.r_ratio,
460 otp_ptr->awb_data.b_ratio,
461 otp_ptr->awb_data.g_ratio);
462 dev_info(dev, "awb gol:(r 0x%x, b 0x%x, g 0x%x),\n",
463 otp_ptr->awb_data.r_golden,
464 otp_ptr->awb_data.b_golden,
465 otp_ptr->awb_data.g_golden);
466 } else {
467 otp_ptr->awb_data.flag = 0;
468 dev_info(dev, "awb info: checksum err, checksum %d, reg_checksum %d\n",
469 (int) (checksum % 255 + 1),
470 (int) otp_ptr->awb_data.checksum);
471 }
472 }
473
rkotp_read_lsc(struct eeprom_device * eeprom_dev,struct otp_info * otp_ptr,u32 base_addr)474 static void rkotp_read_lsc(struct eeprom_device *eeprom_dev,
475 struct otp_info *otp_ptr,
476 u32 base_addr)
477 {
478 struct i2c_client *client = eeprom_dev->client;
479 struct device *dev = &eeprom_dev->client->dev;
480 u32 checksum = 0;
481 u8 *lsc_buf;
482 int i = 0;
483 int ret = 0;
484 #ifdef DEBUG
485 int w, h, j;
486 #endif
487
488 lsc_buf = kzalloc(LSC_DATA_SIZE, GFP_KERNEL);
489 if (!lsc_buf) {
490 dev_err(dev, "%s ENOMEM!\n", __func__);
491 return;
492 }
493
494 ret = read_reg_otp(client, base_addr,
495 4, &otp_ptr->lsc_data.size);
496 checksum += otp_ptr->lsc_data.size;
497 base_addr += 4;
498 ret |= read_reg_otp(client, base_addr,
499 2, &otp_ptr->lsc_data.version);
500 checksum += otp_ptr->lsc_data.version;
501 base_addr += 2;
502
503 ret |= read_reg_otp_buf(client, base_addr,
504 LSC_DATA_SIZE, lsc_buf);
505 base_addr += LSC_DATA_SIZE;
506
507 for (i = 0; i < LSC_DATA_SIZE; i++) {
508 otp_ptr->lsc_data.data[i] = lsc_buf[i];
509 checksum += lsc_buf[i];
510 }
511 otp_ptr->lsc_data.table_size = LSC_DATA_SIZE;
512 #ifdef DEBUG
513 w = 17 * 2;
514 h = 17 * 4;
515 dev_info(dev, "show lsc table\n");
516 for (i = 0; i < h; i++) {
517 for (j = 0; j < w; j++)
518 dev_info(dev, "%d ", otp_ptr->lsc_data.data[i * w + j]);
519 if (i < h)
520 dev_info(dev, "\n");
521 }
522 #endif
523
524 memset(lsc_buf, 0, LSC_DATA_SIZE);
525 ret |= read_reg_otp_buf(client, base_addr,
526 RK_LSC_RESERVED_SIZE, lsc_buf);
527
528 for (i = 0; i < RK_LSC_RESERVED_SIZE; i++) {
529 checksum += lsc_buf[i];
530 }
531 base_addr += RK_LSC_RESERVED_SIZE;
532 ret |= read_reg_otp(client, base_addr,
533 1, &otp_ptr->lsc_data.checksum);
534 if ((checksum % 255 + 1) == otp_ptr->lsc_data.checksum && (!ret)) {
535 otp_ptr->lsc_data.flag = 0x01;
536 otp_ptr->flag++;
537 dev_info(dev, "lsc info:(version 0x%x, checksum 0x%x)\n",
538 otp_ptr->lsc_data.version,
539 (int)otp_ptr->lsc_data.checksum);
540 } else {
541 otp_ptr->lsc_data.flag = 0x00;
542 dev_info(dev, "lsc info: checksum err, checksum %d, reg_checksum %d\n",
543 (int)(checksum % 255 + 1),
544 (int)otp_ptr->lsc_data.checksum);
545 }
546 kfree(lsc_buf);
547 }
548
rkotp_read_pdaf(struct eeprom_device * eeprom_dev,struct otp_info * otp_ptr,u32 base_addr)549 static void rkotp_read_pdaf(struct eeprom_device *eeprom_dev,
550 struct otp_info *otp_ptr,
551 u32 base_addr)
552 {
553 struct i2c_client *client = eeprom_dev->client;
554 struct device *dev = &eeprom_dev->client->dev;
555 u32 checksum = 0;
556 u8 *pdaf_buf;
557 int i = 0;
558 int ret = 0;
559 #ifdef DEBUG
560 int w, h, j;
561 #endif
562
563 pdaf_buf = kzalloc(RK_GAINMAP_SIZE, GFP_KERNEL);
564 if (!pdaf_buf) {
565 dev_err(dev, "%s ENOMEM!\n", __func__);
566 return;
567 }
568
569 ret = read_reg_otp(client, base_addr,
570 4, &otp_ptr->pdaf_data.size);
571 checksum += otp_ptr->pdaf_data.size;
572 base_addr += 4;
573 ret |= read_reg_otp(client, base_addr,
574 2, &otp_ptr->pdaf_data.version);
575 checksum += otp_ptr->pdaf_data.version;
576 base_addr += 2;
577 ret |= read_reg_otp(client, base_addr,
578 1, &otp_ptr->pdaf_data.gainmap_width);
579 checksum += otp_ptr->pdaf_data.gainmap_width;
580 base_addr += 1;
581 ret |= read_reg_otp(client, base_addr,
582 1, &otp_ptr->pdaf_data.gainmap_height);
583 checksum += otp_ptr->pdaf_data.gainmap_height;
584 base_addr += 1;
585
586 ret |= read_reg_otp_buf(client, base_addr,
587 RK_GAINMAP_SIZE, pdaf_buf);
588 base_addr += RK_GAINMAP_SIZE;
589
590 for (i = 0; i < RK_GAINMAP_SIZE; i++) {
591 otp_ptr->pdaf_data.gainmap[i] = pdaf_buf[i];
592 checksum += otp_ptr->pdaf_data.gainmap[i];
593 }
594 #ifdef DEBUG
595 w = 64;
596 h = 32;
597 dev_info(dev, "show pdaf gainmap table\n");
598 for (i = 0; i < h; i++) {
599 for (j = 0; j < w; j++)
600 dev_info(dev, "%d ", otp_ptr->pdaf_data.gainmap[i * w + j]);
601 if (i < h)
602 dev_info(dev, "\n");
603 }
604 #endif
605 ret |= read_reg_otp(client, base_addr,
606 1, &otp_ptr->pdaf_data.gainmap_checksum);
607 checksum += otp_ptr->pdaf_data.gainmap_checksum;
608 base_addr += 1;
609 ret |= read_reg_otp(client, base_addr,
610 1, &otp_ptr->pdaf_data.dcc_mode);
611 checksum += otp_ptr->pdaf_data.dcc_mode;
612 base_addr += 1;
613 ret |= read_reg_otp(client, base_addr,
614 1, &otp_ptr->pdaf_data.dcc_dir);
615 checksum += otp_ptr->pdaf_data.dcc_dir;
616 base_addr += 1;
617 ret |= read_reg_otp(client, base_addr,
618 1, &otp_ptr->pdaf_data.dccmap_width);
619 checksum += otp_ptr->pdaf_data.dccmap_width;
620 base_addr += 1;
621 ret |= read_reg_otp(client, base_addr,
622 1, &otp_ptr->pdaf_data.dccmap_height);
623 checksum += otp_ptr->pdaf_data.dccmap_height;
624 base_addr += 1;
625
626 memset(pdaf_buf, 0, RK_DCCMAP_SIZE);
627 ret |= read_reg_otp_buf(client, base_addr,
628 RK_DCCMAP_SIZE, pdaf_buf);
629
630 for (i = 0; i < RK_DCCMAP_SIZE; i++) {
631 otp_ptr->pdaf_data.dccmap[i] = pdaf_buf[i];
632 checksum += otp_ptr->pdaf_data.dccmap[i];
633 }
634 base_addr += RK_DCCMAP_SIZE;
635
636 #ifdef DEBUG
637 w = 32;
638 h = 16;
639 dev_info(dev, "show pdaf dccmap table\n");
640 for (i = 0; i < h; i++) {
641 for (j = 0; j < w; j++)
642 dev_info(dev, "%d ", otp_ptr->pdaf_data.dccmap[i * w + j]);
643 if (i < h)
644 dev_info(dev, "\n");
645 }
646 #endif
647 ret |= read_reg_otp(client, base_addr,
648 1, &otp_ptr->pdaf_data.dccmap_checksum);
649 checksum += otp_ptr->pdaf_data.dccmap_checksum;
650 base_addr += 1;
651
652 memset(pdaf_buf, 0, RK_PDAF_RESERVED_SIZE);
653 ret |= read_reg_otp_buf(client, base_addr,
654 RK_PDAF_RESERVED_SIZE, pdaf_buf);
655
656 for (i = 0; i < RK_PDAF_RESERVED_SIZE; i++) {
657 checksum += pdaf_buf[i];
658 }
659 base_addr += RK_PDAF_RESERVED_SIZE;
660
661 ret |= read_reg_otp(client, base_addr,
662 1, &otp_ptr->pdaf_data.checksum);
663 if ((checksum % 255 + 1) == otp_ptr->pdaf_data.checksum && (!ret)) {
664 otp_ptr->pdaf_data.flag = 0x01;
665 otp_ptr->flag++;
666 dev_info(dev, "pdaf info:(version 0x%x, checksum 0x%x)\n",
667 otp_ptr->pdaf_data.version,
668 (int)otp_ptr->pdaf_data.checksum);
669 } else {
670 otp_ptr->pdaf_data.flag = 0x00;
671 dev_info(dev, "pdaf info: checksum err, checksum %d, reg_checksum %d\n",
672 (int)(checksum % 255 + 1),
673 (int)otp_ptr->pdaf_data.checksum);
674 }
675 kfree(pdaf_buf);
676 }
677
rkotp_read_af(struct eeprom_device * eeprom_dev,struct otp_info * otp_ptr,u32 base_addr)678 static void rkotp_read_af(struct eeprom_device *eeprom_dev,
679 struct otp_info *otp_ptr,
680 u32 base_addr)
681 {
682 struct i2c_client *client = eeprom_dev->client;
683 struct device *dev = &eeprom_dev->client->dev;
684 u32 checksum = 0;
685 u32 temp = 0;
686 int i = 0;
687 int ret = 0;
688
689 ret = read_reg_otp(client, base_addr,
690 4, &otp_ptr->af_data.size);
691 checksum += otp_ptr->af_data.size;
692 base_addr += 4;
693 ret |= read_reg_otp(client, base_addr,
694 2, &otp_ptr->af_data.version);
695 checksum += otp_ptr->af_data.version;
696 base_addr += 2;
697 ret |= read_reg_otp(client, base_addr,
698 2, &otp_ptr->af_data.af_inf);
699 checksum += otp_ptr->af_data.af_inf;
700 base_addr += 2;
701 ret |= read_reg_otp(client, base_addr,
702 2, &otp_ptr->af_data.af_macro);
703 checksum += otp_ptr->af_data.af_macro;
704 base_addr += 2;
705 for (i = 0; i < RK_AF_RESERVED_SIZE; i++) {
706 ret |= read_reg_otp(client, base_addr,
707 1, &temp);
708 checksum += temp;
709 base_addr += 1;
710 }
711
712 ret |= read_reg_otp(client, base_addr,
713 1, &otp_ptr->af_data.checksum);
714 if ((checksum % 255 + 1) == otp_ptr->af_data.checksum && (!ret)) {
715 otp_ptr->af_data.flag = 0x01;
716 otp_ptr->flag++;
717 dev_info(dev, "af info:(version 0x%x, checksum 0x%x)\n",
718 otp_ptr->af_data.version,
719 (int)otp_ptr->af_data.checksum);
720 } else {
721 otp_ptr->af_data.flag = 0x00;
722 dev_info(dev, "af info: checksum err, checksum %d, reg_checksum %d\n",
723 (int)(checksum % 255 + 1),
724 (int)otp_ptr->af_data.checksum);
725 }
726
727 }
728
rkotp_read_data(struct eeprom_device * eeprom_dev)729 static int rkotp_read_data(struct eeprom_device *eeprom_dev)
730 {
731 struct i2c_client *client = eeprom_dev->client;
732 struct otp_info *otp_ptr;
733 struct device *dev = &eeprom_dev->client->dev;
734 u32 id = 0;
735 u32 base_addr = 0;
736 int i = 0;
737 int ret = 0;
738
739 otp_ptr = kzalloc(sizeof(*otp_ptr), GFP_KERNEL);
740 if (!otp_ptr)
741 return -ENOMEM;
742 base_addr = RKOTP_REG_START;
743 otp_ptr->flag = 0;
744 for (i = 0; i < RKOTP_MAX_MODULE; i++) {
745 read_reg_otp(client, base_addr, 1, &id);
746 dev_info(dev, "show block id %d, addr 0x%x\n", id, base_addr);
747 switch (id) {
748 case RKOTP_INFO_ID:
749 rkotp_read_module_info(eeprom_dev,
750 otp_ptr,
751 base_addr + 1);
752 base_addr += 0x28;//v1 0x30 v2 0x28;
753 break;
754 case RKOTP_AWB_ID:
755 rkotp_read_awb(eeprom_dev,
756 otp_ptr,
757 base_addr + 1);
758 base_addr += 0x30;
759 break;
760 case RKOTP_LSC_ID:
761 rkotp_read_lsc(eeprom_dev,
762 otp_ptr,
763 base_addr + 1);
764 base_addr += 0x930;
765 break;
766 case RKOTP_PDAF_ID:
767 rkotp_read_pdaf(eeprom_dev,
768 otp_ptr,
769 base_addr + 1);
770 base_addr += 0xA30;
771 break;
772 case RKOTP_AF_ID:
773 rkotp_read_af(eeprom_dev,
774 otp_ptr,
775 base_addr + 1);
776 base_addr += 0x20;
777 break;
778 default:
779 id = -1;
780 break;
781 }
782 if (id == -1)
783 break;
784 }
785 if (otp_ptr->flag) {
786 eeprom_dev->otp = otp_ptr;
787 dev_info(dev, "rkotp read successful!\n");
788 } else {
789 eeprom_dev->otp = NULL;
790 kfree(otp_ptr);
791 dev_warn(&client->dev, "otp is NULL!\n");
792 ret = -1;
793 }
794 return ret;
795 }
796
otp_read(struct eeprom_device * eeprom_dev)797 static int otp_read(struct eeprom_device *eeprom_dev)
798 {
799 u8 vendor_flag = 0;
800 struct i2c_client *client = eeprom_dev->client;
801
802 mutex_lock(&eeprom_dev->mutex);
803 vendor_flag = get_vendor_flag(client);
804 if (vendor_flag == 0x80)
805 otp_read_data(eeprom_dev);
806 else if (vendor_flag == 0x40)
807 rkotp_read_data(eeprom_dev);
808 else {
809 dev_warn(&client->dev, "no vendor flag infos!\n");
810 mutex_unlock(&eeprom_dev->mutex);
811 return -1;
812 }
813
814 mutex_unlock(&eeprom_dev->mutex);
815 return 0;
816 }
817
eeprom_ioctl(struct v4l2_subdev * sd,unsigned int cmd,void * arg)818 static long eeprom_ioctl(struct v4l2_subdev *sd,
819 unsigned int cmd, void *arg)
820 {
821 struct eeprom_device *eeprom_dev =
822 sd_to_eeprom(sd);
823 long ret = 0;
824
825 if (!eeprom_dev->otp) {
826 if (otp_read(eeprom_dev))
827 ret = -EFAULT;
828 }
829 if (arg && eeprom_dev->otp)
830 memcpy(arg, eeprom_dev->otp,
831 sizeof(struct otp_info));
832 else
833 ret = -EFAULT;
834 return ret;
835 }
836
837 #ifdef CONFIG_PROC_FS
otp_eeprom_show(struct seq_file * p,void * v)838 static int otp_eeprom_show(struct seq_file *p, void *v)
839 {
840 struct eeprom_device *dev = p->private;
841 int i = 0;
842 int j = 0;
843 u32 gainmap_w, gainmap_h;
844 u32 dccmap_w, dccmap_h;
845
846 if (dev && dev->otp) {
847 seq_puts(p, "[Header]\n");
848 seq_puts(p, "version=1.0;\n\n");
849
850 if (dev->otp->awb_data.flag) {
851 seq_puts(p, "[RKAWBOTPParam]\n");
852 seq_printf(p, "flag=%d;\n", dev->otp->awb_data.flag);
853 seq_printf(p, "r_value=%d;\n", dev->otp->awb_data.r_ratio);
854 seq_printf(p, "b_value=%d;\n", dev->otp->awb_data.b_ratio);
855 seq_printf(p, "gr_value=%d;\n", dev->otp->awb_data.g_ratio);
856 seq_puts(p, "gb_value=-1;\n");
857 seq_printf(p, "golden_r_value=%d;\n", dev->otp->awb_data.r_golden);
858 seq_printf(p, "golden_b_value=%d;\n", dev->otp->awb_data.b_golden);
859 seq_printf(p, "golden_gr_value=%d;\n", dev->otp->awb_data.g_golden);
860 seq_puts(p, "golden_gb_value=-1;\n\n");
861
862 seq_puts(p, "[RKLSCOTPParam]\n");
863 seq_printf(p, "flag=%d;\n", dev->otp->lsc_data.flag);
864 seq_printf(p, "width=%d;\n", dev->otp->basic_data.size.width);
865 seq_printf(p, "height=%d;\n", dev->otp->basic_data.size.height);
866 seq_printf(p, "tablesize=%d;\n\n", dev->otp->lsc_data.table_size);
867
868 seq_puts(p, "lsc_r_table=\n");
869 for (i = 0; i < 17; i++) {
870 for (j = 0; j < 17; j++) {
871 seq_printf(p, "%d", (dev->otp->lsc_data.data[(i * 17 + j) * 2] << 8)
872 | dev->otp->lsc_data.data[(i * 17 + j) * 2 + 1]);
873 if (j < 16)
874 seq_puts(p, " ");
875 }
876 if (i < 16)
877 seq_puts(p, "\n");
878 }
879 seq_puts(p, "\n\n");
880 }
881
882 if (dev->otp->lsc_data.flag) {
883 seq_puts(p, "lsc_b_table=\n");
884 for (i = 0; i < 17; i++) {
885 for (j = 0; j < 17; j++) {
886 seq_printf(p, "%d", (dev->otp->lsc_data.data[(i * 17 + j) * 2 +
887 1734] << 8) | dev->otp->lsc_data.data[(i * 17 + j) *
888 2 + 1735]);
889 if (j < 16)
890 seq_puts(p, " ");
891 }
892 if (i < 16)
893 seq_puts(p, "\n");
894 }
895 seq_puts(p, "\n\n");
896
897 seq_puts(p, "lsc_gr_table=\n");
898 for (i = 0; i < 17; i++) {
899 for (j = 0; j < 17; j++) {
900 seq_printf(p, "%d", (dev->otp->lsc_data.data[(i * 17 + j) * 2 +
901 578] << 8) | dev->otp->lsc_data.data[(i * 17 + j) *
902 2 + 579]);
903 if (j < 16)
904 seq_puts(p, " ");
905 }
906 if (i < 16)
907 seq_puts(p, "\n");
908 }
909 seq_puts(p, "\n\n");
910
911 seq_puts(p, "lsc_gb_table=\n");
912 for (i = 0; i < 17; i++) {
913 for (j = 0; j < 17; j++) {
914 seq_printf(p, "%d", (dev->otp->lsc_data.data[(i * 17 + j) * 2 +
915 1156] << 8) | dev->otp->lsc_data.data[(i * 17 + j) *
916 2 + 1157]);
917 if (j < 16)
918 seq_puts(p, " ");
919 }
920 if (i < 16)
921 seq_puts(p, "\n");
922 }
923 seq_puts(p, "\n\n");
924 }
925 if (dev->otp->pdaf_data.flag) {
926 gainmap_w = dev->otp->pdaf_data.gainmap_width;
927 gainmap_h = dev->otp->pdaf_data.gainmap_height;
928 dccmap_w = dev->otp->pdaf_data.dccmap_width;
929 dccmap_h = dev->otp->pdaf_data.dccmap_height;
930 seq_printf(p, "[RKPDAFOTPParam]\n");
931 seq_printf(p, "flag=%d;\n", dev->otp->pdaf_data.flag);
932 seq_printf(p, "gainmap_width=%d;\n", gainmap_w);
933 seq_printf(p, "gainmap_height=%d;\n", gainmap_h);
934
935 seq_printf(p, "gainmap_table=\n");
936 for (i = 0; i < gainmap_h; i++) {
937 for (j = 0; j < gainmap_w; j++) {
938 seq_printf(p, "%d",
939 (dev->otp->pdaf_data.gainmap[(i * gainmap_w + j) * 2] << 8) |
940 dev->otp->pdaf_data.gainmap[(i * gainmap_w + j) * 2 + 1]);
941 if (j < gainmap_w)
942 seq_printf(p, " ");
943 }
944 if (i < gainmap_h)
945 seq_printf(p, "\n");
946 }
947 seq_printf(p, "\n");
948 seq_printf(p, "dcc_mode=%d\n", dev->otp->pdaf_data.dcc_mode);
949 seq_printf(p, "dcc_dir=%d\n", dev->otp->pdaf_data.dcc_dir);
950 seq_printf(p, "dccmap_width=%d\n", dev->otp->pdaf_data.dccmap_width);
951 seq_printf(p, "dccmap_height=%d\n", dev->otp->pdaf_data.dccmap_height);
952 for (i = 0; i < dccmap_h; i++) {
953 for (j = 0; j < dccmap_w; j++) {
954 seq_printf(p, "%d",
955 (dev->otp->pdaf_data.dccmap[(i * dccmap_w + j) * 2] << 8) |
956 dev->otp->pdaf_data.dccmap[(i * dccmap_w + j) * 2 + 1]);
957 if (j < dccmap_w)
958 seq_printf(p, " ");
959 }
960 if (i < dccmap_h)
961 seq_printf(p, "\n");
962 }
963 seq_printf(p, "\n");
964 }
965
966 if (dev->otp->af_data.flag) {
967 seq_printf(p, "[RKAFOTPParam]\n");
968 seq_printf(p, "flag=%d;\n", dev->otp->af_data.flag);
969 seq_printf(p, "af_inf=%d;\n", dev->otp->af_data.af_inf);
970 seq_printf(p, "af_macro=%d;\n", dev->otp->af_data.af_macro);
971 }
972 } else {
973 seq_puts(p, "otp is null!\n");
974 }
975 return 0;
976 }
977
eeprom_open(struct inode * inode,struct file * file)978 static int eeprom_open(struct inode *inode, struct file *file)
979 {
980 struct eeprom_device *data = PDE_DATA(inode);
981
982 return single_open(file, otp_eeprom_show, data);
983 }
984
985 static const struct proc_ops ops = {
986 .proc_open = eeprom_open,
987 .proc_read = seq_read,
988 .proc_lseek = seq_lseek,
989 .proc_release = single_release,
990 };
991
eeprom_proc_init(struct eeprom_device * dev)992 static int eeprom_proc_init(struct eeprom_device *dev)
993 {
994 dev->procfs = proc_create_data(dev->name, 0, NULL, &ops, dev);
995 if (!dev->procfs)
996 return -EINVAL;
997 return 0;
998 }
999
eeprom_proc_cleanup(struct eeprom_device * dev)1000 static void eeprom_proc_cleanup(struct eeprom_device *dev)
1001 {
1002 if (dev->procfs)
1003 remove_proc_entry(dev->name, NULL);
1004 dev->procfs = NULL;
1005 }
1006
1007 #endif
1008
1009 static const struct v4l2_subdev_core_ops eeprom_core_ops = {
1010 .ioctl = eeprom_ioctl,
1011 };
1012
1013 static const struct v4l2_subdev_ops eeprom_ops = {
1014 .core = &eeprom_core_ops,
1015 };
1016
eeprom_subdev_cleanup(struct eeprom_device * dev)1017 static void eeprom_subdev_cleanup(struct eeprom_device *dev)
1018 {
1019 v4l2_device_unregister_subdev(&dev->sd);
1020 media_entity_cleanup(&dev->sd.entity);
1021 }
1022
eeprom_probe(struct i2c_client * client,const struct i2c_device_id * id)1023 static int eeprom_probe(struct i2c_client *client,
1024 const struct i2c_device_id *id)
1025 {
1026 struct eeprom_device *eeprom_dev;
1027
1028 dev_info(&client->dev, "driver version: %02x.%02x.%02x",
1029 DRIVER_VERSION >> 16,
1030 (DRIVER_VERSION & 0xff00) >> 8,
1031 DRIVER_VERSION & 0x00ff);
1032
1033 eeprom_dev = devm_kzalloc(&client->dev,
1034 sizeof(*eeprom_dev),
1035 GFP_KERNEL);
1036
1037 if (eeprom_dev == NULL) {
1038 dev_err(&client->dev, "Probe failed\n");
1039 return -ENOMEM;
1040 }
1041 mutex_init(&eeprom_dev->mutex);
1042 v4l2_i2c_subdev_init(&eeprom_dev->sd,
1043 client, &eeprom_ops);
1044 eeprom_dev->client = client;
1045 snprintf(eeprom_dev->name, sizeof(eeprom_dev->name), "%s-%d-%02x",
1046 DEVICE_NAME, i2c_adapter_id(client->adapter), client->addr);
1047 eeprom_proc_init(eeprom_dev);
1048 pm_runtime_set_active(&client->dev);
1049 pm_runtime_enable(&client->dev);
1050 pm_runtime_idle(&client->dev);
1051
1052 dev_info(&client->dev, "probing successful\n");
1053
1054 return 0;
1055 }
1056
eeprom_remove(struct i2c_client * client)1057 static int eeprom_remove(struct i2c_client *client)
1058 {
1059 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1060 struct eeprom_device *eeprom_dev =
1061 sd_to_eeprom(sd);
1062 kfree(eeprom_dev->otp);
1063 mutex_destroy(&eeprom_dev->mutex);
1064 pm_runtime_disable(&client->dev);
1065 eeprom_subdev_cleanup(eeprom_dev);
1066 eeprom_proc_cleanup(eeprom_dev);
1067
1068 return 0;
1069 }
1070
eeprom_suspend(struct device * dev)1071 static int __maybe_unused eeprom_suspend(struct device *dev)
1072 {
1073 return 0;
1074 }
1075
eeprom_resume(struct device * dev)1076 static int __maybe_unused eeprom_resume(struct device *dev)
1077 {
1078 return 0;
1079 }
1080
1081 static const struct i2c_device_id eeprom_id_table[] = {
1082 { DEVICE_NAME, 0 },
1083 { { 0 } }
1084 };
1085 MODULE_DEVICE_TABLE(i2c, eeprom_id_table);
1086
1087 static const struct of_device_id eeprom_of_table[] = {
1088 { .compatible = "rk,otp_eeprom" },
1089 { { 0 } }
1090 };
1091 MODULE_DEVICE_TABLE(of, eeprom_of_table);
1092
1093 static const struct dev_pm_ops eeprom_pm_ops = {
1094 SET_SYSTEM_SLEEP_PM_OPS(eeprom_suspend, eeprom_resume)
1095 SET_RUNTIME_PM_OPS(eeprom_suspend, eeprom_resume, NULL)
1096 };
1097
1098 static struct i2c_driver eeprom_i2c_driver = {
1099 .driver = {
1100 .name = DEVICE_NAME,
1101 .pm = &eeprom_pm_ops,
1102 .of_match_table = eeprom_of_table,
1103 },
1104 .probe = &eeprom_probe,
1105 .remove = &eeprom_remove,
1106 .id_table = eeprom_id_table,
1107 };
1108
1109 module_i2c_driver(eeprom_i2c_driver);
1110
1111 MODULE_DESCRIPTION("OTP driver");
1112 MODULE_LICENSE("GPL v2");
1113