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
36 int cec_debug;
37 module_param_named(debug, cec_debug, int, 0644);
38 MODULE_PARM_DESC(debug, "debug level (0-2)");
39
40 static bool debug_phys_addr;
41 module_param(debug_phys_addr, bool, 0644);
42 MODULE_PARM_DESC(debug_phys_addr, "add CEC_CAP_PHYS_ADDR if set");
43
44 static dev_t cec_dev_t;
45
46 /* Active devices */
47 static DEFINE_MUTEX(cec_devnode_lock);
48 static DECLARE_BITMAP(cec_devnode_nums, CEC_NUM_DEVICES);
49
50 static 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. */
cec_devnode_release(struct device * cd)56 static 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
68 static 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 */
cec_devnode_register(struct cec_devnode * devnode,struct module * owner)85 static 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
125 clr_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 */
cec_devnode_unregister(struct cec_adapter * adap)141 static 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
cec_error_inj_write(struct file * file,const char __user * ubuf,size_t count,loff_t * ppos)175 static 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
cec_error_inj_show(struct seq_file * sf,void * unused)202 static 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
cec_error_inj_open(struct inode * inode,struct file * file)209 static 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
214 static 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
cec_allocate_adapter(const struct cec_adap_ops * ops,void * priv,const char * name,u32 caps,u8 available_las)223 struct 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 }
305 EXPORT_SYMBOL_GPL(cec_allocate_adapter);
306
cec_register_adapter(struct cec_adapter * adap,struct device * parent)307 int 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 }
366 EXPORT_SYMBOL_GPL(cec_register_adapter);
367
cec_unregister_adapter(struct cec_adapter * adap)368 void 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 }
384 EXPORT_SYMBOL_GPL(cec_unregister_adapter);
385
cec_delete_adapter(struct cec_adapter * adap)386 void 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 }
400 EXPORT_SYMBOL_GPL(cec_delete_adapter);
401
402 /*
403 * Initialise cec for linux
404 */
cec_devnode_init(void)405 static 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 unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
425 pr_warn("cec: bus_register failed\n");
426 return -EIO;
427 }
428
429 return 0;
430 }
431
cec_devnode_exit(void)432 static void __exit cec_devnode_exit(void)
433 {
434 debugfs_remove_recursive(top_cec_dir);
435 bus_unregister(&cec_bus_type);
436 unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
437 }
438
439 subsys_initcall(cec_devnode_init);
440 module_exit(cec_devnode_exit)
441
442 MODULE_AUTHOR("Hans Verkuil <[email protected]>");
443 MODULE_DESCRIPTION("Device node registration for cec drivers");
444 MODULE_LICENSE("GPL");
445