Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Greybus module code |
| 3 | * |
| 4 | * Copyright 2014 Google Inc. |
| 5 | * Copyright 2014 Linaro Ltd. |
| 6 | * |
| 7 | * Released under the GPLv2 only. |
| 8 | */ |
| 9 | |
| 10 | #include "greybus.h" |
| 11 | |
| 12 | |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 13 | /* module sysfs attributes */ |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 14 | static ssize_t epm_show(struct device *dev, struct device_attribute *attr, |
| 15 | char *buf) |
| 16 | { |
Greg Kroah-Hartman | 764e824 | 2015-04-07 20:26:30 +0200 | [diff] [blame] | 17 | // FIXME |
| 18 | // Implement something here when we have a working control protocol |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 19 | return sprintf(buf, "1\n"); |
| 20 | } |
| 21 | |
| 22 | static ssize_t epm_store(struct device *dev, struct device_attribute *attr, |
| 23 | const char *buf, size_t size) |
| 24 | { |
Greg Kroah-Hartman | 764e824 | 2015-04-07 20:26:30 +0200 | [diff] [blame] | 25 | // FIXME |
| 26 | // Implement something here when we have a working control protocol |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 27 | return 0; |
| 28 | } |
| 29 | static DEVICE_ATTR_RW(epm); |
| 30 | |
Greg Kroah-Hartman | 764e824 | 2015-04-07 20:26:30 +0200 | [diff] [blame] | 31 | static ssize_t power_control_show(struct device *dev, |
| 32 | struct device_attribute *addr, char *buf) |
| 33 | { |
| 34 | // FIXME |
| 35 | // Implement something here when we have a working control protocol |
| 36 | return sprintf(buf, "1\n"); |
| 37 | } |
| 38 | |
| 39 | static ssize_t power_control_store(struct device *dev, |
| 40 | struct device_attribute *attr, |
| 41 | const char *buf, size_t size) |
| 42 | { |
| 43 | // FIXME |
| 44 | // Implement something here when we have a working control protocol |
| 45 | return 0; |
| 46 | } |
| 47 | static DEVICE_ATTR_RW(power_control); |
| 48 | |
| 49 | static ssize_t present_show(struct device *dev, |
| 50 | struct device_attribute *addr, char *buf) |
| 51 | { |
| 52 | // FIXME |
| 53 | // Implement something here when we have a working control protocol |
| 54 | return sprintf(buf, "1\n"); |
| 55 | } |
| 56 | |
| 57 | static ssize_t present_store(struct device *dev, struct device_attribute *attr, |
| 58 | const char *buf, size_t size) |
| 59 | { |
| 60 | // FIXME |
| 61 | // Implement something here when we have a working control protocol |
| 62 | return 0; |
| 63 | } |
| 64 | static DEVICE_ATTR_RW(present); |
| 65 | |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 66 | static struct attribute *module_attrs[] = { |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 67 | &dev_attr_epm.attr, |
Greg Kroah-Hartman | 764e824 | 2015-04-07 20:26:30 +0200 | [diff] [blame] | 68 | &dev_attr_power_control.attr, |
| 69 | &dev_attr_present.attr, |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 70 | NULL, |
| 71 | }; |
| 72 | ATTRIBUTE_GROUPS(module); |
| 73 | |
Viresh Kumar | c16b63e8 | 2015-05-20 16:48:04 +0530 | [diff] [blame] | 74 | static void gb_module_release(struct device *dev) |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 75 | { |
| 76 | struct gb_module *module = to_gb_module(dev); |
| 77 | |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 78 | kfree(module); |
| 79 | } |
| 80 | |
| 81 | struct device_type greybus_module_type = { |
| 82 | .name = "greybus_module", |
Viresh Kumar | c16b63e8 | 2015-05-20 16:48:04 +0530 | [diff] [blame] | 83 | .release = gb_module_release, |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 84 | }; |
| 85 | |
Greg Kroah-Hartman | a4d9150 | 2015-04-07 20:27:15 +0200 | [diff] [blame] | 86 | struct module_find { |
| 87 | struct gb_endo *endo; |
| 88 | u8 module_id; |
| 89 | }; |
| 90 | |
Greg Kroah-Hartman | e564671 | 2014-12-24 13:01:46 -0800 | [diff] [blame] | 91 | static int module_find(struct device *dev, void *data) |
| 92 | { |
| 93 | struct gb_module *module; |
Greg Kroah-Hartman | a4d9150 | 2015-04-07 20:27:15 +0200 | [diff] [blame] | 94 | struct module_find *find = data; |
Greg Kroah-Hartman | e564671 | 2014-12-24 13:01:46 -0800 | [diff] [blame] | 95 | |
| 96 | if (!is_gb_module(dev)) |
| 97 | return 0; |
| 98 | |
| 99 | module = to_gb_module(dev); |
Greg Kroah-Hartman | a4d9150 | 2015-04-07 20:27:15 +0200 | [diff] [blame] | 100 | if ((module->module_id == find->module_id) && |
| 101 | (module->dev.parent == &find->endo->dev)) |
Greg Kroah-Hartman | e564671 | 2014-12-24 13:01:46 -0800 | [diff] [blame] | 102 | return 1; |
| 103 | |
| 104 | return 0; |
| 105 | } |
| 106 | |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 107 | /* |
| 108 | * Search the list of modules in the system. If one is found, return it, with |
| 109 | * the reference count incremented. |
| 110 | */ |
Greg Kroah-Hartman | a4d9150 | 2015-04-07 20:27:15 +0200 | [diff] [blame] | 111 | struct gb_module *gb_module_find(struct greybus_host_device *hd, u8 module_id) |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 112 | { |
Greg Kroah-Hartman | e564671 | 2014-12-24 13:01:46 -0800 | [diff] [blame] | 113 | struct device *dev; |
| 114 | struct gb_module *module = NULL; |
Greg Kroah-Hartman | a4d9150 | 2015-04-07 20:27:15 +0200 | [diff] [blame] | 115 | struct module_find find; |
| 116 | |
Viresh Kumar | 51e93ae | 2015-05-08 12:58:51 +0530 | [diff] [blame] | 117 | if (!module_id) |
| 118 | return NULL; |
| 119 | |
Greg Kroah-Hartman | a4d9150 | 2015-04-07 20:27:15 +0200 | [diff] [blame] | 120 | find.module_id = module_id; |
| 121 | find.endo = hd->endo; |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 122 | |
Greg Kroah-Hartman | e564671 | 2014-12-24 13:01:46 -0800 | [diff] [blame] | 123 | dev = bus_find_device(&greybus_bus_type, NULL, |
Greg Kroah-Hartman | a4d9150 | 2015-04-07 20:27:15 +0200 | [diff] [blame] | 124 | &find, module_find); |
Greg Kroah-Hartman | e564671 | 2014-12-24 13:01:46 -0800 | [diff] [blame] | 125 | if (dev) |
| 126 | module = to_gb_module(dev); |
| 127 | |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 128 | return module; |
| 129 | } |
| 130 | |
Greg Kroah-Hartman | a4d9150 | 2015-04-07 20:27:15 +0200 | [diff] [blame] | 131 | struct gb_module *gb_module_create(struct device *parent, u8 module_id) |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 132 | { |
| 133 | struct gb_module *module; |
| 134 | int retval; |
| 135 | |
| 136 | module = kzalloc(sizeof(*module), GFP_KERNEL); |
| 137 | if (!module) |
| 138 | return NULL; |
| 139 | |
| 140 | module->module_id = module_id; |
Greg Kroah-Hartman | a4d9150 | 2015-04-07 20:27:15 +0200 | [diff] [blame] | 141 | module->dev.parent = parent; |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 142 | module->dev.bus = &greybus_bus_type; |
| 143 | module->dev.type = &greybus_module_type; |
| 144 | module->dev.groups = module_groups; |
Greg Kroah-Hartman | a4d9150 | 2015-04-07 20:27:15 +0200 | [diff] [blame] | 145 | module->dev.dma_mask = parent->dma_mask; |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 146 | device_initialize(&module->dev); |
| 147 | dev_set_name(&module->dev, "%d", module_id); |
| 148 | |
| 149 | retval = device_add(&module->dev); |
| 150 | if (retval) { |
| 151 | pr_err("failed to add module device for id 0x%02hhx\n", |
| 152 | module_id); |
| 153 | put_device(&module->dev); |
| 154 | kfree(module); |
| 155 | return NULL; |
| 156 | } |
| 157 | |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 158 | return module; |
| 159 | } |
| 160 | |
Greg Kroah-Hartman | a4d9150 | 2015-04-07 20:27:15 +0200 | [diff] [blame] | 161 | static int module_remove(struct device *dev, void *data) |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 162 | { |
| 163 | struct gb_module *module; |
Greg Kroah-Hartman | a4d9150 | 2015-04-07 20:27:15 +0200 | [diff] [blame] | 164 | struct gb_endo *endo = data; |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 165 | |
Greg Kroah-Hartman | a4d9150 | 2015-04-07 20:27:15 +0200 | [diff] [blame] | 166 | if (!is_gb_module(dev)) |
| 167 | return 0; |
Greg Kroah-Hartman | df67155 | 2014-12-21 14:10:26 -0800 | [diff] [blame] | 168 | |
Greg Kroah-Hartman | a4d9150 | 2015-04-07 20:27:15 +0200 | [diff] [blame] | 169 | module = to_gb_module(dev); |
| 170 | if (module->dev.parent == &endo->dev) |
Viresh Kumar | 2352a73 | 2015-04-02 17:53:47 +0530 | [diff] [blame] | 171 | device_unregister(&module->dev); |
Greg Kroah-Hartman | a4d9150 | 2015-04-07 20:27:15 +0200 | [diff] [blame] | 172 | |
| 173 | return 0; |
Viresh Kumar | 2352a73 | 2015-04-02 17:53:47 +0530 | [diff] [blame] | 174 | } |
| 175 | |
Greg Kroah-Hartman | a4d9150 | 2015-04-07 20:27:15 +0200 | [diff] [blame] | 176 | void gb_module_remove_all(struct gb_endo *endo) |
| 177 | { |
| 178 | bus_for_each_dev(&greybus_bus_type, NULL, endo, module_remove); |
| 179 | } |