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