drivers/greybus/module.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Greybus Module code
   4  *
   5  * Copyright 2016 Google Inc.
   6  * Copyright 2016 Linaro Ltd.
   7  */
   8
   9 #include <linux/greybus.h>
  10 #include "greybus_trace.h"
  11
  12 static ssize_t eject_store(struct device *dev,
  13                            struct device_attribute *attr,
  14                            const char *buf, size_t len)
  15 {
  16         struct gb_module *module = to_gb_module(dev);
  17         struct gb_interface *intf;
  18         size_t i;
  19         long val;
  20         int ret;
  21
  22         ret = kstrtol(buf, 0, &val);
  23         if (ret)
  24                 return ret;
  25
  26         if (!val)
  27                 return len;
  28
  29         for (i = 0; i < module->num_interfaces; ++i) {
  30                 intf = module->interfaces[i];
  31
  32                 mutex_lock(&intf->mutex);
  33                 /* Set flag to prevent concurrent activation. */
  34                 intf->ejected = true;
  35                 gb_interface_disable(intf);
  36                 gb_interface_deactivate(intf);
  37                 mutex_unlock(&intf->mutex);
  38         }
  39
  40         /* Tell the SVC to eject the primary interface. */
  41         ret = gb_svc_intf_eject(module->hd->svc, module->module_id);
  42         if (ret)
  43                 return ret;
  44
  45         return len;
  46 }
  47 static DEVICE_ATTR_WO(eject);
  48
  49 static ssize_t module_id_show(struct device *dev,
  50                               struct device_attribute *attr, char *buf)
  51 {
  52         struct gb_module *module = to_gb_module(dev);
  53
  54         return sprintf(buf, "%u\n", module->module_id);
  55 }
  56 static DEVICE_ATTR_RO(module_id);
  57
  58 static ssize_t num_interfaces_show(struct device *dev,
  59                                    struct device_attribute *attr, char *buf)
  60 {
  61         struct gb_module *module = to_gb_module(dev);
  62
  63         return sprintf(buf, "%zu\n", module->num_interfaces);
  64 }
  65 static DEVICE_ATTR_RO(num_interfaces);
  66
  67 static struct attribute *module_attrs[] = {
  68         &dev_attr_eject.attr,
  69         &dev_attr_module_id.attr,
  70         &dev_attr_num_interfaces.attr,
  71         NULL,
  72 };
  73 ATTRIBUTE_GROUPS(module);
  74
  75 static void gb_module_release(struct device *dev)
  76 {
  77         struct gb_module *module = to_gb_module(dev);
  78
  79         trace_gb_module_release(module);
  80
  81         kfree(module);
  82 }
  83
  84 struct device_type greybus_module_type = {
  85         .name           = "greybus_module",
  86         .release        = gb_module_release,
  87 };
  88
  89 struct gb_module *gb_module_create(struct gb_host_device *hd, u8 module_id,
  90                                    size_t num_interfaces)
  91 {
  92         struct gb_interface *intf;
  93         struct gb_module *module;
  94         int i;
  95
  96         module = kzalloc(struct_size(module, interfaces, num_interfaces),
  97                          GFP_KERNEL);
  98         if (!module)
  99                 return NULL;
 100
 101         module->hd = hd;
 102         module->module_id = module_id;
 103         module->num_interfaces = num_interfaces;
 104
 105         module->dev.parent = &hd->dev;
 106         module->dev.bus = &greybus_bus_type;
 107         module->dev.type = &greybus_module_type;
 108         module->dev.groups = module_groups;
 109         module->dev.dma_mask = hd->dev.dma_mask;
 110         device_initialize(&module->dev);
 111         dev_set_name(&module->dev, "%d-%u", hd->bus_id, module_id);
 112
 113         trace_gb_module_create(module);
 114
 115         for (i = 0; i < num_interfaces; ++i) {
 116                 intf = gb_interface_create(module, module_id + i);
 117                 if (!intf) {
 118                         dev_err(&module->dev, "failed to create interface %u\n",
 119                                 module_id + i);
 120                         goto err_put_interfaces;
 121                 }
 122                 module->interfaces[i] = intf;
 123         }
 124
 125         return module;
 126
 127 err_put_interfaces:
 128         for (--i; i >= 0; --i)
 129                 gb_interface_put(module->interfaces[i]);
 130
 131         put_device(&module->dev);
 132
 133         return NULL;
 134 }
 135
 136 /*
 137  * Register and enable an interface after first attempting to activate it.
 138  */
 139 static void gb_module_register_interface(struct gb_interface *intf)
 140 {
 141         struct gb_module *module = intf->module;
 142         u8 intf_id = intf->interface_id;
 143         int ret;
 144
 145         mutex_lock(&intf->mutex);
 146
 147         ret = gb_interface_activate(intf);
 148         if (ret) {
 149                 if (intf->type != GB_INTERFACE_TYPE_DUMMY) {
 150                         dev_err(&module->dev,
 151                                 "failed to activate interface %u: %d\n",
 152                                 intf_id, ret);
 153                 }
 154
 155                 gb_interface_add(intf);
 156                 goto err_unlock;
 157         }
 158
 159         ret = gb_interface_add(intf);
 160         if (ret)
 161                 goto err_interface_deactivate;
 162
 163         ret = gb_interface_enable(intf);
 164         if (ret) {
 165                 dev_err(&module->dev, "failed to enable interface %u: %d\n",
 166                         intf_id, ret);
 167                 goto err_interface_deactivate;
 168         }
 169
 170         mutex_unlock(&intf->mutex);
 171
 172         return;
 173
 174 err_interface_deactivate:
 175         gb_interface_deactivate(intf);
 176 err_unlock:
 177         mutex_unlock(&intf->mutex);
 178 }
 179
 180 static void gb_module_deregister_interface(struct gb_interface *intf)
 181 {
 182         /* Mark as disconnected to prevent I/O during disable. */
 183         if (intf->module->disconnected)
 184                 intf->disconnected = true;
 185
 186         mutex_lock(&intf->mutex);
 187         intf->removed = true;
 188         gb_interface_disable(intf);
 189         gb_interface_deactivate(intf);
 190         mutex_unlock(&intf->mutex);
 191
 192         gb_interface_del(intf);
 193 }
 194
 195 /* Register a module and its interfaces. */
 196 int gb_module_add(struct gb_module *module)
 197 {
 198         size_t i;
 199         int ret;
 200
 201         ret = device_add(&module->dev);
 202         if (ret) {
 203                 dev_err(&module->dev, "failed to register module: %d\n", ret);
 204                 return ret;
 205         }
 206
 207         trace_gb_module_add(module);
 208
 209         for (i = 0; i < module->num_interfaces; ++i)
 210                 gb_module_register_interface(module->interfaces[i]);
 211
 212         return 0;
 213 }
 214
 215 /* Deregister a module and its interfaces. */
 216 void gb_module_del(struct gb_module *module)
 217 {
 218         size_t i;
 219
 220         for (i = 0; i < module->num_interfaces; ++i)
 221                 gb_module_deregister_interface(module->interfaces[i]);
 222
 223         trace_gb_module_del(module);
 224
 225         device_del(&module->dev);
 226 }
 227
 228 void gb_module_put(struct gb_module *module)
 229 {
 230         size_t i;
 231
 232         for (i = 0; i < module->num_interfaces; ++i)
 233                 gb_interface_put(module->interfaces[i]);
 234
 235         put_device(&module->dev);
 236 }