1 // SPDX-License-Identifier: (GPL-2.0+ OR MIT)
2 /*
3 * Copyright (c) 2020 Rockchip Electronics Co., Ltd
4 *
5 * author:
6 * Alpha Lin, alpha.lin@rock-chips.com
7 * Ding Wei, leo.ding@rock-chips.com
8 *
9 */
10 #include <asm/cacheflush.h>
11 #include <linux/clk.h>
12 #include <linux/delay.h>
13 #include <linux/iopoll.h>
14 #include <linux/interrupt.h>
15 #include <linux/module.h>
16 #include <linux/types.h>
17 #include <linux/of_platform.h>
18 #include <linux/slab.h>
19 #include <linux/uaccess.h>
20 #include <linux/regmap.h>
21 #include <linux/proc_fs.h>
22 #include <soc/rockchip/pm_domains.h>
23
24 #include "mpp_debug.h"
25 #include "mpp_common.h"
26 #include "mpp_iommu.h"
27
28 #define JPGDEC_DRIVER_NAME "mpp_jpgdec"
29
30 #define JPGDEC_SESSION_MAX_BUFFERS 40
31 /* The maximum registers number of all the version */
32 #define JPGDEC_REG_NUM 42
33 #define JPGDEC_REG_HW_ID_INDEX 0
34 #define JPGDEC_REG_START_INDEX 0
35 #define JPGDEC_REG_END_INDEX 41
36
37 #define JPGDEC_GET_PROD_NUM(x) (((x) >> 16) & 0xffff)
38 #define JPGDEC_GET_SUPPORT_BIT(x) (((x) >> 8) & 0x1)
39
40 #define JPGDEC_REG_INT_EN_BASE 0x004
41 #define JPGDEC_REG_INT_EN_INDEX (1)
42
43 #define JPGDEC_CARE_STREAM_ERROR_EN BIT(16)
44 #define JPGDEC_EMPTY_FORCE_END BIT(15)
45 #define JPGDEC_SOFT_RSET_READY BIT(14)
46 #define JPGDEC_BUF_EMPTY_STA BIT(13)
47 #define JPGDEC_TIMEOUT_STA BIT(12)
48 #define JPGDEC_ERROR_STA BIT(11)
49 #define JPGDEC_BUS_STA BIT(10)
50 #define JPGDEC_REDAY_STA BIT(9)
51 #define JPGDEC_IRQ BIT(8)
52 #define JPGDEC_WAIT_RESET_EN BIT(7)
53 #define JPGDEC_IRQ_RAW BIT(6)
54 #define JPGDEC_SOFT_REST_EN BIT(5)
55 #define JPGDEC_BUF_EMPTY_RELOAD_EN BIT(4)
56 #define JPGDEC_BUF_EMPTY_EN BIT(3)
57 #define JPGDEC_TIMEOUT_EN BIT(2)
58 #define JPGDEC_IRQ_DIS BIT(1)
59 #define JPGDEC_START_EN BIT(0)
60
61 #define JPGDEC_REG_SYS_BASE 0x008
62 #define JPGDEC_FORCE_SOFTRESET_VALID BIT(17)
63
64 #define JPGDEC_REG_PIC_INFO_BASE 0x00c
65 #define JPGDEC_REG_PIC_INFO_INDEX (3)
66 #define JPGDEC_GET_WIDTH(x) (((x) & 0xffff) + 1)
67 #define JPGDEC_GET_HEIGHT(x) ((((x) >> 16) & 0xffff) + 1)
68
69 #define JPGDEC_REG_STREAM_RLC_BASE 0x030
70 #define JPGDEC_REG_STREAM_RLC_BASE_INDEX (12)
71
72 #define to_jpgdec_task(task) \
73 container_of(task, struct jpgdec_task, mpp_task)
74 #define to_jpgdec_dev(dev) \
75 container_of(dev, struct jpgdec_dev, mpp)
76
77 struct jpgdec_task {
78 struct mpp_task mpp_task;
79 enum MPP_CLOCK_MODE clk_mode;
80 u32 reg[JPGDEC_REG_NUM];
81
82 struct reg_offset_info off_inf;
83 u32 strm_addr;
84 u32 irq_status;
85 /* req for current task */
86 u32 w_req_cnt;
87 struct mpp_request w_reqs[MPP_MAX_MSG_NUM];
88 u32 r_req_cnt;
89 struct mpp_request r_reqs[MPP_MAX_MSG_NUM];
90 };
91
92 struct jpgdec_dev {
93 struct mpp_dev mpp;
94
95 struct mpp_clk_info aclk_info;
96 struct mpp_clk_info hclk_info;
97 #ifdef CONFIG_ROCKCHIP_MPP_PROC_FS
98 struct proc_dir_entry *procfs;
99 #endif
100 struct reset_control *rst_a;
101 struct reset_control *rst_h;
102 };
103
104 static struct mpp_hw_info jpgdec_v1_hw_info = {
105 .reg_num = JPGDEC_REG_NUM,
106 .reg_id = JPGDEC_REG_HW_ID_INDEX,
107 .reg_start = JPGDEC_REG_START_INDEX,
108 .reg_end = JPGDEC_REG_END_INDEX,
109 .reg_en = JPGDEC_REG_INT_EN_INDEX,
110 };
111
112 /*
113 * file handle translate information
114 */
115 static const u16 trans_tbl_jpgdec[] = {
116 9, 10, 11, 12, 13,
117 };
118
119 #define JPEGDEC_FMT_DEFAULT 0
120 static struct mpp_trans_info jpgdec_v1_trans[] = {
121 [JPEGDEC_FMT_DEFAULT] = {
122 .count = ARRAY_SIZE(trans_tbl_jpgdec),
123 .table = trans_tbl_jpgdec,
124 },
125 };
126
jpgdec_process_reg_fd(struct mpp_session * session,struct jpgdec_task * task,struct mpp_task_msgs * msgs)127 static int jpgdec_process_reg_fd(struct mpp_session *session,
128 struct jpgdec_task *task,
129 struct mpp_task_msgs *msgs)
130 {
131 int ret = 0;
132
133 ret = mpp_translate_reg_address(session, &task->mpp_task,
134 JPEGDEC_FMT_DEFAULT, task->reg, &task->off_inf);
135 if (ret)
136 return ret;
137
138 mpp_translate_reg_offset_info(&task->mpp_task,
139 &task->off_inf, task->reg);
140 return 0;
141 }
142
jpgdec_extract_task_msg(struct jpgdec_task * task,struct mpp_task_msgs * msgs)143 static int jpgdec_extract_task_msg(struct jpgdec_task *task,
144 struct mpp_task_msgs *msgs)
145 {
146 u32 i;
147 int ret;
148 struct mpp_request *req;
149 struct mpp_hw_info *hw_info = task->mpp_task.hw_info;
150
151 for (i = 0; i < msgs->req_cnt; i++) {
152 u32 off_s, off_e;
153
154 req = &msgs->reqs[i];
155 if (!req->size)
156 continue;
157
158 switch (req->cmd) {
159 case MPP_CMD_SET_REG_WRITE: {
160 off_s = hw_info->reg_start * sizeof(u32);
161 off_e = hw_info->reg_end * sizeof(u32);
162 ret = mpp_check_req(req, 0, sizeof(task->reg),
163 off_s, off_e);
164 if (ret)
165 continue;
166 if (copy_from_user((u8 *)task->reg + req->offset,
167 req->data, req->size)) {
168 mpp_err("copy_from_user reg failed\n");
169 return -EIO;
170 }
171 memcpy(&task->w_reqs[task->w_req_cnt++],
172 req, sizeof(*req));
173 } break;
174 case MPP_CMD_SET_REG_READ: {
175 off_s = hw_info->reg_start * sizeof(u32);
176 off_e = hw_info->reg_end * sizeof(u32);
177 ret = mpp_check_req(req, 0, sizeof(task->reg),
178 off_s, off_e);
179 if (ret)
180 continue;
181 memcpy(&task->r_reqs[task->r_req_cnt++],
182 req, sizeof(*req));
183 } break;
184 case MPP_CMD_SET_REG_ADDR_OFFSET: {
185 mpp_extract_reg_offset_info(&task->off_inf, req);
186 } break;
187 default:
188 break;
189 }
190 }
191 mpp_debug(DEBUG_TASK_INFO, "w_req_cnt %d, r_req_cnt %d\n",
192 task->w_req_cnt, task->r_req_cnt);
193
194 return 0;
195 }
196
jpgdec_alloc_task(struct mpp_session * session,struct mpp_task_msgs * msgs)197 static void *jpgdec_alloc_task(struct mpp_session *session,
198 struct mpp_task_msgs *msgs)
199 {
200 int ret;
201 struct mpp_task *mpp_task = NULL;
202 struct jpgdec_task *task = NULL;
203 struct mpp_dev *mpp = session->mpp;
204
205 mpp_debug_enter();
206
207 task = kzalloc(sizeof(*task), GFP_KERNEL);
208 if (!task)
209 return NULL;
210
211 mpp_task = &task->mpp_task;
212 mpp_task_init(session, mpp_task);
213 mpp_task->hw_info = mpp->var->hw_info;
214 mpp_task->reg = task->reg;
215 /* extract reqs for current task */
216 ret = jpgdec_extract_task_msg(task, msgs);
217 if (ret)
218 goto fail;
219 /* process fd in register */
220 if (!(msgs->flags & MPP_FLAGS_REG_FD_NO_TRANS)) {
221 ret = jpgdec_process_reg_fd(session, task, msgs);
222 if (ret)
223 goto fail;
224 }
225 task->strm_addr = task->reg[JPGDEC_REG_STREAM_RLC_BASE_INDEX];
226 task->clk_mode = CLK_MODE_NORMAL;
227
228 mpp_debug_leave();
229
230 return mpp_task;
231
232 fail:
233 mpp_task_dump_mem_region(mpp, mpp_task);
234 mpp_task_dump_reg(mpp, mpp_task);
235 mpp_task_finalize(session, mpp_task);
236 kfree(task);
237 return NULL;
238 }
239
jpgdec_soft_reset(struct mpp_dev * mpp)240 static int jpgdec_soft_reset(struct mpp_dev *mpp)
241 {
242 mpp_write(mpp, JPGDEC_REG_SYS_BASE, JPGDEC_FORCE_SOFTRESET_VALID);
243 mpp_write(mpp, JPGDEC_REG_INT_EN_BASE, JPGDEC_SOFT_REST_EN);
244
245 return 0;
246 }
247
jpgdec_run(struct mpp_dev * mpp,struct mpp_task * mpp_task)248 static int jpgdec_run(struct mpp_dev *mpp,
249 struct mpp_task *mpp_task)
250 {
251 u32 i;
252 u32 reg_en;
253 struct jpgdec_task *task = to_jpgdec_task(mpp_task);
254
255 mpp_debug_enter();
256
257 /* set registers for hardware */
258 reg_en = mpp_task->hw_info->reg_en;
259 for (i = 0; i < task->w_req_cnt; i++) {
260 struct mpp_request *req = &task->w_reqs[i];
261 int s = req->offset / sizeof(u32);
262 int e = s + req->size / sizeof(u32);
263
264 mpp_write_req(mpp, task->reg, s, e, reg_en);
265 }
266 /* init current task */
267 mpp->cur_task = mpp_task;
268 /* Flush the register before the start the device */
269 wmb();
270 mpp_write(mpp, JPGDEC_REG_INT_EN_BASE,
271 task->reg[reg_en] | JPGDEC_START_EN);
272
273 mpp_debug_leave();
274
275 return 0;
276 }
277
jpgdec_finish(struct mpp_dev * mpp,struct mpp_task * mpp_task)278 static int jpgdec_finish(struct mpp_dev *mpp,
279 struct mpp_task *mpp_task)
280 {
281 u32 i;
282 u32 s, e;
283 u32 dec_get;
284 s32 dec_length;
285 struct mpp_request *req;
286 struct jpgdec_task *task = to_jpgdec_task(mpp_task);
287
288 mpp_debug_enter();
289
290 /* read register after running */
291 for (i = 0; i < task->r_req_cnt; i++) {
292 req = &task->r_reqs[i];
293 s = req->offset / sizeof(u32);
294 e = s + req->size / sizeof(u32);
295 mpp_read_req(mpp, task->reg, s, e);
296 }
297 /* revert hack for irq status */
298 task->reg[JPGDEC_REG_INT_EN_INDEX] = task->irq_status;
299 /* revert hack for decoded length */
300 dec_get = mpp_read_relaxed(mpp, JPGDEC_REG_STREAM_RLC_BASE);
301 dec_length = dec_get - task->strm_addr;
302 task->reg[JPGDEC_REG_STREAM_RLC_BASE_INDEX] = dec_length << 10;
303 /*
304 * If the softrest_rdy bit is low,
305 * it means that the soft-reset of the previous frame
306 * has not been completed.We have to manually trigger to do soft-reset.
307 */
308 if (!(task->irq_status & JPGDEC_SOFT_RSET_READY) &&
309 !atomic_read(&mpp->reset_request))
310 jpgdec_soft_reset(mpp);
311
312 mpp_debug(DEBUG_REGISTER,
313 "dec_get %08x dec_length %d\n", dec_get, dec_length);
314
315 mpp_debug_leave();
316
317 return 0;
318 }
319
jpgdec_result(struct mpp_dev * mpp,struct mpp_task * mpp_task,struct mpp_task_msgs * msgs)320 static int jpgdec_result(struct mpp_dev *mpp,
321 struct mpp_task *mpp_task,
322 struct mpp_task_msgs *msgs)
323 {
324 u32 i;
325 struct mpp_request *req;
326 struct jpgdec_task *task = to_jpgdec_task(mpp_task);
327
328 /* FIXME may overflow the kernel */
329 for (i = 0; i < task->r_req_cnt; i++) {
330 req = &task->r_reqs[i];
331
332 if (copy_to_user(req->data,
333 (u8 *)task->reg + req->offset,
334 req->size)) {
335 mpp_err("copy_to_user reg fail\n");
336 return -EIO;
337 }
338 }
339
340 return 0;
341 }
342
jpgdec_free_task(struct mpp_session * session,struct mpp_task * mpp_task)343 static int jpgdec_free_task(struct mpp_session *session,
344 struct mpp_task *mpp_task)
345 {
346 struct jpgdec_task *task = to_jpgdec_task(mpp_task);
347
348 mpp_task_finalize(session, mpp_task);
349 kfree(task);
350
351 return 0;
352 }
353
354 #ifdef CONFIG_ROCKCHIP_MPP_PROC_FS
jpgdec_procfs_remove(struct mpp_dev * mpp)355 static int jpgdec_procfs_remove(struct mpp_dev *mpp)
356 {
357 struct jpgdec_dev *dec = to_jpgdec_dev(mpp);
358
359 if (dec->procfs) {
360 proc_remove(dec->procfs);
361 dec->procfs = NULL;
362 }
363
364 return 0;
365 }
366
jpgdec_procfs_init(struct mpp_dev * mpp)367 static int jpgdec_procfs_init(struct mpp_dev *mpp)
368 {
369 struct jpgdec_dev *dec = to_jpgdec_dev(mpp);
370
371 dec->procfs = proc_mkdir(mpp->dev->of_node->name, mpp->srv->procfs);
372 if (IS_ERR_OR_NULL(dec->procfs)) {
373 mpp_err("failed on open procfs\n");
374 dec->procfs = NULL;
375 return -EIO;
376 }
377 mpp_procfs_create_u32("aclk", 0644,
378 dec->procfs, &dec->aclk_info.debug_rate_hz);
379 mpp_procfs_create_u32("session_buffers", 0644,
380 dec->procfs, &mpp->session_max_buffers);
381
382 return 0;
383 }
384 #else
jpgdec_procfs_remove(struct mpp_dev * mpp)385 static inline int jpgdec_procfs_remove(struct mpp_dev *mpp)
386 {
387 return 0;
388 }
389
jpgdec_procfs_init(struct mpp_dev * mpp)390 static inline int jpgdec_procfs_init(struct mpp_dev *mpp)
391 {
392 return 0;
393 }
394 #endif
395
jpgdec_init(struct mpp_dev * mpp)396 static int jpgdec_init(struct mpp_dev *mpp)
397 {
398 int ret;
399 struct jpgdec_dev *dec = to_jpgdec_dev(mpp);
400
401 mpp->grf_info = &mpp->srv->grf_infos[MPP_DRIVER_VDPU1];
402
403 /* Get clock info from dtsi */
404 ret = mpp_get_clk_info(mpp, &dec->aclk_info, "aclk_vcodec");
405 if (ret)
406 mpp_err("failed on clk_get aclk_vcodec\n");
407 ret = mpp_get_clk_info(mpp, &dec->hclk_info, "hclk_vcodec");
408 if (ret)
409 mpp_err("failed on clk_get hclk_vcodec\n");
410 /* Set default rates */
411 mpp_set_clk_info_rate_hz(&dec->aclk_info, CLK_MODE_DEFAULT, 300 * MHZ);
412
413 /* Get reset control from dtsi */
414 dec->rst_a = mpp_reset_control_get(mpp, RST_TYPE_A, "video_a");
415 if (!dec->rst_a)
416 mpp_err("No aclk reset resource define\n");
417 dec->rst_h = mpp_reset_control_get(mpp, RST_TYPE_H, "video_h");
418 if (!dec->rst_h)
419 mpp_err("No hclk reset resource define\n");
420
421 return 0;
422 }
423
jpgdec_clk_on(struct mpp_dev * mpp)424 static int jpgdec_clk_on(struct mpp_dev *mpp)
425 {
426 struct jpgdec_dev *dec = to_jpgdec_dev(mpp);
427
428 mpp_clk_safe_enable(dec->aclk_info.clk);
429 mpp_clk_safe_enable(dec->hclk_info.clk);
430
431 return 0;
432 }
433
jpgdec_clk_off(struct mpp_dev * mpp)434 static int jpgdec_clk_off(struct mpp_dev *mpp)
435 {
436 struct jpgdec_dev *dec = to_jpgdec_dev(mpp);
437
438 mpp_clk_safe_disable(dec->aclk_info.clk);
439 mpp_clk_safe_disable(dec->hclk_info.clk);
440
441 return 0;
442 }
443
jpgdec_set_freq(struct mpp_dev * mpp,struct mpp_task * mpp_task)444 static int jpgdec_set_freq(struct mpp_dev *mpp,
445 struct mpp_task *mpp_task)
446 {
447 struct jpgdec_dev *dec = to_jpgdec_dev(mpp);
448 struct jpgdec_task *task = to_jpgdec_task(mpp_task);
449
450 mpp_clk_set_rate(&dec->aclk_info, task->clk_mode);
451
452 return 0;
453 }
454
jpgdec_reduce_freq(struct mpp_dev * mpp)455 static int jpgdec_reduce_freq(struct mpp_dev *mpp)
456 {
457 struct jpgdec_dev *dec = to_jpgdec_dev(mpp);
458
459 mpp_clk_set_rate(&dec->aclk_info, CLK_MODE_REDUCE);
460
461 return 0;
462 }
463
jpgdec_irq(struct mpp_dev * mpp)464 static int jpgdec_irq(struct mpp_dev *mpp)
465 {
466 mpp->irq_status = mpp_read(mpp, JPGDEC_REG_INT_EN_BASE);
467 if (!(mpp->irq_status & JPGDEC_IRQ_RAW))
468 return IRQ_NONE;
469 mpp_write(mpp, JPGDEC_REG_INT_EN_BASE, 0);
470
471 return IRQ_WAKE_THREAD;
472 }
473
jpgdec_isr(struct mpp_dev * mpp)474 static int jpgdec_isr(struct mpp_dev *mpp)
475 {
476 int error_mask;
477 struct jpgdec_task *task = NULL;
478 struct mpp_task *mpp_task = mpp->cur_task;
479
480 /* FIXME use a spin lock here */
481 if (!mpp_task) {
482 dev_err(mpp->dev, "no current task\n");
483 return IRQ_HANDLED;
484 }
485 mpp_time_diff(mpp_task);
486 mpp->cur_task = NULL;
487 task = to_jpgdec_task(mpp_task);
488 task->irq_status = mpp->irq_status;
489 mpp_debug(DEBUG_IRQ_STATUS, "irq_status: %08x\n",
490 task->irq_status);
491
492 error_mask = JPGDEC_BUS_STA | JPGDEC_ERROR_STA |
493 JPGDEC_TIMEOUT_STA | JPGDEC_BUF_EMPTY_STA;
494
495 if (error_mask & task->irq_status)
496 atomic_inc(&mpp->reset_request);
497
498 mpp_task_finish(mpp_task->session, mpp_task);
499
500 mpp_debug_leave();
501
502 return IRQ_HANDLED;
503 }
504
jpgdec_reset(struct mpp_dev * mpp)505 static int jpgdec_reset(struct mpp_dev *mpp)
506 {
507 struct jpgdec_dev *dec = to_jpgdec_dev(mpp);
508
509 if (dec->rst_a && dec->rst_h) {
510 mpp_debug(DEBUG_RESET, "reset in\n");
511
512 /* Don't skip this or iommu won't work after reset */
513 mpp_pmu_idle_request(mpp, true);
514 mpp_safe_reset(dec->rst_a);
515 mpp_safe_reset(dec->rst_h);
516 udelay(5);
517 mpp_safe_unreset(dec->rst_a);
518 mpp_safe_unreset(dec->rst_h);
519 mpp_pmu_idle_request(mpp, false);
520
521 mpp_debug(DEBUG_RESET, "reset out\n");
522 }
523 mpp_write(mpp, JPGDEC_REG_INT_EN_BASE, 0);
524
525 return 0;
526 }
527
528 static struct mpp_hw_ops jpgdec_v1_hw_ops = {
529 .init = jpgdec_init,
530 .clk_on = jpgdec_clk_on,
531 .clk_off = jpgdec_clk_off,
532 .set_freq = jpgdec_set_freq,
533 .reduce_freq = jpgdec_reduce_freq,
534 .reset = jpgdec_reset,
535 };
536
537 static struct mpp_dev_ops jpgdec_v1_dev_ops = {
538 .alloc_task = jpgdec_alloc_task,
539 .run = jpgdec_run,
540 .irq = jpgdec_irq,
541 .isr = jpgdec_isr,
542 .finish = jpgdec_finish,
543 .result = jpgdec_result,
544 .free_task = jpgdec_free_task,
545 };
546
547 static const struct mpp_dev_var jpgdec_v1_data = {
548 .device_type = MPP_DEVICE_JPGDEC,
549 .hw_info = &jpgdec_v1_hw_info,
550 .trans_info = jpgdec_v1_trans,
551 .hw_ops = &jpgdec_v1_hw_ops,
552 .dev_ops = &jpgdec_v1_dev_ops,
553 };
554
555 static const struct of_device_id mpp_jpgdec_dt_match[] = {
556 {
557 .compatible = "rockchip,rkv-jpeg-decoder-v1",
558 .data = &jpgdec_v1_data,
559 },
560 {},
561 };
562
jpgdec_probe(struct platform_device * pdev)563 static int jpgdec_probe(struct platform_device *pdev)
564 {
565 struct device *dev = &pdev->dev;
566 struct jpgdec_dev *dec = NULL;
567 struct mpp_dev *mpp = NULL;
568 const struct of_device_id *match = NULL;
569 int ret = 0;
570
571 dev_info(dev, "probe device\n");
572 dec = devm_kzalloc(dev, sizeof(struct jpgdec_dev), GFP_KERNEL);
573 if (!dec)
574 return -ENOMEM;
575 platform_set_drvdata(pdev, dec);
576
577 mpp = &dec->mpp;
578 if (pdev->dev.of_node) {
579 match = of_match_node(mpp_jpgdec_dt_match, pdev->dev.of_node);
580 if (match)
581 mpp->var = (struct mpp_dev_var *)match->data;
582 }
583
584 ret = mpp_dev_probe(mpp, pdev);
585 if (ret) {
586 dev_err(dev, "probe sub driver failed\n");
587 return -EINVAL;
588 }
589
590 ret = devm_request_threaded_irq(dev, mpp->irq,
591 mpp_dev_irq,
592 mpp_dev_isr_sched,
593 IRQF_SHARED,
594 dev_name(dev), mpp);
595 if (ret) {
596 dev_err(dev, "register interrupter runtime failed\n");
597 return -EINVAL;
598 }
599
600 mpp->session_max_buffers = JPGDEC_SESSION_MAX_BUFFERS;
601 jpgdec_procfs_init(mpp);
602 /* register current device to mpp service */
603 mpp_dev_register_srv(mpp, mpp->srv);
604 dev_info(dev, "probing finish\n");
605
606 return 0;
607 }
608
jpgdec_remove(struct platform_device * pdev)609 static int jpgdec_remove(struct platform_device *pdev)
610 {
611 struct device *dev = &pdev->dev;
612 struct jpgdec_dev *dec = platform_get_drvdata(pdev);
613
614 dev_info(dev, "remove device\n");
615 mpp_dev_remove(&dec->mpp);
616 jpgdec_procfs_remove(&dec->mpp);
617
618 return 0;
619 }
620
jpgdec_shutdown(struct platform_device * pdev)621 static void jpgdec_shutdown(struct platform_device *pdev)
622 {
623 int ret;
624 int val;
625 struct device *dev = &pdev->dev;
626 struct jpgdec_dev *dec = platform_get_drvdata(pdev);
627 struct mpp_dev *mpp = &dec->mpp;
628
629 dev_info(dev, "shutdown device\n");
630
631 atomic_inc(&mpp->srv->shutdown_request);
632 ret = readx_poll_timeout(atomic_read,
633 &mpp->task_count,
634 val, val == 0, 20000, 200000);
635 if (ret == -ETIMEDOUT)
636 dev_err(dev, "wait total running time out\n");
637 }
638
639 struct platform_driver rockchip_jpgdec_driver = {
640 .probe = jpgdec_probe,
641 .remove = jpgdec_remove,
642 .shutdown = jpgdec_shutdown,
643 .driver = {
644 .name = JPGDEC_DRIVER_NAME,
645 .of_match_table = of_match_ptr(mpp_jpgdec_dt_match),
646 },
647 };
648 EXPORT_SYMBOL(rockchip_jpgdec_driver);
649