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