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