drivers/staging/greybus/svc.c

   1 /*
   2  * SVC Greybus driver.
   3  *
   4  * Copyright 2015 Google Inc.
   5  * Copyright 2015 Linaro Ltd.
   6  *
   7  * Released under the GPLv2 only.
   8  */
   9
  10 #include <linux/workqueue.h>
  11
  12 #include "greybus.h"
  13
  14 #define CPORT_FLAGS_E2EFC       BIT(0)
  15 #define CPORT_FLAGS_CSD_N       BIT(1)
  16 #define CPORT_FLAGS_CSV_N       BIT(2)
  17
  18
  19 struct svc_hotplug {
  20         struct work_struct work;
  21         struct gb_connection *connection;
  22         struct gb_svc_intf_hotplug_request data;
  23 };
  24
  25
  26 static ssize_t endo_id_show(struct device *dev,
  27                         struct device_attribute *attr, char *buf)
  28 {
  29         struct gb_svc *svc = to_gb_svc(dev);
  30
  31         return sprintf(buf, "0x%04x\n", svc->endo_id);
  32 }
  33 static DEVICE_ATTR_RO(endo_id);
  34
  35 static ssize_t ap_intf_id_show(struct device *dev,
  36                         struct device_attribute *attr, char *buf)
  37 {
  38         struct gb_svc *svc = to_gb_svc(dev);
  39
  40         return sprintf(buf, "%u\n", svc->ap_intf_id);
  41 }
  42 static DEVICE_ATTR_RO(ap_intf_id);
  43
  44 static struct attribute *svc_attrs[] = {
  45         &dev_attr_endo_id.attr,
  46         &dev_attr_ap_intf_id.attr,
  47         NULL,
  48 };
  49 ATTRIBUTE_GROUPS(svc);
  50
  51 static int gb_svc_intf_device_id(struct gb_svc *svc, u8 intf_id, u8 device_id)
  52 {
  53         struct gb_svc_intf_device_id_request request;
  54
  55         request.intf_id = intf_id;
  56         request.device_id = device_id;
  57
  58         return gb_operation_sync(svc->connection, GB_SVC_TYPE_INTF_DEVICE_ID,
  59                                  &request, sizeof(request), NULL, 0);
  60 }
  61
  62 int gb_svc_intf_reset(struct gb_svc *svc, u8 intf_id)
  63 {
  64         struct gb_svc_intf_reset_request request;
  65
  66         request.intf_id = intf_id;
  67
  68         return gb_operation_sync(svc->connection, GB_SVC_TYPE_INTF_RESET,
  69                                  &request, sizeof(request), NULL, 0);
  70 }
  71 EXPORT_SYMBOL_GPL(gb_svc_intf_reset);
  72
  73 int gb_svc_dme_peer_get(struct gb_svc *svc, u8 intf_id, u16 attr, u16 selector,
  74                         u32 *value)
  75 {
  76         struct gb_svc_dme_peer_get_request request;
  77         struct gb_svc_dme_peer_get_response response;
  78         u16 result;
  79         int ret;
  80
  81         request.intf_id = intf_id;
  82         request.attr = cpu_to_le16(attr);
  83         request.selector = cpu_to_le16(selector);
  84
  85         ret = gb_operation_sync(svc->connection, GB_SVC_TYPE_DME_PEER_GET,
  86                                 &request, sizeof(request),
  87                                 &response, sizeof(response));
  88         if (ret) {
  89                 dev_err(&svc->dev, "failed to get DME attribute (%hhu %hx %hu): %d\n",
  90                                 intf_id, attr, selector, ret);
  91                 return ret;
  92         }
  93
  94         result = le16_to_cpu(response.result_code);
  95         if (result) {
  96                 dev_err(&svc->dev, "UniPro error while getting DME attribute (%hhu %hx %hu): %hu\n",
  97                                 intf_id, attr, selector, result);
  98                 return -EINVAL;
  99         }
 100
 101         if (value)
 102                 *value = le32_to_cpu(response.attr_value);
 103
 104         return 0;
 105 }
 106 EXPORT_SYMBOL_GPL(gb_svc_dme_peer_get);
 107
 108 int gb_svc_dme_peer_set(struct gb_svc *svc, u8 intf_id, u16 attr, u16 selector,
 109                         u32 value)
 110 {
 111         struct gb_svc_dme_peer_set_request request;
 112         struct gb_svc_dme_peer_set_response response;
 113         u16 result;
 114         int ret;
 115
 116         request.intf_id = intf_id;
 117         request.attr = cpu_to_le16(attr);
 118         request.selector = cpu_to_le16(selector);
 119         request.value = cpu_to_le32(value);
 120
 121         ret = gb_operation_sync(svc->connection, GB_SVC_TYPE_DME_PEER_SET,
 122                                 &request, sizeof(request),
 123                                 &response, sizeof(response));
 124         if (ret) {
 125                 dev_err(&svc->dev, "failed to set DME attribute (%hhu %hx %hu %u): %d\n",
 126                                 intf_id, attr, selector, value, ret);
 127                 return ret;
 128         }
 129
 130         result = le16_to_cpu(response.result_code);
 131         if (result) {
 132                 dev_err(&svc->dev, "UniPro error while setting DME attribute (%hhu %hx %hu %u): %hu\n",
 133                                 intf_id, attr, selector, value, result);
 134                 return -EINVAL;
 135         }
 136
 137         return 0;
 138 }
 139 EXPORT_SYMBOL_GPL(gb_svc_dme_peer_set);
 140
 141 /*
 142  * T_TstSrcIncrement is written by the module on ES2 as a stand-in for boot
 143  * status attribute. AP needs to read and clear it, after reading a non-zero
 144  * value from it.
 145  *
 146  * FIXME: This is module-hardware dependent and needs to be extended for every
 147  * type of module we want to support.
 148  */
 149 static int gb_svc_read_and_clear_module_boot_status(struct gb_interface *intf)
 150 {
 151         struct gb_host_device *hd = intf->hd;
 152         int ret;
 153         u32 value;
 154
 155         /* Read and clear boot status in T_TstSrcIncrement */
 156         ret = gb_svc_dme_peer_get(hd->svc, intf->interface_id,
 157                                   DME_ATTR_T_TST_SRC_INCREMENT,
 158                                   DME_ATTR_SELECTOR_INDEX, &value);
 159
 160         if (ret)
 161                 return ret;
 162
 163         /*
 164          * A nonzero boot status indicates the module has finished
 165          * booting. Clear it.
 166          */
 167         if (!value) {
 168                 dev_err(&intf->dev, "Module not ready yet\n");
 169                 return -ENODEV;
 170         }
 171
 172         /*
 173          * Check if the module needs to boot from unipro.
 174          * For ES2: We need to check lowest 8 bits of 'value'.
 175          * For ES3: We need to check highest 8 bits out of 32 of 'value'.
 176          *
 177          * FIXME: Add code to find if we are on ES2 or ES3 to have separate
 178          * checks.
 179          */
 180         if (value == DME_TSI_UNIPRO_BOOT_STARTED ||
 181             value == DME_TSI_FALLBACK_UNIPRO_BOOT_STARTED)
 182                 intf->boot_over_unipro = true;
 183
 184         return gb_svc_dme_peer_set(hd->svc, intf->interface_id,
 185                                    DME_ATTR_T_TST_SRC_INCREMENT,
 186                                    DME_ATTR_SELECTOR_INDEX, 0);
 187 }
 188
 189 int gb_svc_connection_create(struct gb_svc *svc,
 190                                 u8 intf1_id, u16 cport1_id,
 191                                 u8 intf2_id, u16 cport2_id,
 192                                 bool boot_over_unipro)
 193 {
 194         struct gb_svc_conn_create_request request;
 195
 196         request.intf1_id = intf1_id;
 197         request.cport1_id = cpu_to_le16(cport1_id);
 198         request.intf2_id = intf2_id;
 199         request.cport2_id = cpu_to_le16(cport2_id);
 200         /*
 201          * XXX: fix connections paramaters to TC0 and all CPort flags
 202          * for now.
 203          */
 204         request.tc = 0;
 205
 206         /*
 207          * We need to skip setting E2EFC and other flags to the connection
 208          * create request, for all cports, on an interface that need to boot
 209          * over unipro, i.e. interfaces required to download firmware.
 210          */
 211         if (boot_over_unipro)
 212                 request.flags = CPORT_FLAGS_CSV_N | CPORT_FLAGS_CSD_N;
 213         else
 214                 request.flags = CPORT_FLAGS_CSV_N | CPORT_FLAGS_E2EFC;
 215
 216         return gb_operation_sync(svc->connection, GB_SVC_TYPE_CONN_CREATE,
 217                                  &request, sizeof(request), NULL, 0);
 218 }
 219 EXPORT_SYMBOL_GPL(gb_svc_connection_create);
 220
 221 void gb_svc_connection_destroy(struct gb_svc *svc, u8 intf1_id, u16 cport1_id,
 222                                u8 intf2_id, u16 cport2_id)
 223 {
 224         struct gb_svc_conn_destroy_request request;
 225         struct gb_connection *connection = svc->connection;
 226         int ret;
 227
 228         request.intf1_id = intf1_id;
 229         request.cport1_id = cpu_to_le16(cport1_id);
 230         request.intf2_id = intf2_id;
 231         request.cport2_id = cpu_to_le16(cport2_id);
 232
 233         ret = gb_operation_sync(connection, GB_SVC_TYPE_CONN_DESTROY,
 234                                 &request, sizeof(request), NULL, 0);
 235         if (ret) {
 236                 dev_err(&svc->dev, "failed to destroy connection (%hhu:%hu %hhu:%hu): %d\n",
 237                                 intf1_id, cport1_id, intf2_id, cport2_id, ret);
 238         }
 239 }
 240 EXPORT_SYMBOL_GPL(gb_svc_connection_destroy);
 241
 242 /* Creates bi-directional routes between the devices */
 243 static int gb_svc_route_create(struct gb_svc *svc, u8 intf1_id, u8 dev1_id,
 244                                u8 intf2_id, u8 dev2_id)
 245 {
 246         struct gb_svc_route_create_request request;
 247
 248         request.intf1_id = intf1_id;
 249         request.dev1_id = dev1_id;
 250         request.intf2_id = intf2_id;
 251         request.dev2_id = dev2_id;
 252
 253         return gb_operation_sync(svc->connection, GB_SVC_TYPE_ROUTE_CREATE,
 254                                  &request, sizeof(request), NULL, 0);
 255 }
 256
 257 /* Destroys bi-directional routes between the devices */
 258 static void gb_svc_route_destroy(struct gb_svc *svc, u8 intf1_id, u8 intf2_id)
 259 {
 260         struct gb_svc_route_destroy_request request;
 261         int ret;
 262
 263         request.intf1_id = intf1_id;
 264         request.intf2_id = intf2_id;
 265
 266         ret = gb_operation_sync(svc->connection, GB_SVC_TYPE_ROUTE_DESTROY,
 267                                 &request, sizeof(request), NULL, 0);
 268         if (ret) {
 269                 dev_err(&svc->dev, "failed to destroy route (%hhu %hhu): %d\n",
 270                                 intf1_id, intf2_id, ret);
 271         }
 272 }
 273
 274 static int gb_svc_version_request(struct gb_operation *op)
 275 {
 276         struct gb_connection *connection = op->connection;
 277         struct gb_svc *svc = connection->private;
 278         struct gb_protocol_version_request *request;
 279         struct gb_protocol_version_response *response;
 280
 281         if (op->request->payload_size < sizeof(*request)) {
 282                 dev_err(&svc->dev, "short version request (%zu < %zu)\n",
 283                                 op->request->payload_size,
 284                                 sizeof(*request));
 285                 return -EINVAL;
 286         }
 287
 288         request = op->request->payload;
 289
 290         if (request->major > GB_SVC_VERSION_MAJOR) {
 291                 dev_warn(&svc->dev, "unsupported major version (%hhu > %hhu)\n",
 292                                 request->major, GB_SVC_VERSION_MAJOR);
 293                 return -ENOTSUPP;
 294         }
 295
 296         connection->module_major = request->major;
 297         connection->module_minor = request->minor;
 298
 299         if (!gb_operation_response_alloc(op, sizeof(*response), GFP_KERNEL))
 300                 return -ENOMEM;
 301
 302         response = op->response->payload;
 303         response->major = connection->module_major;
 304         response->minor = connection->module_minor;
 305
 306         return 0;
 307 }
 308
 309 static int gb_svc_hello(struct gb_operation *op)
 310 {
 311         struct gb_connection *connection = op->connection;
 312         struct gb_svc *svc = connection->private;
 313         struct gb_svc_hello_request *hello_request;
 314         int ret;
 315
 316         if (op->request->payload_size < sizeof(*hello_request)) {
 317                 dev_warn(&svc->dev, "short hello request (%zu < %zu)\n",
 318                                 op->request->payload_size,
 319                                 sizeof(*hello_request));
 320                 return -EINVAL;
 321         }
 322
 323         hello_request = op->request->payload;
 324         svc->endo_id = le16_to_cpu(hello_request->endo_id);
 325         svc->ap_intf_id = hello_request->interface_id;
 326
 327         ret = device_add(&svc->dev);
 328         if (ret) {
 329                 dev_err(&svc->dev, "failed to register svc device: %d\n", ret);
 330                 return ret;
 331         }
 332
 333         return 0;
 334 }
 335
 336 static void svc_intf_remove(struct gb_connection *connection,
 337                             struct gb_interface *intf)
 338 {
 339         struct gb_svc *svc = connection->private;
 340         u8 intf_id = intf->interface_id;
 341         u8 device_id;
 342
 343         device_id = intf->device_id;
 344         gb_interface_remove(intf);
 345
 346         /*
 347          * Destroy the two-way route between the AP and the interface.
 348          */
 349         gb_svc_route_destroy(svc, svc->ap_intf_id, intf_id);
 350
 351         ida_simple_remove(&svc->device_id_map, device_id);
 352 }
 353
 354 /*
 355  * 'struct svc_hotplug' should be freed by svc_process_hotplug() before it
 356  * returns, irrespective of success or Failure in bringing up the module.
 357  */
 358 static void svc_process_hotplug(struct work_struct *work)
 359 {
 360         struct svc_hotplug *svc_hotplug = container_of(work, struct svc_hotplug,
 361                                                        work);
 362         struct gb_svc_intf_hotplug_request *hotplug = &svc_hotplug->data;
 363         struct gb_connection *connection = svc_hotplug->connection;
 364         struct gb_svc *svc = connection->private;
 365         struct gb_host_device *hd = connection->hd;
 366         struct gb_interface *intf;
 367         u8 intf_id, device_id;
 368         int ret;
 369
 370         /*
 371          * Grab the information we need.
 372          */
 373         intf_id = hotplug->intf_id;
 374
 375         intf = gb_interface_find(hd, intf_id);
 376         if (intf) {
 377                 /*
 378                  * We have received a hotplug request for an interface that
 379                  * already exists.
 380                  *
 381                  * This can happen in cases like:
 382                  * - bootrom loading the firmware image and booting into that,
 383                  *   which only generates a hotplug event. i.e. no hot-unplug
 384                  *   event.
 385                  * - Or the firmware on the module crashed and sent hotplug
 386                  *   request again to the SVC, which got propagated to AP.
 387                  *
 388                  * Remove the interface and add it again, and let user know
 389                  * about this with a print message.
 390                  */
 391                 dev_info(&svc->dev, "removing interface %hhu to add it again\n",
 392                                 intf_id);
 393                 svc_intf_remove(connection, intf);
 394         }
 395
 396         intf = gb_interface_create(hd, intf_id);
 397         if (!intf) {
 398                 dev_err(&svc->dev, "failed to create interface %hhu\n",
 399                                 intf_id);
 400                 goto free_svc_hotplug;
 401         }
 402
 403         ret = gb_svc_read_and_clear_module_boot_status(intf);
 404         if (ret)
 405                 goto destroy_interface;
 406
 407         intf->unipro_mfg_id = le32_to_cpu(hotplug->data.unipro_mfg_id);
 408         intf->unipro_prod_id = le32_to_cpu(hotplug->data.unipro_prod_id);
 409         intf->vendor_id = le32_to_cpu(hotplug->data.ara_vend_id);
 410         intf->product_id = le32_to_cpu(hotplug->data.ara_prod_id);
 411
 412         /*
 413          * Create a device id for the interface:
 414          * - device id 0 (GB_DEVICE_ID_SVC) belongs to the SVC
 415          * - device id 1 (GB_DEVICE_ID_AP) belongs to the AP
 416          *
 417          * XXX Do we need to allocate device ID for SVC or the AP here? And what
 418          * XXX about an AP with multiple interface blocks?
 419          */
 420         device_id = ida_simple_get(&svc->device_id_map,
 421                                    GB_DEVICE_ID_MODULES_START, 0, GFP_KERNEL);
 422         if (device_id < 0) {
 423                 ret = device_id;
 424                 dev_err(&svc->dev, "failed to allocate device id for interface %hhu: %d\n",
 425                                 intf_id, ret);
 426                 goto destroy_interface;
 427         }
 428
 429         ret = gb_svc_intf_device_id(svc, intf_id, device_id);
 430         if (ret) {
 431                 dev_err(&svc->dev, "failed to set device id %hhu for interface %hhu: %d\n",
 432                                 device_id, intf_id, ret);
 433                 goto ida_put;
 434         }
 435
 436         /*
 437          * Create a two-way route between the AP and the new interface
 438          */
 439         ret = gb_svc_route_create(svc, svc->ap_intf_id, GB_DEVICE_ID_AP,
 440                                   intf_id, device_id);
 441         if (ret) {
 442                 dev_err(&svc->dev, "failed to create route to interface %hhu (device id %hhu): %d\n",
 443                                 intf_id, device_id, ret);
 444                 goto svc_id_free;
 445         }
 446
 447         ret = gb_interface_init(intf, device_id);
 448         if (ret) {
 449                 dev_err(&svc->dev, "failed to initialize interface %hhu (device id %hhu): %d\n",
 450                                 intf_id, device_id, ret);
 451                 goto destroy_route;
 452         }
 453
 454         goto free_svc_hotplug;
 455
 456 destroy_route:
 457         gb_svc_route_destroy(svc, svc->ap_intf_id, intf_id);
 458 svc_id_free:
 459         /*
 460          * XXX Should we tell SVC that this id doesn't belong to interface
 461          * XXX anymore.
 462          */
 463 ida_put:
 464         ida_simple_remove(&svc->device_id_map, device_id);
 465 destroy_interface:
 466         gb_interface_remove(intf);
 467 free_svc_hotplug:
 468         kfree(svc_hotplug);
 469 }
 470
 471 /*
 472  * Bringing up a module can be time consuming, as that may require lots of
 473  * initialization on the module side. Over that, we may also need to download
 474  * the firmware first and flash that on the module.
 475  *
 476  * In order to make other hotplug events to not wait for all this to finish,
 477  * handle most of module hotplug stuff outside of the hotplug callback, with
 478  * help of a workqueue.
 479  */
 480 static int gb_svc_intf_hotplug_recv(struct gb_operation *op)
 481 {
 482         struct gb_svc *svc = op->connection->private;
 483         struct gb_message *request = op->request;
 484         struct svc_hotplug *svc_hotplug;
 485
 486         if (request->payload_size < sizeof(svc_hotplug->data)) {
 487                 dev_warn(&svc->dev, "short hotplug request received (%zu < %zu)\n",
 488                                 request->payload_size,
 489                                 sizeof(svc_hotplug->data));
 490                 return -EINVAL;
 491         }
 492
 493         svc_hotplug = kmalloc(sizeof(*svc_hotplug), GFP_KERNEL);
 494         if (!svc_hotplug)
 495                 return -ENOMEM;
 496
 497         svc_hotplug->connection = op->connection;
 498         memcpy(&svc_hotplug->data, op->request->payload, sizeof(svc_hotplug->data));
 499
 500         INIT_WORK(&svc_hotplug->work, svc_process_hotplug);
 501         queue_work(system_unbound_wq, &svc_hotplug->work);
 502
 503         return 0;
 504 }
 505
 506 static int gb_svc_intf_hot_unplug_recv(struct gb_operation *op)
 507 {
 508         struct gb_svc *svc = op->connection->private;
 509         struct gb_message *request = op->request;
 510         struct gb_svc_intf_hot_unplug_request *hot_unplug = request->payload;
 511         struct gb_host_device *hd = op->connection->hd;
 512         struct gb_interface *intf;
 513         u8 intf_id;
 514
 515         if (request->payload_size < sizeof(*hot_unplug)) {
 516                 dev_warn(&svc->dev, "short hot unplug request received (%zu < %zu)\n",
 517                                 request->payload_size,
 518                                 sizeof(*hot_unplug));
 519                 return -EINVAL;
 520         }
 521
 522         intf_id = hot_unplug->intf_id;
 523
 524         intf = gb_interface_find(hd, intf_id);
 525         if (!intf) {
 526                 dev_warn(&svc->dev, "could not find hot-unplug interface %hhu\n",
 527                                 intf_id);
 528                 return -EINVAL;
 529         }
 530
 531         svc_intf_remove(op->connection, intf);
 532
 533         return 0;
 534 }
 535
 536 static int gb_svc_intf_reset_recv(struct gb_operation *op)
 537 {
 538         struct gb_svc *svc = op->connection->private;
 539         struct gb_message *request = op->request;
 540         struct gb_svc_intf_reset_request *reset;
 541         u8 intf_id;
 542
 543         if (request->payload_size < sizeof(*reset)) {
 544                 dev_warn(&svc->dev, "short reset request received (%zu < %zu)\n",
 545                                 request->payload_size, sizeof(*reset));
 546                 return -EINVAL;
 547         }
 548         reset = request->payload;
 549
 550         intf_id = reset->intf_id;
 551
 552         /* FIXME Reset the interface here */
 553
 554         return 0;
 555 }
 556
 557 static int gb_svc_request_recv(u8 type, struct gb_operation *op)
 558 {
 559         struct gb_connection *connection = op->connection;
 560         struct gb_svc *svc = connection->private;
 561         int ret = 0;
 562
 563         /*
 564          * SVC requests need to follow a specific order (at least initially) and
 565          * below code takes care of enforcing that. The expected order is:
 566          * - PROTOCOL_VERSION
 567          * - SVC_HELLO
 568          * - Any other request, but the earlier two.
 569          *
 570          * Incoming requests are guaranteed to be serialized and so we don't
 571          * need to protect 'state' for any races.
 572          */
 573         switch (type) {
 574         case GB_REQUEST_TYPE_PROTOCOL_VERSION:
 575                 if (svc->state != GB_SVC_STATE_RESET)
 576                         ret = -EINVAL;
 577                 break;
 578         case GB_SVC_TYPE_SVC_HELLO:
 579                 if (svc->state != GB_SVC_STATE_PROTOCOL_VERSION)
 580                         ret = -EINVAL;
 581                 break;
 582         default:
 583                 if (svc->state != GB_SVC_STATE_SVC_HELLO)
 584                         ret = -EINVAL;
 585                 break;
 586         }
 587
 588         if (ret) {
 589                 dev_warn(&svc->dev, "unexpected request 0x%02x received (state %u)\n",
 590                                 type, svc->state);
 591                 return ret;
 592         }
 593
 594         switch (type) {
 595         case GB_REQUEST_TYPE_PROTOCOL_VERSION:
 596                 ret = gb_svc_version_request(op);
 597                 if (!ret)
 598                         svc->state = GB_SVC_STATE_PROTOCOL_VERSION;
 599                 return ret;
 600         case GB_SVC_TYPE_SVC_HELLO:
 601                 ret = gb_svc_hello(op);
 602                 if (!ret)
 603                         svc->state = GB_SVC_STATE_SVC_HELLO;
 604                 return ret;
 605         case GB_SVC_TYPE_INTF_HOTPLUG:
 606                 return gb_svc_intf_hotplug_recv(op);
 607         case GB_SVC_TYPE_INTF_HOT_UNPLUG:
 608                 return gb_svc_intf_hot_unplug_recv(op);
 609         case GB_SVC_TYPE_INTF_RESET:
 610                 return gb_svc_intf_reset_recv(op);
 611         default:
 612                 dev_warn(&svc->dev, "unsupported request 0x%02x\n", type);
 613                 return -EINVAL;
 614         }
 615 }
 616
 617 static void gb_svc_release(struct device *dev)
 618 {
 619         struct gb_svc *svc = to_gb_svc(dev);
 620
 621         ida_destroy(&svc->device_id_map);
 622         kfree(svc);
 623 }
 624
 625 struct device_type greybus_svc_type = {
 626         .name           = "greybus_svc",
 627         .release        = gb_svc_release,
 628 };
 629
 630 static int gb_svc_connection_init(struct gb_connection *connection)
 631 {
 632         struct gb_host_device *hd = connection->hd;
 633         struct gb_svc *svc;
 634
 635         svc = kzalloc(sizeof(*svc), GFP_KERNEL);
 636         if (!svc)
 637                 return -ENOMEM;
 638
 639         svc->dev.parent = &hd->dev;
 640         svc->dev.bus = &greybus_bus_type;
 641         svc->dev.type = &greybus_svc_type;
 642         svc->dev.groups = svc_groups;
 643         svc->dev.dma_mask = svc->dev.parent->dma_mask;
 644         device_initialize(&svc->dev);
 645
 646         dev_set_name(&svc->dev, "%d-svc", hd->bus_id);
 647
 648         ida_init(&svc->device_id_map);
 649         svc->state = GB_SVC_STATE_RESET;
 650         svc->connection = connection;
 651         connection->private = svc;
 652
 653         hd->svc = svc;
 654
 655         return 0;
 656 }
 657
 658 static void gb_svc_connection_exit(struct gb_connection *connection)
 659 {
 660         struct gb_svc *svc = connection->private;
 661
 662         if (device_is_registered(&svc->dev))
 663                 device_del(&svc->dev);
 664
 665         connection->hd->svc = NULL;
 666         connection->private = NULL;
 667
 668         put_device(&svc->dev);
 669 }
 670
 671 static struct gb_protocol svc_protocol = {
 672         .name                   = "svc",
 673         .id                     = GREYBUS_PROTOCOL_SVC,
 674         .major                  = GB_SVC_VERSION_MAJOR,
 675         .minor                  = GB_SVC_VERSION_MINOR,
 676         .connection_init        = gb_svc_connection_init,
 677         .connection_exit        = gb_svc_connection_exit,
 678         .request_recv           = gb_svc_request_recv,
 679         .flags                  = GB_PROTOCOL_SKIP_CONTROL_CONNECTED |
 680                                   GB_PROTOCOL_SKIP_CONTROL_DISCONNECTED |
 681                                   GB_PROTOCOL_NO_BUNDLE |
 682                                   GB_PROTOCOL_SKIP_VERSION,
 683 };
 684 gb_builtin_protocol_driver(svc_protocol);