2 * cec-core.c - HDMI Consumer Electronics Control framework - Core
4 * Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
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.
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
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>
27 #include <linux/string.h>
28 #include <linux/types.h>
32 #define CEC_NUM_DEVICES 256
33 #define CEC_NAME "cec"
36 module_param_named(debug
, cec_debug
, int, 0644);
37 MODULE_PARM_DESC(debug
, "debug level (0-2)");
39 static dev_t cec_dev_t
;
42 static DEFINE_MUTEX(cec_devnode_lock
);
43 static DECLARE_BITMAP(cec_devnode_nums
, CEC_NUM_DEVICES
);
45 static struct dentry
*top_cec_dir
;
47 /* dev to cec_devnode */
48 #define to_cec_devnode(cd) container_of(cd, struct cec_devnode, dev)
50 int cec_get_device(struct cec_devnode
*devnode
)
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
59 mutex_lock(&cec_devnode_lock
);
61 * return ENXIO if the cec device has been removed
62 * already or if it is not registered anymore.
64 if (!devnode
->registered
) {
65 mutex_unlock(&cec_devnode_lock
);
68 /* and increase the device refcount */
69 get_device(&devnode
->dev
);
70 mutex_unlock(&cec_devnode_lock
);
74 void cec_put_device(struct cec_devnode
*devnode
)
76 mutex_lock(&cec_devnode_lock
);
77 put_device(&devnode
->dev
);
78 mutex_unlock(&cec_devnode_lock
);
81 /* Called when the last user of the cec device exits. */
82 static void cec_devnode_release(struct device
*cd
)
84 struct cec_devnode
*devnode
= to_cec_devnode(cd
);
86 mutex_lock(&cec_devnode_lock
);
88 /* Mark device node number as free */
89 clear_bit(devnode
->minor
, cec_devnode_nums
);
91 mutex_unlock(&cec_devnode_lock
);
92 cec_delete_adapter(to_cec_adapter(devnode
));
95 static struct bus_type cec_bus_type
= {
100 * Register a cec device node
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.
106 * Zero is returned on success.
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
112 static int __must_check
cec_devnode_register(struct cec_devnode
*devnode
,
113 struct module
*owner
)
119 INIT_LIST_HEAD(&devnode
->fhs
);
120 mutex_init(&devnode
->fhs_lock
);
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");
131 set_bit(minor
, cec_devnode_nums
);
132 mutex_unlock(&cec_devnode_lock
);
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
);
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
;
147 ret
= cdev_add(&devnode
->cdev
, devnode
->dev
.devt
, 1);
149 pr_err("%s: cdev_add failed\n", __func__
);
153 ret
= device_add(&devnode
->dev
);
157 devnode
->registered
= true;
161 cdev_del(&devnode
->cdev
);
163 clear_bit(devnode
->minor
, cec_devnode_nums
);
168 * Unregister a cec device node
170 * This unregisters the passed device. Future open calls will be met with
173 * This function can safely be called if the device node has never been
174 * registered or has already been unregistered.
176 static void cec_devnode_unregister(struct cec_devnode
*devnode
)
180 /* Check if devnode was never registered or already unregistered */
181 if (!devnode
->registered
|| devnode
->unregistered
)
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
);
189 devnode
->registered
= false;
190 devnode
->unregistered
= true;
191 device_del(&devnode
->dev
);
192 cdev_del(&devnode
->cdev
);
193 put_device(&devnode
->dev
);
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
)
200 struct cec_adapter
*adap
;
203 if (WARN_ON(!parent
))
204 return ERR_PTR(-EINVAL
);
206 return ERR_PTR(-EINVAL
);
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
);
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
;
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
);
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
);
239 if (!(caps
& CEC_CAP_RC
))
242 #if IS_REACHABLE(CONFIG_RC_CORE)
243 /* Prepare the RC input device */
244 adap
->rc
= rc_allocate_device();
246 pr_err("cec-%s: failed to allocate memory for rc_dev\n",
248 kthread_stop(adap
->kthread
);
250 return ERR_PTR(-ENOMEM
);
253 snprintf(adap
->input_name
, sizeof(adap
->input_name
),
255 snprintf(adap
->input_phys
, sizeof(adap
->input_phys
),
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);
272 adap
->capabilities
&= ~CEC_CAP_RC
;
276 EXPORT_SYMBOL_GPL(cec_allocate_adapter
);
278 int cec_register_adapter(struct cec_adapter
*adap
)
282 if (IS_ERR_OR_NULL(adap
))
285 #if IS_REACHABLE(CONFIG_RC_CORE)
286 if (adap
->capabilities
& CEC_CAP_RC
) {
287 res
= rc_register_device(adap
->rc
);
290 pr_err("cec-%s: failed to prepare input device\n",
292 rc_free_device(adap
->rc
);
299 res
= cec_devnode_register(&adap
->devnode
, adap
->owner
);
301 #if IS_REACHABLE(CONFIG_RC_CORE)
302 /* Note: rc_unregister also calls rc_free */
303 rc_unregister_device(adap
->rc
);
309 dev_set_drvdata(&adap
->devnode
.dev
, adap
);
310 #ifdef CONFIG_MEDIA_CEC_DEBUG
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
);
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
;
329 EXPORT_SYMBOL_GPL(cec_register_adapter
);
331 void cec_unregister_adapter(struct cec_adapter
*adap
)
333 if (IS_ERR_OR_NULL(adap
))
336 #if IS_REACHABLE(CONFIG_RC_CORE)
337 /* Note: rc_unregister also calls rc_free */
338 rc_unregister_device(adap
->rc
);
341 debugfs_remove_recursive(adap
->cec_dir
);
342 cec_devnode_unregister(&adap
->devnode
);
344 EXPORT_SYMBOL_GPL(cec_unregister_adapter
);
346 void cec_delete_adapter(struct cec_adapter
*adap
)
348 if (IS_ERR_OR_NULL(adap
))
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_REACHABLE(CONFIG_RC_CORE)
358 rc_free_device(adap
->rc
);
362 EXPORT_SYMBOL_GPL(cec_delete_adapter
);
365 * Initialise cec for linux
367 static int __init
cec_devnode_init(void)
371 pr_info("Linux cec interface: v0.10\n");
372 ret
= alloc_chrdev_region(&cec_dev_t
, 0, CEC_NUM_DEVICES
,
375 pr_warn("cec: unable to allocate major\n");
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");
387 ret
= bus_register(&cec_bus_type
);
389 unregister_chrdev_region(cec_dev_t
, CEC_NUM_DEVICES
);
390 pr_warn("cec: bus_register failed\n");
397 static void __exit
cec_devnode_exit(void)
399 debugfs_remove_recursive(top_cec_dir
);
400 bus_unregister(&cec_bus_type
);
401 unregister_chrdev_region(cec_dev_t
, CEC_NUM_DEVICES
);
404 subsys_initcall(cec_devnode_init
);
405 module_exit(cec_devnode_exit
)
407 MODULE_AUTHOR("Hans Verkuil <hans.verkuil@cisco.com>");
408 MODULE_DESCRIPTION("Device node registration for cec drivers");
409 MODULE_LICENSE("GPL");
This page took 0.043256 seconds and 5 git commands to generate.