]>
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; | |
a56960e8 HV |
135 | 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); | |
a56960e8 HV |
140 | devnode->cdev.owner = owner; |
141 | ||
857313e5 LG |
142 | ret = cdev_device_add(&devnode->cdev, &devnode->dev); |
143 | if (ret) { | |
144 | pr_err("%s: cdev_device_add failed\n", __func__); | |
a56960e8 HV |
145 | goto clr_bit; |
146 | } | |
147 | ||
a56960e8 HV |
148 | devnode->registered = true; |
149 | return 0; | |
150 | ||
a56960e8 | 151 | clr_bit: |
2ab25d35 | 152 | mutex_lock(&cec_devnode_lock); |
a56960e8 | 153 | clear_bit(devnode->minor, cec_devnode_nums); |
2ab25d35 | 154 | mutex_unlock(&cec_devnode_lock); |
a56960e8 HV |
155 | 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 | */ | |
167 | static void cec_devnode_unregister(struct cec_devnode *devnode) | |
168 | { | |
169 | struct cec_fh *fh; | |
170 | ||
2ab25d35 HV |
171 | mutex_lock(&devnode->lock); |
172 | ||
a56960e8 | 173 | /* Check if devnode was never registered or already unregistered */ |
2ab25d35 HV |
174 | if (!devnode->registered || devnode->unregistered) { |
175 | mutex_unlock(&devnode->lock); | |
a56960e8 | 176 | return; |
2ab25d35 | 177 | } |
a56960e8 | 178 | |
a56960e8 HV |
179 | list_for_each_entry(fh, &devnode->fhs, list) |
180 | wake_up_interruptible(&fh->wait); | |
a56960e8 HV |
181 | |
182 | devnode->registered = false; | |
183 | devnode->unregistered = true; | |
2ab25d35 HV |
184 | mutex_unlock(&devnode->lock); |
185 | ||
857313e5 | 186 | cdev_device_del(&devnode->cdev, &devnode->dev); |
a56960e8 HV |
187 | put_device(&devnode->dev); |
188 | } | |
189 | ||
e94c3281 | 190 | #ifdef CONFIG_CEC_NOTIFIER |
e3a93adc HV |
191 | static void cec_cec_notify(struct cec_adapter *adap, u16 pa) |
192 | { | |
193 | cec_s_phys_addr(adap, pa, false); | |
194 | } | |
195 | ||
196 | void 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 | } | |
205 | EXPORT_SYMBOL_GPL(cec_register_cec_notifier); | |
206 | #endif | |
207 | ||
a56960e8 HV |
208 | struct cec_adapter *cec_allocate_adapter(const struct cec_adap_ops *ops, |
209 | void *priv, const char *name, u32 caps, | |
f51e8080 | 210 | u8 available_las) |
a56960e8 HV |
211 | { |
212 | struct cec_adapter *adap; | |
213 | int res; | |
214 | ||
5f2c467c | 215 | #ifndef CONFIG_MEDIA_CEC_RC |
ee044f5b HV |
216 | caps &= ~CEC_CAP_RC; |
217 | #endif | |
218 | ||
a56960e8 HV |
219 | 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); | |
a56960e8 HV |
228 | strlcpy(adap->name, name, sizeof(adap->name)); |
229 | adap->phys_addr = CEC_PHYS_ADDR_INVALID; | |
230 | adap->log_addrs.cec_version = CEC_OP_CEC_VERSION_2_0; | |
231 | adap->log_addrs.vendor_id = CEC_VENDOR_ID_NONE; | |
232 | adap->capabilities = caps; | |
233 | adap->available_log_addrs = available_las; | |
234 | adap->sequence = 0; | |
235 | adap->ops = ops; | |
236 | adap->priv = priv; | |
237 | memset(adap->phys_addrs, 0xff, sizeof(adap->phys_addrs)); | |
238 | mutex_init(&adap->lock); | |
239 | INIT_LIST_HEAD(&adap->transmit_queue); | |
240 | INIT_LIST_HEAD(&adap->wait_queue); | |
241 | init_waitqueue_head(&adap->kthread_waitq); | |
242 | ||
243 | adap->kthread = kthread_run(cec_thread_func, adap, "cec-%s", name); | |
244 | if (IS_ERR(adap->kthread)) { | |
245 | pr_err("cec-%s: kernel_thread() failed\n", name); | |
246 | res = PTR_ERR(adap->kthread); | |
247 | kfree(adap); | |
248 | return ERR_PTR(res); | |
249 | } | |
250 | ||
5f2c467c | 251 | #ifdef CONFIG_MEDIA_CEC_RC |
a56960e8 HV |
252 | if (!(caps & CEC_CAP_RC)) |
253 | return adap; | |
254 | ||
a56960e8 | 255 | /* Prepare the RC input device */ |
0f7499fd | 256 | adap->rc = rc_allocate_device(RC_DRIVER_SCANCODE); |
a56960e8 HV |
257 | if (!adap->rc) { |
258 | pr_err("cec-%s: failed to allocate memory for rc_dev\n", | |
259 | name); | |
260 | kthread_stop(adap->kthread); | |
261 | kfree(adap); | |
262 | return ERR_PTR(-ENOMEM); | |
263 | } | |
264 | ||
265 | snprintf(adap->input_name, sizeof(adap->input_name), | |
266 | "RC for %s", name); | |
267 | snprintf(adap->input_phys, sizeof(adap->input_phys), | |
268 | "%s/input0", name); | |
269 | ||
270 | adap->rc->input_name = adap->input_name; | |
271 | adap->rc->input_phys = adap->input_phys; | |
272 | adap->rc->input_id.bustype = BUS_CEC; | |
273 | adap->rc->input_id.vendor = 0; | |
274 | adap->rc->input_id.product = 0; | |
275 | adap->rc->input_id.version = 1; | |
a56960e8 HV |
276 | adap->rc->driver_name = CEC_NAME; |
277 | adap->rc->allowed_protocols = RC_BIT_CEC; | |
278 | adap->rc->priv = adap; | |
279 | adap->rc->map_name = RC_MAP_CEC; | |
280 | adap->rc->timeout = MS_TO_NS(100); | |
a56960e8 HV |
281 | #endif |
282 | return adap; | |
283 | } | |
284 | EXPORT_SYMBOL_GPL(cec_allocate_adapter); | |
285 | ||
f51e8080 HV |
286 | int cec_register_adapter(struct cec_adapter *adap, |
287 | struct device *parent) | |
a56960e8 HV |
288 | { |
289 | int res; | |
290 | ||
291 | if (IS_ERR_OR_NULL(adap)) | |
292 | return 0; | |
293 | ||
f51e8080 HV |
294 | if (WARN_ON(!parent)) |
295 | return -EINVAL; | |
296 | ||
297 | adap->owner = parent->driver->owner; | |
298 | adap->devnode.dev.parent = parent; | |
299 | ||
5f2c467c | 300 | #ifdef CONFIG_MEDIA_CEC_RC |
a56960e8 | 301 | if (adap->capabilities & CEC_CAP_RC) { |
43c0c039 | 302 | adap->rc->dev.parent = parent; |
a56960e8 HV |
303 | res = rc_register_device(adap->rc); |
304 | ||
305 | if (res) { | |
306 | pr_err("cec-%s: failed to prepare input device\n", | |
307 | adap->name); | |
308 | rc_free_device(adap->rc); | |
309 | adap->rc = NULL; | |
310 | return res; | |
311 | } | |
312 | } | |
313 | #endif | |
314 | ||
315 | res = cec_devnode_register(&adap->devnode, adap->owner); | |
316 | if (res) { | |
5f2c467c | 317 | #ifdef CONFIG_MEDIA_CEC_RC |
a56960e8 HV |
318 | /* Note: rc_unregister also calls rc_free */ |
319 | rc_unregister_device(adap->rc); | |
320 | adap->rc = NULL; | |
321 | #endif | |
322 | return res; | |
323 | } | |
324 | ||
325 | dev_set_drvdata(&adap->devnode.dev, adap); | |
20249f84 | 326 | #ifdef CONFIG_DEBUG_FS |
a56960e8 HV |
327 | if (!top_cec_dir) |
328 | return 0; | |
329 | ||
330 | adap->cec_dir = debugfs_create_dir(dev_name(&adap->devnode.dev), top_cec_dir); | |
331 | if (IS_ERR_OR_NULL(adap->cec_dir)) { | |
332 | pr_warn("cec-%s: Failed to create debugfs dir\n", adap->name); | |
333 | return 0; | |
334 | } | |
335 | adap->status_file = debugfs_create_devm_seqfile(&adap->devnode.dev, | |
336 | "status", adap->cec_dir, cec_adap_status); | |
337 | if (IS_ERR_OR_NULL(adap->status_file)) { | |
338 | pr_warn("cec-%s: Failed to create status file\n", adap->name); | |
339 | debugfs_remove_recursive(adap->cec_dir); | |
340 | adap->cec_dir = NULL; | |
341 | } | |
342 | #endif | |
343 | return 0; | |
344 | } | |
345 | EXPORT_SYMBOL_GPL(cec_register_adapter); | |
346 | ||
347 | void cec_unregister_adapter(struct cec_adapter *adap) | |
348 | { | |
349 | if (IS_ERR_OR_NULL(adap)) | |
350 | return; | |
351 | ||
5f2c467c | 352 | #ifdef CONFIG_MEDIA_CEC_RC |
a56960e8 HV |
353 | /* Note: rc_unregister also calls rc_free */ |
354 | rc_unregister_device(adap->rc); | |
355 | adap->rc = NULL; | |
356 | #endif | |
357 | debugfs_remove_recursive(adap->cec_dir); | |
e94c3281 | 358 | #ifdef CONFIG_CEC_NOTIFIER |
e3a93adc HV |
359 | if (adap->notifier) |
360 | cec_notifier_unregister(adap->notifier); | |
361 | #endif | |
a56960e8 HV |
362 | cec_devnode_unregister(&adap->devnode); |
363 | } | |
364 | EXPORT_SYMBOL_GPL(cec_unregister_adapter); | |
365 | ||
366 | void cec_delete_adapter(struct cec_adapter *adap) | |
367 | { | |
368 | if (IS_ERR_OR_NULL(adap)) | |
369 | return; | |
370 | mutex_lock(&adap->lock); | |
371 | __cec_s_phys_addr(adap, CEC_PHYS_ADDR_INVALID, false); | |
372 | mutex_unlock(&adap->lock); | |
373 | kthread_stop(adap->kthread); | |
374 | if (adap->kthread_config) | |
375 | kthread_stop(adap->kthread_config); | |
5f2c467c | 376 | #ifdef CONFIG_MEDIA_CEC_RC |
d8eddb15 | 377 | rc_free_device(adap->rc); |
a56960e8 HV |
378 | #endif |
379 | kfree(adap); | |
380 | } | |
381 | EXPORT_SYMBOL_GPL(cec_delete_adapter); | |
382 | ||
383 | /* | |
384 | * Initialise cec for linux | |
385 | */ | |
386 | static int __init cec_devnode_init(void) | |
387 | { | |
388 | int ret; | |
389 | ||
390 | pr_info("Linux cec interface: v0.10\n"); | |
391 | ret = alloc_chrdev_region(&cec_dev_t, 0, CEC_NUM_DEVICES, | |
392 | CEC_NAME); | |
393 | if (ret < 0) { | |
394 | pr_warn("cec: unable to allocate major\n"); | |
395 | return ret; | |
396 | } | |
397 | ||
20249f84 | 398 | #ifdef CONFIG_DEBUG_FS |
a56960e8 HV |
399 | top_cec_dir = debugfs_create_dir("cec", NULL); |
400 | if (IS_ERR_OR_NULL(top_cec_dir)) { | |
401 | pr_warn("cec: Failed to create debugfs cec dir\n"); | |
402 | top_cec_dir = NULL; | |
403 | } | |
404 | #endif | |
405 | ||
406 | ret = bus_register(&cec_bus_type); | |
407 | if (ret < 0) { | |
408 | unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES); | |
409 | pr_warn("cec: bus_register failed\n"); | |
410 | return -EIO; | |
411 | } | |
412 | ||
413 | return 0; | |
414 | } | |
415 | ||
416 | static void __exit cec_devnode_exit(void) | |
417 | { | |
418 | debugfs_remove_recursive(top_cec_dir); | |
419 | bus_unregister(&cec_bus_type); | |
420 | unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES); | |
421 | } | |
422 | ||
423 | subsys_initcall(cec_devnode_init); | |
424 | module_exit(cec_devnode_exit) | |
425 | ||
426 | MODULE_AUTHOR("Hans Verkuil <hans.verkuil@cisco.com>"); | |
427 | MODULE_DESCRIPTION("Device node registration for cec drivers"); | |
428 | MODULE_LICENSE("GPL"); |