drivers/misc/mei/bus.c

   1 /*
   2  * Intel Management Engine Interface (Intel MEI) Linux driver
   3  * Copyright (c) 2012-2013, Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  */
  15
  16 #include <linux/module.h>
  17 #include <linux/device.h>
  18 #include <linux/kernel.h>
  19 #include <linux/sched.h>
  20 #include <linux/init.h>
  21 #include <linux/errno.h>
  22 #include <linux/slab.h>
  23 #include <linux/mutex.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/pci.h>
  26 #include <linux/mei_cl_bus.h>
  27
  28 #include "mei_dev.h"
  29 #include "client.h"
  30
  31 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver)
  32 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev)
  33
  34 static int mei_cl_device_match(struct device *dev, struct device_driver *drv)
  35 {
  36         struct mei_cl_device *device = to_mei_cl_device(dev);
  37         struct mei_cl_driver *driver = to_mei_cl_driver(drv);
  38         const struct mei_cl_device_id *id;
  39
  40         if (!device)
  41                 return 0;
  42
  43         if (!driver || !driver->id_table)
  44                 return 0;
  45
  46         id = driver->id_table;
  47
  48         while (id->name[0]) {
  49                 if (!strncmp(dev_name(dev), id->name, sizeof(id->name)))
  50                         return 1;
  51
  52                 id++;
  53         }
  54
  55         return 0;
  56 }
  57
  58 static int mei_cl_device_probe(struct device *dev)
  59 {
  60         struct mei_cl_device *device = to_mei_cl_device(dev);
  61         struct mei_cl_driver *driver;
  62         struct mei_cl_device_id id;
  63
  64         if (!device)
  65                 return 0;
  66
  67         driver = to_mei_cl_driver(dev->driver);
  68         if (!driver || !driver->probe)
  69                 return -ENODEV;
  70
  71         dev_dbg(dev, "Device probe\n");
  72
  73         strlcpy(id.name, dev_name(dev), sizeof(id.name));
  74
  75         return driver->probe(device, &id);
  76 }
  77
  78 static int mei_cl_device_remove(struct device *dev)
  79 {
  80         struct mei_cl_device *device = to_mei_cl_device(dev);
  81         struct mei_cl_driver *driver;
  82
  83         if (!device || !dev->driver)
  84                 return 0;
  85
  86         if (device->event_cb) {
  87                 device->event_cb = NULL;
  88                 cancel_work_sync(&device->event_work);
  89         }
  90
  91         driver = to_mei_cl_driver(dev->driver);
  92         if (!driver->remove) {
  93                 dev->driver = NULL;
  94
  95                 return 0;
  96         }
  97
  98         return driver->remove(device);
  99 }
 100
 101 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
 102                              char *buf)
 103 {
 104         int len;
 105
 106         len = snprintf(buf, PAGE_SIZE, "mei:%s\n", dev_name(dev));
 107
 108         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
 109 }
 110 static DEVICE_ATTR_RO(modalias);
 111
 112 static struct attribute *mei_cl_dev_attrs[] = {
 113         &dev_attr_modalias.attr,
 114         NULL,
 115 };
 116 ATTRIBUTE_GROUPS(mei_cl_dev);
 117
 118 static int mei_cl_uevent(struct device *dev, struct kobj_uevent_env *env)
 119 {
 120         if (add_uevent_var(env, "MODALIAS=mei:%s", dev_name(dev)))
 121                 return -ENOMEM;
 122
 123         return 0;
 124 }
 125
 126 static struct bus_type mei_cl_bus_type = {
 127         .name           = "mei",
 128         .dev_groups     = mei_cl_dev_groups,
 129         .match          = mei_cl_device_match,
 130         .probe          = mei_cl_device_probe,
 131         .remove         = mei_cl_device_remove,
 132         .uevent         = mei_cl_uevent,
 133 };
 134
 135 static void mei_cl_dev_release(struct device *dev)
 136 {
 137         kfree(to_mei_cl_device(dev));
 138 }
 139
 140 static struct device_type mei_cl_device_type = {
 141         .release        = mei_cl_dev_release,
 142 };
 143
 144 static struct mei_cl *mei_bus_find_mei_cl_by_uuid(struct mei_device *dev,
 145                                                 uuid_le uuid)
 146 {
 147         struct mei_cl *cl;
 148
 149         list_for_each_entry(cl, &dev->device_list, device_link) {
 150                 if (!uuid_le_cmp(uuid, cl->cl_uuid))
 151                         return cl;
 152         }
 153
 154         return NULL;
 155 }
 156 struct mei_cl_device *mei_cl_add_device(struct mei_device *dev,
 157                                         uuid_le uuid, char *name,
 158                                         struct mei_cl_ops *ops)
 159 {
 160         struct mei_cl_device *device;
 161         struct mei_cl *cl;
 162         int status;
 163
 164         cl = mei_bus_find_mei_cl_by_uuid(dev, uuid);
 165         if (cl == NULL)
 166                 return NULL;
 167
 168         device = kzalloc(sizeof(struct mei_cl_device), GFP_KERNEL);
 169         if (!device)
 170                 return NULL;
 171
 172         device->cl = cl;
 173         device->ops = ops;
 174
 175         device->dev.parent = dev->dev;
 176         device->dev.bus = &mei_cl_bus_type;
 177         device->dev.type = &mei_cl_device_type;
 178
 179         dev_set_name(&device->dev, "%s", name);
 180
 181         status = device_register(&device->dev);
 182         if (status) {
 183                 dev_err(dev->dev, "Failed to register MEI device\n");
 184                 kfree(device);
 185                 return NULL;
 186         }
 187
 188         cl->device = device;
 189
 190         dev_dbg(&device->dev, "client %s registered\n", name);
 191
 192         return device;
 193 }
 194 EXPORT_SYMBOL_GPL(mei_cl_add_device);
 195
 196 void mei_cl_remove_device(struct mei_cl_device *device)
 197 {
 198         device_unregister(&device->dev);
 199 }
 200 EXPORT_SYMBOL_GPL(mei_cl_remove_device);
 201
 202 int __mei_cl_driver_register(struct mei_cl_driver *driver, struct module *owner)
 203 {
 204         int err;
 205
 206         driver->driver.name = driver->name;
 207         driver->driver.owner = owner;
 208         driver->driver.bus = &mei_cl_bus_type;
 209
 210         err = driver_register(&driver->driver);
 211         if (err)
 212                 return err;
 213
 214         pr_debug("mei: driver [%s] registered\n", driver->driver.name);
 215
 216         return 0;
 217 }
 218 EXPORT_SYMBOL_GPL(__mei_cl_driver_register);
 219
 220 void mei_cl_driver_unregister(struct mei_cl_driver *driver)
 221 {
 222         driver_unregister(&driver->driver);
 223
 224         pr_debug("mei: driver [%s] unregistered\n", driver->driver.name);
 225 }
 226 EXPORT_SYMBOL_GPL(mei_cl_driver_unregister);
 227
 228 static int ___mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length,
 229                         bool blocking)
 230 {
 231         struct mei_device *dev;
 232         struct mei_me_client *me_cl;
 233         struct mei_cl_cb *cb;
 234         int rets;
 235
 236         if (WARN_ON(!cl || !cl->dev))
 237                 return -ENODEV;
 238
 239         dev = cl->dev;
 240
 241         if (cl->state != MEI_FILE_CONNECTED)
 242                 return -ENODEV;
 243
 244         /* Check if we have an ME client device */
 245         me_cl = mei_me_cl_by_uuid_id(dev, &cl->cl_uuid, cl->me_client_id);
 246         if (!me_cl)
 247                 return -ENOTTY;
 248
 249         if (length > me_cl->props.max_msg_length)
 250                 return -EFBIG;
 251
 252         cb = mei_io_cb_init(cl, NULL);
 253         if (!cb)
 254                 return -ENOMEM;
 255
 256         rets = mei_io_cb_alloc_req_buf(cb, length);
 257         if (rets < 0) {
 258                 mei_io_cb_free(cb);
 259                 return rets;
 260         }
 261
 262         memcpy(cb->request_buffer.data, buf, length);
 263
 264         mutex_lock(&dev->device_lock);
 265
 266         rets = mei_cl_write(cl, cb, blocking);
 267
 268         mutex_unlock(&dev->device_lock);
 269         if (rets < 0)
 270                 mei_io_cb_free(cb);
 271
 272         return rets;
 273 }
 274
 275 int __mei_cl_recv(struct mei_cl *cl, u8 *buf, size_t length)
 276 {
 277         struct mei_device *dev;
 278         struct mei_cl_cb *cb;
 279         size_t r_length;
 280         int err;
 281
 282         if (WARN_ON(!cl || !cl->dev))
 283                 return -ENODEV;
 284
 285         dev = cl->dev;
 286
 287         mutex_lock(&dev->device_lock);
 288
 289         if (!cl->read_cb) {
 290                 err = mei_cl_read_start(cl, length);
 291                 if (err < 0) {
 292                         mutex_unlock(&dev->device_lock);
 293                         return err;
 294                 }
 295         }
 296
 297         if (cl->reading_state != MEI_READ_COMPLETE &&
 298             !waitqueue_active(&cl->rx_wait)) {
 299
 300                 mutex_unlock(&dev->device_lock);
 301
 302                 if (wait_event_interruptible(cl->rx_wait,
 303                                 cl->reading_state == MEI_READ_COMPLETE  ||
 304                                 mei_cl_is_transitioning(cl))) {
 305
 306                         if (signal_pending(current))
 307                                 return -EINTR;
 308                         return -ERESTARTSYS;
 309                 }
 310
 311                 mutex_lock(&dev->device_lock);
 312         }
 313
 314         cb = cl->read_cb;
 315
 316         if (cl->reading_state != MEI_READ_COMPLETE) {
 317                 r_length = 0;
 318                 goto out;
 319         }
 320
 321         r_length = min_t(size_t, length, cb->buf_idx);
 322
 323         memcpy(buf, cb->response_buffer.data, r_length);
 324
 325         mei_io_cb_free(cb);
 326         cl->reading_state = MEI_IDLE;
 327         cl->read_cb = NULL;
 328
 329 out:
 330         mutex_unlock(&dev->device_lock);
 331
 332         return r_length;
 333 }
 334
 335 inline int __mei_cl_async_send(struct mei_cl *cl, u8 *buf, size_t length)
 336 {
 337         return ___mei_cl_send(cl, buf, length, 0);
 338 }
 339
 340 inline int __mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length)
 341 {
 342         return ___mei_cl_send(cl, buf, length, 1);
 343 }
 344
 345 int mei_cl_send(struct mei_cl_device *device, u8 *buf, size_t length)
 346 {
 347         struct mei_cl *cl = device->cl;
 348
 349         if (cl == NULL)
 350                 return -ENODEV;
 351
 352         if (device->ops && device->ops->send)
 353                 return device->ops->send(device, buf, length);
 354
 355         return __mei_cl_send(cl, buf, length);
 356 }
 357 EXPORT_SYMBOL_GPL(mei_cl_send);
 358
 359 int mei_cl_recv(struct mei_cl_device *device, u8 *buf, size_t length)
 360 {
 361         struct mei_cl *cl =  device->cl;
 362
 363         if (cl == NULL)
 364                 return -ENODEV;
 365
 366         if (device->ops && device->ops->recv)
 367                 return device->ops->recv(device, buf, length);
 368
 369         return __mei_cl_recv(cl, buf, length);
 370 }
 371 EXPORT_SYMBOL_GPL(mei_cl_recv);
 372
 373 static void mei_bus_event_work(struct work_struct *work)
 374 {
 375         struct mei_cl_device *device;
 376
 377         device = container_of(work, struct mei_cl_device, event_work);
 378
 379         if (device->event_cb)
 380                 device->event_cb(device, device->events, device->event_context);
 381
 382         device->events = 0;
 383
 384         /* Prepare for the next read */
 385         mei_cl_read_start(device->cl, 0);
 386 }
 387
 388 int mei_cl_register_event_cb(struct mei_cl_device *device,
 389                           mei_cl_event_cb_t event_cb, void *context)
 390 {
 391         if (device->event_cb)
 392                 return -EALREADY;
 393
 394         device->events = 0;
 395         device->event_cb = event_cb;
 396         device->event_context = context;
 397         INIT_WORK(&device->event_work, mei_bus_event_work);
 398
 399         mei_cl_read_start(device->cl, 0);
 400
 401         return 0;
 402 }
 403 EXPORT_SYMBOL_GPL(mei_cl_register_event_cb);
 404
 405 void *mei_cl_get_drvdata(const struct mei_cl_device *device)
 406 {
 407         return dev_get_drvdata(&device->dev);
 408 }
 409 EXPORT_SYMBOL_GPL(mei_cl_get_drvdata);
 410
 411 void mei_cl_set_drvdata(struct mei_cl_device *device, void *data)
 412 {
 413         dev_set_drvdata(&device->dev, data);
 414 }
 415 EXPORT_SYMBOL_GPL(mei_cl_set_drvdata);
 416
 417 int mei_cl_enable_device(struct mei_cl_device *device)
 418 {
 419         int err;
 420         struct mei_device *dev;
 421         struct mei_cl *cl = device->cl;
 422
 423         if (cl == NULL)
 424                 return -ENODEV;
 425
 426         dev = cl->dev;
 427
 428         mutex_lock(&dev->device_lock);
 429
 430         err = mei_cl_connect(cl, NULL);
 431         if (err < 0) {
 432                 mutex_unlock(&dev->device_lock);
 433                 dev_err(dev->dev, "Could not connect to the ME client");
 434
 435                 return err;
 436         }
 437
 438         mutex_unlock(&dev->device_lock);
 439
 440         if (device->event_cb && !cl->read_cb)
 441                 mei_cl_read_start(device->cl, 0);
 442
 443         if (!device->ops || !device->ops->enable)
 444                 return 0;
 445
 446         return device->ops->enable(device);
 447 }
 448 EXPORT_SYMBOL_GPL(mei_cl_enable_device);
 449
 450 int mei_cl_disable_device(struct mei_cl_device *device)
 451 {
 452         int err;
 453         struct mei_device *dev;
 454         struct mei_cl *cl = device->cl;
 455
 456         if (cl == NULL)
 457                 return -ENODEV;
 458
 459         dev = cl->dev;
 460
 461         mutex_lock(&dev->device_lock);
 462
 463         if (cl->state != MEI_FILE_CONNECTED) {
 464                 mutex_unlock(&dev->device_lock);
 465                 dev_err(dev->dev, "Already disconnected");
 466
 467                 return 0;
 468         }
 469
 470         cl->state = MEI_FILE_DISCONNECTING;
 471
 472         err = mei_cl_disconnect(cl);
 473         if (err < 0) {
 474                 mutex_unlock(&dev->device_lock);
 475                 dev_err(dev->dev,
 476                         "Could not disconnect from the ME client");
 477
 478                 return err;
 479         }
 480
 481         /* Flush queues and remove any pending read */
 482         mei_cl_flush_queues(cl);
 483
 484         if (cl->read_cb) {
 485                 struct mei_cl_cb *cb = NULL;
 486
 487                 cb = mei_cl_find_read_cb(cl);
 488                 /* Remove entry from read list */
 489                 if (cb)
 490                         list_del(&cb->list);
 491
 492                 cb = cl->read_cb;
 493                 cl->read_cb = NULL;
 494
 495                 if (cb) {
 496                         mei_io_cb_free(cb);
 497                         cb = NULL;
 498                 }
 499         }
 500
 501         device->event_cb = NULL;
 502
 503         mutex_unlock(&dev->device_lock);
 504
 505         if (!device->ops || !device->ops->disable)
 506                 return 0;
 507
 508         return device->ops->disable(device);
 509 }
 510 EXPORT_SYMBOL_GPL(mei_cl_disable_device);
 511
 512 void mei_cl_bus_rx_event(struct mei_cl *cl)
 513 {
 514         struct mei_cl_device *device = cl->device;
 515
 516         if (!device || !device->event_cb)
 517                 return;
 518
 519         set_bit(MEI_CL_EVENT_RX, &device->events);
 520
 521         schedule_work(&device->event_work);
 522 }
 523
 524 void mei_cl_bus_remove_devices(struct mei_device *dev)
 525 {
 526         struct mei_cl *cl, *next;
 527
 528         mutex_lock(&dev->device_lock);
 529         list_for_each_entry_safe(cl, next, &dev->device_list, device_link) {
 530                 if (cl->device)
 531                         mei_cl_remove_device(cl->device);
 532
 533                 list_del(&cl->device_link);
 534                 mei_cl_unlink(cl);
 535                 kfree(cl);
 536         }
 537         mutex_unlock(&dev->device_lock);
 538 }
 539
 540 int __init mei_cl_bus_init(void)
 541 {
 542         return bus_register(&mei_cl_bus_type);
 543 }
 544
 545 void __exit mei_cl_bus_exit(void)
 546 {
 547         bus_unregister(&mei_cl_bus_type);
 548 }