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 "hw-me.h"
  30 #include "client.h"
  31
  32 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver)
  33 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev)
  34
  35 static int mei_cl_device_match(struct device *dev, struct device_driver *drv)
  36 {
  37         struct mei_cl_device *device = to_mei_cl_device(dev);
  38         struct mei_cl_driver *driver = to_mei_cl_driver(drv);
  39         const struct mei_cl_device_id *id;
  40
  41         if (!device)
  42                 return 0;
  43
  44         if (!driver || !driver->id_table)
  45                 return 0;
  46
  47         id = driver->id_table;
  48
  49         while (id->name[0]) {
  50                 if (!strncmp(dev_name(dev), id->name, sizeof(id->name)))
  51                         return 1;
  52
  53                 id++;
  54         }
  55
  56         return 0;
  57 }
  58
  59 static int mei_cl_device_probe(struct device *dev)
  60 {
  61         struct mei_cl_device *device = to_mei_cl_device(dev);
  62         struct mei_cl_driver *driver;
  63         struct mei_cl_device_id id;
  64
  65         if (!device)
  66                 return 0;
  67
  68         driver = to_mei_cl_driver(dev->driver);
  69         if (!driver || !driver->probe)
  70                 return -ENODEV;
  71
  72         dev_dbg(dev, "Device probe\n");
  73
  74         strncpy(id.name, dev_name(dev), sizeof(id.name));
  75
  76         return driver->probe(device, &id);
  77 }
  78
  79 static int mei_cl_device_remove(struct device *dev)
  80 {
  81         struct mei_cl_device *device = to_mei_cl_device(dev);
  82         struct mei_cl_driver *driver;
  83
  84         if (!device || !dev->driver)
  85                 return 0;
  86
  87         if (device->event_cb) {
  88                 device->event_cb = NULL;
  89                 cancel_work_sync(&device->event_work);
  90         }
  91
  92         driver = to_mei_cl_driver(dev->driver);
  93         if (!driver->remove) {
  94                 dev->driver = NULL;
  95
  96                 return 0;
  97         }
  98
  99         return driver->remove(device);
 100 }
 101
 102 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
 103                              char *buf)
 104 {
 105         int len;
 106
 107         len = snprintf(buf, PAGE_SIZE, "mei:%s\n", dev_name(dev));
 108
 109         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
 110 }
 111 static DEVICE_ATTR_RO(modalias);
 112
 113 static struct attribute *mei_cl_dev_attrs[] = {
 114         &dev_attr_modalias.attr,
 115         NULL,
 116 };
 117 ATTRIBUTE_GROUPS(mei_cl_dev);
 118
 119 static int mei_cl_uevent(struct device *dev, struct kobj_uevent_env *env)
 120 {
 121         if (add_uevent_var(env, "MODALIAS=mei:%s", dev_name(dev)))
 122                 return -ENOMEM;
 123
 124         return 0;
 125 }
 126
 127 static struct bus_type mei_cl_bus_type = {
 128         .name           = "mei",
 129         .dev_groups     = mei_cl_dev_groups,
 130         .match          = mei_cl_device_match,
 131         .probe          = mei_cl_device_probe,
 132         .remove         = mei_cl_device_remove,
 133         .uevent         = mei_cl_uevent,
 134 };
 135
 136 static void mei_cl_dev_release(struct device *dev)
 137 {
 138         kfree(to_mei_cl_device(dev));
 139 }
 140
 141 static struct device_type mei_cl_device_type = {
 142         .release        = mei_cl_dev_release,
 143 };
 144
 145 static struct mei_cl *mei_bus_find_mei_cl_by_uuid(struct mei_device *dev,
 146                                                 uuid_le uuid)
 147 {
 148         struct mei_cl *cl, *next;
 149
 150         list_for_each_entry_safe(cl, next, &dev->device_list, device_link) {
 151                 if (!uuid_le_cmp(uuid, cl->device_uuid))
 152                         return cl;
 153         }
 154
 155         return NULL;
 156 }
 157 struct mei_cl_device *mei_cl_add_device(struct mei_device *dev,
 158                                         uuid_le uuid, char *name,
 159                                         struct mei_cl_ops *ops)
 160 {
 161         struct mei_cl_device *device;
 162         struct mei_cl *cl;
 163         int status;
 164
 165         cl = mei_bus_find_mei_cl_by_uuid(dev, uuid);
 166         if (cl == NULL)
 167                 return NULL;
 168
 169         device = kzalloc(sizeof(struct mei_cl_device), GFP_KERNEL);
 170         if (!device)
 171                 return NULL;
 172
 173         device->cl = cl;
 174         device->ops = ops;
 175
 176         device->dev.parent = &dev->pdev->dev;
 177         device->dev.bus = &mei_cl_bus_type;
 178         device->dev.type = &mei_cl_device_type;
 179
 180         dev_set_name(&device->dev, "%s", name);
 181
 182         status = device_register(&device->dev);
 183         if (status) {
 184                 dev_err(&dev->pdev->dev, "Failed to register MEI device\n");
 185                 kfree(device);
 186                 return NULL;
 187         }
 188
 189         cl->device = device;
 190
 191         dev_dbg(&device->dev, "client %s registered\n", name);
 192
 193         return device;
 194 }
 195 EXPORT_SYMBOL_GPL(mei_cl_add_device);
 196
 197 void mei_cl_remove_device(struct mei_cl_device *device)
 198 {
 199         device_unregister(&device->dev);
 200 }
 201 EXPORT_SYMBOL_GPL(mei_cl_remove_device);
 202
 203 int __mei_cl_driver_register(struct mei_cl_driver *driver, struct module *owner)
 204 {
 205         int err;
 206
 207         driver->driver.name = driver->name;
 208         driver->driver.owner = owner;
 209         driver->driver.bus = &mei_cl_bus_type;
 210
 211         err = driver_register(&driver->driver);
 212         if (err)
 213                 return err;
 214
 215         pr_debug("mei: driver [%s] registered\n", driver->driver.name);
 216
 217         return 0;
 218 }
 219 EXPORT_SYMBOL_GPL(__mei_cl_driver_register);
 220
 221 void mei_cl_driver_unregister(struct mei_cl_driver *driver)
 222 {
 223         driver_unregister(&driver->driver);
 224
 225         pr_debug("mei: driver [%s] unregistered\n", driver->driver.name);
 226 }
 227 EXPORT_SYMBOL_GPL(mei_cl_driver_unregister);
 228
 229 static int ___mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length,
 230                         bool blocking)
 231 {
 232         struct mei_device *dev;
 233         struct mei_cl_cb *cb;
 234         int id;
 235         int rets;
 236
 237         if (WARN_ON(!cl || !cl->dev))
 238                 return -ENODEV;
 239
 240         dev = cl->dev;
 241
 242         if (cl->state != MEI_FILE_CONNECTED)
 243                 return -ENODEV;
 244
 245         /* Check if we have an ME client device */
 246         id = mei_me_cl_by_id(dev, cl->me_client_id);
 247         if (id < 0)
 248                 return -ENODEV;
 249
 250         if (length > dev->me_clients[id].props.max_msg_length)
 251                 return -EINVAL;
 252
 253         cb = mei_io_cb_init(cl, NULL);
 254         if (!cb)
 255                 return -ENOMEM;
 256
 257         rets = mei_io_cb_alloc_req_buf(cb, length);
 258         if (rets < 0) {
 259                 mei_io_cb_free(cb);
 260                 return rets;
 261         }
 262
 263         memcpy(cb->request_buffer.data, buf, length);
 264
 265         mutex_lock(&dev->device_lock);
 266
 267         rets = mei_cl_write(cl, cb, blocking);
 268
 269         mutex_unlock(&dev->device_lock);
 270         if (rets < 0)
 271                 mei_io_cb_free(cb);
 272
 273         return rets;
 274 }
 275
 276 int __mei_cl_recv(struct mei_cl *cl, u8 *buf, size_t length)
 277 {
 278         struct mei_device *dev;
 279         struct mei_cl_cb *cb;
 280         size_t r_length;
 281         int err;
 282
 283         if (WARN_ON(!cl || !cl->dev))
 284                 return -ENODEV;
 285
 286         dev = cl->dev;
 287
 288         mutex_lock(&dev->device_lock);
 289
 290         if (!cl->read_cb) {
 291                 err = mei_cl_read_start(cl, length);
 292                 if (err < 0) {
 293                         mutex_unlock(&dev->device_lock);
 294                         return err;
 295                 }
 296         }
 297
 298         if (cl->reading_state != MEI_READ_COMPLETE &&
 299             !waitqueue_active(&cl->rx_wait)) {
 300                 mutex_unlock(&dev->device_lock);
 301
 302                 if (wait_event_interruptible(cl->rx_wait,
 303                                 (MEI_READ_COMPLETE == cl->reading_state))) {
 304                         if (signal_pending(current))
 305                                 return -EINTR;
 306                         return -ERESTARTSYS;
 307                 }
 308
 309                 mutex_lock(&dev->device_lock);
 310         }
 311
 312         cb = cl->read_cb;
 313
 314         if (cl->reading_state != MEI_READ_COMPLETE) {
 315                 r_length = 0;
 316                 goto out;
 317         }
 318
 319         r_length = min_t(size_t, length, cb->buf_idx);
 320
 321         memcpy(buf, cb->response_buffer.data, r_length);
 322
 323         mei_io_cb_free(cb);
 324         cl->reading_state = MEI_IDLE;
 325         cl->read_cb = NULL;
 326
 327 out:
 328         mutex_unlock(&dev->device_lock);
 329
 330         return r_length;
 331 }
 332
 333 inline int __mei_cl_async_send(struct mei_cl *cl, u8 *buf, size_t length)
 334 {
 335         return ___mei_cl_send(cl, buf, length, 0);
 336 }
 337
 338 inline int __mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length)
 339 {
 340         return ___mei_cl_send(cl, buf, length, 1);
 341 }
 342
 343 int mei_cl_send(struct mei_cl_device *device, u8 *buf, size_t length)
 344 {
 345         struct mei_cl *cl = device->cl;
 346
 347         if (cl == NULL)
 348                 return -ENODEV;
 349
 350         if (device->ops && device->ops->send)
 351                 return device->ops->send(device, buf, length);
 352
 353         return __mei_cl_send(cl, buf, length);
 354 }
 355 EXPORT_SYMBOL_GPL(mei_cl_send);
 356
 357 int mei_cl_recv(struct mei_cl_device *device, u8 *buf, size_t length)
 358 {
 359         struct mei_cl *cl =  device->cl;
 360
 361         if (cl == NULL)
 362                 return -ENODEV;
 363
 364         if (device->ops && device->ops->recv)
 365                 return device->ops->recv(device, buf, length);
 366
 367         return __mei_cl_recv(cl, buf, length);
 368 }
 369 EXPORT_SYMBOL_GPL(mei_cl_recv);
 370
 371 static void mei_bus_event_work(struct work_struct *work)
 372 {
 373         struct mei_cl_device *device;
 374
 375         device = container_of(work, struct mei_cl_device, event_work);
 376
 377         if (device->event_cb)
 378                 device->event_cb(device, device->events, device->event_context);
 379
 380         device->events = 0;
 381
 382         /* Prepare for the next read */
 383         mei_cl_read_start(device->cl, 0);
 384 }
 385
 386 int mei_cl_register_event_cb(struct mei_cl_device *device,
 387                           mei_cl_event_cb_t event_cb, void *context)
 388 {
 389         if (device->event_cb)
 390                 return -EALREADY;
 391
 392         device->events = 0;
 393         device->event_cb = event_cb;
 394         device->event_context = context;
 395         INIT_WORK(&device->event_work, mei_bus_event_work);
 396
 397         mei_cl_read_start(device->cl, 0);
 398
 399         return 0;
 400 }
 401 EXPORT_SYMBOL_GPL(mei_cl_register_event_cb);
 402
 403 void *mei_cl_get_drvdata(const struct mei_cl_device *device)
 404 {
 405         return dev_get_drvdata(&device->dev);
 406 }
 407 EXPORT_SYMBOL_GPL(mei_cl_get_drvdata);
 408
 409 void mei_cl_set_drvdata(struct mei_cl_device *device, void *data)
 410 {
 411         dev_set_drvdata(&device->dev, data);
 412 }
 413 EXPORT_SYMBOL_GPL(mei_cl_set_drvdata);
 414
 415 int mei_cl_enable_device(struct mei_cl_device *device)
 416 {
 417         int err;
 418         struct mei_device *dev;
 419         struct mei_cl *cl = device->cl;
 420
 421         if (cl == NULL)
 422                 return -ENODEV;
 423
 424         dev = cl->dev;
 425
 426         mutex_lock(&dev->device_lock);
 427
 428         cl->state = MEI_FILE_CONNECTING;
 429
 430         err = mei_cl_connect(cl, NULL);
 431         if (err < 0) {
 432                 mutex_unlock(&dev->device_lock);
 433                 dev_err(&dev->pdev->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->pdev->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->pdev->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 int __init mei_cl_bus_init(void)
 525 {
 526         return bus_register(&mei_cl_bus_type);
 527 }
 528
 529 void __exit mei_cl_bus_exit(void)
 530 {
 531         bus_unregister(&mei_cl_bus_type);
 532 }