rk3568 rt init

hc

2023-11-06 e3e12f52b214121840b44c91de5b3e5af5d3eb84

 kernel/drivers/media/platform/rockchip/isp/capture_v21.c
..
..
@@ -1046,14 +1046,7 @@
1046
1046
 {
1047
1047
 	void __iomem *base = stream->ispdev->base_addr;
1048
1048
 	struct rkisp_device *dev = stream->ispdev;
1049
-	bool is_update = false;
1050
1049
 	int ret;
1051
-
1052
-	if (stream->id == RKISP_STREAM_MP || stream->id == RKISP_STREAM_SP) {
1053
-		is_update = (stream->id == RKISP_STREAM_MP) ?
1054
-			!dev->cap_dev.stream[RKISP_STREAM_SP].streaming :
1055
-			!dev->cap_dev.stream[RKISP_STREAM_MP].streaming;
1056
-	}
1057
1050
 
1058
1051
 	if (stream->ops->set_data_path)
1059
1052
 		stream->ops->set_data_path(base);
..
..
@@ -1064,9 +1057,6 @@
1064
1057
 	stream->ops->enable_mi(stream);
1065
1058
 	if (stream->id == RKISP_STREAM_MP || stream->id == RKISP_STREAM_SP)
1066
1059
 		hdr_config_dmatx(dev);
1067
-	if (is_update)
1068
-		dev->irq_ends_mask |=
1069
-			(stream->id == RKISP_STREAM_MP) ? ISP_FRAME_MP : ISP_FRAME_SP;
1070
1060
 	stream->streaming = true;
1071
1061
 
1072
1062
 	return 0;
..
..
@@ -1217,6 +1207,22 @@
1217
1207
 	spin_unlock_irqrestore(&stream->vbq_lock, lock_flags);
1218
1208
 }
1219
1209
 
1210
+static void rkisp_stop_streaming_tx(struct rkisp_stream *stream)
1211
+{
1212
+	struct rkisp_device *dev = stream->ispdev;
1213
+
1214
+	stream->stopping = true;
1215
+	if (dev->isp_state & ISP_START &&
1216
+	    !stream->ops->is_stream_stopped(dev->base_addr)) {
1217
+		stream->ops->stop_mi(stream);
1218
+		wait_event_timeout(stream->done, !stream->streaming,
1219
+				   msecs_to_jiffies(300));
1220
+	}
1221
+	stream->stopping = false;
1222
+	stream->streaming = false;
1223
+	destroy_buf_queue(stream, VB2_BUF_STATE_ERROR);
1224
+}
1225
+
1220
1226
 static void rkisp_stop_streaming(struct vb2_queue *queue)
1221
1227
 {
1222
1228
 	struct rkisp_stream *stream = queue->drv_priv;
..
..
@@ -1225,24 +1231,23 @@
1225
1231
 	struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
1226
1232
 	int ret;
1227
1233
 
1228
-	mutex_lock(&dev->hw_dev->dev_lock);
1229
-
1230
1234
 	v4l2_dbg(1, rkisp_debug, &dev->v4l2_dev,
1231
1235
 		 "%s %d\n", __func__, stream->id);
1232
-
1233
1236
 	if (!stream->streaming)
1234
-		goto end;
1237
+		return;
1238
+
1239
+	if (stream->id != RKISP_STREAM_MP && stream->id != RKISP_STREAM_SP)
1240
+		return rkisp_stop_streaming_tx(stream);
1241
+
1242
+	mutex_lock(&dev->hw_dev->dev_lock);
1235
1243
 
1236
1244
 	rkisp_stream_stop(stream);
1237
-	if (stream->id == RKISP_STREAM_MP ||
1238
-	    stream->id == RKISP_STREAM_SP) {
1239
-		/* call to the other devices */
1240
-		media_pipeline_stop(&node->vdev.entity);
1241
-		ret = dev->pipe.set_stream(&dev->pipe, false);
1242
-		if (ret < 0)
1243
-			v4l2_err(v4l2_dev,
1244
-				 "pipeline stream-off failed:%d\n", ret);
1245
-	}
1245
+	/* call to the other devices */
1246
+	media_pipeline_stop(&node->vdev.entity);
1247
+	ret = dev->pipe.set_stream(&dev->pipe, false);
1248
+	if (ret < 0)
1249
+		v4l2_err(v4l2_dev,
1250
+			 "pipeline stream-off failed:%d\n", ret);
1246
1251
 
1247
1252
 	/* release buffers */
1248
1253
 	destroy_buf_queue(stream, VB2_BUF_STATE_ERROR);
..
..
@@ -1253,7 +1258,6 @@
1253
1258
 	rkisp_destroy_dummy_buf(stream);
1254
1259
 	atomic_dec(&dev->cap_dev.refcnt);
1255
1260
 
1256
-end:
1257
1261
 	mutex_unlock(&dev->hw_dev->dev_lock);
1258
1262
 }
1259
1263
 
..
..
@@ -1296,6 +1300,25 @@
1296
1300
 }
1297
1301
 
1298
1302
 static int
1303
+rkisp_start_streaming_tx(struct rkisp_stream *stream)
1304
+{
1305
+	struct rkisp_device *dev = stream->ispdev;
1306
+	int ret = -1;
1307
+
1308
+	if (!dev->isp_inp || !stream->linked)
1309
+		goto buffer_done;
1310
+
1311
+	ret = rkisp_stream_start(stream);
1312
+	if (ret < 0)
1313
+		goto buffer_done;
1314
+	return 0;
1315
+buffer_done:
1316
+	destroy_buf_queue(stream, VB2_BUF_STATE_QUEUED);
1317
+	stream->streaming = false;
1318
+	return ret;
1319
+}
1320
+
1321
+static int
1299
1322
 rkisp_start_streaming(struct vb2_queue *queue, unsigned int count)
1300
1323
 {
1301
1324
 	struct rkisp_stream *stream = queue->drv_priv;
..
..
@@ -1304,17 +1327,16 @@
1304
1327
 	struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
1305
1328
 	int ret = -1;
1306
1329
 
1307
-	mutex_lock(&dev->hw_dev->dev_lock);
1308
-
1309
1330
 	v4l2_dbg(1, rkisp_debug, &dev->v4l2_dev,
1310
1331
 		 "%s %d\n", __func__, stream->id);
1311
-
1312
-	if (WARN_ON(stream->streaming)) {
1313
-		mutex_unlock(&dev->hw_dev->dev_lock);
1332
+	if (WARN_ON(stream->streaming))
1314
1333
 		return -EBUSY;
1315
-	}
1316
-
1317
1334
 	memset(&stream->dbg, 0, sizeof(stream->dbg));
1335
+
1336
+	if (stream->id != RKISP_STREAM_MP && stream->id != RKISP_STREAM_SP)
1337
+		return rkisp_start_streaming_tx(stream);
1338
+
1339
+	mutex_lock(&dev->hw_dev->dev_lock);
1318
1340
 	atomic_inc(&dev->cap_dev.refcnt);
1319
1341
 	if (!dev->isp_inp || !stream->linked) {
1320
1342
 		v4l2_err(v4l2_dev, "check video link or isp input\n");
..
..
@@ -1364,19 +1386,16 @@
1364
1386
 		goto close_pipe;
1365
1387
 	}
1366
1388
 
1367
-	if (stream->id == RKISP_STREAM_MP ||
1368
-	    stream->id == RKISP_STREAM_SP) {
1369
-		/* start sub-devices */
1370
-		ret = dev->pipe.set_stream(&dev->pipe, true);
1371
-		if (ret < 0)
1372
-			goto stop_stream;
1389
+	/* start sub-devices */
1390
+	ret = dev->pipe.set_stream(&dev->pipe, true);
1391
+	if (ret < 0)
1392
+		goto stop_stream;
1373
1393
 
1374
-		ret = media_pipeline_start(&node->vdev.entity, &dev->pipe.pipe);
1375
-		if (ret < 0) {
1376
-			v4l2_err(&dev->v4l2_dev,
1377
-				 "start pipeline failed %d\n", ret);
1378
-			goto pipe_stream_off;
1379
-		}
1394
+	ret = media_pipeline_start(&node->vdev.entity, &dev->pipe.pipe);
1395
+	if (ret < 0) {
1396
+		v4l2_err(&dev->v4l2_dev,
1397
+			 "start pipeline failed %d\n", ret);
1398
+		goto pipe_stream_off;
1380
1399
 	}
1381
1400
 
1382
1401
 	mutex_unlock(&dev->hw_dev->dev_lock);
..
..
@@ -1613,17 +1632,13 @@
1613
1632
 		stream = &dev->cap_dev.stream[RKISP_STREAM_MP];
1614
1633
 		if (!stream->streaming)
1615
1634
 			dev->irq_ends_mask &= ~ISP_FRAME_MP;
1616
-		else
1617
-			dev->irq_ends_mask |= ISP_FRAME_MP;
1618
-		rkisp_check_idle(dev, ISP_FRAME_MP);
1635
+		rkisp_check_idle(dev, ISP_FRAME_MP & dev->irq_ends_mask);
1619
1636
 	}
1620
1637
 	if (mis_val & CIF_MI_SP_FRAME) {
1621
1638
 		stream = &dev->cap_dev.stream[RKISP_STREAM_SP];
1622
1639
 		if (!stream->streaming)
1623
1640
 			dev->irq_ends_mask &= ~ISP_FRAME_SP;
1624
-		else
1625
-			dev->irq_ends_mask |= ISP_FRAME_SP;
1626
-		rkisp_check_idle(dev, ISP_FRAME_SP);
1641
+		rkisp_check_idle(dev, ISP_FRAME_SP & dev->irq_ends_mask);
1627
1642
 	}
1628
1643
 }
1629
1644