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/mei_cl_bus.h>
  26
  27 #include "mei_dev.h"
  28 #include "client.h"
  29
  30 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver)
  31 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev)
  32
  33 /**
  34  * __mei_cl_send - internal client send (write)
  35  *
  36  * @cl: host client
  37  * @buf: buffer to send
  38  * @length: buffer length
  39  * @blocking: wait for write completion
  40  *
  41  * Return: written size bytes or < 0 on error
  42  */
  43 ssize_t __mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length,
  44                         bool blocking)
  45 {
  46         struct mei_device *bus;
  47         struct mei_cl_cb *cb = NULL;
  48         ssize_t rets;
  49
  50         if (WARN_ON(!cl || !cl->dev))
  51                 return -ENODEV;
  52
  53         bus = cl->dev;
  54
  55         mutex_lock(&bus->device_lock);
  56         if (!mei_cl_is_connected(cl)) {
  57                 rets = -ENODEV;
  58                 goto out;
  59         }
  60
  61         /* Check if we have an ME client device */
  62         if (!mei_me_cl_is_active(cl->me_cl)) {
  63                 rets = -ENOTTY;
  64                 goto out;
  65         }
  66
  67         if (length > mei_cl_mtu(cl)) {
  68                 rets = -EFBIG;
  69                 goto out;
  70         }
  71
  72         cb = mei_cl_alloc_cb(cl, length, MEI_FOP_WRITE, NULL);
  73         if (!cb) {
  74                 rets = -ENOMEM;
  75                 goto out;
  76         }
  77
  78         memcpy(cb->buf.data, buf, length);
  79
  80         rets = mei_cl_write(cl, cb, blocking);
  81
  82 out:
  83         mutex_unlock(&bus->device_lock);
  84         if (rets < 0)
  85                 mei_io_cb_free(cb);
  86
  87         return rets;
  88 }
  89
  90 /**
  91  * __mei_cl_recv - internal client receive (read)
  92  *
  93  * @cl: host client
  94  * @buf: buffer to receive
  95  * @length: buffer length
  96  *
  97  * Return: read size in bytes of < 0 on error
  98  */
  99 ssize_t __mei_cl_recv(struct mei_cl *cl, u8 *buf, size_t length)
 100 {
 101         struct mei_device *bus;
 102         struct mei_cl_cb *cb;
 103         size_t r_length;
 104         ssize_t rets;
 105
 106         if (WARN_ON(!cl || !cl->dev))
 107                 return -ENODEV;
 108
 109         bus = cl->dev;
 110
 111         mutex_lock(&bus->device_lock);
 112
 113         cb = mei_cl_read_cb(cl, NULL);
 114         if (cb)
 115                 goto copy;
 116
 117         rets = mei_cl_read_start(cl, length, NULL);
 118         if (rets && rets != -EBUSY)
 119                 goto out;
 120
 121         /* wait on event only if there is no other waiter */
 122         if (list_empty(&cl->rd_completed) && !waitqueue_active(&cl->rx_wait)) {
 123
 124                 mutex_unlock(&bus->device_lock);
 125
 126                 if (wait_event_interruptible(cl->rx_wait,
 127                                 (!list_empty(&cl->rd_completed)) ||
 128                                 (!mei_cl_is_connected(cl)))) {
 129
 130                         if (signal_pending(current))
 131                                 return -EINTR;
 132                         return -ERESTARTSYS;
 133                 }
 134
 135                 mutex_lock(&bus->device_lock);
 136
 137                 if (!mei_cl_is_connected(cl)) {
 138                         rets = -EBUSY;
 139                         goto out;
 140                 }
 141         }
 142
 143         cb = mei_cl_read_cb(cl, NULL);
 144         if (!cb) {
 145                 rets = 0;
 146                 goto out;
 147         }
 148
 149 copy:
 150         if (cb->status) {
 151                 rets = cb->status;
 152                 goto free;
 153         }
 154
 155         r_length = min_t(size_t, length, cb->buf_idx);
 156         memcpy(buf, cb->buf.data, r_length);
 157         rets = r_length;
 158
 159 free:
 160         mei_io_cb_free(cb);
 161 out:
 162         mutex_unlock(&bus->device_lock);
 163
 164         return rets;
 165 }
 166
 167 /**
 168  * mei_cldev_send - me device send  (write)
 169  *
 170  * @cldev: me client device
 171  * @buf: buffer to send
 172  * @length: buffer length
 173  *
 174  * Return: written size in bytes or < 0 on error
 175  */
 176 ssize_t mei_cldev_send(struct mei_cl_device *cldev, u8 *buf, size_t length)
 177 {
 178         struct mei_cl *cl = cldev->cl;
 179
 180         if (cl == NULL)
 181                 return -ENODEV;
 182
 183         return __mei_cl_send(cl, buf, length, 1);
 184 }
 185 EXPORT_SYMBOL_GPL(mei_cldev_send);
 186
 187 /**
 188  * mei_cldev_recv - client receive (read)
 189  *
 190  * @cldev: me client device
 191  * @buf: buffer to receive
 192  * @length: buffer length
 193  *
 194  * Return: read size in bytes of < 0 on error
 195  */
 196 ssize_t mei_cldev_recv(struct mei_cl_device *cldev, u8 *buf, size_t length)
 197 {
 198         struct mei_cl *cl = cldev->cl;
 199
 200         if (cl == NULL)
 201                 return -ENODEV;
 202
 203         return __mei_cl_recv(cl, buf, length);
 204 }
 205 EXPORT_SYMBOL_GPL(mei_cldev_recv);
 206
 207 /**
 208  * mei_cl_bus_event_work  - dispatch rx event for a bus device
 209  *    and schedule new work
 210  *
 211  * @work: work
 212  */
 213 static void mei_cl_bus_event_work(struct work_struct *work)
 214 {
 215         struct mei_cl_device *cldev;
 216
 217         cldev = container_of(work, struct mei_cl_device, event_work);
 218
 219         if (cldev->event_cb)
 220                 cldev->event_cb(cldev, cldev->events, cldev->event_context);
 221
 222         cldev->events = 0;
 223
 224         /* Prepare for the next read */
 225         if (cldev->events_mask & BIT(MEI_CL_EVENT_RX))
 226                 mei_cl_read_start(cldev->cl, 0, NULL);
 227 }
 228
 229 /**
 230  * mei_cl_bus_notify_event - schedule notify cb on bus client
 231  *
 232  * @cl: host client
 233  */
 234 void mei_cl_bus_notify_event(struct mei_cl *cl)
 235 {
 236         struct mei_cl_device *cldev = cl->cldev;
 237
 238         if (!cldev || !cldev->event_cb)
 239                 return;
 240
 241         if (!(cldev->events_mask & BIT(MEI_CL_EVENT_NOTIF)))
 242                 return;
 243
 244         if (!cl->notify_ev)
 245                 return;
 246
 247         set_bit(MEI_CL_EVENT_NOTIF, &cldev->events);
 248
 249         schedule_work(&cldev->event_work);
 250
 251         cl->notify_ev = false;
 252 }
 253
 254 /**
 255  * mei_cl_bus_rx_event  - schedule rx evenet
 256  *
 257  * @cl: host client
 258  */
 259 void mei_cl_bus_rx_event(struct mei_cl *cl)
 260 {
 261         struct mei_cl_device *cldev = cl->cldev;
 262
 263         if (!cldev || !cldev->event_cb)
 264                 return;
 265
 266         if (!(cldev->events_mask & BIT(MEI_CL_EVENT_RX)))
 267                 return;
 268
 269         set_bit(MEI_CL_EVENT_RX, &cldev->events);
 270
 271         schedule_work(&cldev->event_work);
 272 }
 273
 274 /**
 275  * mei_cldev_register_event_cb - register event callback
 276  *
 277  * @cldev: me client devices
 278  * @event_cb: callback function
 279  * @events_mask: requested events bitmask
 280  * @context: driver context data
 281  *
 282  * Return: 0 on success
 283  *         -EALREADY if an callback is already registered
 284  *         <0 on other errors
 285  */
 286 int mei_cldev_register_event_cb(struct mei_cl_device *cldev,
 287                                 unsigned long events_mask,
 288                                 mei_cldev_event_cb_t event_cb, void *context)
 289 {
 290         int ret;
 291
 292         if (cldev->event_cb)
 293                 return -EALREADY;
 294
 295         cldev->events = 0;
 296         cldev->events_mask = events_mask;
 297         cldev->event_cb = event_cb;
 298         cldev->event_context = context;
 299         INIT_WORK(&cldev->event_work, mei_cl_bus_event_work);
 300
 301         if (cldev->events_mask & BIT(MEI_CL_EVENT_RX)) {
 302                 ret = mei_cl_read_start(cldev->cl, 0, NULL);
 303                 if (ret && ret != -EBUSY)
 304                         return ret;
 305         }
 306
 307         if (cldev->events_mask & BIT(MEI_CL_EVENT_NOTIF)) {
 308                 mutex_lock(&cldev->cl->dev->device_lock);
 309                 ret = mei_cl_notify_request(cldev->cl, NULL, event_cb ? 1 : 0);
 310                 mutex_unlock(&cldev->cl->dev->device_lock);
 311                 if (ret)
 312                         return ret;
 313         }
 314
 315         return 0;
 316 }
 317 EXPORT_SYMBOL_GPL(mei_cldev_register_event_cb);
 318
 319 /**
 320  * mei_cldev_get_drvdata - driver data getter
 321  *
 322  * @cldev: mei client device
 323  *
 324  * Return: driver private data
 325  */
 326 void *mei_cldev_get_drvdata(const struct mei_cl_device *cldev)
 327 {
 328         return dev_get_drvdata(&cldev->dev);
 329 }
 330 EXPORT_SYMBOL_GPL(mei_cldev_get_drvdata);
 331
 332 /**
 333  * mei_cldev_set_drvdata - driver data setter
 334  *
 335  * @cldev: mei client device
 336  * @data: data to store
 337  */
 338 void mei_cldev_set_drvdata(struct mei_cl_device *cldev, void *data)
 339 {
 340         dev_set_drvdata(&cldev->dev, data);
 341 }
 342 EXPORT_SYMBOL_GPL(mei_cldev_set_drvdata);
 343
 344 /**
 345  * mei_cldev_uuid - return uuid of the underlying me client
 346  *
 347  * @cldev: mei client device
 348  *
 349  * Return: me client uuid
 350  */
 351 const uuid_le *mei_cldev_uuid(const struct mei_cl_device *cldev)
 352 {
 353         return mei_me_cl_uuid(cldev->me_cl);
 354 }
 355 EXPORT_SYMBOL_GPL(mei_cldev_uuid);
 356
 357 /**
 358  * mei_cldev_ver - return protocol version of the underlying me client
 359  *
 360  * @cldev: mei client device
 361  *
 362  * Return: me client protocol version
 363  */
 364 u8 mei_cldev_ver(const struct mei_cl_device *cldev)
 365 {
 366         return mei_me_cl_ver(cldev->me_cl);
 367 }
 368 EXPORT_SYMBOL_GPL(mei_cldev_ver);
 369
 370 /**
 371  * mei_cldev_enabled - check whether the device is enabled
 372  *
 373  * @cldev: mei client device
 374  *
 375  * Return: true if me client is initialized and connected
 376  */
 377 bool mei_cldev_enabled(struct mei_cl_device *cldev)
 378 {
 379         return cldev->cl && mei_cl_is_connected(cldev->cl);
 380 }
 381 EXPORT_SYMBOL_GPL(mei_cldev_enabled);
 382
 383 /**
 384  * mei_cldev_enable_device - enable me client device
 385  *     create connection with me client
 386  *
 387  * @cldev: me client device
 388  *
 389  * Return: 0 on success and < 0 on error
 390  */
 391 int mei_cldev_enable(struct mei_cl_device *cldev)
 392 {
 393         struct mei_device *bus = cldev->bus;
 394         struct mei_cl *cl;
 395         int ret;
 396
 397         cl = cldev->cl;
 398
 399         if (!cl) {
 400                 mutex_lock(&bus->device_lock);
 401                 cl = mei_cl_alloc_linked(bus, MEI_HOST_CLIENT_ID_ANY);
 402                 mutex_unlock(&bus->device_lock);
 403                 if (IS_ERR(cl))
 404                         return PTR_ERR(cl);
 405                 /* update pointers */
 406                 cldev->cl = cl;
 407                 cl->cldev = cldev;
 408         }
 409
 410         mutex_lock(&bus->device_lock);
 411         if (mei_cl_is_connected(cl)) {
 412                 ret = 0;
 413                 goto out;
 414         }
 415
 416         if (!mei_me_cl_is_active(cldev->me_cl)) {
 417                 dev_err(&cldev->dev, "me client is not active\n");
 418                 ret = -ENOTTY;
 419                 goto out;
 420         }
 421
 422         ret = mei_cl_connect(cl, cldev->me_cl, NULL);
 423         if (ret < 0)
 424                 dev_err(&cldev->dev, "cannot connect\n");
 425
 426 out:
 427         mutex_unlock(&bus->device_lock);
 428
 429         return ret;
 430 }
 431 EXPORT_SYMBOL_GPL(mei_cldev_enable);
 432
 433 /**
 434  * mei_cldev_disable - disable me client device
 435  *     disconnect form the me client
 436  *
 437  * @cldev: me client device
 438  *
 439  * Return: 0 on success and < 0 on error
 440  */
 441 int mei_cldev_disable(struct mei_cl_device *cldev)
 442 {
 443         struct mei_device *bus;
 444         struct mei_cl *cl;
 445         int err;
 446
 447         if (!cldev || !cldev->cl)
 448                 return -ENODEV;
 449
 450         cl = cldev->cl;
 451
 452         bus = cldev->bus;
 453
 454         cldev->event_cb = NULL;
 455
 456         mutex_lock(&bus->device_lock);
 457
 458         if (!mei_cl_is_connected(cl)) {
 459                 dev_err(bus->dev, "Already disconnected");
 460                 err = 0;
 461                 goto out;
 462         }
 463
 464         err = mei_cl_disconnect(cl);
 465         if (err < 0)
 466                 dev_err(bus->dev, "Could not disconnect from the ME client");
 467
 468 out:
 469         /* Flush queues and remove any pending read */
 470         mei_cl_flush_queues(cl, NULL);
 471         mei_cl_unlink(cl);
 472
 473         kfree(cl);
 474         cldev->cl = NULL;
 475
 476         mutex_unlock(&bus->device_lock);
 477         return err;
 478 }
 479 EXPORT_SYMBOL_GPL(mei_cldev_disable);
 480
 481 /**
 482  * mei_cl_device_find - find matching entry in the driver id table
 483  *
 484  * @cldev: me client device
 485  * @cldrv: me client driver
 486  *
 487  * Return: id on success; NULL if no id is matching
 488  */
 489 static const
 490 struct mei_cl_device_id *mei_cl_device_find(struct mei_cl_device *cldev,
 491                                             struct mei_cl_driver *cldrv)
 492 {
 493         const struct mei_cl_device_id *id;
 494         const uuid_le *uuid;
 495         u8 version;
 496         bool match;
 497
 498         uuid = mei_me_cl_uuid(cldev->me_cl);
 499         version = mei_me_cl_ver(cldev->me_cl);
 500
 501         id = cldrv->id_table;
 502         while (uuid_le_cmp(NULL_UUID_LE, id->uuid)) {
 503                 if (!uuid_le_cmp(*uuid, id->uuid)) {
 504                         match = true;
 505
 506                         if (cldev->name[0])
 507                                 if (strncmp(cldev->name, id->name,
 508                                             sizeof(id->name)))
 509                                         match = false;
 510
 511                         if (id->version != MEI_CL_VERSION_ANY)
 512                                 if (id->version != version)
 513                                         match = false;
 514                         if (match)
 515                                 return id;
 516                 }
 517
 518                 id++;
 519         }
 520
 521         return NULL;
 522 }
 523
 524 /**
 525  * mei_cl_device_match  - device match function
 526  *
 527  * @dev: device
 528  * @drv: driver
 529  *
 530  * Return:  1 if matching device was found 0 otherwise
 531  */
 532 static int mei_cl_device_match(struct device *dev, struct device_driver *drv)
 533 {
 534         struct mei_cl_device *cldev = to_mei_cl_device(dev);
 535         struct mei_cl_driver *cldrv = to_mei_cl_driver(drv);
 536         const struct mei_cl_device_id *found_id;
 537
 538         if (!cldev)
 539                 return 0;
 540
 541         if (!cldev->do_match)
 542                 return 0;
 543
 544         if (!cldrv || !cldrv->id_table)
 545                 return 0;
 546
 547         found_id = mei_cl_device_find(cldev, cldrv);
 548         if (found_id)
 549                 return 1;
 550
 551         return 0;
 552 }
 553
 554 /**
 555  * mei_cl_device_probe - bus probe function
 556  *
 557  * @dev: device
 558  *
 559  * Return:  0 on success; < 0 otherwise
 560  */
 561 static int mei_cl_device_probe(struct device *dev)
 562 {
 563         struct mei_cl_device *cldev;
 564         struct mei_cl_driver *cldrv;
 565         const struct mei_cl_device_id *id;
 566
 567         cldev = to_mei_cl_device(dev);
 568         cldrv = to_mei_cl_driver(dev->driver);
 569
 570         if (!cldev)
 571                 return 0;
 572
 573         if (!cldrv || !cldrv->probe)
 574                 return -ENODEV;
 575
 576         id = mei_cl_device_find(cldev, cldrv);
 577         if (!id)
 578                 return -ENODEV;
 579
 580         __module_get(THIS_MODULE);
 581
 582         return cldrv->probe(cldev, id);
 583 }
 584
 585 /**
 586  * mei_cl_device_remove - remove device from the bus
 587  *
 588  * @dev: device
 589  *
 590  * Return:  0 on success; < 0 otherwise
 591  */
 592 static int mei_cl_device_remove(struct device *dev)
 593 {
 594         struct mei_cl_device *cldev = to_mei_cl_device(dev);
 595         struct mei_cl_driver *cldrv;
 596         int ret = 0;
 597
 598         if (!cldev || !dev->driver)
 599                 return 0;
 600
 601         if (cldev->event_cb) {
 602                 cldev->event_cb = NULL;
 603                 cancel_work_sync(&cldev->event_work);
 604         }
 605
 606         cldrv = to_mei_cl_driver(dev->driver);
 607         if (cldrv->remove)
 608                 ret = cldrv->remove(cldev);
 609
 610         module_put(THIS_MODULE);
 611         dev->driver = NULL;
 612         return ret;
 613
 614 }
 615
 616 static ssize_t name_show(struct device *dev, struct device_attribute *a,
 617                              char *buf)
 618 {
 619         struct mei_cl_device *cldev = to_mei_cl_device(dev);
 620         size_t len;
 621
 622         len = snprintf(buf, PAGE_SIZE, "%s", cldev->name);
 623
 624         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
 625 }
 626 static DEVICE_ATTR_RO(name);
 627
 628 static ssize_t uuid_show(struct device *dev, struct device_attribute *a,
 629                              char *buf)
 630 {
 631         struct mei_cl_device *cldev = to_mei_cl_device(dev);
 632         const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl);
 633         size_t len;
 634
 635         len = snprintf(buf, PAGE_SIZE, "%pUl", uuid);
 636
 637         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
 638 }
 639 static DEVICE_ATTR_RO(uuid);
 640
 641 static ssize_t version_show(struct device *dev, struct device_attribute *a,
 642                              char *buf)
 643 {
 644         struct mei_cl_device *cldev = to_mei_cl_device(dev);
 645         u8 version = mei_me_cl_ver(cldev->me_cl);
 646         size_t len;
 647
 648         len = snprintf(buf, PAGE_SIZE, "%02X", version);
 649
 650         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
 651 }
 652 static DEVICE_ATTR_RO(version);
 653
 654 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
 655                              char *buf)
 656 {
 657         struct mei_cl_device *cldev = to_mei_cl_device(dev);
 658         const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl);
 659         size_t len;
 660
 661         len = snprintf(buf, PAGE_SIZE, "mei:%s:%pUl:", cldev->name, uuid);
 662         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
 663 }
 664 static DEVICE_ATTR_RO(modalias);
 665
 666 static struct attribute *mei_cldev_attrs[] = {
 667         &dev_attr_name.attr,
 668         &dev_attr_uuid.attr,
 669         &dev_attr_version.attr,
 670         &dev_attr_modalias.attr,
 671         NULL,
 672 };
 673 ATTRIBUTE_GROUPS(mei_cldev);
 674
 675 /**
 676  * mei_cl_device_uevent - me client bus uevent handler
 677  *
 678  * @dev: device
 679  * @env: uevent kobject
 680  *
 681  * Return: 0 on success -ENOMEM on when add_uevent_var fails
 682  */
 683 static int mei_cl_device_uevent(struct device *dev, struct kobj_uevent_env *env)
 684 {
 685         struct mei_cl_device *cldev = to_mei_cl_device(dev);
 686         const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl);
 687         u8 version = mei_me_cl_ver(cldev->me_cl);
 688
 689         if (add_uevent_var(env, "MEI_CL_VERSION=%d", version))
 690                 return -ENOMEM;
 691
 692         if (add_uevent_var(env, "MEI_CL_UUID=%pUl", uuid))
 693                 return -ENOMEM;
 694
 695         if (add_uevent_var(env, "MEI_CL_NAME=%s", cldev->name))
 696                 return -ENOMEM;
 697
 698         if (add_uevent_var(env, "MODALIAS=mei:%s:%pUl:%02X:",
 699                            cldev->name, uuid, version))
 700                 return -ENOMEM;
 701
 702         return 0;
 703 }
 704
 705 static struct bus_type mei_cl_bus_type = {
 706         .name           = "mei",
 707         .dev_groups     = mei_cldev_groups,
 708         .match          = mei_cl_device_match,
 709         .probe          = mei_cl_device_probe,
 710         .remove         = mei_cl_device_remove,
 711         .uevent         = mei_cl_device_uevent,
 712 };
 713
 714 static struct mei_device *mei_dev_bus_get(struct mei_device *bus)
 715 {
 716         if (bus)
 717                 get_device(bus->dev);
 718
 719         return bus;
 720 }
 721
 722 static void mei_dev_bus_put(struct mei_device *bus)
 723 {
 724         if (bus)
 725                 put_device(bus->dev);
 726 }
 727
 728 static void mei_cl_bus_dev_release(struct device *dev)
 729 {
 730         struct mei_cl_device *cldev = to_mei_cl_device(dev);
 731
 732         if (!cldev)
 733                 return;
 734
 735         mei_me_cl_put(cldev->me_cl);
 736         mei_dev_bus_put(cldev->bus);
 737         kfree(cldev);
 738 }
 739
 740 static struct device_type mei_cl_device_type = {
 741         .release        = mei_cl_bus_dev_release,
 742 };
 743
 744 /**
 745  * mei_cl_bus_set_name - set device name for me client device
 746  *
 747  * @cldev: me client device
 748  */
 749 static inline void mei_cl_bus_set_name(struct mei_cl_device *cldev)
 750 {
 751         dev_set_name(&cldev->dev, "mei:%s:%pUl:%02X",
 752                      cldev->name,
 753                      mei_me_cl_uuid(cldev->me_cl),
 754                      mei_me_cl_ver(cldev->me_cl));
 755 }
 756
 757 /**
 758  * mei_cl_bus_dev_alloc - initialize and allocate mei client device
 759  *
 760  * @bus: mei device
 761  * @me_cl: me client
 762  *
 763  * Return: allocated device structur or NULL on allocation failure
 764  */
 765 static struct mei_cl_device *mei_cl_bus_dev_alloc(struct mei_device *bus,
 766                                                   struct mei_me_client *me_cl)
 767 {
 768         struct mei_cl_device *cldev;
 769
 770         cldev = kzalloc(sizeof(struct mei_cl_device), GFP_KERNEL);
 771         if (!cldev)
 772                 return NULL;
 773
 774         device_initialize(&cldev->dev);
 775         cldev->dev.parent = bus->dev;
 776         cldev->dev.bus    = &mei_cl_bus_type;
 777         cldev->dev.type   = &mei_cl_device_type;
 778         cldev->bus        = mei_dev_bus_get(bus);
 779         cldev->me_cl      = mei_me_cl_get(me_cl);
 780         mei_cl_bus_set_name(cldev);
 781         cldev->is_added   = 0;
 782         INIT_LIST_HEAD(&cldev->bus_list);
 783
 784         return cldev;
 785 }
 786
 787 /**
 788  * mei_cl_dev_setup - setup me client device
 789  *    run fix up routines and set the device name
 790  *
 791  * @bus: mei device
 792  * @cldev: me client device
 793  *
 794  * Return: true if the device is eligible for enumeration
 795  */
 796 static bool mei_cl_bus_dev_setup(struct mei_device *bus,
 797                                  struct mei_cl_device *cldev)
 798 {
 799         cldev->do_match = 1;
 800         mei_cl_bus_dev_fixup(cldev);
 801
 802         /* the device name can change during fix up */
 803         if (cldev->do_match)
 804                 mei_cl_bus_set_name(cldev);
 805
 806         return cldev->do_match == 1;
 807 }
 808
 809 /**
 810  * mei_cl_bus_dev_add - add me client devices
 811  *
 812  * @cldev: me client device
 813  *
 814  * Return: 0 on success; < 0 on failre
 815  */
 816 static int mei_cl_bus_dev_add(struct mei_cl_device *cldev)
 817 {
 818         int ret;
 819
 820         dev_dbg(cldev->bus->dev, "adding %pUL:%02X\n",
 821                 mei_me_cl_uuid(cldev->me_cl),
 822                 mei_me_cl_ver(cldev->me_cl));
 823         ret = device_add(&cldev->dev);
 824         if (!ret)
 825                 cldev->is_added = 1;
 826
 827         return ret;
 828 }
 829
 830 /**
 831  * mei_cl_bus_dev_stop - stop the driver
 832  *
 833  * @cldev: me client device
 834  */
 835 static void mei_cl_bus_dev_stop(struct mei_cl_device *cldev)
 836 {
 837         if (cldev->is_added)
 838                 device_release_driver(&cldev->dev);
 839 }
 840
 841 /**
 842  * mei_cl_bus_dev_destroy - destroy me client devices object
 843  *
 844  * @cldev: me client device
 845  *
 846  * Locking: called under "dev->cl_bus_lock" lock
 847  */
 848 static void mei_cl_bus_dev_destroy(struct mei_cl_device *cldev)
 849 {
 850
 851         WARN_ON(!mutex_is_locked(&cldev->bus->cl_bus_lock));
 852
 853         if (!cldev->is_added)
 854                 return;
 855
 856         device_del(&cldev->dev);
 857
 858         list_del_init(&cldev->bus_list);
 859
 860         cldev->is_added = 0;
 861         put_device(&cldev->dev);
 862 }
 863
 864 /**
 865  * mei_cl_bus_remove_device - remove a devices form the bus
 866  *
 867  * @cldev: me client device
 868  */
 869 static void mei_cl_bus_remove_device(struct mei_cl_device *cldev)
 870 {
 871         mei_cl_bus_dev_stop(cldev);
 872         mei_cl_bus_dev_destroy(cldev);
 873 }
 874
 875 /**
 876  * mei_cl_bus_remove_devices - remove all devices form the bus
 877  *
 878  * @bus: mei device
 879  */
 880 void mei_cl_bus_remove_devices(struct mei_device *bus)
 881 {
 882         struct mei_cl_device *cldev, *next;
 883
 884         mutex_lock(&bus->cl_bus_lock);
 885         list_for_each_entry_safe(cldev, next, &bus->device_list, bus_list)
 886                 mei_cl_bus_remove_device(cldev);
 887         mutex_unlock(&bus->cl_bus_lock);
 888 }
 889
 890
 891 /**
 892  * mei_cl_bus_dev_init - allocate and initializes an mei client devices
 893  *     based on me client
 894  *
 895  * @bus: mei device
 896  * @me_cl: me client
 897  *
 898  * Locking: called under "dev->cl_bus_lock" lock
 899  */
 900 static void mei_cl_bus_dev_init(struct mei_device *bus,
 901                                 struct mei_me_client *me_cl)
 902 {
 903         struct mei_cl_device *cldev;
 904
 905         WARN_ON(!mutex_is_locked(&bus->cl_bus_lock));
 906
 907         dev_dbg(bus->dev, "initializing %pUl", mei_me_cl_uuid(me_cl));
 908
 909         if (me_cl->bus_added)
 910                 return;
 911
 912         cldev = mei_cl_bus_dev_alloc(bus, me_cl);
 913         if (!cldev)
 914                 return;
 915
 916         me_cl->bus_added = true;
 917         list_add_tail(&cldev->bus_list, &bus->device_list);
 918
 919 }
 920
 921 /**
 922  * mei_cl_bus_rescan - scan me clients list and add create
 923  *    devices for eligible clients
 924  *
 925  * @bus: mei device
 926  */
 927 void mei_cl_bus_rescan(struct mei_device *bus)
 928 {
 929         struct mei_cl_device *cldev, *n;
 930         struct mei_me_client *me_cl;
 931
 932         mutex_lock(&bus->cl_bus_lock);
 933
 934         down_read(&bus->me_clients_rwsem);
 935         list_for_each_entry(me_cl, &bus->me_clients, list)
 936                 mei_cl_bus_dev_init(bus, me_cl);
 937         up_read(&bus->me_clients_rwsem);
 938
 939         list_for_each_entry_safe(cldev, n, &bus->device_list, bus_list) {
 940
 941                 if (!mei_me_cl_is_active(cldev->me_cl)) {
 942                         mei_cl_bus_remove_device(cldev);
 943                         continue;
 944                 }
 945
 946                 if (cldev->is_added)
 947                         continue;
 948
 949                 if (mei_cl_bus_dev_setup(bus, cldev))
 950                         mei_cl_bus_dev_add(cldev);
 951                 else {
 952                         list_del_init(&cldev->bus_list);
 953                         put_device(&cldev->dev);
 954                 }
 955         }
 956         mutex_unlock(&bus->cl_bus_lock);
 957
 958         dev_dbg(bus->dev, "rescan end");
 959 }
 960
 961 int __mei_cldev_driver_register(struct mei_cl_driver *cldrv,
 962                                 struct module *owner)
 963 {
 964         int err;
 965
 966         cldrv->driver.name = cldrv->name;
 967         cldrv->driver.owner = owner;
 968         cldrv->driver.bus = &mei_cl_bus_type;
 969
 970         err = driver_register(&cldrv->driver);
 971         if (err)
 972                 return err;
 973
 974         pr_debug("mei: driver [%s] registered\n", cldrv->driver.name);
 975
 976         return 0;
 977 }
 978 EXPORT_SYMBOL_GPL(__mei_cldev_driver_register);
 979
 980 void mei_cldev_driver_unregister(struct mei_cl_driver *cldrv)
 981 {
 982         driver_unregister(&cldrv->driver);
 983
 984         pr_debug("mei: driver [%s] unregistered\n", cldrv->driver.name);
 985 }
 986 EXPORT_SYMBOL_GPL(mei_cldev_driver_unregister);
 987
 988
 989 int __init mei_cl_bus_init(void)
 990 {
 991         return bus_register(&mei_cl_bus_type);
 992 }
 993
 994 void __exit mei_cl_bus_exit(void)
 995 {
 996         bus_unregister(&mei_cl_bus_type);
 997 }