blob: 648136e552d5bcbb6c553c96fe2116c0c4919c2c [file] [log] [blame]
Hans Verkuila56960e2016-06-25 09:43:58 -03001/*
2 * cec-core.c - HDMI Consumer Electronics Control framework - Core
3 *
4 * Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
5 *
6 * This program is free software; you may redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2 of the License.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
11 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
12 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
13 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
14 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
15 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
16 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
17 * SOFTWARE.
18 */
19
20#include <linux/errno.h>
21#include <linux/init.h>
22#include <linux/module.h>
23#include <linux/kernel.h>
24#include <linux/kmod.h>
25#include <linux/slab.h>
26#include <linux/mm.h>
27#include <linux/string.h>
28#include <linux/types.h>
29
30#include "cec-priv.h"
31
32#define CEC_NUM_DEVICES 256
33#define CEC_NAME "cec"
34
35int cec_debug;
36module_param_named(debug, cec_debug, int, 0644);
37MODULE_PARM_DESC(debug, "debug level (0-2)");
38
39static dev_t cec_dev_t;
40
41/* Active devices */
42static DEFINE_MUTEX(cec_devnode_lock);
43static DECLARE_BITMAP(cec_devnode_nums, CEC_NUM_DEVICES);
44
45static struct dentry *top_cec_dir;
46
47/* dev to cec_devnode */
48#define to_cec_devnode(cd) container_of(cd, struct cec_devnode, dev)
49
50int cec_get_device(struct cec_devnode *devnode)
51{
52 /*
53 * Check if the cec device is available. This needs to be done with
Hans Verkuil2ab25d32016-08-02 08:13:57 -030054 * the devnode->lock held to prevent an open/unregister race:
Hans Verkuila56960e2016-06-25 09:43:58 -030055 * without the lock, the device could be unregistered and freed between
56 * the devnode->registered check and get_device() calls, leading to
57 * a crash.
58 */
Hans Verkuil2ab25d32016-08-02 08:13:57 -030059 mutex_lock(&devnode->lock);
Hans Verkuila56960e2016-06-25 09:43:58 -030060 /*
61 * return ENXIO if the cec device has been removed
62 * already or if it is not registered anymore.
63 */
64 if (!devnode->registered) {
Hans Verkuil2ab25d32016-08-02 08:13:57 -030065 mutex_unlock(&devnode->lock);
Hans Verkuila56960e2016-06-25 09:43:58 -030066 return -ENXIO;
67 }
68 /* and increase the device refcount */
69 get_device(&devnode->dev);
Hans Verkuil2ab25d32016-08-02 08:13:57 -030070 mutex_unlock(&devnode->lock);
Hans Verkuila56960e2016-06-25 09:43:58 -030071 return 0;
72}
73
74void cec_put_device(struct cec_devnode *devnode)
75{
Hans Verkuila56960e2016-06-25 09:43:58 -030076 put_device(&devnode->dev);
Hans Verkuila56960e2016-06-25 09:43:58 -030077}
78
79/* Called when the last user of the cec device exits. */
80static void cec_devnode_release(struct device *cd)
81{
82 struct cec_devnode *devnode = to_cec_devnode(cd);
83
84 mutex_lock(&cec_devnode_lock);
Hans Verkuila56960e2016-06-25 09:43:58 -030085 /* Mark device node number as free */
86 clear_bit(devnode->minor, cec_devnode_nums);
Hans Verkuila56960e2016-06-25 09:43:58 -030087 mutex_unlock(&cec_devnode_lock);
Hans Verkuil2ab25d32016-08-02 08:13:57 -030088
Hans Verkuila56960e2016-06-25 09:43:58 -030089 cec_delete_adapter(to_cec_adapter(devnode));
90}
91
92static struct bus_type cec_bus_type = {
93 .name = CEC_NAME,
94};
95
96/*
97 * Register a cec device node
98 *
99 * The registration code assigns minor numbers and registers the new device node
100 * with the kernel. An error is returned if no free minor number can be found,
101 * or if the registration of the device node fails.
102 *
103 * Zero is returned on success.
104 *
105 * Note that if the cec_devnode_register call fails, the release() callback of
106 * the cec_devnode structure is *not* called, so the caller is responsible for
107 * freeing any data.
108 */
109static int __must_check cec_devnode_register(struct cec_devnode *devnode,
110 struct module *owner)
111{
112 int minor;
113 int ret;
114
115 /* Initialization */
116 INIT_LIST_HEAD(&devnode->fhs);
Hans Verkuil62148f02016-08-02 08:11:00 -0300117 mutex_init(&devnode->lock);
Hans Verkuila56960e2016-06-25 09:43:58 -0300118
119 /* Part 1: Find a free minor number */
120 mutex_lock(&cec_devnode_lock);
121 minor = find_next_zero_bit(cec_devnode_nums, CEC_NUM_DEVICES, 0);
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;
Hans Verkuila56960e2016-06-25 09:43:58 -0300135 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);
Hans Verkuila56960e2016-06-25 09:43:58 -0300140 devnode->cdev.owner = owner;
141
Logan Gunthorpe857313e2017-03-17 12:48:18 -0600142 ret = cdev_device_add(&devnode->cdev, &devnode->dev);
143 if (ret) {
144 pr_err("%s: cdev_device_add failed\n", __func__);
Hans Verkuila56960e2016-06-25 09:43:58 -0300145 goto clr_bit;
146 }
147
Hans Verkuila56960e2016-06-25 09:43:58 -0300148 devnode->registered = true;
149 return 0;
150
Hans Verkuila56960e2016-06-25 09:43:58 -0300151clr_bit:
Hans Verkuil2ab25d32016-08-02 08:13:57 -0300152 mutex_lock(&cec_devnode_lock);
Hans Verkuila56960e2016-06-25 09:43:58 -0300153 clear_bit(devnode->minor, cec_devnode_nums);
Hans Verkuil2ab25d32016-08-02 08:13:57 -0300154 mutex_unlock(&cec_devnode_lock);
Hans Verkuila56960e2016-06-25 09:43:58 -0300155 return ret;
156}
157
158/*
159 * Unregister a cec device node
160 *
161 * This unregisters the passed device. Future open calls will be met with
162 * errors.
163 *
164 * This function can safely be called if the device node has never been
165 * registered or has already been unregistered.
166 */
167static void cec_devnode_unregister(struct cec_devnode *devnode)
168{
169 struct cec_fh *fh;
170
Hans Verkuil62148f02016-08-02 08:11:00 -0300171 mutex_lock(&devnode->lock);
Hans Verkuila56960e2016-06-25 09:43:58 -0300172
Hans Verkuil2ab25d32016-08-02 08:13:57 -0300173 /* Check if devnode was never registered or already unregistered */
174 if (!devnode->registered || devnode->unregistered) {
175 mutex_unlock(&devnode->lock);
176 return;
177 }
178
Hans Verkuila56960e2016-06-25 09:43:58 -0300179 list_for_each_entry(fh, &devnode->fhs, list)
180 wake_up_interruptible(&fh->wait);
Hans Verkuila56960e2016-06-25 09:43:58 -0300181
182 devnode->registered = false;
183 devnode->unregistered = true;
Hans Verkuil2ab25d32016-08-02 08:13:57 -0300184 mutex_unlock(&devnode->lock);
185
Logan Gunthorpe857313e2017-03-17 12:48:18 -0600186 cdev_device_del(&devnode->cdev, &devnode->dev);
Hans Verkuila56960e2016-06-25 09:43:58 -0300187 put_device(&devnode->dev);
188}
189
Hans Verkuile94c3282017-05-28 05:58:04 -0300190#ifdef CONFIG_CEC_NOTIFIER
Hans Verkuile3a93ad2016-12-13 12:15:57 -0200191static void cec_cec_notify(struct cec_adapter *adap, u16 pa)
192{
193 cec_s_phys_addr(adap, pa, false);
194}
195
196void cec_register_cec_notifier(struct cec_adapter *adap,
197 struct cec_notifier *notifier)
198{
199 if (WARN_ON(!adap->devnode.registered))
200 return;
201
202 adap->notifier = notifier;
203 cec_notifier_register(adap->notifier, adap, cec_cec_notify);
204}
205EXPORT_SYMBOL_GPL(cec_register_cec_notifier);
206#endif
207
Hans Verkuila56960e2016-06-25 09:43:58 -0300208struct cec_adapter *cec_allocate_adapter(const struct cec_adap_ops *ops,
209 void *priv, const char *name, u32 caps,
Hans Verkuilf51e8082016-11-25 06:23:34 -0200210 u8 available_las)
Hans Verkuila56960e2016-06-25 09:43:58 -0300211{
212 struct cec_adapter *adap;
213 int res;
214
Hans Verkuil5f2c4672017-04-17 08:05:10 -0300215#ifndef CONFIG_MEDIA_CEC_RC
Hans Verkuilee044f52017-04-04 13:43:33 -0300216 caps &= ~CEC_CAP_RC;
217#endif
218
Hans Verkuila56960e2016-06-25 09:43:58 -0300219 if (WARN_ON(!caps))
220 return ERR_PTR(-EINVAL);
221 if (WARN_ON(!ops))
222 return ERR_PTR(-EINVAL);
223 if (WARN_ON(!available_las || available_las > CEC_MAX_LOG_ADDRS))
224 return ERR_PTR(-EINVAL);
225 adap = kzalloc(sizeof(*adap), GFP_KERNEL);
226 if (!adap)
227 return ERR_PTR(-ENOMEM);
Hans Verkuila56960e2016-06-25 09:43:58 -0300228 strlcpy(adap->name, name, sizeof(adap->name));
229 adap->phys_addr = CEC_PHYS_ADDR_INVALID;
Hans Verkuil28e11b12017-08-20 06:53:10 -0400230 adap->cec_pin_is_high = true;
Hans Verkuila56960e2016-06-25 09:43:58 -0300231 adap->log_addrs.cec_version = CEC_OP_CEC_VERSION_2_0;
232 adap->log_addrs.vendor_id = CEC_VENDOR_ID_NONE;
233 adap->capabilities = caps;
Hans Verkuilf902c1e2017-06-07 11:46:12 -0300234 adap->needs_hpd = caps & CEC_CAP_NEEDS_HPD;
Hans Verkuila56960e2016-06-25 09:43:58 -0300235 adap->available_log_addrs = available_las;
236 adap->sequence = 0;
237 adap->ops = ops;
238 adap->priv = priv;
239 memset(adap->phys_addrs, 0xff, sizeof(adap->phys_addrs));
240 mutex_init(&adap->lock);
241 INIT_LIST_HEAD(&adap->transmit_queue);
242 INIT_LIST_HEAD(&adap->wait_queue);
243 init_waitqueue_head(&adap->kthread_waitq);
244
245 adap->kthread = kthread_run(cec_thread_func, adap, "cec-%s", name);
246 if (IS_ERR(adap->kthread)) {
247 pr_err("cec-%s: kernel_thread() failed\n", name);
248 res = PTR_ERR(adap->kthread);
249 kfree(adap);
250 return ERR_PTR(res);
251 }
252
Hans Verkuil5f2c4672017-04-17 08:05:10 -0300253#ifdef CONFIG_MEDIA_CEC_RC
Hans Verkuila56960e2016-06-25 09:43:58 -0300254 if (!(caps & CEC_CAP_RC))
255 return adap;
256
Hans Verkuila56960e2016-06-25 09:43:58 -0300257 /* Prepare the RC input device */
Andi Shyti0f7499f2016-12-16 06:50:58 -0200258 adap->rc = rc_allocate_device(RC_DRIVER_SCANCODE);
Hans Verkuila56960e2016-06-25 09:43:58 -0300259 if (!adap->rc) {
260 pr_err("cec-%s: failed to allocate memory for rc_dev\n",
261 name);
262 kthread_stop(adap->kthread);
263 kfree(adap);
264 return ERR_PTR(-ENOMEM);
265 }
266
Sean Young518f4b22017-07-01 12:13:19 -0400267 snprintf(adap->device_name, sizeof(adap->device_name),
Hans Verkuila56960e2016-06-25 09:43:58 -0300268 "RC for %s", name);
269 snprintf(adap->input_phys, sizeof(adap->input_phys),
270 "%s/input0", name);
271
Sean Young518f4b22017-07-01 12:13:19 -0400272 adap->rc->device_name = adap->device_name;
Hans Verkuila56960e2016-06-25 09:43:58 -0300273 adap->rc->input_phys = adap->input_phys;
274 adap->rc->input_id.bustype = BUS_CEC;
275 adap->rc->input_id.vendor = 0;
276 adap->rc->input_id.product = 0;
277 adap->rc->input_id.version = 1;
Hans Verkuila56960e2016-06-25 09:43:58 -0300278 adap->rc->driver_name = CEC_NAME;
Sean Young6d741bf2017-08-07 16:20:58 -0400279 adap->rc->allowed_protocols = RC_PROTO_BIT_CEC;
280 adap->rc->enabled_protocols = RC_PROTO_BIT_CEC;
Hans Verkuila56960e2016-06-25 09:43:58 -0300281 adap->rc->priv = adap;
282 adap->rc->map_name = RC_MAP_CEC;
283 adap->rc->timeout = MS_TO_NS(100);
Hans Verkuila9a249a2017-08-07 09:31:24 -0400284 adap->rc_last_scancode = -1;
Hans Verkuila56960e2016-06-25 09:43:58 -0300285#endif
286 return adap;
287}
288EXPORT_SYMBOL_GPL(cec_allocate_adapter);
289
Hans Verkuilf51e8082016-11-25 06:23:34 -0200290int cec_register_adapter(struct cec_adapter *adap,
291 struct device *parent)
Hans Verkuila56960e2016-06-25 09:43:58 -0300292{
293 int res;
294
295 if (IS_ERR_OR_NULL(adap))
296 return 0;
297
Hans Verkuilf51e8082016-11-25 06:23:34 -0200298 if (WARN_ON(!parent))
299 return -EINVAL;
300
301 adap->owner = parent->driver->owner;
302 adap->devnode.dev.parent = parent;
303
Hans Verkuil5f2c4672017-04-17 08:05:10 -0300304#ifdef CONFIG_MEDIA_CEC_RC
Hans Verkuila56960e2016-06-25 09:43:58 -0300305 if (adap->capabilities & CEC_CAP_RC) {
Lee Jones43c0c032017-04-04 09:32:19 -0300306 adap->rc->dev.parent = parent;
Hans Verkuila56960e2016-06-25 09:43:58 -0300307 res = rc_register_device(adap->rc);
308
309 if (res) {
310 pr_err("cec-%s: failed to prepare input device\n",
311 adap->name);
312 rc_free_device(adap->rc);
313 adap->rc = NULL;
314 return res;
315 }
Hans Verkuila9a249a2017-08-07 09:31:24 -0400316 /*
317 * The REP_DELAY for CEC is really the time between the initial
318 * 'User Control Pressed' message and the second. The first
319 * keypress is always seen as non-repeating, the second
320 * (provided it has the same UI Command) will start the 'Press
321 * and Hold' (aka repeat) behavior. By setting REP_DELAY to the
322 * same value as REP_PERIOD the expected CEC behavior is
323 * reproduced.
324 */
325 adap->rc->input_dev->rep[REP_DELAY] =
326 adap->rc->input_dev->rep[REP_PERIOD];
Hans Verkuila56960e2016-06-25 09:43:58 -0300327 }
328#endif
329
330 res = cec_devnode_register(&adap->devnode, adap->owner);
331 if (res) {
Hans Verkuil5f2c4672017-04-17 08:05:10 -0300332#ifdef CONFIG_MEDIA_CEC_RC
Hans Verkuila56960e2016-06-25 09:43:58 -0300333 /* Note: rc_unregister also calls rc_free */
334 rc_unregister_device(adap->rc);
335 adap->rc = NULL;
336#endif
337 return res;
338 }
339
340 dev_set_drvdata(&adap->devnode.dev, adap);
Hans Verkuil20249f82017-05-28 05:52:16 -0300341#ifdef CONFIG_DEBUG_FS
Hans Verkuila56960e2016-06-25 09:43:58 -0300342 if (!top_cec_dir)
343 return 0;
344
345 adap->cec_dir = debugfs_create_dir(dev_name(&adap->devnode.dev), top_cec_dir);
346 if (IS_ERR_OR_NULL(adap->cec_dir)) {
347 pr_warn("cec-%s: Failed to create debugfs dir\n", adap->name);
348 return 0;
349 }
350 adap->status_file = debugfs_create_devm_seqfile(&adap->devnode.dev,
351 "status", adap->cec_dir, cec_adap_status);
352 if (IS_ERR_OR_NULL(adap->status_file)) {
353 pr_warn("cec-%s: Failed to create status file\n", adap->name);
354 debugfs_remove_recursive(adap->cec_dir);
355 adap->cec_dir = NULL;
356 }
357#endif
358 return 0;
359}
360EXPORT_SYMBOL_GPL(cec_register_adapter);
361
362void cec_unregister_adapter(struct cec_adapter *adap)
363{
364 if (IS_ERR_OR_NULL(adap))
365 return;
366
Hans Verkuil5f2c4672017-04-17 08:05:10 -0300367#ifdef CONFIG_MEDIA_CEC_RC
Hans Verkuila56960e2016-06-25 09:43:58 -0300368 /* Note: rc_unregister also calls rc_free */
369 rc_unregister_device(adap->rc);
370 adap->rc = NULL;
371#endif
372 debugfs_remove_recursive(adap->cec_dir);
Hans Verkuile94c3282017-05-28 05:58:04 -0300373#ifdef CONFIG_CEC_NOTIFIER
Hans Verkuile3a93ad2016-12-13 12:15:57 -0200374 if (adap->notifier)
375 cec_notifier_unregister(adap->notifier);
376#endif
Hans Verkuila56960e2016-06-25 09:43:58 -0300377 cec_devnode_unregister(&adap->devnode);
378}
379EXPORT_SYMBOL_GPL(cec_unregister_adapter);
380
381void cec_delete_adapter(struct cec_adapter *adap)
382{
383 if (IS_ERR_OR_NULL(adap))
384 return;
385 mutex_lock(&adap->lock);
386 __cec_s_phys_addr(adap, CEC_PHYS_ADDR_INVALID, false);
387 mutex_unlock(&adap->lock);
388 kthread_stop(adap->kthread);
389 if (adap->kthread_config)
390 kthread_stop(adap->kthread_config);
Hans Verkuile6259b52017-07-11 03:30:36 -0300391 if (adap->ops->adap_free)
392 adap->ops->adap_free(adap);
Hans Verkuil5f2c4672017-04-17 08:05:10 -0300393#ifdef CONFIG_MEDIA_CEC_RC
Markus Elfringd8eddb12016-07-17 17:52:49 -0300394 rc_free_device(adap->rc);
Hans Verkuila56960e2016-06-25 09:43:58 -0300395#endif
396 kfree(adap);
397}
398EXPORT_SYMBOL_GPL(cec_delete_adapter);
399
400/*
401 * Initialise cec for linux
402 */
403static int __init cec_devnode_init(void)
404{
Hans Verkuiled10b4e2017-07-15 09:30:37 -0300405 int ret = alloc_chrdev_region(&cec_dev_t, 0, CEC_NUM_DEVICES, CEC_NAME);
Hans Verkuila56960e2016-06-25 09:43:58 -0300406
Hans Verkuila56960e2016-06-25 09:43:58 -0300407 if (ret < 0) {
408 pr_warn("cec: unable to allocate major\n");
409 return ret;
410 }
411
Hans Verkuil20249f82017-05-28 05:52:16 -0300412#ifdef CONFIG_DEBUG_FS
Hans Verkuila56960e2016-06-25 09:43:58 -0300413 top_cec_dir = debugfs_create_dir("cec", NULL);
414 if (IS_ERR_OR_NULL(top_cec_dir)) {
415 pr_warn("cec: Failed to create debugfs cec dir\n");
416 top_cec_dir = NULL;
417 }
418#endif
419
420 ret = bus_register(&cec_bus_type);
421 if (ret < 0) {
422 unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
423 pr_warn("cec: bus_register failed\n");
424 return -EIO;
425 }
426
427 return 0;
428}
429
430static void __exit cec_devnode_exit(void)
431{
432 debugfs_remove_recursive(top_cec_dir);
433 bus_unregister(&cec_bus_type);
434 unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
435}
436
437subsys_initcall(cec_devnode_init);
438module_exit(cec_devnode_exit)
439
440MODULE_AUTHOR("Hans Verkuil <hans.verkuil@cisco.com>");
441MODULE_DESCRIPTION("Device node registration for cec drivers");
442MODULE_LICENSE("GPL");