581 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Copyright (C) 2023 Intel Corporation. All rights reserved.4 * Intel Visual Sensing Controller ACE Linux driver5 */6 7/*8 * To set ownership of camera sensor, there is specific command, which9 * is sent via MEI protocol. That's a two-step scheme where the firmware10 * first acks receipt of the command and later responses the command was11 * executed. The command sending function uses "completion" as the12 * synchronization mechanism. The notification for command is received13 * via a mei callback which wakes up the caller. There can be only one14 * outstanding command at a time.15 *16 * The power line of camera sensor is directly connected to IVSC instead17 * of host, when camera sensor ownership is switched to host, sensor is18 * 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 135/* indicating set command */36#define ACE_CMD_SET 437/* command timeout determined experimentally */38#define ACE_CMD_TIMEOUT (5 * HZ)39/* indicating the first command block */40#define ACE_CMD_INIT_BLOCK 141/* indicating the last command block */42#define ACE_CMD_FINAL_BLOCK 143/* size of camera status notification content */44#define ACE_CAMERA_STATUS_SIZE 545 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 else296 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 else302 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 else318 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 driver386 * 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 if (!ace->csi_link) {418 ret = -EINVAL;419 dev_err(dev, "failed to link to %s\n", dev_name(csi_dev));420 goto err_put;421 }422 423 ace->csi_dev = csi_dev;424 425 return 0;426 427err_put:428 put_device(csi_dev);429 430err:431 return ret;432}433 434/* switch camera to host before probe sensor device */435static void mei_ace_post_probe_work(struct work_struct *work)436{437 struct acpi_device *adev;438 struct mei_ace *ace;439 struct device *dev;440 int ret;441 442 ace = container_of(work, struct mei_ace, work);443 dev = &ace->cldev->dev;444 445 ret = ace_set_camera_owner(ace, ACE_CAMERA_HOST);446 if (ret) {447 dev_err(dev, "switch camera to host failed: %d\n", ret);448 return;449 }450 451 adev = ACPI_COMPANION(dev->parent);452 if (!adev)453 return;454 455 acpi_dev_clear_dependencies(adev);456}457 458static int mei_ace_probe(struct mei_cl_device *cldev,459 const struct mei_cl_device_id *id)460{461 struct device *dev = &cldev->dev;462 struct mei_ace *ace;463 int ret;464 465 ace = devm_kzalloc(dev, sizeof(struct mei_ace), GFP_KERNEL);466 if (!ace)467 return -ENOMEM;468 469 ace->cldev = cldev;470 mutex_init(&ace->lock);471 init_completion(&ace->cmd_completion);472 INIT_WORK(&ace->work, mei_ace_post_probe_work);473 474 mei_cldev_set_drvdata(cldev, ace);475 476 ret = mei_cldev_enable(cldev);477 if (ret < 0) {478 dev_err(dev, "mei_cldev_enable failed: %d\n", ret);479 goto destroy_mutex;480 }481 482 ret = mei_cldev_register_rx_cb(cldev, mei_ace_rx);483 if (ret) {484 dev_err(dev, "event cb registration failed: %d\n", ret);485 goto err_disable;486 }487 488 ret = ace_get_firmware_id(ace);489 if (ret) {490 dev_err(dev, "get firmware id failed: %d\n", ret);491 goto err_disable;492 }493 494 pm_runtime_set_active(dev);495 pm_runtime_enable(dev);496 497 ret = mei_ace_setup_dev_link(ace);498 if (ret)499 goto disable_pm;500 501 schedule_work(&ace->work);502 503 return 0;504 505disable_pm:506 pm_runtime_disable(dev);507 pm_runtime_set_suspended(dev);508 509err_disable:510 mei_cldev_disable(cldev);511 512destroy_mutex:513 mutex_destroy(&ace->lock);514 515 return ret;516}517 518static void mei_ace_remove(struct mei_cl_device *cldev)519{520 struct mei_ace *ace = mei_cldev_get_drvdata(cldev);521 522 cancel_work_sync(&ace->work);523 524 device_link_del(ace->csi_link);525 put_device(ace->csi_dev);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 mutex_destroy(&ace->lock);533}534 535static int __maybe_unused mei_ace_runtime_suspend(struct device *dev)536{537 struct mei_ace *ace = dev_get_drvdata(dev);538 539 return ace_set_camera_owner(ace, ACE_CAMERA_IVSC);540}541 542static int __maybe_unused mei_ace_runtime_resume(struct device *dev)543{544 struct mei_ace *ace = dev_get_drvdata(dev);545 546 return ace_set_camera_owner(ace, ACE_CAMERA_HOST);547}548 549static const struct dev_pm_ops mei_ace_pm_ops = {550 SET_RUNTIME_PM_OPS(mei_ace_runtime_suspend,551 mei_ace_runtime_resume, NULL)552};553 554#define MEI_ACE_UUID UUID_LE(0x5DB76CF6, 0x0A68, 0x4ED6, \555 0x9B, 0x78, 0x03, 0x61, 0x63, 0x5E, 0x24, 0x47)556 557static const struct mei_cl_device_id mei_ace_tbl[] = {558 { .uuid = MEI_ACE_UUID, .version = MEI_CL_VERSION_ANY },559 { /* sentinel */ }560};561MODULE_DEVICE_TABLE(mei, mei_ace_tbl);562 563static struct mei_cl_driver mei_ace_driver = {564 .id_table = mei_ace_tbl,565 .name = KBUILD_MODNAME,566 567 .probe = mei_ace_probe,568 .remove = mei_ace_remove,569 570 .driver = {571 .pm = &mei_ace_pm_ops,572 },573};574 575module_mei_cl_driver(mei_ace_driver);576 577MODULE_AUTHOR("Wentong Wu <wentong.wu@intel.com>");578MODULE_AUTHOR("Zhifeng Wang <zhifeng.wang@intel.com>");579MODULE_DESCRIPTION("Device driver for IVSC ACE");580MODULE_LICENSE("GPL");581