cec-core.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * cec-core.c - HDMI Consumer Electronics Control framework - Core
  4 *
  5 * Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
  6 */
  7
  8#include <linux/debugfs.h>
  9#include <linux/errno.h>
 10#include <linux/init.h>
 11#include <linux/kernel.h>
 12#include <linux/kmod.h>
 13#include <linux/mm.h>
 14#include <linux/module.h>
 15#include <linux/slab.h>
 16#include <linux/string.h>
 17#include <linux/types.h>
 18
 19#include "cec-priv.h"
 20
 21#define CEC_NUM_DEVICES	256
 22#define CEC_NAME	"cec"
 23
 24/*
 25 * 400 ms is the time it takes for one 16 byte message to be
 26 * transferred and 5 is the maximum number of retries. Add
 27 * another 100 ms as a margin. So if the transmit doesn't
 28 * finish before that time something is really wrong and we
 29 * have to time out.
 30 *
 31 * This is a sign that something it really wrong and a warning
 32 * will be issued.
 33 */
 34#define CEC_XFER_TIMEOUT_MS (5 * 400 + 100)
 35
 36int cec_debug;
 37module_param_named(debug, cec_debug, int, 0644);
 38MODULE_PARM_DESC(debug, "debug level (0-2)");
 39
 40static bool debug_phys_addr;
 41module_param(debug_phys_addr, bool, 0644);
 42MODULE_PARM_DESC(debug_phys_addr, "add CEC_CAP_PHYS_ADDR if set");
 43
 44static dev_t cec_dev_t;
 45
 46/* Active devices */
 47static DEFINE_MUTEX(cec_devnode_lock);
 48static DECLARE_BITMAP(cec_devnode_nums, CEC_NUM_DEVICES);
 49
 50static struct dentry *top_cec_dir;
 51
 52/* dev to cec_devnode */
 53#define to_cec_devnode(cd) container_of(cd, struct cec_devnode, dev)
 54
 55/* Called when the last user of the cec device exits. */
 56static void cec_devnode_release(struct device *cd)
 57{
 58	struct cec_devnode *devnode = to_cec_devnode(cd);
 59
 60	mutex_lock(&cec_devnode_lock);
 61	/* Mark device node number as free */
 62	clear_bit(devnode->minor, cec_devnode_nums);
 63	mutex_unlock(&cec_devnode_lock);
 64
 65	cec_delete_adapter(to_cec_adapter(devnode));
 66}
 67
 68static const struct bus_type cec_bus_type = {
 69	.name = CEC_NAME,
 70};
 71
 72/*
 73 * Register a cec device node
 74 *
 75 * The registration code assigns minor numbers and registers the new device node
 76 * with the kernel. An error is returned if no free minor number can be found,
 77 * or if the registration of the device node fails.
 78 *
 79 * Zero is returned on success.
 80 *
 81 * Note that if the cec_devnode_register call fails, the release() callback of
 82 * the cec_devnode structure is *not* called, so the caller is responsible for
 83 * freeing any data.
 84 */
 85static int __must_check cec_devnode_register(struct cec_devnode *devnode,
 86					     struct module *owner)
 87{
 88	int minor;
 89	int ret;
 90
 91	/* Part 1: Find a free minor number */
 92	mutex_lock(&cec_devnode_lock);
 93	minor = find_first_zero_bit(cec_devnode_nums, CEC_NUM_DEVICES);
 94	if (minor == CEC_NUM_DEVICES) {
 95		mutex_unlock(&cec_devnode_lock);
 96		pr_err("could not get a free minor\n");
 97		return -ENFILE;
 98	}
 99
100	set_bit(minor, cec_devnode_nums);
101	mutex_unlock(&cec_devnode_lock);
102
103	devnode->minor = minor;
104	devnode->dev.bus = &cec_bus_type;
105	devnode->dev.devt = MKDEV(MAJOR(cec_dev_t), minor);
106	devnode->dev.release = cec_devnode_release;
107	dev_set_name(&devnode->dev, "cec%d", devnode->minor);
108	device_initialize(&devnode->dev);
109
110	/* Part 2: Initialize and register the character device */
111	cdev_init(&devnode->cdev, &cec_devnode_fops);
112	devnode->cdev.owner = owner;
113	kobject_set_name(&devnode->cdev.kobj, "cec%d", devnode->minor);
114
115	devnode->registered = true;
116	ret = cdev_device_add(&devnode->cdev, &devnode->dev);
117	if (ret) {
118		devnode->registered = false;
119		pr_err("%s: cdev_device_add failed\n", __func__);
120		goto clr_bit;
121	}
122
123	return 0;
124
125clr_bit:
126	mutex_lock(&cec_devnode_lock);
127	clear_bit(devnode->minor, cec_devnode_nums);
128	mutex_unlock(&cec_devnode_lock);
129	return ret;
130}
131
132/*
133 * Unregister a cec device node
134 *
135 * This unregisters the passed device. Future open calls will be met with
136 * errors.
137 *
138 * This function can safely be called if the device node has never been
139 * registered or has already been unregistered.
140 */
141static void cec_devnode_unregister(struct cec_adapter *adap)
142{
143	struct cec_devnode *devnode = &adap->devnode;
144	struct cec_fh *fh;
145
146	mutex_lock(&devnode->lock);
147
148	/* Check if devnode was never registered or already unregistered */
149	if (!devnode->registered || devnode->unregistered) {
150		mutex_unlock(&devnode->lock);
151		return;
152	}
153	devnode->registered = false;
154	devnode->unregistered = true;
155
156	mutex_lock(&devnode->lock_fhs);
157	list_for_each_entry(fh, &devnode->fhs, list)
158		wake_up_interruptible(&fh->wait);
159	mutex_unlock(&devnode->lock_fhs);
160
161	mutex_unlock(&devnode->lock);
162
163	mutex_lock(&adap->lock);
164	__cec_s_phys_addr(adap, CEC_PHYS_ADDR_INVALID, false);
165	__cec_s_log_addrs(adap, NULL, false);
166	// Disable the adapter (since adap->devnode.unregistered is true)
167	cec_adap_enable(adap);
168	mutex_unlock(&adap->lock);
169
170	cdev_device_del(&devnode->cdev, &devnode->dev);
171	put_device(&devnode->dev);
172}
173
174#ifdef CONFIG_DEBUG_FS
175static ssize_t cec_error_inj_write(struct file *file,
176	const char __user *ubuf, size_t count, loff_t *ppos)
177{
178	struct seq_file *sf = file->private_data;
179	struct cec_adapter *adap = sf->private;
180	char *buf;
181	char *line;
182	char *p;
183
184	buf = memdup_user_nul(ubuf, min_t(size_t, PAGE_SIZE, count));
185	if (IS_ERR(buf))
186		return PTR_ERR(buf);
187	p = buf;
188	while (p && *p) {
189		p = skip_spaces(p);
190		line = strsep(&p, "\n");
191		if (!*line || *line == '#')
192			continue;
193		if (!call_op(adap, error_inj_parse_line, line)) {
194			kfree(buf);
195			return -EINVAL;
196		}
197	}
198	kfree(buf);
199	return count;
200}
201
202static int cec_error_inj_show(struct seq_file *sf, void *unused)
203{
204	struct cec_adapter *adap = sf->private;
205
206	return call_op(adap, error_inj_show, sf);
207}
208
209static int cec_error_inj_open(struct inode *inode, struct file *file)
210{
211	return single_open(file, cec_error_inj_show, inode->i_private);
212}
213
214static const struct file_operations cec_error_inj_fops = {
215	.open = cec_error_inj_open,
216	.write = cec_error_inj_write,
217	.read = seq_read,
218	.llseek = seq_lseek,
219	.release = single_release,
220};
221#endif
222
223struct cec_adapter *cec_allocate_adapter(const struct cec_adap_ops *ops,
224					 void *priv, const char *name, u32 caps,
225					 u8 available_las)
226{
227	struct cec_adapter *adap;
228	int res;
229
230#ifndef CONFIG_MEDIA_CEC_RC
231	caps &= ~CEC_CAP_RC;
232#endif
233
234	if (WARN_ON(!caps))
235		return ERR_PTR(-EINVAL);
236	if (WARN_ON(!ops))
237		return ERR_PTR(-EINVAL);
238	if (WARN_ON(!available_las || available_las > CEC_MAX_LOG_ADDRS))
239		return ERR_PTR(-EINVAL);
240	adap = kzalloc(sizeof(*adap), GFP_KERNEL);
241	if (!adap)
242		return ERR_PTR(-ENOMEM);
243	strscpy(adap->name, name, sizeof(adap->name));
244	adap->phys_addr = CEC_PHYS_ADDR_INVALID;
245	adap->cec_pin_is_high = true;
246	adap->log_addrs.cec_version = CEC_OP_CEC_VERSION_2_0;
247	adap->log_addrs.vendor_id = CEC_VENDOR_ID_NONE;
248	adap->capabilities = caps | CEC_CAP_REPLY_VENDOR_ID;
249	if (debug_phys_addr)
250		adap->capabilities |= CEC_CAP_PHYS_ADDR;
251	adap->needs_hpd = caps & CEC_CAP_NEEDS_HPD;
252	adap->available_log_addrs = available_las;
253	adap->sequence = 0;
254	adap->ops = ops;
255	adap->priv = priv;
256	mutex_init(&adap->lock);
257	INIT_LIST_HEAD(&adap->transmit_queue);
258	INIT_LIST_HEAD(&adap->wait_queue);
259	init_waitqueue_head(&adap->kthread_waitq);
260
261	/* adap->devnode initialization */
262	INIT_LIST_HEAD(&adap->devnode.fhs);
263	mutex_init(&adap->devnode.lock_fhs);
264	mutex_init(&adap->devnode.lock);
265
266	adap->kthread = kthread_run(cec_thread_func, adap, "cec-%s", name);
267	if (IS_ERR(adap->kthread)) {
268		pr_err("cec-%s: kernel_thread() failed\n", name);
269		res = PTR_ERR(adap->kthread);
270		kfree(adap);
271		return ERR_PTR(res);
272	}
273
274#ifdef CONFIG_MEDIA_CEC_RC
275	if (!(caps & CEC_CAP_RC))
276		return adap;
277
278	/* Prepare the RC input device */
279	adap->rc = rc_allocate_device(RC_DRIVER_SCANCODE);
280	if (!adap->rc) {
281		pr_err("cec-%s: failed to allocate memory for rc_dev\n",
282		       name);
283		kthread_stop(adap->kthread);
284		kfree(adap);
285		return ERR_PTR(-ENOMEM);
286	}
287
288	snprintf(adap->input_phys, sizeof(adap->input_phys),
289		 "%s/input0", adap->name);
290
291	adap->rc->device_name = adap->name;
292	adap->rc->input_phys = adap->input_phys;
293	adap->rc->input_id.bustype = BUS_CEC;
294	adap->rc->input_id.vendor = 0;
295	adap->rc->input_id.product = 0;
296	adap->rc->input_id.version = 1;
297	adap->rc->driver_name = CEC_NAME;
298	adap->rc->allowed_protocols = RC_PROTO_BIT_CEC;
299	adap->rc->priv = adap;
300	adap->rc->map_name = RC_MAP_CEC;
301	adap->rc->timeout = MS_TO_US(550);
302#endif
303	return adap;
304}
305EXPORT_SYMBOL_GPL(cec_allocate_adapter);
306
307int cec_register_adapter(struct cec_adapter *adap,
308			 struct device *parent)
309{
310	int res;
311
312	if (IS_ERR_OR_NULL(adap))
313		return 0;
314
315	if (WARN_ON(!parent))
316		return -EINVAL;
317
318	adap->owner = parent->driver->owner;
319	adap->devnode.dev.parent = parent;
320	if (!adap->xfer_timeout_ms)
321		adap->xfer_timeout_ms = CEC_XFER_TIMEOUT_MS;
322
323#ifdef CONFIG_MEDIA_CEC_RC
324	if (adap->capabilities & CEC_CAP_RC) {
325		adap->rc->dev.parent = parent;
326		res = rc_register_device(adap->rc);
327
328		if (res) {
329			pr_err("cec-%s: failed to prepare input device\n",
330			       adap->name);
331			rc_free_device(adap->rc);
332			adap->rc = NULL;
333			return res;
334		}
335	}
336#endif
337
338	res = cec_devnode_register(&adap->devnode, adap->owner);
339	if (res) {
340#ifdef CONFIG_MEDIA_CEC_RC
341		/* Note: rc_unregister also calls rc_free */
342		rc_unregister_device(adap->rc);
343		adap->rc = NULL;
344#endif
345		return res;
346	}
347
348	dev_set_drvdata(&adap->devnode.dev, adap);
349#ifdef CONFIG_DEBUG_FS
350	if (!top_cec_dir)
351		return 0;
352
353	adap->cec_dir = debugfs_create_dir(dev_name(&adap->devnode.dev),
354					   top_cec_dir);
355
356	debugfs_create_devm_seqfile(&adap->devnode.dev, "status", adap->cec_dir,
357				    cec_adap_status);
358
359	if (!adap->ops->error_inj_show || !adap->ops->error_inj_parse_line)
360		return 0;
361	debugfs_create_file("error-inj", 0644, adap->cec_dir, adap,
362			    &cec_error_inj_fops);
363#endif
364	return 0;
365}
366EXPORT_SYMBOL_GPL(cec_register_adapter);
367
368void cec_unregister_adapter(struct cec_adapter *adap)
369{
370	if (IS_ERR_OR_NULL(adap))
371		return;
372
373#ifdef CONFIG_MEDIA_CEC_RC
374	/* Note: rc_unregister also calls rc_free */
375	rc_unregister_device(adap->rc);
376	adap->rc = NULL;
377#endif
378	debugfs_remove_recursive(adap->cec_dir);
379#ifdef CONFIG_CEC_NOTIFIER
380	cec_notifier_cec_adap_unregister(adap->notifier, adap);
381#endif
382	cec_devnode_unregister(adap);
383}
384EXPORT_SYMBOL_GPL(cec_unregister_adapter);
385
386void cec_delete_adapter(struct cec_adapter *adap)
387{
388	if (IS_ERR_OR_NULL(adap))
389		return;
390	if (adap->kthread_config)
391		kthread_stop(adap->kthread_config);
392	kthread_stop(adap->kthread);
393	if (adap->ops->adap_free)
394		adap->ops->adap_free(adap);
395#ifdef CONFIG_MEDIA_CEC_RC
396	rc_free_device(adap->rc);
397#endif
398	kfree(adap);
399}
400EXPORT_SYMBOL_GPL(cec_delete_adapter);
401
402/*
403 *	Initialise cec for linux
404 */
405static int __init cec_devnode_init(void)
406{
407	int ret = alloc_chrdev_region(&cec_dev_t, 0, CEC_NUM_DEVICES, CEC_NAME);
408
409	if (ret < 0) {
410		pr_warn("cec: unable to allocate major\n");
411		return ret;
412	}
413
414#ifdef CONFIG_DEBUG_FS
415	top_cec_dir = debugfs_create_dir("cec", NULL);
416	if (IS_ERR_OR_NULL(top_cec_dir)) {
417		pr_warn("cec: Failed to create debugfs cec dir\n");
418		top_cec_dir = NULL;
419	}
420#endif
421
422	ret = bus_register(&cec_bus_type);
423	if (ret < 0) {
424		debugfs_remove_recursive(top_cec_dir);
425		unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
426		pr_warn("cec: bus_register failed\n");
427		return -EIO;
428	}
429
430	return 0;
431}
432
433static void __exit cec_devnode_exit(void)
434{
435	debugfs_remove_recursive(top_cec_dir);
436	bus_unregister(&cec_bus_type);
437	unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
438}
439
440subsys_initcall(cec_devnode_init);
441module_exit(cec_devnode_exit)
442
443MODULE_AUTHOR("Hans Verkuil <hverkuil@kernel.org>");
444MODULE_DESCRIPTION("Device node registration for cec drivers");
445MODULE_LICENSE("GPL");