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