Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Greybus CPort control protocol.
0004  *
0005  * Copyright 2015 Google Inc.
0006  * Copyright 2015 Linaro Ltd.
0007  */
0008 
0009 #include <linux/kernel.h>
0010 #include <linux/module.h>
0011 #include <linux/slab.h>
0012 #include <linux/greybus.h>
0013 
0014 /* Highest control-protocol version supported */
0015 #define GB_CONTROL_VERSION_MAJOR    0
0016 #define GB_CONTROL_VERSION_MINOR    1
0017 
0018 static int gb_control_get_version(struct gb_control *control)
0019 {
0020     struct gb_interface *intf = control->connection->intf;
0021     struct gb_control_version_request request;
0022     struct gb_control_version_response response;
0023     int ret;
0024 
0025     request.major = GB_CONTROL_VERSION_MAJOR;
0026     request.minor = GB_CONTROL_VERSION_MINOR;
0027 
0028     ret = gb_operation_sync(control->connection,
0029                 GB_CONTROL_TYPE_VERSION,
0030                 &request, sizeof(request), &response,
0031                 sizeof(response));
0032     if (ret) {
0033         dev_err(&intf->dev,
0034             "failed to get control-protocol version: %d\n",
0035             ret);
0036         return ret;
0037     }
0038 
0039     if (response.major > request.major) {
0040         dev_err(&intf->dev,
0041             "unsupported major control-protocol version (%u > %u)\n",
0042             response.major, request.major);
0043         return -ENOTSUPP;
0044     }
0045 
0046     control->protocol_major = response.major;
0047     control->protocol_minor = response.minor;
0048 
0049     dev_dbg(&intf->dev, "%s - %u.%u\n", __func__, response.major,
0050         response.minor);
0051 
0052     return 0;
0053 }
0054 
0055 static int gb_control_get_bundle_version(struct gb_control *control,
0056                      struct gb_bundle *bundle)
0057 {
0058     struct gb_interface *intf = control->connection->intf;
0059     struct gb_control_bundle_version_request request;
0060     struct gb_control_bundle_version_response response;
0061     int ret;
0062 
0063     request.bundle_id = bundle->id;
0064 
0065     ret = gb_operation_sync(control->connection,
0066                 GB_CONTROL_TYPE_BUNDLE_VERSION,
0067                 &request, sizeof(request),
0068                 &response, sizeof(response));
0069     if (ret) {
0070         dev_err(&intf->dev,
0071             "failed to get bundle %u class version: %d\n",
0072             bundle->id, ret);
0073         return ret;
0074     }
0075 
0076     bundle->class_major = response.major;
0077     bundle->class_minor = response.minor;
0078 
0079     dev_dbg(&intf->dev, "%s - %u: %u.%u\n", __func__, bundle->id,
0080         response.major, response.minor);
0081 
0082     return 0;
0083 }
0084 
0085 int gb_control_get_bundle_versions(struct gb_control *control)
0086 {
0087     struct gb_interface *intf = control->connection->intf;
0088     struct gb_bundle *bundle;
0089     int ret;
0090 
0091     if (!control->has_bundle_version)
0092         return 0;
0093 
0094     list_for_each_entry(bundle, &intf->bundles, links) {
0095         ret = gb_control_get_bundle_version(control, bundle);
0096         if (ret)
0097             return ret;
0098     }
0099 
0100     return 0;
0101 }
0102 
0103 /* Get Manifest's size from the interface */
0104 int gb_control_get_manifest_size_operation(struct gb_interface *intf)
0105 {
0106     struct gb_control_get_manifest_size_response response;
0107     struct gb_connection *connection = intf->control->connection;
0108     int ret;
0109 
0110     ret = gb_operation_sync(connection, GB_CONTROL_TYPE_GET_MANIFEST_SIZE,
0111                 NULL, 0, &response, sizeof(response));
0112     if (ret) {
0113         dev_err(&connection->intf->dev,
0114             "failed to get manifest size: %d\n", ret);
0115         return ret;
0116     }
0117 
0118     return le16_to_cpu(response.size);
0119 }
0120 
0121 /* Reads Manifest from the interface */
0122 int gb_control_get_manifest_operation(struct gb_interface *intf, void *manifest,
0123                       size_t size)
0124 {
0125     struct gb_connection *connection = intf->control->connection;
0126 
0127     return gb_operation_sync(connection, GB_CONTROL_TYPE_GET_MANIFEST,
0128                 NULL, 0, manifest, size);
0129 }
0130 
0131 int gb_control_connected_operation(struct gb_control *control, u16 cport_id)
0132 {
0133     struct gb_control_connected_request request;
0134 
0135     request.cport_id = cpu_to_le16(cport_id);
0136     return gb_operation_sync(control->connection, GB_CONTROL_TYPE_CONNECTED,
0137                  &request, sizeof(request), NULL, 0);
0138 }
0139 
0140 int gb_control_disconnected_operation(struct gb_control *control, u16 cport_id)
0141 {
0142     struct gb_control_disconnected_request request;
0143 
0144     request.cport_id = cpu_to_le16(cport_id);
0145     return gb_operation_sync(control->connection,
0146                  GB_CONTROL_TYPE_DISCONNECTED, &request,
0147                  sizeof(request), NULL, 0);
0148 }
0149 
0150 int gb_control_disconnecting_operation(struct gb_control *control,
0151                        u16 cport_id)
0152 {
0153     struct gb_control_disconnecting_request *request;
0154     struct gb_operation *operation;
0155     int ret;
0156 
0157     operation = gb_operation_create_core(control->connection,
0158                          GB_CONTROL_TYPE_DISCONNECTING,
0159                          sizeof(*request), 0, 0,
0160                          GFP_KERNEL);
0161     if (!operation)
0162         return -ENOMEM;
0163 
0164     request = operation->request->payload;
0165     request->cport_id = cpu_to_le16(cport_id);
0166 
0167     ret = gb_operation_request_send_sync(operation);
0168     if (ret) {
0169         dev_err(&control->dev, "failed to send disconnecting: %d\n",
0170             ret);
0171     }
0172 
0173     gb_operation_put(operation);
0174 
0175     return ret;
0176 }
0177 
0178 int gb_control_mode_switch_operation(struct gb_control *control)
0179 {
0180     struct gb_operation *operation;
0181     int ret;
0182 
0183     operation = gb_operation_create_core(control->connection,
0184                          GB_CONTROL_TYPE_MODE_SWITCH,
0185                          0, 0,
0186                          GB_OPERATION_FLAG_UNIDIRECTIONAL,
0187                          GFP_KERNEL);
0188     if (!operation)
0189         return -ENOMEM;
0190 
0191     ret = gb_operation_request_send_sync(operation);
0192     if (ret)
0193         dev_err(&control->dev, "failed to send mode switch: %d\n", ret);
0194 
0195     gb_operation_put(operation);
0196 
0197     return ret;
0198 }
0199 
0200 static int gb_control_bundle_pm_status_map(u8 status)
0201 {
0202     switch (status) {
0203     case GB_CONTROL_BUNDLE_PM_INVAL:
0204         return -EINVAL;
0205     case GB_CONTROL_BUNDLE_PM_BUSY:
0206         return -EBUSY;
0207     case GB_CONTROL_BUNDLE_PM_NA:
0208         return -ENOMSG;
0209     case GB_CONTROL_BUNDLE_PM_FAIL:
0210     default:
0211         return -EREMOTEIO;
0212     }
0213 }
0214 
0215 int gb_control_bundle_suspend(struct gb_control *control, u8 bundle_id)
0216 {
0217     struct gb_control_bundle_pm_request request;
0218     struct gb_control_bundle_pm_response response;
0219     int ret;
0220 
0221     request.bundle_id = bundle_id;
0222     ret = gb_operation_sync(control->connection,
0223                 GB_CONTROL_TYPE_BUNDLE_SUSPEND, &request,
0224                 sizeof(request), &response, sizeof(response));
0225     if (ret) {
0226         dev_err(&control->dev, "failed to send bundle %u suspend: %d\n",
0227             bundle_id, ret);
0228         return ret;
0229     }
0230 
0231     if (response.status != GB_CONTROL_BUNDLE_PM_OK) {
0232         dev_err(&control->dev, "failed to suspend bundle %u: %d\n",
0233             bundle_id, response.status);
0234         return gb_control_bundle_pm_status_map(response.status);
0235     }
0236 
0237     return 0;
0238 }
0239 
0240 int gb_control_bundle_resume(struct gb_control *control, u8 bundle_id)
0241 {
0242     struct gb_control_bundle_pm_request request;
0243     struct gb_control_bundle_pm_response response;
0244     int ret;
0245 
0246     request.bundle_id = bundle_id;
0247     ret = gb_operation_sync(control->connection,
0248                 GB_CONTROL_TYPE_BUNDLE_RESUME, &request,
0249                 sizeof(request), &response, sizeof(response));
0250     if (ret) {
0251         dev_err(&control->dev, "failed to send bundle %u resume: %d\n",
0252             bundle_id, ret);
0253         return ret;
0254     }
0255 
0256     if (response.status != GB_CONTROL_BUNDLE_PM_OK) {
0257         dev_err(&control->dev, "failed to resume bundle %u: %d\n",
0258             bundle_id, response.status);
0259         return gb_control_bundle_pm_status_map(response.status);
0260     }
0261 
0262     return 0;
0263 }
0264 
0265 int gb_control_bundle_deactivate(struct gb_control *control, u8 bundle_id)
0266 {
0267     struct gb_control_bundle_pm_request request;
0268     struct gb_control_bundle_pm_response response;
0269     int ret;
0270 
0271     request.bundle_id = bundle_id;
0272     ret = gb_operation_sync(control->connection,
0273                 GB_CONTROL_TYPE_BUNDLE_DEACTIVATE, &request,
0274                 sizeof(request), &response, sizeof(response));
0275     if (ret) {
0276         dev_err(&control->dev,
0277             "failed to send bundle %u deactivate: %d\n", bundle_id,
0278             ret);
0279         return ret;
0280     }
0281 
0282     if (response.status != GB_CONTROL_BUNDLE_PM_OK) {
0283         dev_err(&control->dev, "failed to deactivate bundle %u: %d\n",
0284             bundle_id, response.status);
0285         return gb_control_bundle_pm_status_map(response.status);
0286     }
0287 
0288     return 0;
0289 }
0290 
0291 int gb_control_bundle_activate(struct gb_control *control, u8 bundle_id)
0292 {
0293     struct gb_control_bundle_pm_request request;
0294     struct gb_control_bundle_pm_response response;
0295     int ret;
0296 
0297     if (!control->has_bundle_activate)
0298         return 0;
0299 
0300     request.bundle_id = bundle_id;
0301     ret = gb_operation_sync(control->connection,
0302                 GB_CONTROL_TYPE_BUNDLE_ACTIVATE, &request,
0303                 sizeof(request), &response, sizeof(response));
0304     if (ret) {
0305         dev_err(&control->dev,
0306             "failed to send bundle %u activate: %d\n", bundle_id,
0307             ret);
0308         return ret;
0309     }
0310 
0311     if (response.status != GB_CONTROL_BUNDLE_PM_OK) {
0312         dev_err(&control->dev, "failed to activate bundle %u: %d\n",
0313             bundle_id, response.status);
0314         return gb_control_bundle_pm_status_map(response.status);
0315     }
0316 
0317     return 0;
0318 }
0319 
0320 static int gb_control_interface_pm_status_map(u8 status)
0321 {
0322     switch (status) {
0323     case GB_CONTROL_INTF_PM_BUSY:
0324         return -EBUSY;
0325     case GB_CONTROL_INTF_PM_NA:
0326         return -ENOMSG;
0327     default:
0328         return -EREMOTEIO;
0329     }
0330 }
0331 
0332 int gb_control_interface_suspend_prepare(struct gb_control *control)
0333 {
0334     struct gb_control_intf_pm_response response;
0335     int ret;
0336 
0337     ret = gb_operation_sync(control->connection,
0338                 GB_CONTROL_TYPE_INTF_SUSPEND_PREPARE, NULL, 0,
0339                 &response, sizeof(response));
0340     if (ret) {
0341         dev_err(&control->dev,
0342             "failed to send interface suspend prepare: %d\n", ret);
0343         return ret;
0344     }
0345 
0346     if (response.status != GB_CONTROL_INTF_PM_OK) {
0347         dev_err(&control->dev, "interface error while preparing suspend: %d\n",
0348             response.status);
0349         return gb_control_interface_pm_status_map(response.status);
0350     }
0351 
0352     return 0;
0353 }
0354 
0355 int gb_control_interface_deactivate_prepare(struct gb_control *control)
0356 {
0357     struct gb_control_intf_pm_response response;
0358     int ret;
0359 
0360     ret = gb_operation_sync(control->connection,
0361                 GB_CONTROL_TYPE_INTF_DEACTIVATE_PREPARE, NULL,
0362                 0, &response, sizeof(response));
0363     if (ret) {
0364         dev_err(&control->dev, "failed to send interface deactivate prepare: %d\n",
0365             ret);
0366         return ret;
0367     }
0368 
0369     if (response.status != GB_CONTROL_INTF_PM_OK) {
0370         dev_err(&control->dev, "interface error while preparing deactivate: %d\n",
0371             response.status);
0372         return gb_control_interface_pm_status_map(response.status);
0373     }
0374 
0375     return 0;
0376 }
0377 
0378 int gb_control_interface_hibernate_abort(struct gb_control *control)
0379 {
0380     struct gb_control_intf_pm_response response;
0381     int ret;
0382 
0383     ret = gb_operation_sync(control->connection,
0384                 GB_CONTROL_TYPE_INTF_HIBERNATE_ABORT, NULL, 0,
0385                 &response, sizeof(response));
0386     if (ret) {
0387         dev_err(&control->dev,
0388             "failed to send interface aborting hibernate: %d\n",
0389             ret);
0390         return ret;
0391     }
0392 
0393     if (response.status != GB_CONTROL_INTF_PM_OK) {
0394         dev_err(&control->dev, "interface error while aborting hibernate: %d\n",
0395             response.status);
0396         return gb_control_interface_pm_status_map(response.status);
0397     }
0398 
0399     return 0;
0400 }
0401 
0402 static ssize_t vendor_string_show(struct device *dev,
0403                   struct device_attribute *attr, char *buf)
0404 {
0405     struct gb_control *control = to_gb_control(dev);
0406 
0407     return scnprintf(buf, PAGE_SIZE, "%s\n", control->vendor_string);
0408 }
0409 static DEVICE_ATTR_RO(vendor_string);
0410 
0411 static ssize_t product_string_show(struct device *dev,
0412                    struct device_attribute *attr, char *buf)
0413 {
0414     struct gb_control *control = to_gb_control(dev);
0415 
0416     return scnprintf(buf, PAGE_SIZE, "%s\n", control->product_string);
0417 }
0418 static DEVICE_ATTR_RO(product_string);
0419 
0420 static struct attribute *control_attrs[] = {
0421     &dev_attr_vendor_string.attr,
0422     &dev_attr_product_string.attr,
0423     NULL,
0424 };
0425 ATTRIBUTE_GROUPS(control);
0426 
0427 static void gb_control_release(struct device *dev)
0428 {
0429     struct gb_control *control = to_gb_control(dev);
0430 
0431     gb_connection_destroy(control->connection);
0432 
0433     kfree(control->vendor_string);
0434     kfree(control->product_string);
0435 
0436     kfree(control);
0437 }
0438 
0439 struct device_type greybus_control_type = {
0440     .name =     "greybus_control",
0441     .release =  gb_control_release,
0442 };
0443 
0444 struct gb_control *gb_control_create(struct gb_interface *intf)
0445 {
0446     struct gb_connection *connection;
0447     struct gb_control *control;
0448 
0449     control = kzalloc(sizeof(*control), GFP_KERNEL);
0450     if (!control)
0451         return ERR_PTR(-ENOMEM);
0452 
0453     control->intf = intf;
0454 
0455     connection = gb_connection_create_control(intf);
0456     if (IS_ERR(connection)) {
0457         dev_err(&intf->dev,
0458             "failed to create control connection: %ld\n",
0459             PTR_ERR(connection));
0460         kfree(control);
0461         return ERR_CAST(connection);
0462     }
0463 
0464     control->connection = connection;
0465 
0466     control->dev.parent = &intf->dev;
0467     control->dev.bus = &greybus_bus_type;
0468     control->dev.type = &greybus_control_type;
0469     control->dev.groups = control_groups;
0470     control->dev.dma_mask = intf->dev.dma_mask;
0471     device_initialize(&control->dev);
0472     dev_set_name(&control->dev, "%s.ctrl", dev_name(&intf->dev));
0473 
0474     gb_connection_set_data(control->connection, control);
0475 
0476     return control;
0477 }
0478 
0479 int gb_control_enable(struct gb_control *control)
0480 {
0481     int ret;
0482 
0483     dev_dbg(&control->connection->intf->dev, "%s\n", __func__);
0484 
0485     ret = gb_connection_enable_tx(control->connection);
0486     if (ret) {
0487         dev_err(&control->connection->intf->dev,
0488             "failed to enable control connection: %d\n",
0489             ret);
0490         return ret;
0491     }
0492 
0493     ret = gb_control_get_version(control);
0494     if (ret)
0495         goto err_disable_connection;
0496 
0497     if (control->protocol_major > 0 || control->protocol_minor > 1)
0498         control->has_bundle_version = true;
0499 
0500     /* FIXME: use protocol version instead */
0501     if (!(control->intf->quirks & GB_INTERFACE_QUIRK_NO_BUNDLE_ACTIVATE))
0502         control->has_bundle_activate = true;
0503 
0504     return 0;
0505 
0506 err_disable_connection:
0507     gb_connection_disable(control->connection);
0508 
0509     return ret;
0510 }
0511 
0512 void gb_control_disable(struct gb_control *control)
0513 {
0514     dev_dbg(&control->connection->intf->dev, "%s\n", __func__);
0515 
0516     if (control->intf->disconnected)
0517         gb_connection_disable_forced(control->connection);
0518     else
0519         gb_connection_disable(control->connection);
0520 }
0521 
0522 int gb_control_suspend(struct gb_control *control)
0523 {
0524     gb_connection_disable(control->connection);
0525 
0526     return 0;
0527 }
0528 
0529 int gb_control_resume(struct gb_control *control)
0530 {
0531     int ret;
0532 
0533     ret = gb_connection_enable_tx(control->connection);
0534     if (ret) {
0535         dev_err(&control->connection->intf->dev,
0536             "failed to enable control connection: %d\n", ret);
0537         return ret;
0538     }
0539 
0540     return 0;
0541 }
0542 
0543 int gb_control_add(struct gb_control *control)
0544 {
0545     int ret;
0546 
0547     ret = device_add(&control->dev);
0548     if (ret) {
0549         dev_err(&control->dev,
0550             "failed to register control device: %d\n",
0551             ret);
0552         return ret;
0553     }
0554 
0555     return 0;
0556 }
0557 
0558 void gb_control_del(struct gb_control *control)
0559 {
0560     if (device_is_registered(&control->dev))
0561         device_del(&control->dev);
0562 }
0563 
0564 struct gb_control *gb_control_get(struct gb_control *control)
0565 {
0566     get_device(&control->dev);
0567 
0568     return control;
0569 }
0570 
0571 void gb_control_put(struct gb_control *control)
0572 {
0573     put_device(&control->dev);
0574 }
0575 
0576 void gb_control_mode_switch_prepare(struct gb_control *control)
0577 {
0578     gb_connection_mode_switch_prepare(control->connection);
0579 }
0580 
0581 void gb_control_mode_switch_complete(struct gb_control *control)
0582 {
0583     gb_connection_mode_switch_complete(control->connection);
0584 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!