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