1 // SPDX-License-Identifier: GPL-2.0-only
3 * cec-core.c - HDMI Consumer Electronics Control framework - Core
5 * Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
8 #include <linux/errno.h>
9 #include <linux/init.h>
10 #include <linux/module.h>
11 #include <linux/kernel.h>
12 #include <linux/kmod.h>
13 #include <linux/slab.h>
15 #include <linux/string.h>
16 #include <linux/types.h>
20 #define CEC_NUM_DEVICES 256
21 #define CEC_NAME "cec"
24 * 400 ms is the time it takes for one 16 byte message to be
25 * transferred and 5 is the maximum number of retries. Add
26 * another 100 ms as a margin. So if the transmit doesn't
27 * finish before that time something is really wrong and we
30 * This is a sign that something it really wrong and a warning
33 #define CEC_XFER_TIMEOUT_MS (5 * 400 + 100)
36 module_param_named(debug, cec_debug, int, 0644);
37 MODULE_PARM_DESC(debug, "debug level (0-2)");
39 static bool debug_phys_addr;
40 module_param(debug_phys_addr, bool, 0644);
41 MODULE_PARM_DESC(debug_phys_addr, "add CEC_CAP_PHYS_ADDR if set");
43 static dev_t cec_dev_t;
46 static DEFINE_MUTEX(cec_devnode_lock);
47 static DECLARE_BITMAP(cec_devnode_nums, CEC_NUM_DEVICES);
49 static struct dentry *top_cec_dir;
51 /* dev to cec_devnode */
52 #define to_cec_devnode(cd) container_of(cd, struct cec_devnode, dev)
54 /* Called when the last user of the cec device exits. */
55 static void cec_devnode_release(struct device *cd)
57 struct cec_devnode *devnode = to_cec_devnode(cd);
59 mutex_lock(&cec_devnode_lock);
60 /* Mark device node number as free */
61 clear_bit(devnode->minor, cec_devnode_nums);
62 mutex_unlock(&cec_devnode_lock);
64 cec_delete_adapter(to_cec_adapter(devnode));
67 static const struct bus_type cec_bus_type = {
72 * Register a cec device node
74 * The registration code assigns minor numbers and registers the new device node
75 * with the kernel. An error is returned if no free minor number can be found,
76 * or if the registration of the device node fails.
78 * Zero is returned on success.
80 * Note that if the cec_devnode_register call fails, the release() callback of
81 * the cec_devnode structure is *not* called, so the caller is responsible for
84 static int __must_check cec_devnode_register(struct cec_devnode *devnode,
90 /* Part 1: Find a free minor number */
91 mutex_lock(&cec_devnode_lock);
92 minor = find_first_zero_bit(cec_devnode_nums, CEC_NUM_DEVICES);
93 if (minor == CEC_NUM_DEVICES) {
94 mutex_unlock(&cec_devnode_lock);
95 pr_err("could not get a free minor\n");
99 set_bit(minor, cec_devnode_nums);
100 mutex_unlock(&cec_devnode_lock);
102 devnode->minor = minor;
103 devnode->dev.bus = &cec_bus_type;
104 devnode->dev.devt = MKDEV(MAJOR(cec_dev_t), minor);
105 devnode->dev.release = cec_devnode_release;
106 dev_set_name(&devnode->dev, "cec%d", devnode->minor);
107 device_initialize(&devnode->dev);
109 /* Part 2: Initialize and register the character device */
110 cdev_init(&devnode->cdev, &cec_devnode_fops);
111 devnode->cdev.owner = owner;
112 kobject_set_name(&devnode->cdev.kobj, "cec%d", devnode->minor);
114 devnode->registered = true;
115 ret = cdev_device_add(&devnode->cdev, &devnode->dev);
117 devnode->registered = false;
118 pr_err("%s: cdev_device_add failed\n", __func__);
125 mutex_lock(&cec_devnode_lock);
126 clear_bit(devnode->minor, cec_devnode_nums);
127 mutex_unlock(&cec_devnode_lock);
132 * Unregister a cec device node
134 * This unregisters the passed device. Future open calls will be met with
137 * This function can safely be called if the device node has never been
138 * registered or has already been unregistered.
140 static void cec_devnode_unregister(struct cec_adapter *adap)
142 struct cec_devnode *devnode = &adap->devnode;
145 mutex_lock(&devnode->lock);
147 /* Check if devnode was never registered or already unregistered */
148 if (!devnode->registered || devnode->unregistered) {
149 mutex_unlock(&devnode->lock);
152 devnode->registered = false;
153 devnode->unregistered = true;
155 mutex_lock(&devnode->lock_fhs);
156 list_for_each_entry(fh, &devnode->fhs, list)
157 wake_up_interruptible(&fh->wait);
158 mutex_unlock(&devnode->lock_fhs);
160 mutex_unlock(&devnode->lock);
162 mutex_lock(&adap->lock);
163 __cec_s_phys_addr(adap, CEC_PHYS_ADDR_INVALID, false);
164 __cec_s_log_addrs(adap, NULL, false);
165 // Disable the adapter (since adap->devnode.unregistered is true)
166 cec_adap_enable(adap);
167 mutex_unlock(&adap->lock);
169 cdev_device_del(&devnode->cdev, &devnode->dev);
170 put_device(&devnode->dev);
173 #ifdef CONFIG_DEBUG_FS
174 static ssize_t cec_error_inj_write(struct file *file,
175 const char __user *ubuf, size_t count, loff_t *ppos)
177 struct seq_file *sf = file->private_data;
178 struct cec_adapter *adap = sf->private;
183 buf = memdup_user_nul(ubuf, min_t(size_t, PAGE_SIZE, count));
189 line = strsep(&p, "\n");
190 if (!*line || *line == '#')
192 if (!call_op(adap, error_inj_parse_line, line)) {
201 static int cec_error_inj_show(struct seq_file *sf, void *unused)
203 struct cec_adapter *adap = sf->private;
205 return call_op(adap, error_inj_show, sf);
208 static int cec_error_inj_open(struct inode *inode, struct file *file)
210 return single_open(file, cec_error_inj_show, inode->i_private);
213 static const struct file_operations cec_error_inj_fops = {
214 .open = cec_error_inj_open,
215 .write = cec_error_inj_write,
218 .release = single_release,
222 struct cec_adapter *cec_allocate_adapter(const struct cec_adap_ops *ops,
223 void *priv, const char *name, u32 caps,
226 struct cec_adapter *adap;
229 #ifndef CONFIG_MEDIA_CEC_RC
234 return ERR_PTR(-EINVAL);
236 return ERR_PTR(-EINVAL);
237 if (WARN_ON(!available_las || available_las > CEC_MAX_LOG_ADDRS))
238 return ERR_PTR(-EINVAL);
239 adap = kzalloc(sizeof(*adap), GFP_KERNEL);
241 return ERR_PTR(-ENOMEM);
242 strscpy(adap->name, name, sizeof(adap->name));
243 adap->phys_addr = CEC_PHYS_ADDR_INVALID;
244 adap->cec_pin_is_high = true;
245 adap->log_addrs.cec_version = CEC_OP_CEC_VERSION_2_0;
246 adap->log_addrs.vendor_id = CEC_VENDOR_ID_NONE;
247 adap->capabilities = caps | CEC_CAP_REPLY_VENDOR_ID;
249 adap->capabilities |= CEC_CAP_PHYS_ADDR;
250 adap->needs_hpd = caps & CEC_CAP_NEEDS_HPD;
251 adap->available_log_addrs = available_las;
255 mutex_init(&adap->lock);
256 INIT_LIST_HEAD(&adap->transmit_queue);
257 INIT_LIST_HEAD(&adap->wait_queue);
258 init_waitqueue_head(&adap->kthread_waitq);
260 /* adap->devnode initialization */
261 INIT_LIST_HEAD(&adap->devnode.fhs);
262 mutex_init(&adap->devnode.lock_fhs);
263 mutex_init(&adap->devnode.lock);
265 adap->kthread = kthread_run(cec_thread_func, adap, "cec-%s", name);
266 if (IS_ERR(adap->kthread)) {
267 pr_err("cec-%s: kernel_thread() failed\n", name);
268 res = PTR_ERR(adap->kthread);
273 #ifdef CONFIG_MEDIA_CEC_RC
274 if (!(caps & CEC_CAP_RC))
277 /* Prepare the RC input device */
278 adap->rc = rc_allocate_device(RC_DRIVER_SCANCODE);
280 pr_err("cec-%s: failed to allocate memory for rc_dev\n",
282 kthread_stop(adap->kthread);
284 return ERR_PTR(-ENOMEM);
287 snprintf(adap->input_phys, sizeof(adap->input_phys),
288 "%s/input0", adap->name);
290 adap->rc->device_name = adap->name;
291 adap->rc->input_phys = adap->input_phys;
292 adap->rc->input_id.bustype = BUS_CEC;
293 adap->rc->input_id.vendor = 0;
294 adap->rc->input_id.product = 0;
295 adap->rc->input_id.version = 1;
296 adap->rc->driver_name = CEC_NAME;
297 adap->rc->allowed_protocols = RC_PROTO_BIT_CEC;
298 adap->rc->priv = adap;
299 adap->rc->map_name = RC_MAP_CEC;
300 adap->rc->timeout = MS_TO_US(550);
304 EXPORT_SYMBOL_GPL(cec_allocate_adapter);
306 int cec_register_adapter(struct cec_adapter *adap,
307 struct device *parent)
311 if (IS_ERR_OR_NULL(adap))
314 if (WARN_ON(!parent))
317 adap->owner = parent->driver->owner;
318 adap->devnode.dev.parent = parent;
319 if (!adap->xfer_timeout_ms)
320 adap->xfer_timeout_ms = CEC_XFER_TIMEOUT_MS;
322 #ifdef CONFIG_MEDIA_CEC_RC
323 if (adap->capabilities & CEC_CAP_RC) {
324 adap->rc->dev.parent = parent;
325 res = rc_register_device(adap->rc);
328 pr_err("cec-%s: failed to prepare input device\n",
330 rc_free_device(adap->rc);
337 res = cec_devnode_register(&adap->devnode, adap->owner);
339 #ifdef CONFIG_MEDIA_CEC_RC
340 /* Note: rc_unregister also calls rc_free */
341 rc_unregister_device(adap->rc);
347 dev_set_drvdata(&adap->devnode.dev, adap);
348 #ifdef CONFIG_DEBUG_FS
352 adap->cec_dir = debugfs_create_dir(dev_name(&adap->devnode.dev),
355 debugfs_create_devm_seqfile(&adap->devnode.dev, "status", adap->cec_dir,
358 if (!adap->ops->error_inj_show || !adap->ops->error_inj_parse_line)
360 debugfs_create_file("error-inj", 0644, adap->cec_dir, adap,
361 &cec_error_inj_fops);
365 EXPORT_SYMBOL_GPL(cec_register_adapter);
367 void cec_unregister_adapter(struct cec_adapter *adap)
369 if (IS_ERR_OR_NULL(adap))
372 #ifdef CONFIG_MEDIA_CEC_RC
373 /* Note: rc_unregister also calls rc_free */
374 rc_unregister_device(adap->rc);
377 debugfs_remove_recursive(adap->cec_dir);
378 #ifdef CONFIG_CEC_NOTIFIER
379 cec_notifier_cec_adap_unregister(adap->notifier, adap);
381 cec_devnode_unregister(adap);
383 EXPORT_SYMBOL_GPL(cec_unregister_adapter);
385 void cec_delete_adapter(struct cec_adapter *adap)
387 if (IS_ERR_OR_NULL(adap))
389 if (adap->kthread_config)
390 kthread_stop(adap->kthread_config);
391 kthread_stop(adap->kthread);
392 if (adap->ops->adap_free)
393 adap->ops->adap_free(adap);
394 #ifdef CONFIG_MEDIA_CEC_RC
395 rc_free_device(adap->rc);
399 EXPORT_SYMBOL_GPL(cec_delete_adapter);
402 * Initialise cec for linux
404 static int __init cec_devnode_init(void)
406 int ret = alloc_chrdev_region(&cec_dev_t, 0, CEC_NUM_DEVICES, CEC_NAME);
409 pr_warn("cec: unable to allocate major\n");
413 #ifdef CONFIG_DEBUG_FS
414 top_cec_dir = debugfs_create_dir("cec", NULL);
415 if (IS_ERR_OR_NULL(top_cec_dir)) {
416 pr_warn("cec: Failed to create debugfs cec dir\n");
421 ret = bus_register(&cec_bus_type);
423 unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
424 pr_warn("cec: bus_register failed\n");
431 static void __exit cec_devnode_exit(void)
433 debugfs_remove_recursive(top_cec_dir);
434 bus_unregister(&cec_bus_type);
435 unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
438 subsys_initcall(cec_devnode_init);
439 module_exit(cec_devnode_exit)
442 MODULE_DESCRIPTION("Device node registration for cec drivers");
443 MODULE_LICENSE("GPL");