1 /* 2 * 3 * Intel Management Engine Interface (Intel MEI) Linux driver 4 * Copyright (c) 2003-2012, Intel Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms and conditions of the GNU General Public License, 8 * version 2, as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13 * more details. 14 * 15 */ 16 #include <linux/module.h> 17 #include <linux/moduleparam.h> 18 #include <linux/kernel.h> 19 #include <linux/device.h> 20 #include <linux/slab.h> 21 #include <linux/fs.h> 22 #include <linux/errno.h> 23 #include <linux/types.h> 24 #include <linux/fcntl.h> 25 #include <linux/poll.h> 26 #include <linux/init.h> 27 #include <linux/ioctl.h> 28 #include <linux/cdev.h> 29 #include <linux/sched/signal.h> 30 #include <linux/uuid.h> 31 #include <linux/compat.h> 32 #include <linux/jiffies.h> 33 #include <linux/interrupt.h> 34 35 #include <linux/mei.h> 36 37 #include "mei_dev.h" 38 #include "client.h" 39 40 /** 41 * mei_open - the open function 42 * 43 * @inode: pointer to inode structure 44 * @file: pointer to file structure 45 * 46 * Return: 0 on success, <0 on error 47 */ 48 static int mei_open(struct inode *inode, struct file *file) 49 { 50 struct mei_device *dev; 51 struct mei_cl *cl; 52 53 int err; 54 55 dev = container_of(inode->i_cdev, struct mei_device, cdev); 56 if (!dev) 57 return -ENODEV; 58 59 mutex_lock(&dev->device_lock); 60 61 if (dev->dev_state != MEI_DEV_ENABLED) { 62 dev_dbg(dev->dev, "dev_state != MEI_ENABLED dev_state = %s\n", 63 mei_dev_state_str(dev->dev_state)); 64 err = -ENODEV; 65 goto err_unlock; 66 } 67 68 cl = mei_cl_alloc_linked(dev); 69 if (IS_ERR(cl)) { 70 err = PTR_ERR(cl); 71 goto err_unlock; 72 } 73 74 cl->fp = file; 75 file->private_data = cl; 76 77 mutex_unlock(&dev->device_lock); 78 79 return nonseekable_open(inode, file); 80 81 err_unlock: 82 mutex_unlock(&dev->device_lock); 83 return err; 84 } 85 86 /** 87 * mei_release - the release function 88 * 89 * @inode: pointer to inode structure 90 * @file: pointer to file structure 91 * 92 * Return: 0 on success, <0 on error 93 */ 94 static int mei_release(struct inode *inode, struct file *file) 95 { 96 struct mei_cl *cl = file->private_data; 97 struct mei_device *dev; 98 int rets; 99 100 if (WARN_ON(!cl || !cl->dev)) 101 return -ENODEV; 102 103 dev = cl->dev; 104 105 mutex_lock(&dev->device_lock); 106 107 rets = mei_cl_disconnect(cl); 108 109 mei_cl_flush_queues(cl, file); 110 cl_dbg(dev, cl, "removing\n"); 111 112 mei_cl_unlink(cl); 113 114 file->private_data = NULL; 115 116 kfree(cl); 117 118 mutex_unlock(&dev->device_lock); 119 return rets; 120 } 121 122 123 /** 124 * mei_read - the read function. 125 * 126 * @file: pointer to file structure 127 * @ubuf: pointer to user buffer 128 * @length: buffer length 129 * @offset: data offset in buffer 130 * 131 * Return: >=0 data length on success , <0 on error 132 */ 133 static ssize_t mei_read(struct file *file, char __user *ubuf, 134 size_t length, loff_t *offset) 135 { 136 struct mei_cl *cl = file->private_data; 137 struct mei_device *dev; 138 struct mei_cl_cb *cb = NULL; 139 bool nonblock = !!(file->f_flags & O_NONBLOCK); 140 int rets; 141 142 if (WARN_ON(!cl || !cl->dev)) 143 return -ENODEV; 144 145 dev = cl->dev; 146 147 148 mutex_lock(&dev->device_lock); 149 if (dev->dev_state != MEI_DEV_ENABLED) { 150 rets = -ENODEV; 151 goto out; 152 } 153 154 if (length == 0) { 155 rets = 0; 156 goto out; 157 } 158 159 if (ubuf == NULL) { 160 rets = -EMSGSIZE; 161 goto out; 162 } 163 164 cb = mei_cl_read_cb(cl, file); 165 if (cb) 166 goto copy_buffer; 167 168 if (*offset > 0) 169 *offset = 0; 170 171 rets = mei_cl_read_start(cl, length, file); 172 if (rets && rets != -EBUSY) { 173 cl_dbg(dev, cl, "mei start read failure status = %d\n", rets); 174 goto out; 175 } 176 177 if (nonblock) { 178 rets = -EAGAIN; 179 goto out; 180 } 181 182 mutex_unlock(&dev->device_lock); 183 if (wait_event_interruptible(cl->rx_wait, 184 !list_empty(&cl->rd_completed) || 185 !mei_cl_is_connected(cl))) { 186 if (signal_pending(current)) 187 return -EINTR; 188 return -ERESTARTSYS; 189 } 190 mutex_lock(&dev->device_lock); 191 192 if (!mei_cl_is_connected(cl)) { 193 rets = -ENODEV; 194 goto out; 195 } 196 197 cb = mei_cl_read_cb(cl, file); 198 if (!cb) { 199 rets = 0; 200 goto out; 201 } 202 203 copy_buffer: 204 /* now copy the data to user space */ 205 if (cb->status) { 206 rets = cb->status; 207 cl_dbg(dev, cl, "read operation failed %d\n", rets); 208 goto free; 209 } 210 211 cl_dbg(dev, cl, "buf.size = %zu buf.idx = %zu offset = %lld\n", 212 cb->buf.size, cb->buf_idx, *offset); 213 if (*offset >= cb->buf_idx) { 214 rets = 0; 215 goto free; 216 } 217 218 /* length is being truncated to PAGE_SIZE, 219 * however buf_idx may point beyond that */ 220 length = min_t(size_t, length, cb->buf_idx - *offset); 221 222 if (copy_to_user(ubuf, cb->buf.data + *offset, length)) { 223 dev_dbg(dev->dev, "failed to copy data to userland\n"); 224 rets = -EFAULT; 225 goto free; 226 } 227 228 rets = length; 229 *offset += length; 230 /* not all data was read, keep the cb */ 231 if (*offset < cb->buf_idx) 232 goto out; 233 234 free: 235 mei_io_cb_free(cb); 236 *offset = 0; 237 238 out: 239 cl_dbg(dev, cl, "end mei read rets = %d\n", rets); 240 mutex_unlock(&dev->device_lock); 241 return rets; 242 } 243 /** 244 * mei_write - the write function. 245 * 246 * @file: pointer to file structure 247 * @ubuf: pointer to user buffer 248 * @length: buffer length 249 * @offset: data offset in buffer 250 * 251 * Return: >=0 data length on success , <0 on error 252 */ 253 static ssize_t mei_write(struct file *file, const char __user *ubuf, 254 size_t length, loff_t *offset) 255 { 256 struct mei_cl *cl = file->private_data; 257 struct mei_cl_cb *cb; 258 struct mei_device *dev; 259 int rets; 260 261 if (WARN_ON(!cl || !cl->dev)) 262 return -ENODEV; 263 264 dev = cl->dev; 265 266 mutex_lock(&dev->device_lock); 267 268 if (dev->dev_state != MEI_DEV_ENABLED) { 269 rets = -ENODEV; 270 goto out; 271 } 272 273 if (!mei_cl_is_connected(cl)) { 274 cl_err(dev, cl, "is not connected"); 275 rets = -ENODEV; 276 goto out; 277 } 278 279 if (!mei_me_cl_is_active(cl->me_cl)) { 280 rets = -ENOTTY; 281 goto out; 282 } 283 284 if (length > mei_cl_mtu(cl)) { 285 rets = -EFBIG; 286 goto out; 287 } 288 289 if (length == 0) { 290 rets = 0; 291 goto out; 292 } 293 294 *offset = 0; 295 cb = mei_cl_alloc_cb(cl, length, MEI_FOP_WRITE, file); 296 if (!cb) { 297 rets = -ENOMEM; 298 goto out; 299 } 300 301 rets = copy_from_user(cb->buf.data, ubuf, length); 302 if (rets) { 303 dev_dbg(dev->dev, "failed to copy data from userland\n"); 304 rets = -EFAULT; 305 mei_io_cb_free(cb); 306 goto out; 307 } 308 309 rets = mei_cl_write(cl, cb); 310 out: 311 mutex_unlock(&dev->device_lock); 312 return rets; 313 } 314 315 /** 316 * mei_ioctl_connect_client - the connect to fw client IOCTL function 317 * 318 * @file: private data of the file object 319 * @data: IOCTL connect data, input and output parameters 320 * 321 * Locking: called under "dev->device_lock" lock 322 * 323 * Return: 0 on success, <0 on failure. 324 */ 325 static int mei_ioctl_connect_client(struct file *file, 326 struct mei_connect_client_data *data) 327 { 328 struct mei_device *dev; 329 struct mei_client *client; 330 struct mei_me_client *me_cl; 331 struct mei_cl *cl; 332 int rets; 333 334 cl = file->private_data; 335 dev = cl->dev; 336 337 if (dev->dev_state != MEI_DEV_ENABLED) 338 return -ENODEV; 339 340 if (cl->state != MEI_FILE_INITIALIZING && 341 cl->state != MEI_FILE_DISCONNECTED) 342 return -EBUSY; 343 344 /* find ME client we're trying to connect to */ 345 me_cl = mei_me_cl_by_uuid(dev, &data->in_client_uuid); 346 if (!me_cl) { 347 dev_dbg(dev->dev, "Cannot connect to FW Client UUID = %pUl\n", 348 &data->in_client_uuid); 349 rets = -ENOTTY; 350 goto end; 351 } 352 353 if (me_cl->props.fixed_address) { 354 bool forbidden = dev->override_fixed_address ? 355 !dev->allow_fixed_address : !dev->hbm_f_fa_supported; 356 if (forbidden) { 357 dev_dbg(dev->dev, "Connection forbidden to FW Client UUID = %pUl\n", 358 &data->in_client_uuid); 359 rets = -ENOTTY; 360 goto end; 361 } 362 } 363 364 dev_dbg(dev->dev, "Connect to FW Client ID = %d\n", 365 me_cl->client_id); 366 dev_dbg(dev->dev, "FW Client - Protocol Version = %d\n", 367 me_cl->props.protocol_version); 368 dev_dbg(dev->dev, "FW Client - Max Msg Len = %d\n", 369 me_cl->props.max_msg_length); 370 371 /* prepare the output buffer */ 372 client = &data->out_client_properties; 373 client->max_msg_length = me_cl->props.max_msg_length; 374 client->protocol_version = me_cl->props.protocol_version; 375 dev_dbg(dev->dev, "Can connect?\n"); 376 377 rets = mei_cl_connect(cl, me_cl, file); 378 379 end: 380 mei_me_cl_put(me_cl); 381 return rets; 382 } 383 384 /** 385 * mei_ioctl_client_notify_request - 386 * propagate event notification request to client 387 * 388 * @file: pointer to file structure 389 * @request: 0 - disable, 1 - enable 390 * 391 * Return: 0 on success , <0 on error 392 */ 393 static int mei_ioctl_client_notify_request(const struct file *file, u32 request) 394 { 395 struct mei_cl *cl = file->private_data; 396 397 if (request != MEI_HBM_NOTIFICATION_START && 398 request != MEI_HBM_NOTIFICATION_STOP) 399 return -EINVAL; 400 401 return mei_cl_notify_request(cl, file, (u8)request); 402 } 403 404 /** 405 * mei_ioctl_client_notify_get - wait for notification request 406 * 407 * @file: pointer to file structure 408 * @notify_get: 0 - disable, 1 - enable 409 * 410 * Return: 0 on success , <0 on error 411 */ 412 static int mei_ioctl_client_notify_get(const struct file *file, u32 *notify_get) 413 { 414 struct mei_cl *cl = file->private_data; 415 bool notify_ev; 416 bool block = (file->f_flags & O_NONBLOCK) == 0; 417 int rets; 418 419 rets = mei_cl_notify_get(cl, block, ¬ify_ev); 420 if (rets) 421 return rets; 422 423 *notify_get = notify_ev ? 1 : 0; 424 return 0; 425 } 426 427 /** 428 * mei_ioctl - the IOCTL function 429 * 430 * @file: pointer to file structure 431 * @cmd: ioctl command 432 * @data: pointer to mei message structure 433 * 434 * Return: 0 on success , <0 on error 435 */ 436 static long mei_ioctl(struct file *file, unsigned int cmd, unsigned long data) 437 { 438 struct mei_device *dev; 439 struct mei_cl *cl = file->private_data; 440 struct mei_connect_client_data connect_data; 441 u32 notify_get, notify_req; 442 int rets; 443 444 445 if (WARN_ON(!cl || !cl->dev)) 446 return -ENODEV; 447 448 dev = cl->dev; 449 450 dev_dbg(dev->dev, "IOCTL cmd = 0x%x", cmd); 451 452 mutex_lock(&dev->device_lock); 453 if (dev->dev_state != MEI_DEV_ENABLED) { 454 rets = -ENODEV; 455 goto out; 456 } 457 458 switch (cmd) { 459 case IOCTL_MEI_CONNECT_CLIENT: 460 dev_dbg(dev->dev, ": IOCTL_MEI_CONNECT_CLIENT.\n"); 461 if (copy_from_user(&connect_data, (char __user *)data, 462 sizeof(struct mei_connect_client_data))) { 463 dev_dbg(dev->dev, "failed to copy data from userland\n"); 464 rets = -EFAULT; 465 goto out; 466 } 467 468 rets = mei_ioctl_connect_client(file, &connect_data); 469 if (rets) 470 goto out; 471 472 /* if all is ok, copying the data back to user. */ 473 if (copy_to_user((char __user *)data, &connect_data, 474 sizeof(struct mei_connect_client_data))) { 475 dev_dbg(dev->dev, "failed to copy data to userland\n"); 476 rets = -EFAULT; 477 goto out; 478 } 479 480 break; 481 482 case IOCTL_MEI_NOTIFY_SET: 483 dev_dbg(dev->dev, ": IOCTL_MEI_NOTIFY_SET.\n"); 484 if (copy_from_user(¬ify_req, 485 (char __user *)data, sizeof(notify_req))) { 486 dev_dbg(dev->dev, "failed to copy data from userland\n"); 487 rets = -EFAULT; 488 goto out; 489 } 490 rets = mei_ioctl_client_notify_request(file, notify_req); 491 break; 492 493 case IOCTL_MEI_NOTIFY_GET: 494 dev_dbg(dev->dev, ": IOCTL_MEI_NOTIFY_GET.\n"); 495 rets = mei_ioctl_client_notify_get(file, ¬ify_get); 496 if (rets) 497 goto out; 498 499 dev_dbg(dev->dev, "copy connect data to user\n"); 500 if (copy_to_user((char __user *)data, 501 ¬ify_get, sizeof(notify_get))) { 502 dev_dbg(dev->dev, "failed to copy data to userland\n"); 503 rets = -EFAULT; 504 goto out; 505 506 } 507 break; 508 509 default: 510 dev_err(dev->dev, ": unsupported ioctl %d.\n", cmd); 511 rets = -ENOIOCTLCMD; 512 } 513 514 out: 515 mutex_unlock(&dev->device_lock); 516 return rets; 517 } 518 519 /** 520 * mei_compat_ioctl - the compat IOCTL function 521 * 522 * @file: pointer to file structure 523 * @cmd: ioctl command 524 * @data: pointer to mei message structure 525 * 526 * Return: 0 on success , <0 on error 527 */ 528 #ifdef CONFIG_COMPAT 529 static long mei_compat_ioctl(struct file *file, 530 unsigned int cmd, unsigned long data) 531 { 532 return mei_ioctl(file, cmd, (unsigned long)compat_ptr(data)); 533 } 534 #endif 535 536 537 /** 538 * mei_poll - the poll function 539 * 540 * @file: pointer to file structure 541 * @wait: pointer to poll_table structure 542 * 543 * Return: poll mask 544 */ 545 static unsigned int mei_poll(struct file *file, poll_table *wait) 546 { 547 unsigned long req_events = poll_requested_events(wait); 548 struct mei_cl *cl = file->private_data; 549 struct mei_device *dev; 550 unsigned int mask = 0; 551 bool notify_en; 552 553 if (WARN_ON(!cl || !cl->dev)) 554 return POLLERR; 555 556 dev = cl->dev; 557 558 mutex_lock(&dev->device_lock); 559 560 notify_en = cl->notify_en && (req_events & POLLPRI); 561 562 if (dev->dev_state != MEI_DEV_ENABLED || 563 !mei_cl_is_connected(cl)) { 564 mask = POLLERR; 565 goto out; 566 } 567 568 if (notify_en) { 569 poll_wait(file, &cl->ev_wait, wait); 570 if (cl->notify_ev) 571 mask |= POLLPRI; 572 } 573 574 if (req_events & (POLLIN | POLLRDNORM)) { 575 poll_wait(file, &cl->rx_wait, wait); 576 577 if (!list_empty(&cl->rd_completed)) 578 mask |= POLLIN | POLLRDNORM; 579 else 580 mei_cl_read_start(cl, mei_cl_mtu(cl), file); 581 } 582 583 out: 584 mutex_unlock(&dev->device_lock); 585 return mask; 586 } 587 588 /** 589 * mei_cl_is_write_queued - check if the client has pending writes. 590 * 591 * @cl: writing host client 592 * 593 * Return: true if client is writing, false otherwise. 594 */ 595 static bool mei_cl_is_write_queued(struct mei_cl *cl) 596 { 597 struct mei_device *dev = cl->dev; 598 struct mei_cl_cb *cb; 599 600 list_for_each_entry(cb, &dev->write_list, list) 601 if (cb->cl == cl) 602 return true; 603 list_for_each_entry(cb, &dev->write_waiting_list, list) 604 if (cb->cl == cl) 605 return true; 606 return false; 607 } 608 609 /** 610 * mei_fsync - the fsync handler 611 * 612 * @fp: pointer to file structure 613 * @start: unused 614 * @end: unused 615 * @datasync: unused 616 * 617 * Return: 0 on success, -ENODEV if client is not connected 618 */ 619 static int mei_fsync(struct file *fp, loff_t start, loff_t end, int datasync) 620 { 621 struct mei_cl *cl = fp->private_data; 622 struct mei_device *dev; 623 int rets; 624 625 if (WARN_ON(!cl || !cl->dev)) 626 return -ENODEV; 627 628 dev = cl->dev; 629 630 mutex_lock(&dev->device_lock); 631 632 if (dev->dev_state != MEI_DEV_ENABLED || !mei_cl_is_connected(cl)) { 633 rets = -ENODEV; 634 goto out; 635 } 636 637 while (mei_cl_is_write_queued(cl)) { 638 mutex_unlock(&dev->device_lock); 639 rets = wait_event_interruptible(cl->tx_wait, 640 cl->writing_state == MEI_WRITE_COMPLETE || 641 !mei_cl_is_connected(cl)); 642 mutex_lock(&dev->device_lock); 643 if (rets) { 644 if (signal_pending(current)) 645 rets = -EINTR; 646 goto out; 647 } 648 if (!mei_cl_is_connected(cl)) { 649 rets = -ENODEV; 650 goto out; 651 } 652 } 653 rets = 0; 654 out: 655 mutex_unlock(&dev->device_lock); 656 return rets; 657 } 658 659 /** 660 * mei_fasync - asynchronous io support 661 * 662 * @fd: file descriptor 663 * @file: pointer to file structure 664 * @band: band bitmap 665 * 666 * Return: negative on error, 667 * 0 if it did no changes, 668 * and positive a process was added or deleted 669 */ 670 static int mei_fasync(int fd, struct file *file, int band) 671 { 672 673 struct mei_cl *cl = file->private_data; 674 675 if (!mei_cl_is_connected(cl)) 676 return -ENODEV; 677 678 return fasync_helper(fd, file, band, &cl->ev_async); 679 } 680 681 /** 682 * fw_status_show - mei device fw_status attribute show method 683 * 684 * @device: device pointer 685 * @attr: attribute pointer 686 * @buf: char out buffer 687 * 688 * Return: number of the bytes printed into buf or error 689 */ 690 static ssize_t fw_status_show(struct device *device, 691 struct device_attribute *attr, char *buf) 692 { 693 struct mei_device *dev = dev_get_drvdata(device); 694 struct mei_fw_status fw_status; 695 int err, i; 696 ssize_t cnt = 0; 697 698 mutex_lock(&dev->device_lock); 699 err = mei_fw_status(dev, &fw_status); 700 mutex_unlock(&dev->device_lock); 701 if (err) { 702 dev_err(device, "read fw_status error = %d\n", err); 703 return err; 704 } 705 706 for (i = 0; i < fw_status.count; i++) 707 cnt += scnprintf(buf + cnt, PAGE_SIZE - cnt, "%08X\n", 708 fw_status.status[i]); 709 return cnt; 710 } 711 static DEVICE_ATTR_RO(fw_status); 712 713 /** 714 * hbm_ver_show - display HBM protocol version negotiated with FW 715 * 716 * @device: device pointer 717 * @attr: attribute pointer 718 * @buf: char out buffer 719 * 720 * Return: number of the bytes printed into buf or error 721 */ 722 static ssize_t hbm_ver_show(struct device *device, 723 struct device_attribute *attr, char *buf) 724 { 725 struct mei_device *dev = dev_get_drvdata(device); 726 struct hbm_version ver; 727 728 mutex_lock(&dev->device_lock); 729 ver = dev->version; 730 mutex_unlock(&dev->device_lock); 731 732 return sprintf(buf, "%u.%u\n", ver.major_version, ver.minor_version); 733 } 734 static DEVICE_ATTR_RO(hbm_ver); 735 736 /** 737 * hbm_ver_drv_show - display HBM protocol version advertised by driver 738 * 739 * @device: device pointer 740 * @attr: attribute pointer 741 * @buf: char out buffer 742 * 743 * Return: number of the bytes printed into buf or error 744 */ 745 static ssize_t hbm_ver_drv_show(struct device *device, 746 struct device_attribute *attr, char *buf) 747 { 748 return sprintf(buf, "%u.%u\n", HBM_MAJOR_VERSION, HBM_MINOR_VERSION); 749 } 750 static DEVICE_ATTR_RO(hbm_ver_drv); 751 752 static struct attribute *mei_attrs[] = { 753 &dev_attr_fw_status.attr, 754 &dev_attr_hbm_ver.attr, 755 &dev_attr_hbm_ver_drv.attr, 756 NULL 757 }; 758 ATTRIBUTE_GROUPS(mei); 759 760 /* 761 * file operations structure will be used for mei char device. 762 */ 763 static const struct file_operations mei_fops = { 764 .owner = THIS_MODULE, 765 .read = mei_read, 766 .unlocked_ioctl = mei_ioctl, 767 #ifdef CONFIG_COMPAT 768 .compat_ioctl = mei_compat_ioctl, 769 #endif 770 .open = mei_open, 771 .release = mei_release, 772 .write = mei_write, 773 .poll = mei_poll, 774 .fsync = mei_fsync, 775 .fasync = mei_fasync, 776 .llseek = no_llseek 777 }; 778 779 static struct class *mei_class; 780 static dev_t mei_devt; 781 #define MEI_MAX_DEVS MINORMASK 782 static DEFINE_MUTEX(mei_minor_lock); 783 static DEFINE_IDR(mei_idr); 784 785 /** 786 * mei_minor_get - obtain next free device minor number 787 * 788 * @dev: device pointer 789 * 790 * Return: allocated minor, or -ENOSPC if no free minor left 791 */ 792 static int mei_minor_get(struct mei_device *dev) 793 { 794 int ret; 795 796 mutex_lock(&mei_minor_lock); 797 ret = idr_alloc(&mei_idr, dev, 0, MEI_MAX_DEVS, GFP_KERNEL); 798 if (ret >= 0) 799 dev->minor = ret; 800 else if (ret == -ENOSPC) 801 dev_err(dev->dev, "too many mei devices\n"); 802 803 mutex_unlock(&mei_minor_lock); 804 return ret; 805 } 806 807 /** 808 * mei_minor_free - mark device minor number as free 809 * 810 * @dev: device pointer 811 */ 812 static void mei_minor_free(struct mei_device *dev) 813 { 814 mutex_lock(&mei_minor_lock); 815 idr_remove(&mei_idr, dev->minor); 816 mutex_unlock(&mei_minor_lock); 817 } 818 819 int mei_register(struct mei_device *dev, struct device *parent) 820 { 821 struct device *clsdev; /* class device */ 822 int ret, devno; 823 824 ret = mei_minor_get(dev); 825 if (ret < 0) 826 return ret; 827 828 /* Fill in the data structures */ 829 devno = MKDEV(MAJOR(mei_devt), dev->minor); 830 cdev_init(&dev->cdev, &mei_fops); 831 dev->cdev.owner = parent->driver->owner; 832 833 /* Add the device */ 834 ret = cdev_add(&dev->cdev, devno, 1); 835 if (ret) { 836 dev_err(parent, "unable to add device %d:%d\n", 837 MAJOR(mei_devt), dev->minor); 838 goto err_dev_add; 839 } 840 841 clsdev = device_create_with_groups(mei_class, parent, devno, 842 dev, mei_groups, 843 "mei%d", dev->minor); 844 845 if (IS_ERR(clsdev)) { 846 dev_err(parent, "unable to create device %d:%d\n", 847 MAJOR(mei_devt), dev->minor); 848 ret = PTR_ERR(clsdev); 849 goto err_dev_create; 850 } 851 852 ret = mei_dbgfs_register(dev, dev_name(clsdev)); 853 if (ret) { 854 dev_err(clsdev, "cannot register debugfs ret = %d\n", ret); 855 goto err_dev_dbgfs; 856 } 857 858 return 0; 859 860 err_dev_dbgfs: 861 device_destroy(mei_class, devno); 862 err_dev_create: 863 cdev_del(&dev->cdev); 864 err_dev_add: 865 mei_minor_free(dev); 866 return ret; 867 } 868 EXPORT_SYMBOL_GPL(mei_register); 869 870 void mei_deregister(struct mei_device *dev) 871 { 872 int devno; 873 874 devno = dev->cdev.dev; 875 cdev_del(&dev->cdev); 876 877 mei_dbgfs_deregister(dev); 878 879 device_destroy(mei_class, devno); 880 881 mei_minor_free(dev); 882 } 883 EXPORT_SYMBOL_GPL(mei_deregister); 884 885 static int __init mei_init(void) 886 { 887 int ret; 888 889 mei_class = class_create(THIS_MODULE, "mei"); 890 if (IS_ERR(mei_class)) { 891 pr_err("couldn't create class\n"); 892 ret = PTR_ERR(mei_class); 893 goto err; 894 } 895 896 ret = alloc_chrdev_region(&mei_devt, 0, MEI_MAX_DEVS, "mei"); 897 if (ret < 0) { 898 pr_err("unable to allocate char dev region\n"); 899 goto err_class; 900 } 901 902 ret = mei_cl_bus_init(); 903 if (ret < 0) { 904 pr_err("unable to initialize bus\n"); 905 goto err_chrdev; 906 } 907 908 return 0; 909 910 err_chrdev: 911 unregister_chrdev_region(mei_devt, MEI_MAX_DEVS); 912 err_class: 913 class_destroy(mei_class); 914 err: 915 return ret; 916 } 917 918 static void __exit mei_exit(void) 919 { 920 unregister_chrdev_region(mei_devt, MEI_MAX_DEVS); 921 class_destroy(mei_class); 922 mei_cl_bus_exit(); 923 } 924 925 module_init(mei_init); 926 module_exit(mei_exit); 927 928 MODULE_AUTHOR("Intel Corporation"); 929 MODULE_DESCRIPTION("Intel(R) Management Engine Interface"); 930 MODULE_LICENSE("GPL v2"); 931 932