drivers/greybus/module.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Greybus Module code
0004  *
0005  * Copyright 2016 Google Inc.
0006  * Copyright 2016 Linaro Ltd.
0007  */
0008
0009 #include <linux/greybus.h>
0010 #include "greybus_trace.h"
0011
0012 static ssize_t eject_store(struct device *dev,
0013                struct device_attribute *attr,
0014                const char *buf, size_t len)
0015 {
0016     struct gb_module *module = to_gb_module(dev);
0017     struct gb_interface *intf;
0018     size_t i;
0019     long val;
0020     int ret;
0021
0022     ret = kstrtol(buf, 0, &val);
0023     if (ret)
0024         return ret;
0025
0026     if (!val)
0027         return len;
0028
0029     for (i = 0; i < module->num_interfaces; ++i) {
0030         intf = module->interfaces[i];
0031
0032         mutex_lock(&intf->mutex);
0033         /* Set flag to prevent concurrent activation. */
0034         intf->ejected = true;
0035         gb_interface_disable(intf);
0036         gb_interface_deactivate(intf);
0037         mutex_unlock(&intf->mutex);
0038     }
0039
0040     /* Tell the SVC to eject the primary interface. */
0041     ret = gb_svc_intf_eject(module->hd->svc, module->module_id);
0042     if (ret)
0043         return ret;
0044
0045     return len;
0046 }
0047 static DEVICE_ATTR_WO(eject);
0048
0049 static ssize_t module_id_show(struct device *dev,
0050                   struct device_attribute *attr, char *buf)
0051 {
0052     struct gb_module *module = to_gb_module(dev);
0053
0054     return sprintf(buf, "%u\n", module->module_id);
0055 }
0056 static DEVICE_ATTR_RO(module_id);
0057
0058 static ssize_t num_interfaces_show(struct device *dev,
0059                    struct device_attribute *attr, char *buf)
0060 {
0061     struct gb_module *module = to_gb_module(dev);
0062
0063     return sprintf(buf, "%zu\n", module->num_interfaces);
0064 }
0065 static DEVICE_ATTR_RO(num_interfaces);
0066
0067 static struct attribute *module_attrs[] = {
0068     &dev_attr_eject.attr,
0069     &dev_attr_module_id.attr,
0070     &dev_attr_num_interfaces.attr,
0071     NULL,
0072 };
0073 ATTRIBUTE_GROUPS(module);
0074
0075 static void gb_module_release(struct device *dev)
0076 {
0077     struct gb_module *module = to_gb_module(dev);
0078
0079     trace_gb_module_release(module);
0080
0081     kfree(module);
0082 }
0083
0084 struct device_type greybus_module_type = {
0085     .name       = "greybus_module",
0086     .release    = gb_module_release,
0087 };
0088
0089 struct gb_module *gb_module_create(struct gb_host_device *hd, u8 module_id,
0090                    size_t num_interfaces)
0091 {
0092     struct gb_interface *intf;
0093     struct gb_module *module;
0094     int i;
0095
0096     module = kzalloc(struct_size(module, interfaces, num_interfaces),
0097              GFP_KERNEL);
0098     if (!module)
0099         return NULL;
0100
0101     module->hd = hd;
0102     module->module_id = module_id;
0103     module->num_interfaces = num_interfaces;
0104
0105     module->dev.parent = &hd->dev;
0106     module->dev.bus = &greybus_bus_type;
0107     module->dev.type = &greybus_module_type;
0108     module->dev.groups = module_groups;
0109     module->dev.dma_mask = hd->dev.dma_mask;
0110     device_initialize(&module->dev);
0111     dev_set_name(&module->dev, "%d-%u", hd->bus_id, module_id);
0112
0113     trace_gb_module_create(module);
0114
0115     for (i = 0; i < num_interfaces; ++i) {
0116         intf = gb_interface_create(module, module_id + i);
0117         if (!intf) {
0118             dev_err(&module->dev, "failed to create interface %u\n",
0119                 module_id + i);
0120             goto err_put_interfaces;
0121         }
0122         module->interfaces[i] = intf;
0123     }
0124
0125     return module;
0126
0127 err_put_interfaces:
0128     for (--i; i >= 0; --i)
0129         gb_interface_put(module->interfaces[i]);
0130
0131     put_device(&module->dev);
0132
0133     return NULL;
0134 }
0135
0136 /*
0137  * Register and enable an interface after first attempting to activate it.
0138  */
0139 static void gb_module_register_interface(struct gb_interface *intf)
0140 {
0141     struct gb_module *module = intf->module;
0142     u8 intf_id = intf->interface_id;
0143     int ret;
0144
0145     mutex_lock(&intf->mutex);
0146
0147     ret = gb_interface_activate(intf);
0148     if (ret) {
0149         if (intf->type != GB_INTERFACE_TYPE_DUMMY) {
0150             dev_err(&module->dev,
0151                 "failed to activate interface %u: %d\n",
0152                 intf_id, ret);
0153         }
0154
0155         gb_interface_add(intf);
0156         goto err_unlock;
0157     }
0158
0159     ret = gb_interface_add(intf);
0160     if (ret)
0161         goto err_interface_deactivate;
0162
0163     ret = gb_interface_enable(intf);
0164     if (ret) {
0165         dev_err(&module->dev, "failed to enable interface %u: %d\n",
0166             intf_id, ret);
0167         goto err_interface_deactivate;
0168     }
0169
0170     mutex_unlock(&intf->mutex);
0171
0172     return;
0173
0174 err_interface_deactivate:
0175     gb_interface_deactivate(intf);
0176 err_unlock:
0177     mutex_unlock(&intf->mutex);
0178 }
0179
0180 static void gb_module_deregister_interface(struct gb_interface *intf)
0181 {
0182     /* Mark as disconnected to prevent I/O during disable. */
0183     if (intf->module->disconnected)
0184         intf->disconnected = true;
0185
0186     mutex_lock(&intf->mutex);
0187     intf->removed = true;
0188     gb_interface_disable(intf);
0189     gb_interface_deactivate(intf);
0190     mutex_unlock(&intf->mutex);
0191
0192     gb_interface_del(intf);
0193 }
0194
0195 /* Register a module and its interfaces. */
0196 int gb_module_add(struct gb_module *module)
0197 {
0198     size_t i;
0199     int ret;
0200
0201     ret = device_add(&module->dev);
0202     if (ret) {
0203         dev_err(&module->dev, "failed to register module: %d\n", ret);
0204         return ret;
0205     }
0206
0207     trace_gb_module_add(module);
0208
0209     for (i = 0; i < module->num_interfaces; ++i)
0210         gb_module_register_interface(module->interfaces[i]);
0211
0212     return 0;
0213 }
0214
0215 /* Deregister a module and its interfaces. */
0216 void gb_module_del(struct gb_module *module)
0217 {
0218     size_t i;
0219
0220     for (i = 0; i < module->num_interfaces; ++i)
0221         gb_module_deregister_interface(module->interfaces[i]);
0222
0223     trace_gb_module_del(module);
0224
0225     device_del(&module->dev);
0226 }
0227
0228 void gb_module_put(struct gb_module *module)
0229 {
0230     size_t i;
0231
0232     for (i = 0; i < module->num_interfaces; ++i)
0233         gb_interface_put(module->interfaces[i]);
0234
0235     put_device(&module->dev);
0236 }