kernel_5.10 no rt

hc

2023-12-11 6778948f9de86c3cfaf36725a7c87dcff9ba247f

 kernel/drivers/media/platform/mtk-vcodec/venc_vpu_if.c
..
..
@@ -1,33 +1,43 @@
1
+// SPDX-License-Identifier: GPL-2.0
1
2
 /*
2
3
  * Copyright (c) 2016 MediaTek Inc.
3
4
  * Author: PoChun Lin <pochun.lin@mediatek.com>
4
- *
5
- * This program is free software; you can redistribute it and/or
6
- * modify
7
- * it under the terms of the GNU General Public License version 2 as
8
- * published by the Free Software Foundation.
9
- *
10
- * This program is distributed in the hope that it will be useful,
11
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
- * GNU General Public License for more details.
14
5
  */
15
6
 
16
-#include "mtk_vpu.h"
7
+#include "mtk_vcodec_drv.h"
8
+#include "mtk_vcodec_fw.h"
17
9
 #include "venc_ipi_msg.h"
18
10
 #include "venc_vpu_if.h"
19
11
 
20
-static void handle_enc_init_msg(struct venc_vpu_inst *vpu, void *data)
12
+static void handle_enc_init_msg(struct venc_vpu_inst *vpu, const void *data)
21
13
 {
22
-	struct venc_vpu_ipi_msg_init *msg = data;
14
+	const struct venc_vpu_ipi_msg_init *msg = data;
23
15
 
24
16
 	vpu->inst_addr = msg->vpu_inst_addr;
25
-	vpu->vsi = vpu_mapping_dm_addr(vpu->dev, msg->vpu_inst_addr);
17
+	vpu->vsi = mtk_vcodec_fw_map_dm_addr(vpu->ctx->dev->fw_handler,
18
+					     msg->vpu_inst_addr);
19
+
20
+	/* Firmware version field value is unspecified on MT8173. */
21
+	if (vpu->ctx->dev->venc_pdata->chip == MTK_MT8173)
22
+		return;
23
+
24
+	/* Check firmware version. */
25
+	mtk_vcodec_debug(vpu, "firmware version: 0x%x\n",
26
+			 msg->venc_abi_version);
27
+	switch (msg->venc_abi_version) {
28
+	case 1:
29
+		break;
30
+	default:
31
+		mtk_vcodec_err(vpu, "unhandled firmware version 0x%x\n",
32
+			       msg->venc_abi_version);
33
+		vpu->failure = 1;
34
+		break;
35
+	}
26
36
 }
27
37
 
28
-static void handle_enc_encode_msg(struct venc_vpu_inst *vpu, void *data)
38
+static void handle_enc_encode_msg(struct venc_vpu_inst *vpu, const void *data)
29
39
 {
30
-	struct venc_vpu_ipi_msg_enc *msg = data;
40
+	const struct venc_vpu_ipi_msg_enc *msg = data;
31
41
 
32
42
 	vpu->state = msg->state;
33
43
 	vpu->bs_size = msg->bs_size;
..
..
@@ -36,12 +46,17 @@
36
46
 
37
47
 static void vpu_enc_ipi_handler(void *data, unsigned int len, void *priv)
38
48
 {
39
-	struct venc_vpu_ipi_msg_common *msg = data;
49
+	const struct venc_vpu_ipi_msg_common *msg = data;
40
50
 	struct venc_vpu_inst *vpu =
41
51
 		(struct venc_vpu_inst *)(unsigned long)msg->venc_inst;
42
52
 
43
53
 	mtk_vcodec_debug(vpu, "msg_id %x inst %p status %d",
44
54
 			 msg->msg_id, vpu, msg->status);
55
+
56
+	vpu->signaled = 1;
57
+	vpu->failure = (msg->status != VENC_IPI_MSG_STATUS_OK);
58
+	if (vpu->failure)
59
+		goto failure;
45
60
 
46
61
 	switch (msg->msg_id) {
47
62
 	case VPU_IPIMSG_ENC_INIT_DONE:
..
..
@@ -59,9 +74,7 @@
59
74
 		break;
60
75
 	}
61
76
 
62
-	vpu->signaled = 1;
63
-	vpu->failure = (msg->status != VENC_IPI_MSG_STATUS_OK);
64
-
77
+failure:
65
78
 	mtk_vcodec_debug_leave(vpu);
66
79
 }
67
80
 
..
..
@@ -72,12 +85,13 @@
72
85
 
73
86
 	mtk_vcodec_debug_enter(vpu);
74
87
 
75
-	if (!vpu->dev) {
88
+	if (!vpu->ctx->dev->fw_handler) {
76
89
 		mtk_vcodec_err(vpu, "inst dev is NULL");
77
90
 		return -EINVAL;
78
91
 	}
79
92
 
80
-	status = vpu_ipi_send(vpu->dev, vpu->id, msg, len);
93
+	status = mtk_vcodec_fw_ipi_send(vpu->ctx->dev->fw_handler, vpu->id, msg,
94
+					len, 2000);
81
95
 	if (status) {
82
96
 		mtk_vcodec_err(vpu, "vpu_ipi_send msg_id %x len %d fail %d",
83
97
 			       *(uint32_t *)msg, len, status);
..
..
@@ -102,8 +116,9 @@
102
116
 	vpu->signaled = 0;
103
117
 	vpu->failure = 0;
104
118
 
105
-	status = vpu_ipi_register(vpu->dev, vpu->id, vpu_enc_ipi_handler,
106
-				  NULL, NULL);
119
+	status = mtk_vcodec_fw_ipi_register(vpu->ctx->dev->fw_handler, vpu->id,
120
+					    vpu_enc_ipi_handler, "venc", NULL);
121
+
107
122
 	if (status) {
108
123
 		mtk_vcodec_err(vpu, "vpu_ipi_register fail %d", status);
109
124
 		return -EINVAL;
..
..
@@ -122,49 +137,81 @@
122
137
 	return 0;
123
138
 }
124
139
 
140
+static unsigned int venc_enc_param_crop_right(struct venc_vpu_inst *vpu,
141
+					      struct venc_enc_param *enc_prm)
142
+{
143
+	unsigned int img_crop_right = enc_prm->buf_width - enc_prm->width;
144
+
145
+	return img_crop_right % 16;
146
+}
147
+
148
+static unsigned int venc_enc_param_crop_bottom(struct venc_enc_param *enc_prm)
149
+{
150
+	return round_up(enc_prm->height, 16) - enc_prm->height;
151
+}
152
+
153
+static unsigned int venc_enc_param_num_mb(struct venc_enc_param *enc_prm)
154
+{
155
+	return DIV_ROUND_UP(enc_prm->width, 16) *
156
+	       DIV_ROUND_UP(enc_prm->height, 16);
157
+}
158
+
125
159
 int vpu_enc_set_param(struct venc_vpu_inst *vpu,
126
160
 		      enum venc_set_param_type id,
127
161
 		      struct venc_enc_param *enc_param)
128
162
 {
129
-	struct venc_ap_ipi_msg_set_param out;
163
+	const bool is_ext = MTK_ENC_CTX_IS_EXT(vpu->ctx);
164
+	size_t msg_size = is_ext ?
165
+		sizeof(struct venc_ap_ipi_msg_set_param_ext) :
166
+		sizeof(struct venc_ap_ipi_msg_set_param);
167
+	struct venc_ap_ipi_msg_set_param_ext out;
130
168
 
131
169
 	mtk_vcodec_debug(vpu, "id %d ->", id);
132
170
 
133
171
 	memset(&out, 0, sizeof(out));
134
-	out.msg_id = AP_IPIMSG_ENC_SET_PARAM;
135
-	out.vpu_inst_addr = vpu->inst_addr;
136
-	out.param_id = id;
172
+	out.base.msg_id = AP_IPIMSG_ENC_SET_PARAM;
173
+	out.base.vpu_inst_addr = vpu->inst_addr;
174
+	out.base.param_id = id;
137
175
 	switch (id) {
138
176
 	case VENC_SET_PARAM_ENC:
139
-		out.data_item = 0;
177
+		if (is_ext) {
178
+			out.base.data_item = 3;
179
+			out.base.data[0] =
180
+				venc_enc_param_crop_right(vpu, enc_param);
181
+			out.base.data[1] =
182
+				venc_enc_param_crop_bottom(enc_param);
183
+			out.base.data[2] = venc_enc_param_num_mb(enc_param);
184
+		} else {
185
+			out.base.data_item = 0;
186
+		}
140
187
 		break;
141
188
 	case VENC_SET_PARAM_FORCE_INTRA:
142
-		out.data_item = 0;
189
+		out.base.data_item = 0;
143
190
 		break;
144
191
 	case VENC_SET_PARAM_ADJUST_BITRATE:
145
-		out.data_item = 1;
146
-		out.data[0] = enc_param->bitrate;
192
+		out.base.data_item = 1;
193
+		out.base.data[0] = enc_param->bitrate;
147
194
 		break;
148
195
 	case VENC_SET_PARAM_ADJUST_FRAMERATE:
149
-		out.data_item = 1;
150
-		out.data[0] = enc_param->frm_rate;
196
+		out.base.data_item = 1;
197
+		out.base.data[0] = enc_param->frm_rate;
151
198
 		break;
152
199
 	case VENC_SET_PARAM_GOP_SIZE:
153
-		out.data_item = 1;
154
-		out.data[0] = enc_param->gop_size;
200
+		out.base.data_item = 1;
201
+		out.base.data[0] = enc_param->gop_size;
155
202
 		break;
156
203
 	case VENC_SET_PARAM_INTRA_PERIOD:
157
-		out.data_item = 1;
158
-		out.data[0] = enc_param->intra_period;
204
+		out.base.data_item = 1;
205
+		out.base.data[0] = enc_param->intra_period;
159
206
 		break;
160
207
 	case VENC_SET_PARAM_SKIP_FRAME:
161
-		out.data_item = 0;
208
+		out.base.data_item = 0;
162
209
 		break;
163
210
 	default:
164
211
 		mtk_vcodec_err(vpu, "id %d not supported", id);
165
212
 		return -EINVAL;
166
213
 	}
167
-	if (vpu_enc_send_msg(vpu, &out, sizeof(out))) {
214
+	if (vpu_enc_send_msg(vpu, &out, msg_size)) {
168
215
 		mtk_vcodec_err(vpu,
169
216
 			       "AP_IPIMSG_ENC_SET_PARAM %d fail", id);
170
217
 		return -EINVAL;
..
..
@@ -178,33 +225,44 @@
178
225
 int vpu_enc_encode(struct venc_vpu_inst *vpu, unsigned int bs_mode,
179
226
 		   struct venc_frm_buf *frm_buf,
180
227
 		   struct mtk_vcodec_mem *bs_buf,
181
-		   unsigned int *bs_size)
228
+		   unsigned int *bs_size,
229
+		   struct venc_frame_info *frame_info)
182
230
 {
183
-	struct venc_ap_ipi_msg_enc out;
231
+	const bool is_ext = MTK_ENC_CTX_IS_EXT(vpu->ctx);
232
+	size_t msg_size = is_ext ?
233
+		sizeof(struct venc_ap_ipi_msg_enc_ext) :
234
+		sizeof(struct venc_ap_ipi_msg_enc);
235
+	struct venc_ap_ipi_msg_enc_ext out;
184
236
 
185
237
 	mtk_vcodec_debug(vpu, "bs_mode %d ->", bs_mode);
186
238
 
187
239
 	memset(&out, 0, sizeof(out));
188
-	out.msg_id = AP_IPIMSG_ENC_ENCODE;
189
-	out.vpu_inst_addr = vpu->inst_addr;
190
-	out.bs_mode = bs_mode;
240
+	out.base.msg_id = AP_IPIMSG_ENC_ENCODE;
241
+	out.base.vpu_inst_addr = vpu->inst_addr;
242
+	out.base.bs_mode = bs_mode;
191
243
 	if (frm_buf) {
192
244
 		if ((frm_buf->fb_addr[0].dma_addr % 16 == 0) &&
193
245
 		    (frm_buf->fb_addr[1].dma_addr % 16 == 0) &&
194
246
 		    (frm_buf->fb_addr[2].dma_addr % 16 == 0)) {
195
-			out.input_addr[0] = frm_buf->fb_addr[0].dma_addr;
196
-			out.input_addr[1] = frm_buf->fb_addr[1].dma_addr;
197
-			out.input_addr[2] = frm_buf->fb_addr[2].dma_addr;
247
+			out.base.input_addr[0] = frm_buf->fb_addr[0].dma_addr;
248
+			out.base.input_addr[1] = frm_buf->fb_addr[1].dma_addr;
249
+			out.base.input_addr[2] = frm_buf->fb_addr[2].dma_addr;
198
250
 		} else {
199
251
 			mtk_vcodec_err(vpu, "dma_addr not align to 16");
200
252
 			return -EINVAL;
201
253
 		}
202
254
 	}
203
255
 	if (bs_buf) {
204
-		out.bs_addr = bs_buf->dma_addr;
205
-		out.bs_size = bs_buf->size;
256
+		out.base.bs_addr = bs_buf->dma_addr;
257
+		out.base.bs_size = bs_buf->size;
206
258
 	}
207
-	if (vpu_enc_send_msg(vpu, &out, sizeof(out))) {
259
+	if (is_ext && frame_info) {
260
+		out.data_item = 3;
261
+		out.data[0] = frame_info->frm_count;
262
+		out.data[1] = frame_info->skip_frm_count;
263
+		out.data[2] = frame_info->frm_type;
264
+	}
265
+	if (vpu_enc_send_msg(vpu, &out, msg_size)) {
208
266
 		mtk_vcodec_err(vpu, "AP_IPIMSG_ENC_ENCODE %d fail",
209
267
 			       bs_mode);
210
268
 		return -EINVAL;