mei_ace.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright (C) 2023 Intel Corporation. All rights reserved.
  4 * Intel Visual Sensing Controller ACE Linux driver
  5 */
  6
  7/*
  8 * To set ownership of camera sensor, there is specific command, which
  9 * is sent via MEI protocol. That's a two-step scheme where the firmware
 10 * first acks receipt of the command and later responses the command was
 11 * executed. The command sending function uses "completion" as the
 12 * synchronization mechanism. The notification for command is received
 13 * via a mei callback which wakes up the caller. There can be only one
 14 * outstanding command at a time.
 15 *
 16 * The power line of camera sensor is directly connected to IVSC instead
 17 * of host, when camera sensor ownership is switched to host, sensor is
 18 * already powered up by firmware.
 19 */
 20
 21#include <linux/acpi.h>
 22#include <linux/completion.h>
 23#include <linux/delay.h>
 24#include <linux/kernel.h>
 25#include <linux/mei_cl_bus.h>
 26#include <linux/module.h>
 27#include <linux/mutex.h>
 28#include <linux/pm_runtime.h>
 29#include <linux/slab.h>
 30#include <linux/uuid.h>
 31#include <linux/workqueue.h>
 32
 33/* indicating driver message */
 34#define	ACE_DRV_MSG		1
 35/* indicating set command */
 36#define	ACE_CMD_SET		4
 37/* command timeout determined experimentally */
 38#define	ACE_CMD_TIMEOUT		(5 * HZ)
 39/* indicating the first command block */
 40#define	ACE_CMD_INIT_BLOCK	1
 41/* indicating the last command block */
 42#define	ACE_CMD_FINAL_BLOCK	1
 43/* size of camera status notification content */
 44#define	ACE_CAMERA_STATUS_SIZE	5
 45
 46/* UUID used to get firmware id */
 47#define ACE_GET_FW_ID_UUID UUID_LE(0x6167DCFB, 0x72F1, 0x4584, 0xBF, \
 48				   0xE3, 0x84, 0x17, 0x71, 0xAA, 0x79, 0x0B)
 49
 50/* UUID used to get csi device */
 51#define MEI_CSI_UUID UUID_LE(0x92335FCF, 0x3203, 0x4472, \
 52			     0xAF, 0x93, 0x7b, 0x44, 0x53, 0xAC, 0x29, 0xDA)
 53
 54/* identify firmware event type */
 55enum ace_event_type {
 56	/* firmware ready */
 57	ACE_FW_READY = 0x8,
 58
 59	/* command response */
 60	ACE_CMD_RESPONSE = 0x10,
 61};
 62
 63/* identify camera sensor ownership */
 64enum ace_camera_owner {
 65	ACE_CAMERA_IVSC,
 66	ACE_CAMERA_HOST,
 67};
 68
 69/* identify the command id supported by firmware IPC */
 70enum ace_cmd_id {
 71	/* used to switch camera sensor to host */
 72	ACE_SWITCH_CAMERA_TO_HOST = 0x13,
 73
 74	/* used to switch camera sensor to IVSC */
 75	ACE_SWITCH_CAMERA_TO_IVSC = 0x14,
 76
 77	/* used to get firmware id */
 78	ACE_GET_FW_ID = 0x1A,
 79};
 80
 81/* ACE command header structure */
 82struct ace_cmd_hdr {
 83	u32 firmware_id : 16;
 84	u32 instance_id : 8;
 85	u32 type : 5;
 86	u32 rsp : 1;
 87	u32 msg_tgt : 1;
 88	u32 _hw_rsvd_1 : 1;
 89	u32 param_size : 20;
 90	u32 cmd_id : 8;
 91	u32 final_block : 1;
 92	u32 init_block : 1;
 93	u32 _hw_rsvd_2 : 2;
 94} __packed;
 95
 96/* ACE command parameter structure */
 97union ace_cmd_param {
 98	uuid_le uuid;
 99	u32 param;
100};
101
102/* ACE command structure */
103struct ace_cmd {
104	struct ace_cmd_hdr hdr;
105	union ace_cmd_param param;
106} __packed;
107
108/* ACE notification header */
109union ace_notif_hdr {
110	struct _confirm {
111		u32 status : 24;
112		u32 type : 5;
113		u32 rsp : 1;
114		u32 msg_tgt : 1;
115		u32 _hw_rsvd_1 : 1;
116		u32 param_size : 20;
117		u32 cmd_id : 8;
118		u32 final_block : 1;
119		u32 init_block : 1;
120		u32 _hw_rsvd_2 : 2;
121	} __packed ack;
122
123	struct _event {
124		u32 rsvd1 : 16;
125		u32 event_type : 8;
126		u32 type : 5;
127		u32 ack : 1;
128		u32 msg_tgt : 1;
129		u32 _hw_rsvd_1 : 1;
130		u32 rsvd2 : 30;
131		u32 _hw_rsvd_2 : 2;
132	} __packed event;
133
134	struct _response {
135		u32 event_id : 16;
136		u32 notif_type : 8;
137		u32 type : 5;
138		u32 rsp : 1;
139		u32 msg_tgt : 1;
140		u32 _hw_rsvd_1 : 1;
141		u32 event_data_size : 16;
142		u32 request_target : 1;
143		u32 request_type : 5;
144		u32 cmd_id : 8;
145		u32 _hw_rsvd_2 : 2;
146	} __packed response;
147};
148
149/* ACE notification content */
150union ace_notif_cont {
151	u16 firmware_id;
152	u8 state_notif;
153	u8 camera_status[ACE_CAMERA_STATUS_SIZE];
154};
155
156/* ACE notification structure */
157struct ace_notif {
158	union ace_notif_hdr hdr;
159	union ace_notif_cont cont;
160} __packed;
161
162struct mei_ace {
163	struct mei_cl_device *cldev;
164
165	/* command ack */
166	struct ace_notif cmd_ack;
167	/* command response */
168	struct ace_notif cmd_response;
169	/* used to wait for command ack and response */
170	struct completion cmd_completion;
171	/* lock used to prevent multiple call to send command */
172	struct mutex lock;
173
174	/* used to construct command */
175	u16 firmware_id;
176
177	struct device *csi_dev;
178
179	/* runtime PM link from ace to csi */
180	struct device_link *csi_link;
181
182	struct work_struct work;
183};
184
185static inline void init_cmd_hdr(struct ace_cmd_hdr *hdr)
186{
187	memset(hdr, 0, sizeof(struct ace_cmd_hdr));
188
189	hdr->type = ACE_CMD_SET;
190	hdr->msg_tgt = ACE_DRV_MSG;
191	hdr->init_block = ACE_CMD_INIT_BLOCK;
192	hdr->final_block = ACE_CMD_FINAL_BLOCK;
193}
194
195static int construct_command(struct mei_ace *ace, struct ace_cmd *cmd,
196			     enum ace_cmd_id cmd_id)
197{
198	union ace_cmd_param *param = &cmd->param;
199	struct ace_cmd_hdr *hdr = &cmd->hdr;
200
201	init_cmd_hdr(hdr);
202
203	hdr->cmd_id = cmd_id;
204	switch (cmd_id) {
205	case ACE_GET_FW_ID:
206		param->uuid = ACE_GET_FW_ID_UUID;
207		hdr->param_size = sizeof(param->uuid);
208		break;
209	case ACE_SWITCH_CAMERA_TO_IVSC:
210		param->param = 0;
211		hdr->firmware_id = ace->firmware_id;
212		hdr->param_size = sizeof(param->param);
213		break;
214	case ACE_SWITCH_CAMERA_TO_HOST:
215		hdr->firmware_id = ace->firmware_id;
216		break;
217	default:
218		return -EINVAL;
219	}
220
221	return hdr->param_size + sizeof(cmd->hdr);
222}
223
224/* send command to firmware */
225static int mei_ace_send(struct mei_ace *ace, struct ace_cmd *cmd,
226			size_t len, bool only_ack)
227{
228	union ace_notif_hdr *resp_hdr = &ace->cmd_response.hdr;
229	union ace_notif_hdr *ack_hdr = &ace->cmd_ack.hdr;
230	struct ace_cmd_hdr *cmd_hdr = &cmd->hdr;
231	int ret;
232
233	mutex_lock(&ace->lock);
234
235	reinit_completion(&ace->cmd_completion);
236
237	ret = mei_cldev_send(ace->cldev, (u8 *)cmd, len);
238	if (ret < 0)
239		goto out;
240
241	ret = wait_for_completion_killable_timeout(&ace->cmd_completion,
242						   ACE_CMD_TIMEOUT);
243	if (ret < 0) {
244		goto out;
245	} else if (!ret) {
246		ret = -ETIMEDOUT;
247		goto out;
248	}
249
250	if (ack_hdr->ack.cmd_id != cmd_hdr->cmd_id) {
251		ret = -EINVAL;
252		goto out;
253	}
254
255	/* command ack status */
256	ret = ack_hdr->ack.status;
257	if (ret) {
258		ret = -EIO;
259		goto out;
260	}
261
262	if (only_ack)
263		goto out;
264
265	ret = wait_for_completion_killable_timeout(&ace->cmd_completion,
266						   ACE_CMD_TIMEOUT);
267	if (ret < 0) {
268		goto out;
269	} else if (!ret) {
270		ret = -ETIMEDOUT;
271		goto out;
272	} else {
273		ret = 0;
274	}
275
276	if (resp_hdr->response.cmd_id != cmd_hdr->cmd_id)
277		ret = -EINVAL;
278
279out:
280	mutex_unlock(&ace->lock);
281
282	return ret;
283}
284
285static int ace_set_camera_owner(struct mei_ace *ace,
286				enum ace_camera_owner owner)
287{
288	enum ace_cmd_id cmd_id;
289	struct ace_cmd cmd;
290	int cmd_size;
291	int ret;
292
293	if (owner == ACE_CAMERA_IVSC)
294		cmd_id = ACE_SWITCH_CAMERA_TO_IVSC;
295	else
296		cmd_id = ACE_SWITCH_CAMERA_TO_HOST;
297
298	cmd_size = construct_command(ace, &cmd, cmd_id);
299	if (cmd_size >= 0)
300		ret = mei_ace_send(ace, &cmd, cmd_size, false);
301	else
302		ret = cmd_size;
303
304	return ret;
305}
306
307/* the first command downloaded to firmware */
308static inline int ace_get_firmware_id(struct mei_ace *ace)
309{
310	struct ace_cmd cmd;
311	int cmd_size;
312	int ret;
313
314	cmd_size = construct_command(ace, &cmd, ACE_GET_FW_ID);
315	if (cmd_size >= 0)
316		ret = mei_ace_send(ace, &cmd, cmd_size, true);
317	else
318		ret = cmd_size;
319
320	return ret;
321}
322
323static void handle_command_response(struct mei_ace *ace,
324				    struct ace_notif *resp, int len)
325{
326	union ace_notif_hdr *hdr = &resp->hdr;
327
328	switch (hdr->response.cmd_id) {
329	case ACE_SWITCH_CAMERA_TO_IVSC:
330	case ACE_SWITCH_CAMERA_TO_HOST:
331		memcpy(&ace->cmd_response, resp, len);
332		complete(&ace->cmd_completion);
333		break;
334	case ACE_GET_FW_ID:
335		break;
336	default:
337		break;
338	}
339}
340
341static void handle_command_ack(struct mei_ace *ace,
342			       struct ace_notif *ack, int len)
343{
344	union ace_notif_hdr *hdr = &ack->hdr;
345
346	switch (hdr->ack.cmd_id) {
347	case ACE_GET_FW_ID:
348		ace->firmware_id = ack->cont.firmware_id;
349		fallthrough;
350	case ACE_SWITCH_CAMERA_TO_IVSC:
351	case ACE_SWITCH_CAMERA_TO_HOST:
352		memcpy(&ace->cmd_ack, ack, len);
353		complete(&ace->cmd_completion);
354		break;
355	default:
356		break;
357	}
358}
359
360/* callback for receive */
361static void mei_ace_rx(struct mei_cl_device *cldev)
362{
363	struct mei_ace *ace = mei_cldev_get_drvdata(cldev);
364	struct ace_notif event;
365	union ace_notif_hdr *hdr = &event.hdr;
366	int ret;
367
368	ret = mei_cldev_recv(cldev, (u8 *)&event, sizeof(event));
369	if (ret < 0) {
370		dev_err(&cldev->dev, "recv error: %d\n", ret);
371		return;
372	}
373
374	if (hdr->event.ack) {
375		handle_command_ack(ace, &event, ret);
376		return;
377	}
378
379	switch (hdr->event.event_type) {
380	case ACE_CMD_RESPONSE:
381		handle_command_response(ace, &event, ret);
382		break;
383	case ACE_FW_READY:
384		/*
385		 * firmware ready notification sent to driver
386		 * after HECI client connected with firmware.
387		 */
388		dev_dbg(&cldev->dev, "firmware ready\n");
389		break;
390	default:
391		break;
392	}
393}
394
395static int mei_ace_setup_dev_link(struct mei_ace *ace)
396{
397	struct device *dev = &ace->cldev->dev;
398	uuid_le uuid = MEI_CSI_UUID;
399	struct device *csi_dev;
400	char name[64];
401	int ret;
402
403	snprintf(name, sizeof(name), "%s-%pUl", dev_name(dev->parent), &uuid);
404
405	csi_dev = device_find_child_by_name(dev->parent, name);
406	if (!csi_dev) {
407		ret = -EPROBE_DEFER;
408		goto err;
409	} else if (!dev_fwnode(csi_dev)) {
410		ret = -EPROBE_DEFER;
411		goto err_put;
412	}
413
414	/* setup link between mei_ace and mei_csi */
415	ace->csi_link = device_link_add(csi_dev, dev, DL_FLAG_PM_RUNTIME |
416					DL_FLAG_RPM_ACTIVE | DL_FLAG_STATELESS);
417	put_device(csi_dev);
418	if (!ace->csi_link) {
419		ret = -EINVAL;
420		dev_err(dev, "failed to link to %s\n", dev_name(csi_dev));
421		goto err;
422	}
423
424	ace->csi_dev = csi_dev;
425
426	return 0;
427
428err_put:
429	put_device(csi_dev);
430
431err:
432	return ret;
433}
434
435/* switch camera to host before probe sensor device */
436static void mei_ace_post_probe_work(struct work_struct *work)
437{
438	struct acpi_device *adev;
439	struct mei_ace *ace;
440	struct device *dev;
441	int ret;
442
443	ace = container_of(work, struct mei_ace, work);
444	dev = &ace->cldev->dev;
445
446	ret = ace_set_camera_owner(ace, ACE_CAMERA_HOST);
447	if (ret) {
448		dev_err(dev, "switch camera to host failed: %d\n", ret);
449		return;
450	}
451
452	adev = ACPI_COMPANION(dev->parent);
453	if (!adev)
454		return;
455
456	acpi_dev_clear_dependencies(adev);
457}
458
459static int mei_ace_probe(struct mei_cl_device *cldev,
460			 const struct mei_cl_device_id *id)
461{
462	struct device *dev = &cldev->dev;
463	struct mei_ace *ace;
464	int ret;
465
466	ace = devm_kzalloc(dev, sizeof(struct mei_ace), GFP_KERNEL);
467	if (!ace)
468		return -ENOMEM;
469
470	ace->cldev = cldev;
471	mutex_init(&ace->lock);
472	init_completion(&ace->cmd_completion);
473	INIT_WORK(&ace->work, mei_ace_post_probe_work);
474
475	mei_cldev_set_drvdata(cldev, ace);
476
477	ret = mei_cldev_enable(cldev);
478	if (ret < 0) {
479		dev_err(dev, "mei_cldev_enable failed: %d\n", ret);
480		goto destroy_mutex;
481	}
482
483	ret = mei_cldev_register_rx_cb(cldev, mei_ace_rx);
484	if (ret) {
485		dev_err(dev, "event cb registration failed: %d\n", ret);
486		goto err_disable;
487	}
488
489	ret = ace_get_firmware_id(ace);
490	if (ret) {
491		dev_err(dev, "get firmware id failed: %d\n", ret);
492		goto err_disable;
493	}
494
495	pm_runtime_set_active(dev);
496	pm_runtime_enable(dev);
497
498	ret = mei_ace_setup_dev_link(ace);
499	if (ret)
500		goto disable_pm;
501
502	schedule_work(&ace->work);
503
504	return 0;
505
506disable_pm:
507	pm_runtime_disable(dev);
508	pm_runtime_set_suspended(dev);
509
510err_disable:
511	mei_cldev_disable(cldev);
512
513destroy_mutex:
514	mutex_destroy(&ace->lock);
515
516	return ret;
517}
518
519static void mei_ace_remove(struct mei_cl_device *cldev)
520{
521	struct mei_ace *ace = mei_cldev_get_drvdata(cldev);
522
523	cancel_work_sync(&ace->work);
524
525	device_link_del(ace->csi_link);
526
527	pm_runtime_disable(&cldev->dev);
528	pm_runtime_set_suspended(&cldev->dev);
529
530	ace_set_camera_owner(ace, ACE_CAMERA_IVSC);
531
532	mei_cldev_disable(cldev);
533
534	mutex_destroy(&ace->lock);
535}
536
537static int __maybe_unused mei_ace_runtime_suspend(struct device *dev)
538{
539	struct mei_ace *ace = dev_get_drvdata(dev);
540
541	return ace_set_camera_owner(ace, ACE_CAMERA_IVSC);
542}
543
544static int __maybe_unused mei_ace_runtime_resume(struct device *dev)
545{
546	struct mei_ace *ace = dev_get_drvdata(dev);
547
548	return ace_set_camera_owner(ace, ACE_CAMERA_HOST);
549}
550
551static const struct dev_pm_ops mei_ace_pm_ops = {
552	SET_RUNTIME_PM_OPS(mei_ace_runtime_suspend,
553			   mei_ace_runtime_resume, NULL)
554};
555
556#define MEI_ACE_UUID UUID_LE(0x5DB76CF6, 0x0A68, 0x4ED6, \
557			     0x9B, 0x78, 0x03, 0x61, 0x63, 0x5E, 0x24, 0x47)
558
559static const struct mei_cl_device_id mei_ace_tbl[] = {
560	{ .uuid = MEI_ACE_UUID, .version = MEI_CL_VERSION_ANY },
561	{ /* sentinel */ }
562};
563MODULE_DEVICE_TABLE(mei, mei_ace_tbl);
564
565static struct mei_cl_driver mei_ace_driver = {
566	.id_table = mei_ace_tbl,
567	.name = KBUILD_MODNAME,
568
569	.probe = mei_ace_probe,
570	.remove = mei_ace_remove,
571
572	.driver = {
573		.pm = &mei_ace_pm_ops,
574	},
575};
576
577module_mei_cl_driver(mei_ace_driver);
578
579MODULE_AUTHOR("Wentong Wu");
580MODULE_AUTHOR("Zhifeng Wang <zhifeng.wang@intel.com>");
581MODULE_DESCRIPTION("Device driver for IVSC ACE");
582MODULE_LICENSE("GPL");