1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * cec-core.c - HDMI Consumer Electronics Control framework - Core 4 * 5 * Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved. 6 */ 7 8 #include <linux/errno.h> 9 #include <linux/init.h> 10 #include <linux/module.h> 11 #include <linux/kernel.h> 12 #include <linux/kmod.h> 13 #include <linux/slab.h> 14 #include <linux/mm.h> 15 #include <linux/string.h> 16 #include <linux/types.h> 17 18 #include "cec-priv.h" 19 20 #define CEC_NUM_DEVICES 256 21 #define CEC_NAME "cec" 22 23 /* 24 * 400 ms is the time it takes for one 16 byte message to be 25 * transferred and 5 is the maximum number of retries. Add 26 * another 100 ms as a margin. So if the transmit doesn't 27 * finish before that time something is really wrong and we 28 * have to time out. 29 * 30 * This is a sign that something it really wrong and a warning 31 * will be issued. 32 */ 33 #define CEC_XFER_TIMEOUT_MS (5 * 400 + 100) 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 bool debug_phys_addr; 40 module_param(debug_phys_addr, bool, 0644); 41 MODULE_PARM_DESC(debug_phys_addr, "add CEC_CAP_PHYS_ADDR if set"); 42 43 static dev_t cec_dev_t; 44 45 /* Active devices */ 46 static DEFINE_MUTEX(cec_devnode_lock); 47 static DECLARE_BITMAP(cec_devnode_nums, CEC_NUM_DEVICES); 48 49 static struct dentry *top_cec_dir; 50 51 /* dev to cec_devnode */ 52 #define to_cec_devnode(cd) container_of(cd, struct cec_devnode, dev) 53 54 int cec_get_device(struct cec_devnode *devnode) 55 { 56 /* 57 * Check if the cec device is available. This needs to be done with 58 * the devnode->lock held to prevent an open/unregister race: 59 * without the lock, the device could be unregistered and freed between 60 * the devnode->registered check and get_device() calls, leading to 61 * a crash. 62 */ 63 mutex_lock(&devnode->lock); 64 /* 65 * return ENXIO if the cec device has been removed 66 * already or if it is not registered anymore. 67 */ 68 if (!devnode->registered) { 69 mutex_unlock(&devnode->lock); 70 return -ENXIO; 71 } 72 /* and increase the device refcount */ 73 get_device(&devnode->dev); 74 mutex_unlock(&devnode->lock); 75 return 0; 76 } 77 78 void cec_put_device(struct cec_devnode *devnode) 79 { 80 put_device(&devnode->dev); 81 } 82 83 /* Called when the last user of the cec device exits. */ 84 static void cec_devnode_release(struct device *cd) 85 { 86 struct cec_devnode *devnode = to_cec_devnode(cd); 87 88 mutex_lock(&cec_devnode_lock); 89 /* Mark device node number as free */ 90 clear_bit(devnode->minor, cec_devnode_nums); 91 mutex_unlock(&cec_devnode_lock); 92 93 cec_delete_adapter(to_cec_adapter(devnode)); 94 } 95 96 static struct bus_type cec_bus_type = { 97 .name = CEC_NAME, 98 }; 99 100 /* 101 * Register a cec device node 102 * 103 * The registration code assigns minor numbers and registers the new device node 104 * with the kernel. An error is returned if no free minor number can be found, 105 * or if the registration of the device node fails. 106 * 107 * Zero is returned on success. 108 * 109 * Note that if the cec_devnode_register call fails, the release() callback of 110 * the cec_devnode structure is *not* called, so the caller is responsible for 111 * freeing any data. 112 */ 113 static int __must_check cec_devnode_register(struct cec_devnode *devnode, 114 struct module *owner) 115 { 116 int minor; 117 int ret; 118 119 /* Part 1: Find a free minor number */ 120 mutex_lock(&cec_devnode_lock); 121 minor = find_first_zero_bit(cec_devnode_nums, CEC_NUM_DEVICES); 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 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.owner = owner; 141 kobject_set_name(&devnode->cdev.kobj, "cec%d", devnode->minor); 142 143 devnode->registered = true; 144 ret = cdev_device_add(&devnode->cdev, &devnode->dev); 145 if (ret) { 146 devnode->registered = false; 147 pr_err("%s: cdev_device_add failed\n", __func__); 148 goto clr_bit; 149 } 150 151 return 0; 152 153 clr_bit: 154 mutex_lock(&cec_devnode_lock); 155 clear_bit(devnode->minor, cec_devnode_nums); 156 mutex_unlock(&cec_devnode_lock); 157 return ret; 158 } 159 160 /* 161 * Unregister a cec device node 162 * 163 * This unregisters the passed device. Future open calls will be met with 164 * errors. 165 * 166 * This function can safely be called if the device node has never been 167 * registered or has already been unregistered. 168 */ 169 static void cec_devnode_unregister(struct cec_adapter *adap) 170 { 171 struct cec_devnode *devnode = &adap->devnode; 172 struct cec_fh *fh; 173 174 mutex_lock(&devnode->lock); 175 176 /* Check if devnode was never registered or already unregistered */ 177 if (!devnode->registered || devnode->unregistered) { 178 mutex_unlock(&devnode->lock); 179 return; 180 } 181 devnode->registered = false; 182 devnode->unregistered = true; 183 184 mutex_lock(&devnode->lock_fhs); 185 list_for_each_entry(fh, &devnode->fhs, list) 186 wake_up_interruptible(&fh->wait); 187 mutex_unlock(&devnode->lock_fhs); 188 189 mutex_unlock(&devnode->lock); 190 191 mutex_lock(&adap->lock); 192 __cec_s_phys_addr(adap, CEC_PHYS_ADDR_INVALID, false); 193 __cec_s_log_addrs(adap, NULL, false); 194 mutex_unlock(&adap->lock); 195 196 cdev_device_del(&devnode->cdev, &devnode->dev); 197 put_device(&devnode->dev); 198 } 199 200 #ifdef CONFIG_DEBUG_FS 201 static ssize_t cec_error_inj_write(struct file *file, 202 const char __user *ubuf, size_t count, loff_t *ppos) 203 { 204 struct seq_file *sf = file->private_data; 205 struct cec_adapter *adap = sf->private; 206 char *buf; 207 char *line; 208 char *p; 209 210 buf = memdup_user_nul(ubuf, min_t(size_t, PAGE_SIZE, count)); 211 if (IS_ERR(buf)) 212 return PTR_ERR(buf); 213 p = buf; 214 while (p && *p) { 215 p = skip_spaces(p); 216 line = strsep(&p, "\n"); 217 if (!*line || *line == '#') 218 continue; 219 if (!call_op(adap, error_inj_parse_line, line)) { 220 kfree(buf); 221 return -EINVAL; 222 } 223 } 224 kfree(buf); 225 return count; 226 } 227 228 static int cec_error_inj_show(struct seq_file *sf, void *unused) 229 { 230 struct cec_adapter *adap = sf->private; 231 232 return call_op(adap, error_inj_show, sf); 233 } 234 235 static int cec_error_inj_open(struct inode *inode, struct file *file) 236 { 237 return single_open(file, cec_error_inj_show, inode->i_private); 238 } 239 240 static const struct file_operations cec_error_inj_fops = { 241 .open = cec_error_inj_open, 242 .write = cec_error_inj_write, 243 .read = seq_read, 244 .llseek = seq_lseek, 245 .release = single_release, 246 }; 247 #endif 248 249 struct cec_adapter *cec_allocate_adapter(const struct cec_adap_ops *ops, 250 void *priv, const char *name, u32 caps, 251 u8 available_las) 252 { 253 struct cec_adapter *adap; 254 int res; 255 256 #ifndef CONFIG_MEDIA_CEC_RC 257 caps &= ~CEC_CAP_RC; 258 #endif 259 260 if (WARN_ON(!caps)) 261 return ERR_PTR(-EINVAL); 262 if (WARN_ON(!ops)) 263 return ERR_PTR(-EINVAL); 264 if (WARN_ON(!available_las || available_las > CEC_MAX_LOG_ADDRS)) 265 return ERR_PTR(-EINVAL); 266 adap = kzalloc(sizeof(*adap), GFP_KERNEL); 267 if (!adap) 268 return ERR_PTR(-ENOMEM); 269 strscpy(adap->name, name, sizeof(adap->name)); 270 adap->phys_addr = CEC_PHYS_ADDR_INVALID; 271 adap->cec_pin_is_high = true; 272 adap->log_addrs.cec_version = CEC_OP_CEC_VERSION_2_0; 273 adap->log_addrs.vendor_id = CEC_VENDOR_ID_NONE; 274 adap->capabilities = caps; 275 if (debug_phys_addr) 276 adap->capabilities |= CEC_CAP_PHYS_ADDR; 277 adap->needs_hpd = caps & CEC_CAP_NEEDS_HPD; 278 adap->available_log_addrs = available_las; 279 adap->sequence = 0; 280 adap->ops = ops; 281 adap->priv = priv; 282 mutex_init(&adap->lock); 283 INIT_LIST_HEAD(&adap->transmit_queue); 284 INIT_LIST_HEAD(&adap->wait_queue); 285 init_waitqueue_head(&adap->kthread_waitq); 286 287 /* adap->devnode initialization */ 288 INIT_LIST_HEAD(&adap->devnode.fhs); 289 mutex_init(&adap->devnode.lock_fhs); 290 mutex_init(&adap->devnode.lock); 291 292 adap->kthread = kthread_run(cec_thread_func, adap, "cec-%s", name); 293 if (IS_ERR(adap->kthread)) { 294 pr_err("cec-%s: kernel_thread() failed\n", name); 295 res = PTR_ERR(adap->kthread); 296 kfree(adap); 297 return ERR_PTR(res); 298 } 299 300 #ifdef CONFIG_MEDIA_CEC_RC 301 if (!(caps & CEC_CAP_RC)) 302 return adap; 303 304 /* Prepare the RC input device */ 305 adap->rc = rc_allocate_device(RC_DRIVER_SCANCODE); 306 if (!adap->rc) { 307 pr_err("cec-%s: failed to allocate memory for rc_dev\n", 308 name); 309 kthread_stop(adap->kthread); 310 kfree(adap); 311 return ERR_PTR(-ENOMEM); 312 } 313 314 snprintf(adap->input_phys, sizeof(adap->input_phys), 315 "%s/input0", adap->name); 316 317 adap->rc->device_name = adap->name; 318 adap->rc->input_phys = adap->input_phys; 319 adap->rc->input_id.bustype = BUS_CEC; 320 adap->rc->input_id.vendor = 0; 321 adap->rc->input_id.product = 0; 322 adap->rc->input_id.version = 1; 323 adap->rc->driver_name = CEC_NAME; 324 adap->rc->allowed_protocols = RC_PROTO_BIT_CEC; 325 adap->rc->priv = adap; 326 adap->rc->map_name = RC_MAP_CEC; 327 adap->rc->timeout = MS_TO_US(550); 328 #endif 329 return adap; 330 } 331 EXPORT_SYMBOL_GPL(cec_allocate_adapter); 332 333 int cec_register_adapter(struct cec_adapter *adap, 334 struct device *parent) 335 { 336 int res; 337 338 if (IS_ERR_OR_NULL(adap)) 339 return 0; 340 341 if (WARN_ON(!parent)) 342 return -EINVAL; 343 344 adap->owner = parent->driver->owner; 345 adap->devnode.dev.parent = parent; 346 if (!adap->xfer_timeout_ms) 347 adap->xfer_timeout_ms = CEC_XFER_TIMEOUT_MS; 348 349 #ifdef CONFIG_MEDIA_CEC_RC 350 if (adap->capabilities & CEC_CAP_RC) { 351 adap->rc->dev.parent = parent; 352 res = rc_register_device(adap->rc); 353 354 if (res) { 355 pr_err("cec-%s: failed to prepare input device\n", 356 adap->name); 357 rc_free_device(adap->rc); 358 adap->rc = NULL; 359 return res; 360 } 361 } 362 #endif 363 364 res = cec_devnode_register(&adap->devnode, adap->owner); 365 if (res) { 366 #ifdef CONFIG_MEDIA_CEC_RC 367 /* Note: rc_unregister also calls rc_free */ 368 rc_unregister_device(adap->rc); 369 adap->rc = NULL; 370 #endif 371 return res; 372 } 373 374 dev_set_drvdata(&adap->devnode.dev, adap); 375 #ifdef CONFIG_DEBUG_FS 376 if (!top_cec_dir) 377 return 0; 378 379 adap->cec_dir = debugfs_create_dir(dev_name(&adap->devnode.dev), 380 top_cec_dir); 381 382 debugfs_create_devm_seqfile(&adap->devnode.dev, "status", adap->cec_dir, 383 cec_adap_status); 384 385 if (!adap->ops->error_inj_show || !adap->ops->error_inj_parse_line) 386 return 0; 387 debugfs_create_file("error-inj", 0644, adap->cec_dir, adap, 388 &cec_error_inj_fops); 389 #endif 390 return 0; 391 } 392 EXPORT_SYMBOL_GPL(cec_register_adapter); 393 394 void cec_unregister_adapter(struct cec_adapter *adap) 395 { 396 if (IS_ERR_OR_NULL(adap)) 397 return; 398 399 #ifdef CONFIG_MEDIA_CEC_RC 400 /* Note: rc_unregister also calls rc_free */ 401 rc_unregister_device(adap->rc); 402 adap->rc = NULL; 403 #endif 404 debugfs_remove_recursive(adap->cec_dir); 405 #ifdef CONFIG_CEC_NOTIFIER 406 cec_notifier_cec_adap_unregister(adap->notifier, adap); 407 #endif 408 cec_devnode_unregister(adap); 409 } 410 EXPORT_SYMBOL_GPL(cec_unregister_adapter); 411 412 void cec_delete_adapter(struct cec_adapter *adap) 413 { 414 if (IS_ERR_OR_NULL(adap)) 415 return; 416 if (adap->kthread_config) 417 kthread_stop(adap->kthread_config); 418 kthread_stop(adap->kthread); 419 if (adap->ops->adap_free) 420 adap->ops->adap_free(adap); 421 #ifdef CONFIG_MEDIA_CEC_RC 422 rc_free_device(adap->rc); 423 #endif 424 kfree(adap); 425 } 426 EXPORT_SYMBOL_GPL(cec_delete_adapter); 427 428 /* 429 * Initialise cec for linux 430 */ 431 static int __init cec_devnode_init(void) 432 { 433 int ret = alloc_chrdev_region(&cec_dev_t, 0, CEC_NUM_DEVICES, CEC_NAME); 434 435 if (ret < 0) { 436 pr_warn("cec: unable to allocate major\n"); 437 return ret; 438 } 439 440 #ifdef CONFIG_DEBUG_FS 441 top_cec_dir = debugfs_create_dir("cec", NULL); 442 if (IS_ERR_OR_NULL(top_cec_dir)) { 443 pr_warn("cec: Failed to create debugfs cec dir\n"); 444 top_cec_dir = NULL; 445 } 446 #endif 447 448 ret = bus_register(&cec_bus_type); 449 if (ret < 0) { 450 unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES); 451 pr_warn("cec: bus_register failed\n"); 452 return -EIO; 453 } 454 455 return 0; 456 } 457 458 static void __exit cec_devnode_exit(void) 459 { 460 debugfs_remove_recursive(top_cec_dir); 461 bus_unregister(&cec_bus_type); 462 unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES); 463 } 464 465 subsys_initcall(cec_devnode_init); 466 module_exit(cec_devnode_exit) 467 468 MODULE_AUTHOR("Hans Verkuil <hans.verkuil@cisco.com>"); 469 MODULE_DESCRIPTION("Device node registration for cec drivers"); 470 MODULE_LICENSE("GPL"); 471