Commit | Line | Data |
---|---|---|
a56960e8 HV |
1 | /* |
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 | ||
35 | int cec_debug; | |
36 | module_param_named(debug, cec_debug, int, 0644); | |
37 | MODULE_PARM_DESC(debug, "debug level (0-2)"); | |
38 | ||
39 | static dev_t cec_dev_t; | |
40 | ||
41 | /* Active devices */ | |
42 | static DEFINE_MUTEX(cec_devnode_lock); | |
43 | static DECLARE_BITMAP(cec_devnode_nums, CEC_NUM_DEVICES); | |
44 | ||
45 | static 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 | ||
50 | int cec_get_device(struct cec_devnode *devnode) | |
51 | { | |
52 | /* | |
53 | * Check if the cec device is available. This needs to be done with | |
2ab25d35 | 54 | * the devnode->lock held to prevent an open/unregister race: |
a56960e8 HV |
55 | * 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 | */ | |
2ab25d35 | 59 | mutex_lock(&devnode->lock); |
a56960e8 HV |
60 | /* |
61 | * return ENXIO if the cec device has been removed | |
62 | * already or if it is not registered anymore. | |
63 | */ | |
64 | if (!devnode->registered) { | |
2ab25d35 | 65 | mutex_unlock(&devnode->lock); |
a56960e8 HV |
66 | return -ENXIO; |
67 | } | |
68 | /* and increase the device refcount */ | |
69 | get_device(&devnode->dev); | |
2ab25d35 | 70 | mutex_unlock(&devnode->lock); |
a56960e8 HV |
71 | return 0; |
72 | } | |
73 | ||
74 | void cec_put_device(struct cec_devnode *devnode) | |
75 | { | |
a56960e8 | 76 | put_device(&devnode->dev); |
a56960e8 HV |
77 | } |
78 | ||
79 | /* Called when the last user of the cec device exits. */ | |
80 | static void cec_devnode_release(struct device *cd) | |
81 | { | |
82 | struct cec_devnode *devnode = to_cec_devnode(cd); | |
83 | ||
84 | mutex_lock(&cec_devnode_lock); | |
a56960e8 HV |
85 | /* Mark device node number as free */ |
86 | clear_bit(devnode->minor, cec_devnode_nums); | |
a56960e8 | 87 | mutex_unlock(&cec_devnode_lock); |
2ab25d35 | 88 | |
a56960e8 HV |
89 | cec_delete_adapter(to_cec_adapter(devnode)); |
90 | } | |
91 | ||
92 | static 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 | */ | |
109 | static 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); | |
62148f09 | 117 | mutex_init(&devnode->lock); |
a56960e8 HV |
118 | |
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; | |
135 | devnode->dev.parent = devnode->parent; | |
136 | dev_set_name(&devnode->dev, "cec%d", devnode->minor); | |
137 | device_initialize(&devnode->dev); | |
138 | ||
139 | /* Part 2: Initialize and register the character device */ | |
140 | cdev_init(&devnode->cdev, &cec_devnode_fops); | |
141 | devnode->cdev.kobj.parent = &devnode->dev.kobj; | |
142 | devnode->cdev.owner = owner; | |
143 | ||
144 | ret = cdev_add(&devnode->cdev, devnode->dev.devt, 1); | |
145 | if (ret < 0) { | |
146 | pr_err("%s: cdev_add failed\n", __func__); | |
147 | goto clr_bit; | |
148 | } | |
149 | ||
150 | ret = device_add(&devnode->dev); | |
151 | if (ret) | |
152 | goto cdev_del; | |
153 | ||
154 | devnode->registered = true; | |
155 | return 0; | |
156 | ||
157 | cdev_del: | |
158 | cdev_del(&devnode->cdev); | |
159 | clr_bit: | |
2ab25d35 | 160 | mutex_lock(&cec_devnode_lock); |
a56960e8 | 161 | clear_bit(devnode->minor, cec_devnode_nums); |
2ab25d35 | 162 | mutex_unlock(&cec_devnode_lock); |
a56960e8 HV |
163 | return ret; |
164 | } | |
165 | ||
166 | /* | |
167 | * Unregister a cec device node | |
168 | * | |
169 | * This unregisters the passed device. Future open calls will be met with | |
170 | * errors. | |
171 | * | |
172 | * This function can safely be called if the device node has never been | |
173 | * registered or has already been unregistered. | |
174 | */ | |
175 | static void cec_devnode_unregister(struct cec_devnode *devnode) | |
176 | { | |
177 | struct cec_fh *fh; | |
178 | ||
2ab25d35 HV |
179 | mutex_lock(&devnode->lock); |
180 | ||
a56960e8 | 181 | /* Check if devnode was never registered or already unregistered */ |
2ab25d35 HV |
182 | if (!devnode->registered || devnode->unregistered) { |
183 | mutex_unlock(&devnode->lock); | |
a56960e8 | 184 | return; |
2ab25d35 | 185 | } |
a56960e8 | 186 | |
a56960e8 HV |
187 | list_for_each_entry(fh, &devnode->fhs, list) |
188 | wake_up_interruptible(&fh->wait); | |
a56960e8 HV |
189 | |
190 | devnode->registered = false; | |
191 | devnode->unregistered = true; | |
2ab25d35 HV |
192 | mutex_unlock(&devnode->lock); |
193 | ||
a56960e8 HV |
194 | device_del(&devnode->dev); |
195 | cdev_del(&devnode->cdev); | |
196 | put_device(&devnode->dev); | |
197 | } | |
198 | ||
199 | struct cec_adapter *cec_allocate_adapter(const struct cec_adap_ops *ops, | |
200 | void *priv, const char *name, u32 caps, | |
201 | u8 available_las, struct device *parent) | |
202 | { | |
203 | struct cec_adapter *adap; | |
204 | int res; | |
205 | ||
206 | if (WARN_ON(!parent)) | |
207 | return ERR_PTR(-EINVAL); | |
208 | if (WARN_ON(!caps)) | |
209 | return ERR_PTR(-EINVAL); | |
210 | if (WARN_ON(!ops)) | |
211 | return ERR_PTR(-EINVAL); | |
212 | if (WARN_ON(!available_las || available_las > CEC_MAX_LOG_ADDRS)) | |
213 | return ERR_PTR(-EINVAL); | |
214 | adap = kzalloc(sizeof(*adap), GFP_KERNEL); | |
215 | if (!adap) | |
216 | return ERR_PTR(-ENOMEM); | |
217 | adap->owner = parent->driver->owner; | |
218 | adap->devnode.parent = parent; | |
219 | strlcpy(adap->name, name, sizeof(adap->name)); | |
220 | adap->phys_addr = CEC_PHYS_ADDR_INVALID; | |
221 | adap->log_addrs.cec_version = CEC_OP_CEC_VERSION_2_0; | |
222 | adap->log_addrs.vendor_id = CEC_VENDOR_ID_NONE; | |
223 | adap->capabilities = caps; | |
224 | adap->available_log_addrs = available_las; | |
225 | adap->sequence = 0; | |
226 | adap->ops = ops; | |
227 | adap->priv = priv; | |
228 | memset(adap->phys_addrs, 0xff, sizeof(adap->phys_addrs)); | |
229 | mutex_init(&adap->lock); | |
230 | INIT_LIST_HEAD(&adap->transmit_queue); | |
231 | INIT_LIST_HEAD(&adap->wait_queue); | |
232 | init_waitqueue_head(&adap->kthread_waitq); | |
233 | ||
234 | adap->kthread = kthread_run(cec_thread_func, adap, "cec-%s", name); | |
235 | if (IS_ERR(adap->kthread)) { | |
236 | pr_err("cec-%s: kernel_thread() failed\n", name); | |
237 | res = PTR_ERR(adap->kthread); | |
238 | kfree(adap); | |
239 | return ERR_PTR(res); | |
240 | } | |
241 | ||
242 | if (!(caps & CEC_CAP_RC)) | |
243 | return adap; | |
244 | ||
5bb2399a | 245 | #if IS_REACHABLE(CONFIG_RC_CORE) |
a56960e8 HV |
246 | /* Prepare the RC input device */ |
247 | adap->rc = rc_allocate_device(); | |
248 | if (!adap->rc) { | |
249 | pr_err("cec-%s: failed to allocate memory for rc_dev\n", | |
250 | name); | |
251 | kthread_stop(adap->kthread); | |
252 | kfree(adap); | |
253 | return ERR_PTR(-ENOMEM); | |
254 | } | |
255 | ||
256 | snprintf(adap->input_name, sizeof(adap->input_name), | |
257 | "RC for %s", name); | |
258 | snprintf(adap->input_phys, sizeof(adap->input_phys), | |
259 | "%s/input0", name); | |
260 | ||
261 | adap->rc->input_name = adap->input_name; | |
262 | adap->rc->input_phys = adap->input_phys; | |
263 | adap->rc->input_id.bustype = BUS_CEC; | |
264 | adap->rc->input_id.vendor = 0; | |
265 | adap->rc->input_id.product = 0; | |
266 | adap->rc->input_id.version = 1; | |
267 | adap->rc->dev.parent = parent; | |
268 | adap->rc->driver_type = RC_DRIVER_SCANCODE; | |
269 | adap->rc->driver_name = CEC_NAME; | |
270 | adap->rc->allowed_protocols = RC_BIT_CEC; | |
271 | adap->rc->priv = adap; | |
272 | adap->rc->map_name = RC_MAP_CEC; | |
273 | adap->rc->timeout = MS_TO_NS(100); | |
274 | #else | |
275 | adap->capabilities &= ~CEC_CAP_RC; | |
276 | #endif | |
277 | return adap; | |
278 | } | |
279 | EXPORT_SYMBOL_GPL(cec_allocate_adapter); | |
280 | ||
281 | int cec_register_adapter(struct cec_adapter *adap) | |
282 | { | |
283 | int res; | |
284 | ||
285 | if (IS_ERR_OR_NULL(adap)) | |
286 | return 0; | |
287 | ||
5bb2399a | 288 | #if IS_REACHABLE(CONFIG_RC_CORE) |
a56960e8 HV |
289 | if (adap->capabilities & CEC_CAP_RC) { |
290 | res = rc_register_device(adap->rc); | |
291 | ||
292 | if (res) { | |
293 | pr_err("cec-%s: failed to prepare input device\n", | |
294 | adap->name); | |
295 | rc_free_device(adap->rc); | |
296 | adap->rc = NULL; | |
297 | return res; | |
298 | } | |
299 | } | |
300 | #endif | |
301 | ||
302 | res = cec_devnode_register(&adap->devnode, adap->owner); | |
303 | if (res) { | |
5bb2399a | 304 | #if IS_REACHABLE(CONFIG_RC_CORE) |
a56960e8 HV |
305 | /* Note: rc_unregister also calls rc_free */ |
306 | rc_unregister_device(adap->rc); | |
307 | adap->rc = NULL; | |
308 | #endif | |
309 | return res; | |
310 | } | |
311 | ||
312 | dev_set_drvdata(&adap->devnode.dev, adap); | |
313 | #ifdef CONFIG_MEDIA_CEC_DEBUG | |
314 | if (!top_cec_dir) | |
315 | return 0; | |
316 | ||
317 | adap->cec_dir = debugfs_create_dir(dev_name(&adap->devnode.dev), top_cec_dir); | |
318 | if (IS_ERR_OR_NULL(adap->cec_dir)) { | |
319 | pr_warn("cec-%s: Failed to create debugfs dir\n", adap->name); | |
320 | return 0; | |
321 | } | |
322 | adap->status_file = debugfs_create_devm_seqfile(&adap->devnode.dev, | |
323 | "status", adap->cec_dir, cec_adap_status); | |
324 | if (IS_ERR_OR_NULL(adap->status_file)) { | |
325 | pr_warn("cec-%s: Failed to create status file\n", adap->name); | |
326 | debugfs_remove_recursive(adap->cec_dir); | |
327 | adap->cec_dir = NULL; | |
328 | } | |
329 | #endif | |
330 | return 0; | |
331 | } | |
332 | EXPORT_SYMBOL_GPL(cec_register_adapter); | |
333 | ||
334 | void cec_unregister_adapter(struct cec_adapter *adap) | |
335 | { | |
336 | if (IS_ERR_OR_NULL(adap)) | |
337 | return; | |
338 | ||
5bb2399a | 339 | #if IS_REACHABLE(CONFIG_RC_CORE) |
a56960e8 HV |
340 | /* Note: rc_unregister also calls rc_free */ |
341 | rc_unregister_device(adap->rc); | |
342 | adap->rc = NULL; | |
343 | #endif | |
344 | debugfs_remove_recursive(adap->cec_dir); | |
345 | cec_devnode_unregister(&adap->devnode); | |
346 | } | |
347 | EXPORT_SYMBOL_GPL(cec_unregister_adapter); | |
348 | ||
349 | void cec_delete_adapter(struct cec_adapter *adap) | |
350 | { | |
351 | if (IS_ERR_OR_NULL(adap)) | |
352 | return; | |
353 | mutex_lock(&adap->lock); | |
354 | __cec_s_phys_addr(adap, CEC_PHYS_ADDR_INVALID, false); | |
355 | mutex_unlock(&adap->lock); | |
356 | kthread_stop(adap->kthread); | |
357 | if (adap->kthread_config) | |
358 | kthread_stop(adap->kthread_config); | |
5bb2399a | 359 | #if IS_REACHABLE(CONFIG_RC_CORE) |
d8eddb15 | 360 | rc_free_device(adap->rc); |
a56960e8 HV |
361 | #endif |
362 | kfree(adap); | |
363 | } | |
364 | EXPORT_SYMBOL_GPL(cec_delete_adapter); | |
365 | ||
366 | /* | |
367 | * Initialise cec for linux | |
368 | */ | |
369 | static int __init cec_devnode_init(void) | |
370 | { | |
371 | int ret; | |
372 | ||
373 | pr_info("Linux cec interface: v0.10\n"); | |
374 | ret = alloc_chrdev_region(&cec_dev_t, 0, CEC_NUM_DEVICES, | |
375 | CEC_NAME); | |
376 | if (ret < 0) { | |
377 | pr_warn("cec: unable to allocate major\n"); | |
378 | return ret; | |
379 | } | |
380 | ||
381 | #ifdef CONFIG_MEDIA_CEC_DEBUG | |
382 | top_cec_dir = debugfs_create_dir("cec", NULL); | |
383 | if (IS_ERR_OR_NULL(top_cec_dir)) { | |
384 | pr_warn("cec: Failed to create debugfs cec dir\n"); | |
385 | top_cec_dir = NULL; | |
386 | } | |
387 | #endif | |
388 | ||
389 | ret = bus_register(&cec_bus_type); | |
390 | if (ret < 0) { | |
391 | unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES); | |
392 | pr_warn("cec: bus_register failed\n"); | |
393 | return -EIO; | |
394 | } | |
395 | ||
396 | return 0; | |
397 | } | |
398 | ||
399 | static void __exit cec_devnode_exit(void) | |
400 | { | |
401 | debugfs_remove_recursive(top_cec_dir); | |
402 | bus_unregister(&cec_bus_type); | |
403 | unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES); | |
404 | } | |
405 | ||
406 | subsys_initcall(cec_devnode_init); | |
407 | module_exit(cec_devnode_exit) | |
408 | ||
409 | MODULE_AUTHOR("Hans Verkuil <hans.verkuil@cisco.com>"); | |
410 | MODULE_DESCRIPTION("Device node registration for cec drivers"); | |
411 | MODULE_LICENSE("GPL"); |