drivers/misc/mei/main.c

   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, &notify_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(&notify_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, &notify_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                                 &notify_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