1 // SPDX-License-Identifier: GPL-2.0
2 /**
3 * Rockchip rk1608 driver
4 *
5 * Copyright (C) 2017-2018 Rockchip Electronics Co., Ltd.
6 *
7 */
8 #include <linux/i2c.h>
9 #include <linux/clk.h>
10 #include <linux/clkdev.h>
11 #include <linux/delay.h>
12 #include <linux/firmware.h>
13 #include <linux/gpio/consumer.h>
14 #include <linux/interrupt.h>
15 #include <linux/module.h>
16 #include <linux/of_graph.h>
17 #include <linux/of_gpio.h>
18 #include <linux/of_platform.h>
19 #include <linux/regulator/consumer.h>
20 #include <linux/completion.h>
21 #include <linux/rk-preisp.h>
22 #include <linux/rk-camera-module.h>
23 #include <media/v4l2-ctrls.h>
24 #include <media/v4l2-fwnode.h>
25 #include <media/v4l2-subdev.h>
26 #include <linux/crc32.h>
27 #include "rk1608_core.h"
28 #include "rk1608_dev.h"
29
30 #define REF_DATA_PATH "/data/ref_data.img"
31
32 #define ENABLE_DMA_BUFFER 1
33 #define SPI_BUFSIZ max(32, SMP_CACHE_BYTES)
34
35 struct msg_disp {
36 struct msg msg;
37 int32_t value[2];
38 };
39
40 struct rk1608_power_work {
41 struct work_struct wk;
42 struct rk1608_state *pdata;
43 struct completion work_fin;
44 };
45
46 static struct rk1608_power_work gwork;
47
48 /**
49 * Rk1608 is used as the Pre-ISP to link on Soc, which mainly has two
50 * functions. One is to download the firmware of RK1608, and the other
51 * is to match the extra sensor such as camera and enable sensor by
52 * calling sensor's s_power.
53 * |-----------------------|
54 * | Sensor Camera |
55 * |-----------------------|
56 * |-----------||----------|
57 * |-----------||----------|
58 * |-----------\/----------|
59 * | Pre-ISP RK1608 |
60 * |-----------------------|
61 * |-----------||----------|
62 * |-----------||----------|
63 * |-----------\/----------|
64 * | Rockchip Soc |
65 * |-----------------------|
66 * Data Transfer As shown above. In RK1608, the data received from the
67 * extra sensor,and it is passed to the Soc through ISP.
68 */
69
to_state(struct v4l2_subdev * sd)70 static inline struct rk1608_state *to_state(struct v4l2_subdev *sd)
71 {
72 return container_of(sd, struct rk1608_state, sd);
73 }
74
75 /**
76 * rk1608_operation_query - RK1608 last operation state query
77 *
78 * @spi: device from which data will be read
79 * @state: last operation state [out]
80 * Context: can sleep
81 *
82 * It returns zero on success, else a negative error code.
83 */
rk1608_operation_query(struct spi_device * spi,s32 * state)84 int rk1608_operation_query(struct spi_device *spi, s32 *state)
85 {
86 s32 query_cmd = RK1608_CMD_QUERY;
87 struct spi_transfer query_cmd_packet = {
88 .tx_buf = &query_cmd,
89 .len = sizeof(query_cmd),
90 };
91 struct spi_transfer state_packet = {
92 .rx_buf = state,
93 .len = sizeof(*state),
94 };
95 struct spi_message m;
96
97 spi_message_init(&m);
98 spi_message_add_tail(&query_cmd_packet, &m);
99 spi_message_add_tail(&state_packet, &m);
100 spi_sync(spi, &m);
101
102 return ((*state & RK1608_STATE_ID_MASK) == RK1608_STATE_ID) ? 0 : -1;
103 }
104
105 /**
106 * rk1608_state_query - RK1608 system state query
107 *
108 * @spi: spi device
109 * @state: system state [out]
110 * Context: can sleep
111 *
112 * It returns zero on success, else a negative error code.
113 */
rk1608_state_query(struct spi_device * spi,int32_t * state)114 int rk1608_state_query(struct spi_device *spi, int32_t *state)
115 {
116 int ret = 0;
117 s32 query_cmd = RK1608_CMD_QUERY_REG2;
118 struct spi_transfer query_cmd_packet = {
119 .tx_buf = &query_cmd,
120 .len = sizeof(query_cmd),
121 };
122 struct spi_transfer state_packet = {
123 .rx_buf = state,
124 .len = sizeof(*state),
125 };
126 struct spi_message m;
127
128 spi_message_init(&m);
129 spi_message_add_tail(&query_cmd_packet, &m);
130 spi_message_add_tail(&state_packet, &m);
131 ret = spi_sync(spi, &m);
132
133 return ret;
134 }
135
rk1608_write(struct spi_device * spi,s32 addr,const s32 * data,size_t data_len)136 int rk1608_write(struct spi_device *spi,
137 s32 addr, const s32 *data, size_t data_len)
138 {
139 u8 *local_buf = NULL;
140 int ret = 0;
141 s32 write_cmd = RK1608_CMD_WRITE;
142
143 struct spi_transfer write_cmd_packet = {
144 .tx_buf = &write_cmd,
145 .len = sizeof(write_cmd),
146 };
147 struct spi_transfer addr_packet = {
148 .tx_buf = &addr,
149 .len = sizeof(addr),
150 };
151 struct spi_transfer data_packet = {
152 .tx_buf = data,
153 .len = data_len,
154 };
155 struct spi_message m;
156 u32 trans_len;
157
158 #if ENABLE_DMA_BUFFER
159 trans_len = data_len + sizeof(write_cmd) + sizeof(addr);
160 if (trans_len > (size_t)SPI_BUFSIZ) {
161 local_buf = kmalloc(max_t(size_t, SPI_BUFSIZ, data_len),
162 GFP_KERNEL | GFP_DMA);
163 if (!local_buf)
164 return -ENOMEM;
165 memcpy(local_buf, data, data_len);
166 data_packet.tx_buf = local_buf;
167 }
168 #endif
169
170 spi_message_init(&m);
171 spi_message_add_tail(&write_cmd_packet, &m);
172 spi_message_add_tail(&addr_packet, &m);
173 spi_message_add_tail(&data_packet, &m);
174 ret = spi_sync(spi, &m);
175
176 kfree(local_buf);
177
178 return ret;
179 }
180
181 /**
182 * rk1608_safe_write - RK1608 synchronous write with state check
183 *
184 * @spi: spi device
185 * @addr: resource address
186 * @data: data buffer
187 * @data_len: data buffer size, in bytes
188 * Context: can sleep
189 *
190 * It returns zero on success, else a negative error code.
191 */
_rk1608_safe_write(struct rk1608_state * rk1608,struct spi_device * spi,s32 addr,const s32 * data,size_t data_len)192 static int _rk1608_safe_write(struct rk1608_state *rk1608, struct spi_device *spi,
193 s32 addr, const s32 *data, size_t data_len)
194 {
195 int ret = 0;
196 s32 state = 0;
197 s32 try = 0;
198
199 do {
200 mutex_lock(&rk1608->spi2apb_lock);
201 ret = rk1608_write(spi, addr, data, data_len);
202 if (ret == 0)
203 ret = rk1608_operation_query(spi, &state);
204 mutex_unlock(&rk1608->spi2apb_lock);
205
206 if (ret != 0)
207 return ret;
208 else if ((state & RK1608_STATE_MASK) == 0)
209 break;
210
211 if (try++ == RK1608_OP_TRY_MAX)
212 break;
213 udelay(RK1608_OP_TRY_DELAY);
214 } while (1);
215
216 return (state & RK1608_STATE_MASK);
217 }
218
rk1608_safe_write(struct rk1608_state * rk1608,struct spi_device * spi,s32 addr,const s32 * data,size_t data_len)219 int rk1608_safe_write(struct rk1608_state *rk1608, struct spi_device *spi,
220 s32 addr, const s32 *data, size_t data_len)
221 {
222 int ret = 0;
223 size_t max_op_size = (size_t)RK1608_MAX_OP_BYTES;
224
225 while (data_len > 0) {
226 size_t slen = ALIGN(MIN(data_len, max_op_size), 4);
227
228 ret = _rk1608_safe_write(rk1608, spi, addr, data, slen);
229 if (ret == -ENOMEM) {
230 max_op_size = slen / 2;
231 continue;
232 }
233
234 if (ret)
235 break;
236 data_len = data_len - slen;
237 data = (s32 *)((s8 *)data + slen);
238 addr += slen;
239 }
240
241 return ret;
242 }
243
rk1608_hw_init(struct rk1608_state * rk1608,struct spi_device * spi)244 static void rk1608_hw_init(struct rk1608_state *rk1608, struct spi_device *spi)
245 {
246 s32 write_data = SPI0_PLL_SEL_APLL;
247
248 /* modify rk1608 spi slave clk to 300M */
249 rk1608_safe_write(rk1608, spi, CRUPMU_CLKSEL14_CON, &write_data, 4);
250
251 /* modify rk1608 spi io driver strength to 8mA */
252 write_data = BIT7_6_SEL_8MA;
253 rk1608_safe_write(rk1608, spi, PMUGRF_GPIO1A_E, &write_data, 4);
254 write_data = BIT1_0_SEL_8MA;
255 rk1608_safe_write(rk1608, spi, PMUGRF_GPIO1B_E, &write_data, 4);
256 }
257
258 /**
259 * rk1608_read - RK1608 synchronous read
260 *
261 * @spi: spi device
262 * @addr: resource address
263 * @data: data buffer [out]
264 * @data_len: data buffer size, in bytes
265 * Context: can sleep
266 *
267 * It returns zero on success, else a negative error code.
268 */
rk1608_read(struct spi_device * spi,s32 addr,s32 * data,size_t data_len)269 int rk1608_read(struct spi_device *spi,
270 s32 addr, s32 *data, size_t data_len)
271 {
272 u8 *local_buf = NULL;
273 int ret;
274 s32 real_len = MIN(data_len, RK1608_MAX_OP_BYTES);
275 s32 read_cmd = RK1608_CMD_READ | (real_len << 14 &
276 RK1608_STATE_ID_MASK);
277 s32 read_begin_cmd = RK1608_CMD_READ_BEGIN;
278 s32 dummy = 0;
279 struct spi_transfer read_cmd_packet = {
280 .tx_buf = &read_cmd,
281 .len = sizeof(read_cmd),
282 };
283 struct spi_transfer addr_packet = {
284 .tx_buf = &addr,
285 .len = sizeof(addr),
286 };
287 struct spi_transfer read_dummy_packet = {
288 .tx_buf = &dummy,
289 .len = sizeof(dummy),
290 };
291 struct spi_transfer read_begin_cmd_packet = {
292 .tx_buf = &read_begin_cmd,
293 .len = sizeof(read_begin_cmd),
294 };
295 struct spi_transfer data_packet = {
296 .rx_buf = data,
297 .len = data_len,
298 };
299 struct spi_message m;
300 u32 trans_len;
301
302 #if ENABLE_DMA_BUFFER
303 trans_len = data_len + sizeof(read_cmd) + sizeof(addr) +
304 sizeof(dummy) + sizeof(read_begin_cmd);
305 if (trans_len > (size_t)SPI_BUFSIZ) {
306 local_buf = kmalloc(max_t(size_t, SPI_BUFSIZ, data_len),
307 GFP_KERNEL | GFP_DMA);
308 if (!local_buf)
309 return -ENOMEM;
310 data_packet.rx_buf = local_buf;
311 }
312 #endif
313
314 spi_message_init(&m);
315 spi_message_add_tail(&read_cmd_packet, &m);
316 spi_message_add_tail(&addr_packet, &m);
317 spi_message_add_tail(&read_dummy_packet, &m);
318 spi_message_add_tail(&read_begin_cmd_packet, &m);
319 spi_message_add_tail(&data_packet, &m);
320 ret = spi_sync(spi, &m);
321
322 if (local_buf) {
323 memcpy(data, local_buf, data_len);
324 kfree(local_buf);
325 }
326
327 return ret;
328 }
329
330 /**
331 * rk1608_safe_read - RK1608 synchronous read with state check
332 *
333 * @spi: spi device
334 * @addr: resource address
335 * @data: data buffer [out]
336 * @data_len: data buffer size, in bytes
337 * Context: can sleep
338 *
339 * It returns zero on success, else a negative error code.
340 */
_rk1608_safe_read(struct rk1608_state * rk1608,struct spi_device * spi,s32 addr,s32 * data,size_t data_len)341 static int _rk1608_safe_read(struct rk1608_state *rk1608, struct spi_device *spi,
342 s32 addr, s32 *data, size_t data_len)
343 {
344 s32 state = 0;
345 s32 retry = 0;
346 int ret = 0;
347
348 do {
349 mutex_lock(&rk1608->spi2apb_lock);
350 ret = rk1608_read(spi, addr, data, data_len);
351 if (ret == 0)
352 ret = rk1608_operation_query(spi, &state);
353 mutex_unlock(&rk1608->spi2apb_lock);
354
355 if (ret != 0)
356 return ret;
357
358 if ((state & RK1608_STATE_MASK) == 0)
359 break;
360 udelay(RK1608_OP_TRY_DELAY);
361 } while (retry++ != RK1608_OP_TRY_MAX);
362
363 return -(state & RK1608_STATE_MASK);
364 }
365
rk1608_safe_read(struct rk1608_state * rk1608,struct spi_device * spi,s32 addr,s32 * data,size_t data_len)366 int rk1608_safe_read(struct rk1608_state *rk1608, struct spi_device *spi,
367 s32 addr, s32 *data, size_t data_len)
368 {
369 int ret = 0;
370 size_t max_op_size = (size_t)RK1608_MAX_OP_BYTES;
371
372 while (data_len > 0) {
373 size_t slen = ALIGN(MIN(data_len, max_op_size), 4);
374
375 ret = _rk1608_safe_read(rk1608, spi, addr, data, slen);
376 if (ret == -ENOMEM) {
377 max_op_size = slen / 2;
378 continue;
379 }
380
381 if (ret)
382 break;
383 data_len = data_len - slen;
384 data = (s32 *)((s8 *)data + slen);
385 addr += slen;
386 }
387
388 return ret;
389 }
390
rk1608_read_wait(struct rk1608_state * rk1608,struct spi_device * spi,const struct rk1608_section * sec)391 static int rk1608_read_wait(struct rk1608_state *rk1608, struct spi_device *spi,
392 const struct rk1608_section *sec)
393 {
394 s32 value = 0;
395 int retry = 0;
396 int ret = 0;
397
398 do {
399 ret = rk1608_safe_read(rk1608, spi, sec->wait_addr, &value, 4);
400 if (!ret && value == sec->wait_value)
401 break;
402
403 if (retry++ == sec->timeout) {
404 ret = -EPERM;
405 dev_err(&spi->dev, "Read 0x%x is %x != %x timeout\n",
406 sec->wait_addr, value, sec->wait_value);
407 break;
408 }
409 msleep(sec->wait_time);
410 } while (1);
411
412 return ret;
413 }
414
rk1608_boot_request(struct rk1608_state * rk1608,struct spi_device * spi,const struct rk1608_section * sec)415 static int rk1608_boot_request(struct rk1608_state *rk1608,
416 struct spi_device *spi,
417 const struct rk1608_section *sec)
418 {
419 struct rk1608_boot_req boot_req;
420 int retry = 0;
421 int ret = 0;
422
423 /* Send boot request to rk1608 for ddr init */
424 boot_req.flag = sec->flag;
425 boot_req.load_addr = sec->load_addr;
426 boot_req.boot_len = sec->size;
427 boot_req.status = 1;
428 boot_req.cmd = 2;
429
430 ret = rk1608_safe_write(rk1608, spi, BOOT_REQUEST_ADDR,
431 (s32 *)&boot_req, sizeof(boot_req));
432 if (ret)
433 return ret;
434
435 if (sec->flag & BOOT_FLAG_READ_WAIT) {
436 /* Waitting for rk1608 init ddr done */
437 do {
438 ret = rk1608_safe_read(rk1608, spi, BOOT_REQUEST_ADDR,
439 (s32 *)&boot_req,
440 sizeof(boot_req));
441
442 if (!ret && boot_req.status == 0)
443 break;
444
445 if (retry++ == sec->timeout) {
446 ret = -EPERM;
447 dev_err(&spi->dev, "Boot request timeout\n");
448 break;
449 }
450 msleep(sec->wait_time);
451 } while (1);
452 }
453
454 return ret;
455 }
456
rk1608_download_section(struct rk1608_state * rk1608,struct spi_device * spi,const u8 * data,const struct rk1608_section * sec)457 static int rk1608_download_section(struct rk1608_state *rk1608,
458 struct spi_device *spi, const u8 *data,
459 const struct rk1608_section *sec)
460 {
461 int ret = 0;
462
463 dev_info(&spi->dev, "offset:%x,size:%x,addr:%x,wait_time:%x",
464 sec->offset, sec->size, sec->load_addr, sec->wait_time);
465
466 dev_info(&spi->dev, "timeout:%x,crc:%x,flag:%x,type:%x",
467 sec->timeout, sec->crc_16, sec->flag, sec->type);
468
469 if (sec->size > 0) {
470 ret = rk1608_safe_write(rk1608, spi, sec->load_addr,
471 (s32 *)(data + sec->offset),
472 sec->size);
473 if (ret) {
474 dev_err(&spi->dev, "RK1608 safe write err =%d\n", ret);
475 return ret;
476 }
477 }
478
479 if (sec->flag & BOOT_FLAG_BOOT_REQUEST)
480 ret = rk1608_boot_request(rk1608, spi, sec);
481 else if (sec->flag & BOOT_FLAG_READ_WAIT)
482 ret = rk1608_read_wait(rk1608, spi, sec);
483
484 return ret;
485 }
486
487 /**
488 * rk1608_download_fw: - rk1608 firmware download through spi
489 *
490 * @spi: spi device
491 * @fw_name: name of firmware file, NULL for default firmware name
492 * Context: can sleep
493 *
494 * It returns zero on success, else a negative error code.
495 */
rk1608_download_fw(struct rk1608_state * rk1608,struct spi_device * spi,const char * fw_name)496 int rk1608_download_fw(struct rk1608_state *rk1608, struct spi_device *spi,
497 const char *fw_name)
498 {
499 const struct rk1608_header *head;
500 const struct firmware *fw;
501 u32 i = 0;
502 int ret = 0;
503
504 if (!fw_name)
505 fw_name = RK1608_FW_NAME;
506
507 dev_info(&spi->dev, "Before request firmware");
508 ret = request_firmware(&fw, fw_name, &spi->dev);
509 if (ret) {
510 dev_err(&spi->dev, "Request firmware %s failed!", fw_name);
511 return ret;
512 }
513
514 head = (const struct rk1608_header *)fw->data;
515
516 dev_info(&spi->dev, "Request firmware %s (version:%s) success!",
517 fw_name, head->version);
518
519 for (i = 0; i < head->section_count; i++) {
520 ret = rk1608_download_section(rk1608, spi, fw->data,
521 &head->sections[i]);
522 if (ret)
523 break;
524 }
525
526 release_firmware(fw);
527 return ret;
528 }
529
rk1608_lsb_w32(struct spi_device * spi,s32 addr,s32 data)530 static int rk1608_lsb_w32(struct spi_device *spi, s32 addr, s32 data)
531 {
532 s32 write_cmd = RK1608_CMD_WRITE;
533 struct spi_transfer write_cmd_packet = {
534 .tx_buf = &write_cmd,
535 .len = sizeof(write_cmd),
536 };
537 struct spi_transfer addr_packet = {
538 .tx_buf = &addr,
539 .len = sizeof(addr),
540 };
541 struct spi_transfer data_packet = {
542 .tx_buf = &data,
543 .len = sizeof(data),
544 };
545 struct spi_message m;
546
547 write_cmd = MSB2LSB32(write_cmd);
548 addr = MSB2LSB32(addr);
549 data = MSB2LSB32(data);
550 spi_message_init(&m);
551 spi_message_add_tail(&write_cmd_packet, &m);
552 spi_message_add_tail(&addr_packet, &m);
553 spi_message_add_tail(&data_packet, &m);
554
555 return spi_sync(spi, &m);
556 }
557
rk1608_msg_init_sensor(struct rk1608_state * pdata,struct msg_init * msg,int in_mipi,int out_mipi,int id,int cam_id)558 static int rk1608_msg_init_sensor(struct rk1608_state *pdata,
559 struct msg_init *msg, int in_mipi, int out_mipi,
560 int id, int cam_id)
561 {
562 u32 idx = pdata->dphy[id]->fmt_inf_idx;
563
564 msg->msg_head.size = sizeof(struct msg_init);
565 msg->msg_head.type = id_msg_init_sensor_t;
566 msg->msg_head.id.camera_id = cam_id;
567 msg->msg_head.mux.sync = 1;
568 msg->in_mipi_phy = in_mipi;
569 msg->out_mipi_phy = out_mipi;
570 msg->mipi_lane = pdata->dphy[id]->fmt_inf[idx].mipi_lane;
571 msg->bayer = 0;
572 memcpy(msg->sensor_name, pdata->dphy[id]->sensor_name,
573 sizeof(msg->sensor_name));
574
575 msg->i2c_slave_addr = pdata->dphy[id]->i2c_addr;
576 msg->i2c_bus = pdata->dphy[id]->i2c_bus;
577 msg->sub_sensor_num = pdata->dphy[id]->sub_sensor_num;
578
579 return rk1608_send_msg_to_dsp(pdata, &msg->msg_head);
580 }
581
rk1608_msg_init_dsp_time(struct rk1608_state * pdata,struct msg_init_dsp_time * msg,int id)582 static int rk1608_msg_init_dsp_time(struct rk1608_state *pdata,
583 struct msg_init_dsp_time *msg, int id)
584 {
585 u64 usecs64;
586 u32 mod;
587
588 msg->msg_head.size = sizeof(struct msg_init_dsp_time);
589 msg->msg_head.type = id_msg_sys_time_set_t;
590 msg->msg_head.id.camera_id = id;
591 msg->msg_head.mux.sync = 0;
592
593 usecs64 = ktime_to_us(ktime_get());
594
595 mod = do_div(usecs64, USEC_PER_MSEC);
596 msg->tv_usec = mod;
597 msg->tv_sec = usecs64;
598
599 return rk1608_send_msg_to_dsp(pdata, &msg->msg_head);
600 }
601
rk1608_msg_set_input_size(struct rk1608_state * pdata,struct msg_in_size * msg,int id,int cam_id)602 static int rk1608_msg_set_input_size(struct rk1608_state *pdata,
603 struct msg_in_size *msg, int id, int cam_id)
604 {
605 u32 i;
606 u32 msg_size = sizeof(struct msg);
607 u32 idx = pdata->dphy[id]->fmt_inf_idx;
608 struct rk1608_fmt_inf *fmt_inf = &pdata->dphy[id]->fmt_inf[idx];
609
610 for (i = 0; i < 4; i++) {
611 if (fmt_inf->in_ch[i].width == 0)
612 break;
613
614 msg->channel[i].width = fmt_inf->in_ch[i].width;
615 msg->channel[i].height = fmt_inf->in_ch[i].height;
616 msg->channel[i].data_id = fmt_inf->in_ch[i].data_id;
617 msg->channel[i].decode_format =
618 fmt_inf->in_ch[i].decode_format;
619 msg->channel[i].flag = fmt_inf->in_ch[i].flag;
620 msg_size += sizeof(struct preisp_vc_cfg);
621 }
622
623 msg->msg_head.size = msg_size / sizeof(int);
624 msg->msg_head.type = id_msg_set_input_size_t;
625 msg->msg_head.id.camera_id = cam_id;
626 msg->msg_head.mux.sync = 1;
627
628 return rk1608_send_msg_to_dsp(pdata, &msg->msg_head);
629 }
630
rk1608_msg_set_output_size(struct rk1608_state * pdata,struct msg_set_output_size * msg,int id,int cam_id)631 static int rk1608_msg_set_output_size(struct rk1608_state *pdata,
632 struct msg_set_output_size *msg, int id, int cam_id)
633 {
634 u32 i;
635 u32 msg_size = sizeof(struct msg_out_size_head);
636 u32 idx = pdata->dphy[id]->fmt_inf_idx;
637 struct rk1608_fmt_inf *fmt_inf = &pdata->dphy[id]->fmt_inf[idx];
638
639 for (i = 0; i < 4; i++) {
640 if (fmt_inf->out_ch[i].width == 0)
641 break;
642
643 msg->channel[i].width = fmt_inf->out_ch[i].width;
644 msg->channel[i].height = fmt_inf->out_ch[i].height;
645 msg->channel[i].data_id = fmt_inf->out_ch[i].data_id;
646 msg->channel[i].decode_format =
647 fmt_inf->out_ch[i].decode_format;
648 msg->channel[i].flag = fmt_inf->out_ch[i].flag;
649 msg_size += sizeof(struct preisp_vc_cfg);
650 }
651
652 msg->head.msg_head.size = msg_size / sizeof(int);
653 msg->head.msg_head.type = id_msg_set_output_size_t;
654 msg->head.msg_head.id.camera_id = cam_id;
655 msg->head.msg_head.mux.sync = 1;
656 msg->head.width = fmt_inf->hactive;
657 msg->head.height = fmt_inf->vactive;
658 msg->head.mipi_clk = 2 * pdata->dphy[id]->link_freqs;
659 msg->head.line_length_pclk = fmt_inf->htotal;
660 msg->head.frame_length_lines = fmt_inf->vtotal;
661 msg->head.mipi_lane = fmt_inf->mipi_lane_out;
662 msg->head.flip = pdata->flip;
663
664 return rk1608_send_msg_to_dsp(pdata, &msg->head.msg_head);
665 }
666
rk1608_msg_set_stream_in_on(struct rk1608_state * pdata,struct msg * msg,int id)667 static int rk1608_msg_set_stream_in_on(struct rk1608_state *pdata,
668 struct msg *msg, int id)
669 {
670 msg->size = sizeof(struct msg);
671 msg->type = id_msg_set_stream_in_on_t;
672 msg->id.camera_id = id;
673 msg->mux.sync = 1;
674
675 return rk1608_send_msg_to_dsp(pdata, msg);
676 }
677
rk1608_msg_set_stream_in_off(struct rk1608_state * pdata,struct msg * msg,int id)678 static int rk1608_msg_set_stream_in_off(struct rk1608_state *pdata,
679 struct msg *msg, int id)
680 {
681 msg->size = sizeof(struct msg);
682 msg->type = id_msg_set_stream_in_off_t;
683 msg->id.camera_id = id;
684 msg->mux.sync = 1;
685
686 return rk1608_send_msg_to_dsp(pdata, msg);
687 }
688
rk1608_msg_set_stream_out_on(struct rk1608_state * pdata,struct msg * msg,int id)689 static int rk1608_msg_set_stream_out_on(struct rk1608_state *pdata,
690 struct msg *msg, int id)
691 {
692 msg->size = sizeof(struct msg);
693 msg->type = id_msg_set_stream_out_on_t;
694 msg->id.camera_id = id;
695 msg->mux.sync = 1;
696
697 return rk1608_send_msg_to_dsp(pdata, msg);
698 }
699
rk1608_msg_set_stream_out_off(struct rk1608_state * pdata,struct msg * msg,int id)700 static int rk1608_msg_set_stream_out_off(struct rk1608_state *pdata,
701 struct msg *msg, int id)
702 {
703 msg->size = sizeof(struct msg);
704 msg->type = id_msg_set_stream_out_off_t;
705 msg->id.camera_id = id;
706 msg->mux.sync = 1;
707
708 return rk1608_send_msg_to_dsp(pdata, msg);
709 }
710
rk1608_set_log_level(struct rk1608_state * pdata,int level)711 int rk1608_set_log_level(struct rk1608_state *pdata, int level)
712 {
713 struct msg *msg = kzalloc(sizeof(*msg), GFP_KERNEL);
714 int ret = 0;
715
716 if (!msg)
717 return -ENOMEM;
718
719 msg->size = sizeof(struct msg);
720 msg->type = id_msg_set_log_level_t;
721 msg->mux.log_level = level;
722
723 ret = rk1608_send_msg_to_dsp(pdata, msg);
724 kfree(msg);
725
726 return ret;
727 }
728
rk1608_send_meta_hdrae(struct rk1608_state * pdata,struct preisp_hdrae_exp_s * hdrae_exp)729 static int rk1608_send_meta_hdrae(struct rk1608_state *pdata,
730 struct preisp_hdrae_exp_s *hdrae_exp)
731 {
732 int ret = 0;
733 unsigned long flags;
734 struct msg_set_sensor_info_s *msg;
735
736 msg = kzalloc(sizeof(*msg), GFP_KERNEL);
737 if (!msg)
738 return -ENOMEM;
739
740 msg->msg_head.size = sizeof(*msg) / 4;
741 msg->msg_head.type = id_msg_set_sensor_info_t;
742 msg->msg_head.id.camera_id = 0;
743 msg->msg_head.mux.sync = 0;
744 msg->set_exp_cnt = pdata->set_exp_cnt++;
745
746 spin_lock_irqsave(&pdata->hdrae_lock, flags);
747 msg->r_gain = pdata->hdrae_para.r_gain;
748 msg->b_gain = pdata->hdrae_para.b_gain;
749 msg->gr_gain = pdata->hdrae_para.gr_gain;
750 msg->gb_gain = pdata->hdrae_para.gb_gain;
751 memcpy(msg->lsc_table, pdata->hdrae_para.lsc_table,
752 sizeof(msg->lsc_table));
753 spin_unlock_irqrestore(&pdata->hdrae_lock, flags);
754
755 /* dsp hdrae */
756 msg->dsp_hdrae.bayer_mode = BAYER_MODE_BGGR;
757 msg->dsp_hdrae.grid_mode = AE_MEASURE_GRID_15X15;
758 memset(&msg->dsp_hdrae.weight[0], 3, ISP_DSP_HDRAE_MAXGRIDITEMS);
759 msg->dsp_hdrae.hist_mode = AE_HISTSTATICMODE_Y;
760 msg->dsp_hdrae.ycoeff.rcoef = 1;
761 msg->dsp_hdrae.ycoeff.gcoef = 1;
762 msg->dsp_hdrae.ycoeff.bcoef = 1;
763 msg->dsp_hdrae.ycoeff.offset = 0;
764 msg->dsp_hdrae.imgbits = 0;
765 msg->dsp_hdrae.width = 1920;
766 msg->dsp_hdrae.height = 1080;
767 msg->dsp_hdrae.frames = 2;
768
769 msg->reg_exp_time[0] = hdrae_exp->long_exp_reg;
770 msg->reg_exp_gain[0] = hdrae_exp->long_gain_reg;
771 msg->reg_exp_time[1] = hdrae_exp->middle_exp_reg;
772 msg->reg_exp_gain[1] = hdrae_exp->middle_gain_reg;
773 msg->reg_exp_time[2] = hdrae_exp->short_exp_reg;
774 msg->reg_exp_gain[2] = hdrae_exp->short_gain_reg;
775
776 msg->exp_time[0] = hdrae_exp->long_exp_val;
777 msg->exp_gain[0] = hdrae_exp->long_gain_val;
778 msg->exp_time[1] = hdrae_exp->middle_exp_val;
779 msg->exp_gain[1] = hdrae_exp->middle_gain_val;
780 msg->exp_time[2] = hdrae_exp->short_exp_val;
781 msg->exp_gain[2] = hdrae_exp->short_gain_val;
782
783 ret = rk1608_send_msg_to_dsp(pdata, &msg->msg_head);
784 kfree(msg);
785
786 return ret;
787 }
788
rk1608_disp_set_frame_output(struct rk1608_state * pdata,void * args)789 static int rk1608_disp_set_frame_output(struct rk1608_state *pdata,
790 void *args)
791 {
792 int ret = 0;
793 int value = *(unsigned int *)args;
794 struct msg_disp msg_disp;
795
796 dev_info(pdata->dev, "%s:%d\n", __func__, value);
797 msg_disp.msg.size = sizeof(msg_disp) / 4;
798 msg_disp.msg.type = id_msg_disp_set_frame_output_t;
799 msg_disp.msg.id.camera_id = pdata->sd.grp_id;
800 msg_disp.msg.mux.sync = 0;
801 msg_disp.value[0] = value;
802 ret = rk1608_send_msg_to_dsp(pdata, (struct msg *)&msg_disp);
803 return ret;
804 }
805
rk1608_disp_set_frame_format(struct rk1608_state * pdata,void * args)806 static int rk1608_disp_set_frame_format(struct rk1608_state *pdata,
807 void *args)
808 {
809 int ret = 0;
810 unsigned int value = *(unsigned int *)args;
811 struct msg_disp msg_disp;
812
813 dev_info(pdata->dev, "%s:%d\n", __func__, value);
814 msg_disp.msg.size = sizeof(msg_disp) / 4;
815 msg_disp.msg.type = id_msg_disp_set_frame_format_t;
816 msg_disp.msg.id.camera_id = pdata->sd.grp_id;
817 msg_disp.msg.mux.sync = 0;
818 msg_disp.value[0] = value;
819 ret = rk1608_send_msg_to_dsp(pdata, (struct msg *)&msg_disp);
820 return ret;
821 }
822
rk1608_disp_set_led_on_off(struct rk1608_state * pdata,void * args)823 static int rk1608_disp_set_led_on_off(struct rk1608_state *pdata,
824 void *args)
825 {
826 int ret = 0;
827 unsigned int value = *(unsigned int *)args;
828 struct msg_disp msg_disp;
829
830 dev_info(pdata->dev, "%s:%d\n", __func__, value);
831 msg_disp.msg.size = sizeof(msg_disp) / 4;
832 msg_disp.msg.type = id_msg_disp_set_led_on_off_t;
833 msg_disp.msg.id.camera_id = pdata->sd.grp_id;
834 msg_disp.msg.mux.sync = 0;
835 msg_disp.value[0] = value;
836 ret = rk1608_send_msg_to_dsp(pdata, (struct msg *)&msg_disp);
837 return ret;
838 }
839
rk1608_disp_set_frame_type(struct rk1608_state * pdata,void * args)840 static int rk1608_disp_set_frame_type(struct rk1608_state *pdata,
841 void *args)
842 {
843 int ret = 0;
844 unsigned int value = *(unsigned int *)args;
845 struct msg_disp msg_disp;
846
847 dev_info(pdata->dev, "%s:%d\n", __func__, value);
848 msg_disp.msg.size = sizeof(msg_disp) / 4;
849 msg_disp.msg.type = id_msg_disp_set_frame_type_t;
850 msg_disp.msg.id.camera_id = pdata->sd.grp_id;
851 msg_disp.msg.mux.sync = 0;
852 msg_disp.value[0] = value;
853 ret = rk1608_send_msg_to_dsp(pdata, (struct msg *)&msg_disp);
854 return ret;
855 }
856
rk1608_disp_set_pro_time(struct rk1608_state * pdata,void * args)857 static int rk1608_disp_set_pro_time(struct rk1608_state *pdata,
858 void *args)
859 {
860 int ret = 0;
861 unsigned int value = *(unsigned int *)args;
862 struct msg_disp msg_disp;
863
864 dev_info(pdata->dev, "%s:%d\n", __func__, value);
865
866 msg_disp.msg.size = sizeof(msg_disp) / 4;
867 msg_disp.msg.type = id_msg_disp_set_pro_time_t;
868 msg_disp.msg.id.camera_id = pdata->sd.grp_id;
869 msg_disp.msg.mux.sync = 0;
870 msg_disp.value[0] = value;
871 ret = rk1608_send_msg_to_dsp(pdata, (struct msg *)&msg_disp);
872 return ret;
873 }
874
rk1608_disp_set_pro_current(struct rk1608_state * pdata,void * args)875 static int rk1608_disp_set_pro_current(struct rk1608_state *pdata,
876 void *args)
877 {
878 int ret = 0;
879 unsigned int value = *(unsigned int *)args;
880 struct msg_disp msg_disp;
881
882 dev_info(pdata->dev, "%s:%d\n", __func__, value);
883 msg_disp.msg.size = sizeof(msg_disp) / 4;
884 msg_disp.msg.type = id_msg_disp_set_pro_current_t;
885 msg_disp.msg.id.camera_id = pdata->sd.grp_id;
886 msg_disp.msg.mux.sync = 0;
887 msg_disp.value[0] = value;
888 ret = rk1608_send_msg_to_dsp(pdata, (struct msg *)&msg_disp);
889 return ret;
890 }
891
rk1608_disp_set_denoise(struct rk1608_state * pdata,void * args)892 static int rk1608_disp_set_denoise(struct rk1608_state *pdata,
893 void *args)
894 {
895 int ret = 0;
896 unsigned int *value = (unsigned int *)args;
897 struct msg_disp msg_disp;
898
899 dev_info(pdata->dev, "%s:%d %d\n", __func__, value[0], value[1]);
900 msg_disp.msg.size = sizeof(msg_disp) / 4;
901 msg_disp.msg.type = id_msg_disp_set_denoise_t;
902 msg_disp.msg.id.camera_id = pdata->sd.grp_id;
903 msg_disp.msg.mux.sync = 0;
904 msg_disp.value[0] = value[0];
905 msg_disp.value[1] = value[1];
906 ret = rk1608_send_msg_to_dsp(pdata, (struct msg *)&msg_disp);
907 return ret;
908 }
909
rk1608_disp_write_eeprom_request(struct rk1608_state * pdata)910 static int rk1608_disp_write_eeprom_request(struct rk1608_state *pdata)
911 {
912 int ret = 0;
913 struct msg msg;
914
915 dev_info(pdata->dev, "%s\n", __func__);
916 msg.size = sizeof(struct msg) / 4;
917 msg.type = id_msg_calibration_write_req_mode2_t;
918 msg.id.camera_id = pdata->sd.grp_id;
919 msg.mux.sync = 0;
920 ret = rk1608_send_msg_to_dsp(pdata, (struct msg *)&msg);
921 return ret;
922 }
923
rk1608_disp_read_eeprom_request(struct rk1608_state * pdata)924 static int rk1608_disp_read_eeprom_request(struct rk1608_state *pdata)
925 {
926 int ret = 0;
927 struct msg msg;
928
929 dev_info(pdata->dev, "%s\n", __func__);
930 msg.size = sizeof(struct msg) / 4;
931 msg.type = id_msg_calibration_read_req_mode2_t;
932 msg.id.camera_id = pdata->sd.grp_id;
933 msg.mux.sync = 0;
934 ret = rk1608_send_msg_to_dsp(pdata, (struct msg *)&msg);
935 return ret;
936 }
937
rk1608_init_virtual_sub_sensor(struct rk1608_state * pdata,int id,int index)938 static int rk1608_init_virtual_sub_sensor(
939 struct rk1608_state *pdata, int id, int index)
940 {
941 struct msg *msg = NULL;
942 struct msg_init *msg_init = NULL;
943 struct msg_in_size *msg_in_size = NULL;
944 struct msg_set_output_size *msg_out_size = NULL;
945 int cam_id = pdata->dphy[id]->sub_sensor[index].id;
946 int in_mipi = pdata->dphy[id]->sub_sensor[index].in_mipi;
947 int out_mipi = pdata->dphy[id]->sub_sensor[index].out_mipi;
948 int ret = 0;
949
950 msg = kzalloc(sizeof(*msg), GFP_KERNEL);
951 if (!msg) {
952 ret = -ENOMEM;
953 goto err;
954 }
955 msg_init = kzalloc(sizeof(*msg_init), GFP_KERNEL);
956 if (!msg_init) {
957 ret = -ENOMEM;
958 goto err;
959 }
960
961 msg_in_size = kzalloc(sizeof(*msg_in_size), GFP_KERNEL);
962 if (!msg_in_size) {
963 ret = -ENOMEM;
964 goto err;
965 }
966 msg_out_size = kzalloc(sizeof(*msg_out_size), GFP_KERNEL);
967 if (!msg_out_size) {
968 ret = -ENOMEM;
969 goto err;
970 }
971
972 ret = rk1608_msg_init_sensor(pdata, msg_init, in_mipi, out_mipi, id, cam_id);
973 ret |= rk1608_msg_set_input_size(pdata, msg_in_size, id, cam_id);
974 ret |= rk1608_msg_set_output_size(pdata, msg_out_size, id, cam_id);
975 ret |= rk1608_msg_set_stream_in_on(pdata, msg, cam_id);
976
977 err:
978 kfree(msg_init);
979 kfree(msg_in_size);
980 kfree(msg_out_size);
981 kfree(msg);
982
983 return ret;
984 }
985
rk1608_init_sensor(struct rk1608_state * pdata,int id)986 static int rk1608_init_sensor(struct rk1608_state *pdata, int id)
987 {
988 struct msg *msg = NULL;
989 struct msg_init *msg_init = NULL;
990 struct msg_in_size *msg_in_size = NULL;
991 struct msg_set_output_size *msg_out_size = NULL;
992 struct msg_init_dsp_time *msg_init_time = NULL;
993 int in_mipi = pdata->dphy[id]->in_mipi;
994 int out_mipi = pdata->dphy[id]->out_mipi;
995 int cam_id = id;
996 int ret = 0;
997
998 if (!pdata->sensor[id]) {
999 dev_err(pdata->dev, "Did not find a sensor[%d]!\n", id);
1000 return -EINVAL;
1001 }
1002
1003 msg = kzalloc(sizeof(*msg), GFP_KERNEL);
1004 if (!msg) {
1005 ret = -ENOMEM;
1006 goto err;
1007 }
1008 msg_init = kzalloc(sizeof(*msg_init), GFP_KERNEL);
1009 if (!msg_init) {
1010 ret = -ENOMEM;
1011 goto err;
1012 }
1013
1014 msg_init_time = kzalloc(sizeof(*msg_init_time), GFP_KERNEL);
1015 if (!msg_init_time) {
1016 ret = -ENOMEM;
1017 goto err;
1018 }
1019
1020 msg_in_size = kzalloc(sizeof(*msg_in_size), GFP_KERNEL);
1021 if (!msg_in_size) {
1022 ret = -ENOMEM;
1023 goto err;
1024 }
1025 msg_out_size = kzalloc(sizeof(*msg_out_size), GFP_KERNEL);
1026 if (!msg_out_size) {
1027 ret = -ENOMEM;
1028 goto err;
1029 }
1030
1031
1032 ret = rk1608_msg_init_sensor(pdata, msg_init, in_mipi, out_mipi, id, cam_id);
1033 ret |= rk1608_msg_init_dsp_time(pdata, msg_init_time, id);
1034 ret |= rk1608_msg_set_input_size(pdata, msg_in_size, id, cam_id);
1035 ret |= rk1608_msg_set_output_size(pdata, msg_out_size, id, cam_id);
1036 ret |= rk1608_msg_set_stream_in_on(pdata, msg, cam_id);
1037 ret |= rk1608_msg_set_stream_out_on(pdata, msg, cam_id);
1038
1039 err:
1040 kfree(msg_init);
1041 kfree(msg_init_time);
1042 kfree(msg_in_size);
1043 kfree(msg_out_size);
1044 kfree(msg);
1045
1046 return ret;
1047 }
1048
rk1608_deinit(struct rk1608_state * pdata,int id)1049 static int rk1608_deinit(struct rk1608_state *pdata, int id)
1050 {
1051 struct msg *msg;
1052 int ret = 0;
1053
1054 msg = kzalloc(sizeof(*msg), GFP_KERNEL);
1055 if (!msg)
1056 return -ENOMEM;
1057 ret = rk1608_msg_set_stream_out_off(pdata, msg, id);
1058 ret |= rk1608_msg_set_stream_in_off(pdata, msg, id);
1059 kfree(msg);
1060
1061 return ret;
1062 }
1063
rk1608_cs_set_value(struct rk1608_state * pdata,int value)1064 static void rk1608_cs_set_value(struct rk1608_state *pdata, int value)
1065 {
1066 s8 null_cmd = 0;
1067
1068 struct spi_transfer null_cmd_packet = {
1069 .tx_buf = &null_cmd,
1070 .len = sizeof(null_cmd),
1071 .cs_change = !value,
1072 };
1073 struct spi_message m;
1074
1075 spi_message_init(&m);
1076 spi_message_add_tail(&null_cmd_packet, &m);
1077 spi_sync(pdata->spi, &m);
1078 }
1079
rk1608_set_spi_speed(struct rk1608_state * pdata,u32 hz)1080 void rk1608_set_spi_speed(struct rk1608_state *pdata, u32 hz)
1081 {
1082 pdata->spi->max_speed_hz = hz;
1083 }
1084
rk1608_power_on(struct rk1608_state * pdata)1085 static int rk1608_power_on(struct rk1608_state *pdata)
1086 {
1087 struct spi_device *spi = pdata->spi;
1088 int ret = 0;
1089
1090 if (pdata->pwren_gpio)
1091 gpiod_direction_output(pdata->pwren_gpio, 1);
1092
1093 if (!IS_ERR(pdata->mclk)) {
1094 ret = clk_set_rate(pdata->mclk, RK1608_MCLK_RATE);
1095 if (ret < 0)
1096 dev_warn(pdata->dev, "Failed to set mclk rate\n");
1097 if (clk_get_rate(pdata->mclk) != RK1608_MCLK_RATE)
1098 dev_warn(pdata->dev, "mclk(%lu) mismatched\n",
1099 clk_get_rate(pdata->mclk));
1100
1101 ret = clk_prepare_enable(pdata->mclk);
1102 if (ret < 0)
1103 dev_warn(pdata->dev, "Failed to enable mclk\n");
1104 else
1105 usleep_range(3000, 3500);
1106 }
1107
1108 /* Request rk1608 enter slave mode */
1109 rk1608_cs_set_value(pdata, 0);
1110 if (pdata->wakeup_gpio)
1111 gpiod_direction_output(pdata->wakeup_gpio, 1);
1112
1113 usleep_range(3000, 3500);
1114 if (pdata->reset_gpio) {
1115 gpiod_direction_output(pdata->reset_gpio, 1);
1116 gpiod_direction_output(pdata->reset_gpio, 0);
1117 gpiod_direction_output(pdata->reset_gpio, 1);
1118 }
1119
1120 /* After Reset pull-up, CSn should keep low for 2ms+ */
1121 usleep_range(3000, 3500);
1122 rk1608_cs_set_value(pdata, 1);
1123 rk1608_set_spi_speed(pdata, pdata->min_speed_hz);
1124 rk1608_lsb_w32(spi, SPI_ENR, 0);
1125 rk1608_lsb_w32(spi, SPI_CTRL0,
1126 OPM_SLAVE_MODE | RSD_SEL_2CYC | DFS_SEL_16BIT);
1127 rk1608_hw_init(pdata, pdata->spi);
1128 rk1608_set_spi_speed(pdata, pdata->max_speed_hz);
1129
1130 /* Download system firmware */
1131 ret = rk1608_download_fw(pdata, pdata->spi, pdata->firm_name);
1132 if (ret)
1133 dev_err(pdata->dev, "Download firmware failed!");
1134 else
1135 dev_info(pdata->dev, "Download firmware success!");
1136
1137 if (pdata->irq > 0)
1138 enable_irq(pdata->irq);
1139
1140 if (!ret)
1141 ret = rk1608_set_log_level(pdata, pdata->log_level);
1142
1143 return ret;
1144 }
1145
rk1608_power_off(struct rk1608_state * pdata)1146 static int rk1608_power_off(struct rk1608_state *pdata)
1147 {
1148 /* Request rk1608 enter slave mode */
1149 if (pdata->irq > 0)
1150 disable_irq(pdata->irq);
1151 if (pdata->wakeup_gpio)
1152 gpiod_direction_output(pdata->wakeup_gpio, 0);
1153 if (pdata->reset_gpio)
1154 gpiod_direction_output(pdata->reset_gpio, 0);
1155 rk1608_cs_set_value(pdata, 0);
1156
1157 if (pdata->pwren_gpio)
1158 gpiod_direction_output(pdata->pwren_gpio, 0);
1159
1160 if (!IS_ERR(pdata->mclk))
1161 clk_disable_unprepare(pdata->mclk);
1162
1163 return 0;
1164 }
1165
rk1608_set_power(struct rk1608_state * pdata,int on)1166 int rk1608_set_power(struct rk1608_state *pdata, int on)
1167 {
1168 mutex_lock(&pdata->lock);
1169 if (on) {
1170 if (!pdata->power_count)
1171 rk1608_power_on(pdata);
1172 } else {
1173 if (pdata->power_count == 1)
1174 rk1608_power_off(pdata);
1175 }
1176
1177 pdata->power_count += on ? 1 : -1;
1178 if (pdata->power_count < 0)
1179 pdata->power_count = 0;
1180 mutex_unlock(&pdata->lock);
1181
1182 return 0;
1183 }
1184
rk1608_poweron_func(struct work_struct * work)1185 static void rk1608_poweron_func(struct work_struct *work)
1186 {
1187 struct rk1608_power_work *pwork = (struct rk1608_power_work *)work;
1188 int ret = rk1608_power_on(pwork->pdata);
1189
1190 if (!ret)
1191 complete(&pwork->work_fin);
1192 }
1193
rk1608_sensor_power(struct v4l2_subdev * sd,int on)1194 static int rk1608_sensor_power(struct v4l2_subdev *sd, int on)
1195 {
1196 struct rk1608_state *pdata = to_state(sd);
1197 int ret = 0;
1198
1199 mutex_lock(&pdata->lock);
1200 if (on) {
1201 if (!pdata->power_count) {
1202 INIT_WORK(&gwork.wk, rk1608_poweron_func);
1203 init_completion(&gwork.work_fin);
1204 gwork.pdata = pdata;
1205 schedule_work(&gwork.wk);
1206
1207 v4l2_subdev_call(pdata->sensor[sd->grp_id],
1208 core, s_power, on);
1209 if (!wait_for_completion_timeout(&gwork.work_fin,
1210 msecs_to_jiffies(1000))) {
1211 dev_err(pdata->dev,
1212 "wait for preisp power on timeout!");
1213 ret = -EBUSY;
1214 }
1215 }
1216 } else if (!on && pdata->power_count == 1) {
1217 v4l2_subdev_call(pdata->sensor[sd->grp_id], core, s_power, on);
1218 ret = rk1608_power_off(pdata);
1219 }
1220
1221 /* Update the power count. */
1222 pdata->power_count += on ? 1 : -1;
1223 WARN_ON(pdata->power_count < 0);
1224 mutex_unlock(&pdata->lock);
1225
1226 return ret;
1227 }
1228
rk1608_stream_on(struct rk1608_state * pdata)1229 static int rk1608_stream_on(struct rk1608_state *pdata)
1230 {
1231 int id = 0, cnt = 0, ret = 0;
1232 int sub_sensor_num = 0, index = 0;
1233
1234 mutex_lock(&pdata->lock);
1235 id = pdata->sd.grp_id;
1236 pdata->sensor_cnt = 0;
1237 pdata->set_exp_cnt = 1;
1238
1239 sub_sensor_num = pdata->dphy[id]->sub_sensor_num;
1240 for (index = 0; index < sub_sensor_num; index++) {
1241 ret = rk1608_init_virtual_sub_sensor(pdata, id, index);
1242 if (ret) {
1243 dev_err(pdata->dev, "Init rk1608[%d] sub[%d] is failed!",
1244 id,
1245 index);
1246 mutex_unlock(&pdata->lock);
1247 return ret;
1248 }
1249 }
1250
1251 ret = rk1608_init_sensor(pdata, id);
1252 if (ret) {
1253 dev_err(pdata->dev, "Init rk1608[%d] is failed!",
1254 pdata->sd.grp_id);
1255 mutex_unlock(&pdata->lock);
1256 return ret;
1257 }
1258
1259 /* Waiting for the sensor to be ready */
1260 while (pdata->sensor_cnt < pdata->sensor_nums[id]) {
1261 /* TIMEOUT 10s break */
1262 if (cnt++ > SENSOR_TIMEOUT) {
1263 dev_err(pdata->dev,
1264 "Sensor%d is ready to timeout!",
1265 pdata->sensor_cnt);
1266 break;
1267 }
1268 usleep_range(10000, 11000);
1269 }
1270
1271 if (pdata->sensor_nums[id]) {
1272 if (pdata->sensor_cnt == pdata->sensor_nums[id])
1273 dev_info(pdata->dev, "Sensor(num %d) is ready!",
1274 pdata->sensor_cnt);
1275 } else {
1276 dev_warn(pdata->dev, "No sensor is found!");
1277 }
1278 mutex_unlock(&pdata->lock);
1279
1280 pdata->hdrae_para.r_gain = 0x0100;
1281 pdata->hdrae_para.b_gain = 0x0100;
1282 pdata->hdrae_para.gr_gain = 0x0100;
1283 pdata->hdrae_para.gb_gain = 0x0100;
1284 for (cnt = 0; cnt < PREISP_LSCTBL_SIZE; cnt++)
1285 pdata->hdrae_para.lsc_table[cnt] = 0x0400;
1286 memset(&pdata->hdrae_exp, 0, sizeof(pdata->hdrae_exp));
1287 return 0;
1288 }
1289
rk1608_stream_off(struct rk1608_state * pdata)1290 static int rk1608_stream_off(struct rk1608_state *pdata)
1291 {
1292 u32 sub_sensor_num = 0, index = 0, sub_id = 0;
1293
1294 mutex_lock(&pdata->sensor_lock);
1295 pdata->sensor_cnt = 0;
1296 mutex_unlock(&pdata->sensor_lock);
1297
1298 sub_sensor_num = pdata->dphy[pdata->sd.grp_id]->sub_sensor_num;
1299 for (index = 0; index < sub_sensor_num; index++) {
1300 sub_id = pdata->dphy[pdata->sd.grp_id]->sub_sensor[index].id;
1301 rk1608_deinit(pdata, sub_id);
1302 }
1303
1304 rk1608_deinit(pdata, pdata->sd.grp_id);
1305
1306 return 0;
1307 }
1308
rk1608_set_quick_stream(struct rk1608_state * pdata,void * args)1309 static int rk1608_set_quick_stream(struct rk1608_state *pdata, void *args)
1310 {
1311 u32 stream = *(u32 *)args;
1312
1313 if (stream)
1314 return rk1608_stream_on(pdata);
1315 else
1316 return rk1608_stream_off(pdata);
1317 }
1318
rk1608_s_stream(struct v4l2_subdev * sd,int enable)1319 static int rk1608_s_stream(struct v4l2_subdev *sd, int enable)
1320 {
1321 int ret;
1322 struct rk1608_state *pdata = to_state(sd);
1323
1324 pdata->msg_num = 0;
1325 if (enable) {
1326 v4l2_subdev_call(pdata->sensor[sd->grp_id], core, s_power, enable);
1327 ret = rk1608_stream_on(pdata);
1328 } else {
1329 ret = rk1608_stream_off(pdata);
1330 v4l2_subdev_call(pdata->sensor[sd->grp_id], core, s_power, enable);
1331 }
1332
1333 v4l2_subdev_call(pdata->sensor[sd->grp_id], video, s_stream, enable);
1334
1335 return ret;
1336 }
1337
rk1608_g_frame_interval(struct v4l2_subdev * sd,struct v4l2_subdev_frame_interval * fi)1338 static int rk1608_g_frame_interval(struct v4l2_subdev *sd,
1339 struct v4l2_subdev_frame_interval *fi)
1340 {
1341 struct rk1608_state *pdata = to_state(sd);
1342
1343 v4l2_subdev_call(pdata->sensor[sd->grp_id],
1344 video,
1345 g_frame_interval,
1346 fi);
1347
1348 return 0;
1349 }
1350
rk1608_set_fmt(struct v4l2_subdev * sd,struct v4l2_subdev_pad_config * cfg,struct v4l2_subdev_format * fmt)1351 static int rk1608_set_fmt(struct v4l2_subdev *sd,
1352 struct v4l2_subdev_pad_config *cfg,
1353 struct v4l2_subdev_format *fmt)
1354 {
1355 struct rk1608_state *pdata = to_state(sd);
1356
1357 v4l2_subdev_call(pdata->sensor[sd->grp_id],
1358 pad,
1359 set_fmt,
1360 cfg,
1361 fmt);
1362
1363 return 0;
1364 }
1365
rk1608_ioctl(struct v4l2_subdev * sd,unsigned int cmd,void * arg)1366 static long rk1608_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
1367 {
1368 struct rk1608_state *pdata = to_state(sd);
1369 struct preisp_hdrae_para_s *hdrae_para;
1370 struct preisp_hdrae_exp_s *hdrae_exp;
1371
1372 switch (cmd) {
1373 case PREISP_CMD_SAVE_HDRAE_PARAM:
1374 hdrae_para = arg;
1375 spin_lock(&pdata->hdrae_lock);
1376 pdata->hdrae_para = *hdrae_para;
1377 spin_unlock(&pdata->hdrae_lock);
1378 break;
1379 case PREISP_CMD_SET_HDRAE_EXP:
1380 hdrae_exp = arg;
1381 if (pdata->hdrae_exp.long_exp_reg == hdrae_exp->long_exp_reg &&
1382 pdata->hdrae_exp.long_gain_reg == hdrae_exp->long_gain_reg &&
1383 pdata->hdrae_exp.short_exp_reg == hdrae_exp->short_exp_reg &&
1384 pdata->hdrae_exp.short_gain_reg == hdrae_exp->short_gain_reg)
1385 break;
1386
1387 if (!pdata->sensor_cnt) {
1388 dev_info(pdata->dev, "set Aec before stream on");
1389 break;
1390 }
1391
1392 pdata->hdrae_exp = *hdrae_exp;
1393
1394 /* hdr exposure start */
1395 if (pdata->aesync_gpio)
1396 gpiod_direction_output(pdata->aesync_gpio, 1);
1397
1398 v4l2_subdev_call(pdata->sensor[sd->grp_id], core, ioctl,
1399 cmd, hdrae_exp);
1400
1401 if (pdata->aesync_gpio)
1402 gpiod_direction_output(pdata->aesync_gpio, 0);
1403
1404 rk1608_send_meta_hdrae(pdata, hdrae_exp);
1405 break;
1406 case RKMODULE_GET_MODULE_INFO:
1407 case RKMODULE_AWB_CFG:
1408 v4l2_subdev_call(pdata->sensor[sd->grp_id], core, ioctl,
1409 cmd, arg);
1410 break;
1411 case PREISP_DISP_SET_FRAME_OUTPUT:
1412 rk1608_disp_set_frame_output(pdata, arg);
1413 break;
1414 case PREISP_DISP_SET_FRAME_FORMAT:
1415 rk1608_disp_set_frame_format(pdata, arg);
1416 break;
1417 case PREISP_DISP_SET_FRAME_TYPE:
1418 rk1608_disp_set_frame_type(pdata, arg);
1419 break;
1420 case PREISP_DISP_SET_PRO_TIME:
1421 rk1608_disp_set_pro_time(pdata, arg);
1422 break;
1423 case PREISP_DISP_SET_PRO_CURRENT:
1424 rk1608_disp_set_pro_current(pdata, arg);
1425 break;
1426 case PREISP_DISP_SET_DENOISE:
1427 rk1608_disp_set_denoise(pdata, arg);
1428 break;
1429 case PREISP_DISP_WRITE_EEPROM:
1430 rk1608_disp_write_eeprom_request(pdata);
1431 break;
1432 case PREISP_DISP_READ_EEPROM:
1433 rk1608_disp_read_eeprom_request(pdata);
1434 break;
1435 case PREISP_DISP_SET_LED_ON_OFF:
1436 rk1608_disp_set_led_on_off(pdata, arg);
1437 break;
1438 case RKMODULE_SET_QUICK_STREAM:
1439 rk1608_set_quick_stream(pdata, arg);
1440 break;
1441 default:
1442 return -ENOTTY;
1443 }
1444
1445 return 0;
1446 }
1447
rk1608_g_volatile_ctrl(struct v4l2_ctrl * ctrl)1448 static int rk1608_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1449 {
1450 struct v4l2_ctrl *remote_ctrl;
1451 struct rk1608_state *pdata =
1452 container_of(ctrl->handler,
1453 struct rk1608_state, ctrl_handler);
1454 int id = pdata->sd.grp_id;
1455
1456 if (!pdata->sensor[id]) {
1457 dev_err(pdata->dev, "Did not find a sensor[%d]!\n", id);
1458 return -EINVAL;
1459 }
1460
1461 remote_ctrl = v4l2_ctrl_find(pdata->sensor[id]->ctrl_handler,
1462 ctrl->id);
1463 if (remote_ctrl) {
1464 ctrl->val = v4l2_ctrl_g_ctrl(remote_ctrl);
1465 __v4l2_ctrl_modify_range(ctrl,
1466 remote_ctrl->minimum,
1467 remote_ctrl->maximum,
1468 remote_ctrl->step,
1469 remote_ctrl->default_value);
1470 }
1471
1472 return 0;
1473 }
1474
rk1608_set_ctrl(struct v4l2_ctrl * ctrl)1475 static int rk1608_set_ctrl(struct v4l2_ctrl *ctrl)
1476 {
1477 int ret = 0;
1478
1479 struct v4l2_ctrl *remote_ctrl;
1480 struct rk1608_state *pdata =
1481 container_of(ctrl->handler,
1482 struct rk1608_state, ctrl_handler);
1483 int id = pdata->sd.grp_id;
1484
1485 if (id == 1) {
1486 switch (ctrl->id) {
1487 case V4L2_CID_HFLIP:
1488 if (ctrl->val)
1489 pdata->flip |= MIRROR_BIT_MASK;
1490 else
1491 pdata->flip &= ~MIRROR_BIT_MASK;
1492 dev_info(pdata->dev, "%s V4L2_CID_HFLIP ctrl id:0x%x, flip:0x%x\n",
1493 __func__, ctrl->id, pdata->flip);
1494 break;
1495 case V4L2_CID_VFLIP:
1496 if (ctrl->val)
1497 pdata->flip |= FLIP_BIT_MASK;
1498 else
1499 pdata->flip &= ~FLIP_BIT_MASK;
1500 dev_info(pdata->dev, "%s V4L2_CID_VFLIP ctrl id:0x%x, flip:0x%x\n",
1501 __func__, ctrl->id, pdata->flip);
1502 break;
1503 default:
1504 dev_warn(pdata->dev, "%s Unhandled id:0x%x, val:0x%x\n",
1505 __func__, ctrl->id, ctrl->val);
1506 break;
1507 }
1508 }
1509 if (!pdata->sensor[id]) {
1510 dev_err(pdata->dev, "Did not find a sensor[%d]!\n", id);
1511 return -EINVAL;
1512 }
1513
1514 remote_ctrl = v4l2_ctrl_find(pdata->sensor[id]->ctrl_handler,
1515 ctrl->id);
1516 if (remote_ctrl)
1517 ret = v4l2_ctrl_s_ctrl(remote_ctrl, ctrl->val);
1518
1519 return ret;
1520 }
1521
1522 static const struct v4l2_ctrl_ops rk1608_ctrl_ops = {
1523 .g_volatile_ctrl = rk1608_g_volatile_ctrl,
1524 .s_ctrl = rk1608_set_ctrl,
1525 };
1526
rk1608_initialize_controls(struct rk1608_state * rk1608)1527 static int rk1608_initialize_controls(struct rk1608_state *rk1608)
1528 {
1529 int ret;
1530 struct v4l2_ctrl_handler *handler;
1531 unsigned long flags = V4L2_CTRL_FLAG_VOLATILE |
1532 V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1533
1534 handler = &rk1608->ctrl_handler;
1535 ret = v4l2_ctrl_handler_init(handler, 10);
1536 if (ret)
1537 return ret;
1538
1539 rk1608->hblank = v4l2_ctrl_new_std(handler,
1540 &rk1608_ctrl_ops,
1541 V4L2_CID_HBLANK,
1542 0, 0x7FFFFFFF, 1, 0);
1543 if (rk1608->hblank)
1544 rk1608->hblank->flags |= flags;
1545
1546 rk1608->vblank = v4l2_ctrl_new_std(handler,
1547 &rk1608_ctrl_ops,
1548 V4L2_CID_VBLANK,
1549 0, 0x7FFFFFFF, 1, 0);
1550 if (rk1608->vblank)
1551 rk1608->vblank->flags |= flags;
1552
1553 rk1608->exposure = v4l2_ctrl_new_std(handler,
1554 &rk1608_ctrl_ops,
1555 V4L2_CID_EXPOSURE,
1556 0, 0x7FFFFFFF, 1, 0);
1557 if (rk1608->exposure)
1558 rk1608->exposure->flags |= flags;
1559
1560 rk1608->gain = v4l2_ctrl_new_std(handler,
1561 &rk1608_ctrl_ops,
1562 V4L2_CID_ANALOGUE_GAIN,
1563 0, 0x7FFFFFFF, 1, 0);
1564 if (rk1608->gain)
1565 rk1608->gain->flags |= flags;
1566 rk1608->h_flip = v4l2_ctrl_new_std(handler, &rk1608_ctrl_ops,
1567 V4L2_CID_HFLIP, 0, 1, 1, 0);
1568 if (rk1608->h_flip)
1569 rk1608->h_flip->flags |= flags;
1570 rk1608->v_flip = v4l2_ctrl_new_std(handler, &rk1608_ctrl_ops,
1571 V4L2_CID_VFLIP, 0, 1, 1, 0);
1572 if (rk1608->v_flip)
1573 rk1608->v_flip->flags |= flags;
1574 rk1608->flip = 0;
1575
1576 if (handler->error) {
1577 ret = handler->error;
1578 dev_err(rk1608->dev,
1579 "Failed to init controls(%d)\n", ret);
1580 goto err_free_handler;
1581 }
1582
1583 rk1608->sd.ctrl_handler = handler;
1584
1585 return 0;
1586
1587 err_free_handler:
1588 v4l2_ctrl_handler_free(handler);
1589
1590 return ret;
1591 }
1592
1593 static const struct v4l2_subdev_video_ops rk1608_subdev_video_ops = {
1594 .s_stream = rk1608_s_stream,
1595 .g_frame_interval = rk1608_g_frame_interval,
1596 };
1597
1598 static const struct v4l2_subdev_core_ops rk1608_core_ops = {
1599 .s_power = rk1608_sensor_power,
1600 .ioctl = rk1608_ioctl,
1601 };
1602
1603 static const struct v4l2_subdev_pad_ops rk1608_subdev_pad_ops = {
1604 .set_fmt = rk1608_set_fmt,
1605 };
1606
1607 static const struct v4l2_subdev_ops rk1608_subdev_ops = {
1608 .core = &rk1608_core_ops,
1609 .video = &rk1608_subdev_video_ops,
1610 .pad = &rk1608_subdev_pad_ops,
1611 };
1612
1613 /**
1614 * rk1608_msq_read_head - read rk1608 msg queue head
1615 *
1616 * @spi: spi device
1617 * @addr: msg queue head addr
1618 * @m: msg queue pointer
1619 *
1620 * It returns zero on success, else a negative error code.
1621 */
rk1608_msq_read_head(struct rk1608_state * rk1608,struct spi_device * spi,u32 addr,struct rk1608_msg_queue * q)1622 static int rk1608_msq_read_head(struct rk1608_state *rk1608,
1623 struct spi_device *spi,
1624 u32 addr, struct rk1608_msg_queue *q)
1625 {
1626 int err = 0;
1627 s32 reg;
1628
1629 err = rk1608_safe_read(rk1608, spi, RK1608_PMU_SYS_REG0, ®, 4);
1630
1631 if (err || ((reg & RK1608_MSG_QUEUE_OK_MASK) !=
1632 RK1608_MSG_QUEUE_OK_TAG))
1633 return -EINVAL;
1634
1635 err = rk1608_safe_read(rk1608, spi, addr, (s32 *)q, sizeof(*q));
1636
1637 return err;
1638 }
1639
1640 /**
1641 * rk1608_msq_recv_msg - receive a msg from RK1608 -> AP msg queue
1642 *
1643 * @q: msg queue
1644 * @m: a msg pointer buf [out]
1645 *
1646 * need free msg after msg use done
1647 *
1648 * It returns zero on success, else a negative error code.
1649 */
rk1608_msq_recv_msg(struct rk1608_state * rk1608,struct spi_device * spi,struct msg ** m)1650 int rk1608_msq_recv_msg(struct rk1608_state *rk1608, struct spi_device *spi,
1651 struct msg **m)
1652 {
1653 struct rk1608_msg_queue queue;
1654 struct rk1608_msg_queue *q = &queue;
1655 u32 size = 0, msg_size = 0;
1656 u32 recv_addr = 0;
1657 u32 next_recv_addr = 0;
1658 int err = 0;
1659
1660 *m = NULL;
1661 err = rk1608_msq_read_head(rk1608, spi, RK1608_S_MSG_QUEUE_ADDR, q);
1662 if (err)
1663 return err;
1664
1665 if (q->cur_send == q->cur_recv)
1666 return -EINVAL;
1667 /* Skip to head when size is 0 */
1668 err = rk1608_safe_read(rk1608, spi, (s32)q->cur_recv, (s32 *)&size, 4);
1669 if (err)
1670 return err;
1671 if (size == 0) {
1672 err = rk1608_safe_read(rk1608, spi, (s32)q->buf_head,
1673 (s32 *)&size, 4);
1674 if (err)
1675 return err;
1676
1677 msg_size = size * sizeof(u32);
1678 recv_addr = q->buf_head;
1679 next_recv_addr = q->buf_head + msg_size;
1680 } else {
1681 msg_size = size * sizeof(u32);
1682 recv_addr = q->cur_recv;
1683 next_recv_addr = q->cur_recv + msg_size;
1684 if (next_recv_addr == q->buf_tail)
1685 next_recv_addr = q->buf_head;
1686 }
1687
1688 if (msg_size > (q->buf_tail - q->buf_head))
1689 return -EPERM;
1690
1691 *m = kmalloc(msg_size, GFP_KERNEL);
1692 if (!*m)
1693 return -ENOMEM;
1694 err = rk1608_safe_read(rk1608, spi, recv_addr, (s32 *)*m, msg_size);
1695 if (err == 0) {
1696 err = rk1608_safe_write(rk1608, spi, RK1608_S_MSG_QUEUE_ADDR +
1697 (u8 *)&q->cur_recv - (u8 *)q,
1698 &next_recv_addr, 4);
1699 }
1700 if (err) {
1701 kfree(*m);
1702 *m = NULL;
1703 }
1704
1705 return err;
1706 }
1707
1708 /**
1709 * rk1608_msq_tail_free_size - get msg queue tail unused buf size
1710 *
1711 * @q: msg queue
1712 *
1713 * It returns size of msg queue tail unused buf size, unit byte
1714 */
rk1608_msq_tail_free_size(const struct rk1608_msg_queue * q)1715 static u32 rk1608_msq_tail_free_size(const struct rk1608_msg_queue *q)
1716 {
1717 if (q->cur_send >= q->cur_recv)
1718 return (q->buf_tail - q->cur_send);
1719
1720 return q->cur_recv - q->cur_send;
1721 }
1722
1723 /**
1724 * rk1608_interrupt_request - RK1608 request a dsp interrupt
1725 *
1726 * @spi: spi device
1727 * @interrupt_num: interrupt identification
1728 * Context: can sleep
1729 *
1730 * It returns zero on success, else a negative error code.
1731 */
rk1608_interrupt_request(struct spi_device * spi,s32 interrupt_num)1732 int rk1608_interrupt_request(struct spi_device *spi, s32 interrupt_num)
1733 {
1734 s32 write_reg1_cmd = APB_CMD_WRITE_REG1;
1735 struct spi_transfer write_reg1_cmd_packet = {
1736 .tx_buf = &write_reg1_cmd,
1737 .len = sizeof(write_reg1_cmd),
1738 };
1739 struct spi_transfer reg1_packet = {
1740 .tx_buf = &interrupt_num,
1741 .len = sizeof(interrupt_num),
1742 };
1743 struct spi_message m;
1744
1745 spi_message_init(&m);
1746 spi_message_add_tail(&write_reg1_cmd_packet, &m);
1747 spi_message_add_tail(®1_packet, &m);
1748
1749 return spi_sync(spi, &m);
1750 }
1751
1752 /**
1753 * dsp_msq_head_free_size - get msg queue head unused buf size
1754 *
1755 * @q: msg queue
1756 *
1757 * It returns size of msg queue head unused buf size, unit byte
1758 */
rk1608_msq_head_free_size(const struct rk1608_msg_queue * q)1759 static u32 rk1608_msq_head_free_size(const struct rk1608_msg_queue *q)
1760 {
1761 if (q->cur_send >= q->cur_recv)
1762 return (q->cur_recv - q->buf_head);
1763
1764 return 0;
1765 }
1766
1767 /*
1768 * rk1608_msq_send_msg - send a msg to Soc -> DSP msg queue
1769 *
1770 * @spi: spi device
1771 * @m: a msg to send
1772 *
1773 * It returns zero on success, else a negative error code.
1774 */
rk1608_msq_send_msg(struct rk1608_state * rk1608,struct spi_device * spi,struct msg * m)1775 int rk1608_msq_send_msg(struct rk1608_state *rk1608, struct spi_device *spi,
1776 struct msg *m)
1777 {
1778 int err = 0;
1779 s32 tmp = 0;
1780 struct rk1608_msg_queue queue;
1781 struct rk1608_msg_queue *q = &queue;
1782 u32 msg_size = m->size * sizeof(u32);
1783
1784 err = rk1608_msq_read_head(rk1608, spi, RK1608_R_MSG_QUEUE_ADDR, q);
1785 if (err)
1786 return err;
1787
1788 if (rk1608_msq_tail_free_size(q) > msg_size) {
1789 u32 next_send;
1790
1791 err = rk1608_safe_write(rk1608, spi, q->cur_send,
1792 (s32 *)m, msg_size);
1793 next_send = q->cur_send + msg_size;
1794 if (next_send == q->buf_tail)
1795 next_send = q->buf_head;
1796 q->cur_send = next_send;
1797 } else if (rk1608_msq_head_free_size(q) > msg_size) {
1798 /* Set size to 0 for skip to head mark */
1799 err = rk1608_safe_write(rk1608, spi, q->cur_send, &tmp, 4);
1800 if (err)
1801 return err;
1802 err = rk1608_safe_write(rk1608, spi, q->buf_head, (s32 *)m,
1803 msg_size);
1804 q->cur_send = q->buf_head + msg_size;
1805 } else {
1806 return -EPERM;
1807 }
1808
1809 if (err)
1810 return err;
1811
1812 err = rk1608_safe_write(rk1608, spi, RK1608_R_MSG_QUEUE_ADDR +
1813 (u8 *)&q->cur_send - (u8 *)q, &q->cur_send, 4);
1814 rk1608_interrupt_request(spi, RK1608_IRQ_TYPE_MSG);
1815
1816 return err;
1817 }
1818
rk1608_send_msg_to_dsp(struct rk1608_state * pdata,struct msg * m)1819 int rk1608_send_msg_to_dsp(struct rk1608_state *pdata, struct msg *m)
1820 {
1821 int ret, msg_num = 0, timeout = 0;
1822
1823 /* For msg sync */
1824 if (pdata->msg_num >= 8) {
1825 dev_err(pdata->dev, "MSG sync queue full\n!");
1826 return -EINVAL;
1827 } else if (m->mux.sync == 1) {
1828 mutex_lock(&pdata->send_msg_lock);
1829 msg_num = pdata->msg_num;
1830 pdata->msg_done[pdata->msg_num++] = 0;
1831 mutex_unlock(&pdata->send_msg_lock);
1832 }
1833
1834 mutex_lock(&pdata->send_msg_lock);
1835 ret = rk1608_msq_send_msg(pdata, pdata->spi, m);
1836 mutex_unlock(&pdata->send_msg_lock);
1837
1838 /* For msg sync */
1839 if (m->mux.sync == 1) {
1840 timeout = wait_event_timeout(pdata->msg_wait,
1841 pdata->msg_done[msg_num],
1842 MSG_SYNC_TIMEOUT);
1843 if (unlikely(timeout <= 0)) {
1844 dev_info(pdata->dev,
1845 "MSG wait timeout %d msg_num:%d\n",
1846 timeout, pdata->msg_num);
1847 mutex_lock(&pdata->send_msg_lock);
1848 pdata->msg_done[msg_num] = 0;
1849 mutex_unlock(&pdata->send_msg_lock);
1850 }
1851 }
1852
1853 return ret;
1854 }
1855
rk1608_print_rk1608_log(struct rk1608_state * pdata,struct msg * log)1856 static void rk1608_print_rk1608_log(struct rk1608_state *pdata,
1857 struct msg *log)
1858 {
1859 char *str = (char *)(log);
1860
1861 str[log->size * sizeof(s32) - 1] = 0;
1862 str += sizeof(struct msg);
1863 dev_info(pdata->dev, "DSP(%d): %s", log->id.core_id, str);
1864 }
1865
preisp_file_import_part(struct rk1608_state * pdata,struct msg * msg)1866 static int preisp_file_import_part(struct rk1608_state *pdata, struct msg *msg)
1867 {
1868 struct file *fp;
1869 int ret = -1;
1870 loff_t pos = 0;
1871 unsigned int file_size = 0;
1872 unsigned int write_size = 0;
1873 char *file_data = NULL;
1874 struct msg_xfile *xfile;
1875 struct calib_head *head = NULL;
1876 char *name;
1877 u32 crc_val;
1878 int i;
1879
1880 xfile = (struct msg_xfile *)msg;
1881 fp = filp_open(REF_DATA_PATH, O_RDONLY, 0);
1882 if (IS_ERR(fp)) {
1883 pr_err("open %s error\n", REF_DATA_PATH);
1884 return -EFAULT;
1885 }
1886
1887 head = vmalloc(sizeof(struct calib_head));
1888 if (!head) {
1889 ret = -ENOMEM;
1890 goto err;
1891 }
1892
1893 pos = 0;
1894 ret = kernel_read(fp, (char *)head, sizeof(struct calib_head), &pos);
1895 if (ret <= 0)
1896 pr_err("%s: read error: ret=%d\n", __func__, ret);
1897
1898 if (strncmp(head->magic, PREISP_CALIB_MAGIC, sizeof(head->magic))) {
1899 pr_err("%s: magic(%s) is unmatch\n", __func__, head->magic);
1900 goto err;
1901 }
1902
1903 name = strrchr(xfile->path, '/');
1904 if (!name)
1905 goto err;
1906
1907 name += 1;
1908 for (i = 0; i < head->items_number; i++) {
1909 if (!strncmp(head->item[i].name, name, sizeof(head->item[i].name)))
1910 break;
1911 }
1912
1913 if (i >= head->items_number) {
1914 pr_err("%s: cannot find %s\n", __func__, name);
1915 goto err;
1916 }
1917
1918 file_size = head->item[i].size;
1919 /* file_size = align4(file_size); */
1920
1921 pr_info("start import addr:0x%x size:%d to %s\n", xfile->addr, file_size, xfile->path);
1922
1923 file_data = vmalloc(file_size);
1924 if (!file_data) {
1925 ret = -ENOMEM;
1926 goto err;
1927 }
1928
1929 pos = head->item[i].offset;
1930 ret = kernel_read(fp, file_data, head->item[i].size, &pos);
1931 if (ret <= 0) {
1932 pr_err("%s: read error: ret=%d\n", __func__, ret);
1933 goto err;
1934 }
1935
1936 crc_val = crc32_le(~0, file_data, head->item[i].size);
1937 crc_val = ~crc_val;
1938 if (crc_val != head->item[i].crc32) {
1939 pr_err("%s: crc check error: 0x%x, 0x%x\n", __func__,
1940 crc_val, head->item[i].crc32);
1941 goto err;
1942 }
1943
1944 write_size = (file_size <= xfile->data_size)?file_size:xfile->data_size;
1945 if (file_size != xfile->data_size)
1946 pr_err("%s import size:%d != file size:%d, write size:%d\n",
1947 __func__, xfile->data_size, file_size, write_size);
1948
1949 ret = rk1608_safe_write(pdata, pdata->spi, xfile->addr, (s32 *)file_data, write_size);
1950 if (ret) {
1951 pr_err("%s: spi2apb write addr 0x%x size %d failed\n",
1952 __func__, xfile->addr, file_size);
1953 goto err;
1954 }
1955
1956 xfile->data_size = file_size;
1957 xfile->ret = ret;
1958 rk1608_msq_send_msg(pdata, pdata->spi, (struct msg *)xfile);
1959
1960 pr_info("import %s to preisp addr:0x%x size:%d success!\n",
1961 xfile->path, xfile->addr, file_size);
1962
1963 err:
1964 if (file_data)
1965 vfree(file_data);
1966 if (fp)
1967 filp_close(fp, NULL);
1968 if (head)
1969 vfree(head);
1970
1971 return ret;
1972 }
1973
preisp_file_import_data(struct rk1608_state * pdata,struct msg * msg)1974 static int preisp_file_import_data(struct rk1608_state *pdata, struct msg *msg)
1975 {
1976 struct file *fp;
1977 int ret = -1;
1978 loff_t pos = 0;
1979 unsigned int file_size = 0;
1980 unsigned int write_size = 0;
1981 char *file_data = NULL;
1982 struct msg_xfile *xfile;
1983
1984 char *ref_data_path = REF_DATA_PATH;
1985 char *file_path = NULL;
1986
1987 xfile = (struct msg_xfile *)msg;
1988
1989 if (!strncmp(xfile->path, "ref_data.img", sizeof("ref_data.img") - 1))
1990 file_path = ref_data_path;
1991 else
1992 file_path = xfile->path;
1993
1994 fp = filp_open(file_path, O_RDONLY, 0766);
1995 if (IS_ERR(fp)) {
1996 dev_err(pdata->dev, "open import file(%s) error\n", file_path);
1997 return -EFAULT;
1998 }
1999
2000 dev_info(pdata->dev, "start import %s to addr:0x%x size:%d\n",
2001 file_path, xfile->addr, xfile->data_size);
2002
2003 file_data = vmalloc(xfile->data_size);
2004 if (!file_data) {
2005 ret = -ENOMEM;
2006 goto err;
2007 }
2008
2009 file_size = kernel_read(fp, file_data, xfile->data_size, &pos);
2010 if (file_size <= 0) {
2011 dev_err(pdata->dev, "%s: read error: ret=%d\n",
2012 __func__, ret);
2013 goto err;
2014 }
2015
2016 write_size = (file_size <= xfile->data_size)?file_size:xfile->data_size;
2017 if (file_size != xfile->data_size)
2018 dev_err(pdata->dev,
2019 "%s import size:%d != file size:%d, write size:%d\n",
2020 __func__, xfile->data_size, file_size, write_size);
2021
2022 ret = rk1608_safe_write(pdata, pdata->spi, xfile->addr, (s32 *)file_data, write_size);
2023 if (ret) {
2024 dev_err(pdata->dev,
2025 "%s: spi2apb write addr 0x%x size %d failed\n",
2026 __func__, xfile->addr, file_size);
2027 goto err;
2028 }
2029
2030 xfile->data_size = file_size;
2031 xfile->ret = ret;
2032 rk1608_msq_send_msg(pdata, pdata->spi, (struct msg *)xfile);
2033
2034 dev_info(pdata->dev, "import %s to preisp addr:0x%x size:%d success!\n",
2035 xfile->path, xfile->addr, file_size);
2036
2037 err:
2038 if (file_data)
2039 vfree(file_data);
2040 if (fp)
2041 filp_close(fp, NULL);
2042
2043 return ret;
2044 }
2045
rk1608_file_export(struct rk1608_state * pdata,struct msg * msg)2046 static int rk1608_file_export(struct rk1608_state *pdata, struct msg *msg)
2047 {
2048 struct file *fp;
2049 int ret = -1;
2050 loff_t pos = 0;
2051 unsigned int file_size = 0;
2052 char *file_data = NULL;
2053 struct msg_xfile *xfile;
2054
2055 char *ref_data_path = REF_DATA_PATH;
2056 char *file_path = NULL;
2057
2058 xfile = (struct msg_xfile *)msg;
2059
2060 if (!strncmp(xfile->path, "ref_data.img", sizeof("ref_data.img") - 1))
2061 file_path = ref_data_path;
2062 else
2063 file_path = xfile->path;
2064
2065 dev_info(pdata->dev, "start export addr:0x%x size:%d to %s\n",
2066 xfile->addr, xfile->data_size, file_path);
2067
2068 fp = filp_open(file_path, O_RDWR | O_CREAT, 0666);
2069 if (IS_ERR(fp)) {
2070 dev_err(pdata->dev, "%s open/create export file(%s) error\n",
2071 __func__, file_path);
2072 return -EFAULT;
2073 }
2074
2075 file_size = xfile->data_size;
2076 file_size = (file_size + 3)&(~3);
2077
2078 file_data = vmalloc(file_size);
2079 if (!file_data) {
2080 ret = -ENOMEM;
2081 goto err;
2082 }
2083
2084 ret = rk1608_safe_read(pdata, pdata->spi, xfile->addr, (s32 *)file_data, file_size);
2085 if (ret) {
2086 dev_err(pdata->dev,
2087 "%s: spi2apb read addr 0x%x size %d failed, ret:%d\n",
2088 __func__, xfile->addr, file_size, ret);
2089 goto err;
2090 }
2091
2092 ret = kernel_write(fp, file_data, file_size, &pos);
2093 if (ret <= 0) {
2094 dev_err(pdata->dev, "%s: read error: ret=%d\n",
2095 __func__, ret);
2096 }
2097
2098 xfile->data_size = file_size;
2099 xfile->ret = ret;
2100
2101 rk1608_msq_send_msg(pdata, pdata->spi, (struct msg *)xfile);
2102 dev_info(pdata->dev, "export %s to preisp addr:0x%x size:%d success!\n",
2103 xfile->path, xfile->addr, file_size);
2104
2105 err:
2106 if (file_data)
2107 vfree(file_data);
2108 if (fp)
2109 filp_close(fp, NULL);
2110
2111 return ret;
2112 }
2113
rk1608_file_import(struct rk1608_state * pdata,struct msg * msg)2114 static int rk1608_file_import(struct rk1608_state *pdata, struct msg *msg)
2115 {
2116 struct msg_xfile *xfile;
2117
2118 xfile = (struct msg_xfile *)msg;
2119
2120 if (!strncmp(xfile->path, "/dev", sizeof("/dev") - 1))
2121 return preisp_file_import_part(pdata, msg);
2122 else
2123 return preisp_file_import_data(pdata, msg);
2124 }
2125
2126 #if UPDATE_REF_DATA_FROM_EEPROM
rk1608_get_calib_version_temperature_sn(struct rk1608_state * pdata,struct msg_calib_temp ** calibdata)2127 static int rk1608_get_calib_version_temperature_sn(struct rk1608_state *pdata,
2128 struct msg_calib_temp **calibdata)
2129 {
2130 struct file *fp;
2131 int ret = -1;
2132 loff_t pos = 0;
2133 struct calib_head *head = NULL;
2134 int i;
2135 struct msg_calib_temp *calibdata_ = NULL;
2136 unsigned int msg_size;
2137
2138 fp = filp_open(REF_DATA_PATH, O_RDONLY, 0);
2139 if (IS_ERR(fp)) {
2140 dev_err(pdata->dev, "open %s error\n", REF_DATA_PATH);
2141 ret = -ENOMEM;
2142 goto file_err;
2143 }
2144
2145 head = vmalloc(sizeof(struct calib_head));
2146 if (!head) {
2147 ret = -ENOMEM;
2148 goto err;
2149 }
2150
2151 pos = 0;
2152 ret = kernel_read(fp, (char *)head, sizeof(*head), &pos);
2153 if (ret <= 0)
2154 dev_err(pdata->dev, "%s: read error: ret=%d\n", __func__, ret);
2155
2156 if (strncmp(head->magic, PREISP_CALIB_MAGIC, sizeof(head->magic))) {
2157 dev_err(pdata->dev, "%s: magic(%s) is unmatch\n", __func__, head->magic);
2158 goto err;
2159 }
2160
2161 dev_info(pdata->dev,
2162 "version: 0x%x, head_size: 0x%x, image_size: 0x%x, items_number: 0x%x, hash_len: 0x%x, sign_len: 0x%x\n",
2163 head->version,
2164 head->head_size,
2165 head->image_size,
2166 head->items_number,
2167 head->hash_len,
2168 head->sign_len);
2169
2170 for (i = 0; i < head->items_number; i++) {
2171 dev_info(pdata->dev, "item[%d]: %s, 0x%08x, 0x%08x, 0x%08x, 0x%08x\n",
2172 i,
2173 head->item[i].name,
2174 head->item[i].offset,
2175 head->item[i].size,
2176 head->item[i].temp,
2177 head->item[i].crc32);
2178 }
2179
2180 for (i = 0; i < head->items_number; i++) {
2181 if (!strncmp(head->item[i].name, "sn_code", strlen("sn_code")))
2182 break;
2183 }
2184 if (i >= head->items_number) {
2185 dev_err(pdata->dev, "%s: cannot find %s\n", __func__, "sn_code");
2186 goto err;
2187 }
2188
2189 if (head->item[i].size > sizeof(calibdata_->calib_sn_code)) {
2190 dev_err(pdata->dev, "%s: %s size:%d error!\n",
2191 __func__, head->item[i].name, head->item[i].size);
2192 goto err;
2193 }
2194
2195 msg_size = sizeof(struct msg_calib_temp) + head->item[i].size;
2196 msg_size = (msg_size + 3)&(~0x03);
2197 calibdata_ = vmalloc(msg_size);
2198 if (!calibdata_) {
2199 ret = -ENOMEM;
2200 goto err;
2201 }
2202 memset((char *)calibdata_, 0, msg_size);
2203
2204 pos = head->item[i].offset;
2205
2206 ret = kernel_read(fp, (char *)calibdata_->calib_sn_code, head->item[i].size, &pos);
2207 if (ret <= 0) {
2208 dev_err(pdata->dev, "%s: read error: ret=%d\n", __func__, ret);
2209 goto err;
2210 }
2211
2212 calibdata_->size = msg_size>>2;
2213 calibdata_->calib_version = head->version;
2214 calibdata_->temp = head->item[i].temp;
2215 calibdata_->calib_sn_size = head->item[i].size;
2216 calibdata_->calib_sn_offset = head->item[i].offset;
2217 calibdata_->calib_exist = 1;
2218
2219 dev_info(pdata->dev, "version:%#x, temp:%#x, name:%s, size:%d sn_code:%s\n",
2220 head->version,
2221 head->item[i].temp,
2222 head->item[i].name,
2223 head->item[i].size,
2224 (char *)&calibdata_->calib_sn_code);
2225
2226 err:
2227 *calibdata = calibdata_;
2228
2229 if (fp)
2230 filp_close(fp, NULL);
2231 if (head)
2232 vfree(head);
2233
2234 if (calibdata_ != NULL)
2235 return ret;
2236
2237 file_err:
2238 msg_size = sizeof(struct msg_calib_temp);
2239 calibdata_ = vmalloc(msg_size);
2240 if (!calibdata_) {
2241 ret = -ENOMEM;
2242 *calibdata = NULL;
2243 return ret;
2244 }
2245
2246 memset((char *)calibdata_, 0, msg_size);
2247 calibdata_->size = msg_size>>2;
2248 *calibdata = calibdata_;
2249
2250 return ret;
2251 }
2252
rk1608_send_calib_version_temperature(struct rk1608_state * pdata,struct msg * msg)2253 static int rk1608_send_calib_version_temperature(struct rk1608_state *pdata, struct msg *msg)
2254 {
2255 int ret = 0;
2256 struct msg_calib_temp *calibdata = NULL;
2257
2258 rk1608_get_calib_version_temperature_sn(pdata, &calibdata);
2259
2260 if (calibdata == NULL) {
2261 dev_err(pdata->dev, "%s error\n", __func__);
2262 return -1;
2263 }
2264
2265 calibdata->type = id_msg_calib_temperature_t;
2266 calibdata->camera_id = msg->id.camera_id;
2267
2268 mutex_lock(&pdata->send_msg_lock);
2269 ret = rk1608_msq_send_msg(pdata, pdata->spi, (struct msg *)calibdata);
2270 mutex_unlock(&pdata->send_msg_lock);
2271
2272 if (calibdata)
2273 vfree(calibdata);
2274
2275 return ret;
2276 }
2277 #else
rk1608_get_calib_version_temperature(u32 * version,u32 * temp)2278 static int rk1608_get_calib_version_temperature(u32 *version, u32 *temp)
2279 {
2280 struct file *fp;
2281 int ret = -1;
2282 loff_t pos = 0;
2283 struct calib_head *head = NULL;
2284 int i;
2285
2286 fp = filp_open(REF_DATA_PATH, O_RDONLY, 0);
2287 if (IS_ERR(fp)) {
2288 pr_err("open %s error\n", REF_DATA_PATH);
2289 return -1;
2290 }
2291
2292 head = vmalloc(sizeof(struct calib_head));
2293 if (!head) {
2294 ret = -ENOMEM;
2295 goto err;
2296 }
2297
2298 pos = 0;
2299 ret = kernel_read(fp, (char *)head, sizeof(*head), &pos);
2300 if (ret <= 0)
2301 pr_err("%s: read error: ret=%d\n", __func__, ret);
2302
2303 if (strncmp(head->magic, PREISP_CALIB_MAGIC, sizeof(head->magic))) {
2304 pr_err("%s: magic(%s) is unmatch\n", __func__, head->magic);
2305 goto err;
2306 }
2307
2308 pr_info("%s: version: 0x%x, head_size: 0x%x, image_size: 0x%x, items_number: 0x%x, hash_len: 0x%x, sign_len: 0x%x\n",
2309 __func__,
2310 head->version,
2311 head->head_size,
2312 head->image_size,
2313 head->items_number,
2314 head->hash_len,
2315 head->sign_len);
2316
2317 for (i = 0; i < head->items_number; i++) {
2318 pr_info("%s: item[%d]: %s, 0x%08x, 0x%08x, 0x%08x, 0x%08x\n",
2319 __func__, i,
2320 head->item[i].name,
2321 head->item[i].offset,
2322 head->item[i].size,
2323 head->item[i].temp,
2324 head->item[i].crc32);
2325 }
2326
2327 *version = head->version;
2328 for (i = 0; i < head->items_number; i++) {
2329 if (!strncmp(head->item[i].name, "ref1bit.bin", sizeof(head->item[i].name)))
2330 break;
2331 }
2332 if (i >= head->items_number) {
2333 pr_err("%s: cannot find %s\n", __func__, "ref1bit.bin");
2334 goto err;
2335 }
2336
2337 *temp = head->item[i].temp;
2338
2339 err:
2340 if (fp)
2341 filp_close(fp, NULL);
2342 if (head)
2343 vfree(head);
2344
2345 return ret;
2346 }
2347
rk1608_send_calib_version_temperature(struct rk1608_state * pdata,struct msg * msg)2348 static int rk1608_send_calib_version_temperature(struct rk1608_state *pdata, struct msg *msg)
2349 {
2350 struct msg_calib_temp m;
2351 int ret = 0;
2352
2353 m.type = id_msg_calib_temperature_t;
2354 m.size = sizeof(struct msg_calib_temp) / 4;
2355 m.camera_id = msg->id.camera_id;
2356 rk1608_get_calib_version_temperature(&m.calib_version, &m.temp);
2357 mutex_lock(&pdata->send_msg_lock);
2358 ret = rk1608_msq_send_msg(pdata, pdata->spi, (struct msg *)&m);
2359 mutex_unlock(&pdata->send_msg_lock);
2360
2361 return ret;
2362 }
2363 #endif
2364
rk1608_dispatch_received_msg(struct rk1608_state * pdata,struct msg * msg)2365 static void rk1608_dispatch_received_msg(struct rk1608_state *pdata,
2366 struct msg *msg)
2367 {
2368 if (msg->type == id_msg_set_stream_out_on_ret_t) {
2369 mutex_lock(&pdata->sensor_lock);
2370 pdata->sensor_cnt++;
2371 mutex_unlock(&pdata->sensor_lock);
2372 }
2373
2374 if (msg->type == id_msg_rk1608_log_t)
2375 rk1608_print_rk1608_log(pdata, msg);
2376 else if (msg->type == id_msg_xfile_import_t)
2377 rk1608_file_import(pdata, msg);
2378 else if (msg->type == id_msg_xfile_export_t)
2379 rk1608_file_export(pdata, msg);
2380 else if (msg->type == id_msg_calib_temperature_req_t)
2381 rk1608_send_calib_version_temperature(pdata, msg);
2382 else
2383 rk1608_dev_receive_msg(pdata, msg);
2384 }
2385
2386 #define PREISP_DCROP_ITEM_NAME "calib_data.bin"
2387 #define PREISP_DCROP_CALIB_RATIO 192
2388 #define PREISP_DCROP_CALIB_XOFFSET 196
2389 #define PREISP_DCROP_CALIB_YOFFSET 198
rk1608_get_dcrop_cfg(struct v4l2_rect * crop_in,struct v4l2_rect * crop_out)2390 int rk1608_get_dcrop_cfg(struct v4l2_rect *crop_in,
2391 struct v4l2_rect *crop_out)
2392 {
2393 struct file *fp;
2394 int ret = 0;
2395 loff_t pos = 0;
2396 unsigned int file_size = 0;
2397 char *file_data = NULL;
2398 struct calib_head *head = NULL;
2399 short xoffset, yoffset;
2400 int left, top, width, height, temp;
2401 int ratio;
2402 int i;
2403
2404 fp = filp_open("/data/ref_data.img", O_RDONLY, 0);
2405 if (IS_ERR(fp)) {
2406 pr_err("%s: open /data/ref_data.img error\n", __func__);
2407 return -1;
2408 }
2409
2410 head = vmalloc(sizeof(struct calib_head));
2411 if (!head) {
2412 ret = -ENOMEM;
2413 goto err;
2414 }
2415
2416 pos = 0;
2417 ret = kernel_read(fp, (char *)head, sizeof(*head), &pos);
2418 if (ret <= 0) {
2419 ret = -EFAULT;
2420 pr_err("%s: read error: ret=%d\n", __func__, ret);
2421 goto err;
2422 }
2423
2424 if (strncmp(head->magic, PREISP_CALIB_MAGIC, sizeof(head->magic))) {
2425 ret = -EFAULT;
2426 pr_err("%s: magic(%s) is unmatch\n", __func__, head->magic);
2427 goto err;
2428 }
2429
2430 for (i = 0; i < head->items_number; i++) {
2431 if (!strncmp(head->item[i].name, PREISP_DCROP_ITEM_NAME,
2432 strlen(PREISP_DCROP_ITEM_NAME)))
2433 break;
2434 }
2435
2436 if (i >= head->items_number) {
2437 ret = -EFAULT;
2438 pr_err("%s: cannot find %s\n", __func__, PREISP_DCROP_ITEM_NAME);
2439 goto err;
2440 }
2441
2442 file_size = head->item[i].size;
2443 if (file_size < (PREISP_DCROP_CALIB_YOFFSET + 2)) {
2444 ret = -EFAULT;
2445 pr_err("%s: file_size is not correct:%d\n", __func__, file_size);
2446 goto err;
2447 }
2448
2449 file_data = vmalloc(file_size);
2450 if (!file_data) {
2451 ret = -ENOMEM;
2452 pr_err("%s: no memory\n", __func__);
2453 goto err;
2454 }
2455
2456 pos = head->item[i].offset;
2457 ret = kernel_read(fp, file_data, head->item[i].size, &pos);
2458 if (ret <= 0) {
2459 ret = -EFAULT;
2460 pr_err("%s: read error: ret=%d\n", __func__, ret);
2461 goto err;
2462 }
2463
2464 ratio = *(int *)(file_data + PREISP_DCROP_CALIB_RATIO);
2465 xoffset = *(short *)(file_data + PREISP_DCROP_CALIB_XOFFSET);
2466 yoffset = *(short *)(file_data + PREISP_DCROP_CALIB_YOFFSET);
2467 pr_info("%s: item %s: file_size %d, ratio 0x%x, xoffset %d, yoffset %d\n",
2468 __func__, head->item[i].name, file_size, ratio, xoffset, yoffset);
2469 if (ratio > 0x10000 || ratio == 0) {
2470 ret = -EFAULT;
2471 goto err;
2472 }
2473
2474 temp = xoffset * crop_in->width;
2475 temp = temp / 2592 / 16;
2476 left = (0x10000 - ratio) * crop_in->width / 0x10000 / 2 + temp;
2477 top = (0x10000 - ratio) * crop_in->height / 0x10000 / 2;
2478 width = crop_in->width * ratio / 0x10000;
2479 height = crop_in->height * ratio / 0x10000;
2480 width = (width + 1) & 0xFFFFFFFE;
2481 height = (height + 1) & 0xFFFFFFFE;
2482 pr_info("%s: calculate left %d, top %d, width %d, height %d, crop_in %d, %d\n",
2483 __func__, left, top, width, height, crop_in->width, crop_in->height);
2484
2485 if ((left + width) > crop_in->width ||
2486 (top + height) > crop_in->height ||
2487 left < 0 || top < 0) {
2488 ret = -EFAULT;
2489 goto err;
2490 }
2491
2492 ret = 0;
2493 crop_out->left = left;
2494 crop_out->top = top;
2495 crop_out->width = width;
2496 crop_out->height = height;
2497 pr_info("%s: DEFRECT %d, %d, %d, %d\n",
2498 __func__, crop_out->left, crop_out->top, crop_out->width, crop_out->height);
2499
2500 err:
2501 if (file_data)
2502 vfree(file_data);
2503 if (fp)
2504 filp_close(fp, NULL);
2505 if (head)
2506 vfree(head);
2507
2508 return ret;
2509 }
2510 EXPORT_SYMBOL(rk1608_get_dcrop_cfg);
2511
rk1608_threaded_isr(int irq,void * ctx)2512 static irqreturn_t rk1608_threaded_isr(int irq, void *ctx)
2513 {
2514 struct rk1608_state *pdata = ctx;
2515 struct msg *msg;
2516
2517 while (!rk1608_msq_recv_msg(pdata, pdata->spi, &msg) && NULL != msg) {
2518 rk1608_dispatch_received_msg(pdata, msg);
2519 /* For kernel msg sync */
2520 if (msg->type >= id_msg_init_sensor_ret_t &&
2521 msg->type <= id_msg_set_stream_out_off_ret_t) {
2522 dev_info(pdata->dev, "RK1608 kernel sync\n");
2523 mutex_lock(&pdata->send_msg_lock);
2524 pdata->msg_num--;
2525 pdata->msg_done[pdata->msg_num] = 1;
2526 mutex_unlock(&pdata->send_msg_lock);
2527 wake_up(&pdata->msg_wait);
2528 }
2529 kfree(msg);
2530 }
2531
2532 return IRQ_HANDLED;
2533 }
2534
rk1608_parse_dt_property(struct rk1608_state * pdata)2535 static int rk1608_parse_dt_property(struct rk1608_state *pdata)
2536 {
2537 int i, ret = 0;
2538 struct device *dev = pdata->dev;
2539 struct device_node *node = dev->of_node;
2540
2541 if (!node)
2542 return -ENODEV;
2543
2544 of_property_read_u32(node, "spi-max-frequency",
2545 &pdata->max_speed_hz);
2546 if (ret) {
2547 dev_err(dev, "can not get spi-max-frequency!");
2548 return -ENOENT;
2549 }
2550
2551 ret = of_property_read_u32(node, "spi-min-frequency",
2552 &pdata->min_speed_hz);
2553 if (ret) {
2554 dev_warn(dev, "can not get spi-min-frequency!");
2555 pdata->min_speed_hz = pdata->max_speed_hz / 2;
2556 }
2557
2558 ret = of_property_read_string(node, "firmware-names",
2559 &pdata->firm_name);
2560 if (ret) {
2561 dev_warn(dev, "can not get firmware-names!");
2562 pdata->firm_name = NULL;
2563 }
2564
2565 pdata->pwren_gpio = devm_gpiod_get_optional(dev, "pwren",
2566 GPIOD_OUT_HIGH);
2567 if (IS_ERR(pdata->pwren_gpio)) {
2568 dev_err(dev, "can not find pwren_gpio\n");
2569 return PTR_ERR(pdata->pwren_gpio);
2570 }
2571
2572 pdata->reset_gpio = devm_gpiod_get_optional(dev, "reset",
2573 GPIOD_OUT_LOW);
2574 if (IS_ERR(pdata->reset_gpio)) {
2575 dev_err(dev, "can not find reset-gpio\n");
2576 return PTR_ERR(pdata->reset_gpio);
2577 }
2578
2579 pdata->irq = -1;
2580 pdata->irq_gpio = devm_gpiod_get(dev, "irq", GPIOD_IN);
2581 if (IS_ERR(pdata->irq_gpio)) {
2582 dev_err(dev, "can not find irq-gpio\n");
2583 return -ENOENT;
2584 }
2585
2586 pdata->wakeup_gpio = devm_gpiod_get_optional(dev, "wakeup",
2587 GPIOD_OUT_LOW);
2588 if (IS_ERR(pdata->wakeup_gpio)) {
2589 dev_err(dev, "can not find wakeup_gpio\n");
2590 return PTR_ERR(pdata->wakeup_gpio);
2591 }
2592
2593 pdata->aesync_gpio = devm_gpiod_get_optional(dev, "aesync",
2594 GPIOD_OUT_LOW);
2595 if (IS_ERR(pdata->aesync_gpio)) {
2596 dev_err(dev, "can not find aesync_gpio\n");
2597 return PTR_ERR(pdata->aesync_gpio);
2598 }
2599
2600 pdata->mclk = devm_clk_get(dev, "mclk");
2601 if (IS_ERR(pdata->mclk))
2602 dev_warn(dev, "Failed to get mclk, do you use ext 24M clk?\n");
2603
2604 pdata->msg_num = 0;
2605 init_waitqueue_head(&pdata->msg_wait);
2606 for (i = 0; i < 8; i++)
2607 pdata->msg_done[i] = 0;
2608
2609 return ret;
2610 }
2611
rk1608_get_remote_node_dev(struct rk1608_state * pdev)2612 static int rk1608_get_remote_node_dev(struct rk1608_state *pdev)
2613 {
2614 struct i2c_client *sensor_pdev = NULL;
2615 struct platform_device *dphydev = NULL;
2616 struct device *dev = pdev->dev;
2617 struct device_node *parent = dev->of_node;
2618 struct device_node *remote = NULL;
2619 int ret = 0, dphys = 0, sensor_nums = 0;
2620 int i;
2621
2622 for (i = 0; i < 2; i++) {
2623 remote = of_graph_get_remote_node(parent, 0, i);
2624 if (!remote)
2625 continue;
2626
2627 dphydev = of_find_device_by_node(remote);
2628 of_node_put(remote);
2629 if (!dphydev) {
2630 dev_err(dev, "Failed to get dhpy device(%s)\n",
2631 of_node_full_name(remote));
2632 continue;
2633 } else {
2634 pdev->dphy[dphys] = platform_get_drvdata(dphydev);
2635 if (pdev->dphy[dphys]) {
2636 dphydev = NULL;
2637 pdev->dphy[dphys]->rk1608_sd = &pdev->sd;
2638 pdev->sensor_nums[dphys] =
2639 pdev->dphy[dphys]->cam_nums;
2640 dphys++;
2641 } else {
2642 dev_err(dev, "Failed to get dhpy drvdata\n");
2643 }
2644 }
2645 }
2646
2647 for (i = 0; i < 4; i++) {
2648 remote = of_graph_get_remote_node(parent, 1, i);
2649 if (!remote)
2650 continue;
2651
2652 sensor_pdev = of_find_i2c_device_by_node(remote);
2653 of_node_put(remote);
2654 if (!sensor_pdev) {
2655 dev_err(dev, "Failed to get sensor device(%s)\n",
2656 of_node_full_name(remote));
2657 continue;
2658 } else {
2659 pdev->sensor[sensor_nums] =
2660 i2c_get_clientdata(sensor_pdev);
2661 if (pdev->sensor[sensor_nums]) {
2662 sensor_pdev = NULL;
2663 sensor_nums++;
2664 } else {
2665 dev_err(dev, "Failed to get sensor drvdata\n");
2666 }
2667 }
2668 }
2669
2670 if (dphys && sensor_nums)
2671 dev_info(dev, "Get %d dphys, %d sensors!\n",
2672 dphys, sensor_nums);
2673 else
2674 ret = -EINVAL;
2675
2676 return ret;
2677 }
2678
rk1608_probe(struct spi_device * spi)2679 static int rk1608_probe(struct spi_device *spi)
2680 {
2681 struct rk1608_state *rk1608;
2682 struct v4l2_subdev *sd;
2683 int ret = 0;
2684
2685 dev_info(&spi->dev, "driver version: %02x.%02x.%02x",
2686 RK1608_VERSION >> 16,
2687 (RK1608_VERSION & 0xff00) >> 8,
2688 RK1608_VERSION & 0x00ff);
2689
2690 rk1608 = devm_kzalloc(&spi->dev, sizeof(*rk1608), GFP_KERNEL);
2691 if (!rk1608)
2692 return -ENOMEM;
2693 rk1608->dev = &spi->dev;
2694 rk1608->spi = spi;
2695 rk1608->log_level = LOG_INFO;
2696 spi_set_drvdata(spi, rk1608);
2697
2698 ret = rk1608_parse_dt_property(rk1608);
2699 if (ret) {
2700 dev_err(rk1608->dev, "RK1608 parse dt property err %x\n", ret);
2701 return ret;
2702 }
2703
2704 ret = rk1608_get_remote_node_dev(rk1608);
2705 if (ret)
2706 dev_info(rk1608->dev, "remote node dev is NULL\n");
2707
2708 rk1608->sensor_cnt = 0;
2709 mutex_init(&rk1608->sensor_lock);
2710 mutex_init(&rk1608->send_msg_lock);
2711 mutex_init(&rk1608->lock);
2712 mutex_init(&rk1608->spi2apb_lock);
2713 spin_lock_init(&rk1608->hdrae_lock);
2714 sd = &rk1608->sd;
2715
2716 rk1608_initialize_controls(rk1608);
2717 v4l2_spi_subdev_init(sd, spi, &rk1608_subdev_ops);
2718
2719 if (!IS_ERR(rk1608->irq_gpio)) {
2720 rk1608->irq = gpiod_to_irq(rk1608->irq_gpio);
2721 ret = devm_request_threaded_irq(
2722 rk1608->dev,
2723 rk1608->irq,
2724 NULL,
2725 rk1608_threaded_isr,
2726 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
2727 "msg-irq",
2728 rk1608);
2729 if (ret) {
2730 dev_err(rk1608->dev,
2731 "cannot request thread irq: %d\n", ret);
2732 v4l2_ctrl_handler_free(&rk1608->ctrl_handler);
2733 return ret;
2734 }
2735 disable_irq(rk1608->irq);
2736 }
2737
2738 rk1608_dev_register(rk1608);
2739
2740 return 0;
2741 }
2742
rk1608_remove(struct spi_device * spi)2743 static int rk1608_remove(struct spi_device *spi)
2744 {
2745 struct rk1608_state *rk1608 = spi_get_drvdata(spi);
2746
2747 v4l2_ctrl_handler_free(&rk1608->ctrl_handler);
2748 mutex_destroy(&rk1608->lock);
2749 mutex_destroy(&rk1608->send_msg_lock);
2750 mutex_destroy(&rk1608->sensor_lock);
2751 mutex_destroy(&rk1608->spi2apb_lock);
2752 rk1608_dev_unregister(rk1608);
2753
2754 return 0;
2755 }
2756
2757 static const struct spi_device_id rk1608_id[] = {
2758 { "rk1608", 0 },
2759 { }
2760 };
2761 MODULE_DEVICE_TABLE(spi, rk1608_id);
2762
2763 #if IS_ENABLED(CONFIG_OF)
2764 static const struct of_device_id rk1608_of_match[] = {
2765 { .compatible = "rockchip,rk1608" },
2766 { /* sentinel */ },
2767 };
2768 MODULE_DEVICE_TABLE(of, rk1608_of_match);
2769 #endif
2770
2771 static struct spi_driver rk1608_driver = {
2772 .driver = {
2773 .of_match_table = of_match_ptr(rk1608_of_match),
2774 .name = "rk1608",
2775 },
2776 .probe = rk1608_probe,
2777 .remove = rk1608_remove,
2778 .id_table = rk1608_id,
2779 };
2780
preisp_mod_init(void)2781 static int __init preisp_mod_init(void)
2782 {
2783 return spi_register_driver(&rk1608_driver);
2784 }
2785
preisp_mod_exit(void)2786 static void __exit preisp_mod_exit(void)
2787 {
2788 spi_unregister_driver(&rk1608_driver);
2789 }
2790
2791 late_initcall(preisp_mod_init);
2792 module_exit(preisp_mod_exit);
2793
2794 MODULE_AUTHOR("Rockchip Camera/ISP team");
2795 MODULE_DESCRIPTION("A DSP driver for rk1608 chip");
2796 MODULE_LICENSE("GPL v2");
2797 MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
2798