Greg Kroah-Hartman | de536e3 | 2014-08-31 16:17:04 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Greybus "AP" message loop handling |
| 3 | * |
| 4 | * Copyright 2014 Google Inc. |
Alex Elder | a46e967 | 2014-12-12 12:08:42 -0600 | [diff] [blame] | 5 | * Copyright 2014 Linaro Ltd. |
Greg Kroah-Hartman | de536e3 | 2014-08-31 16:17:04 -0700 | [diff] [blame] | 6 | * |
| 7 | * Released under the GPLv2 only. |
| 8 | */ |
| 9 | |
| 10 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 11 | |
| 12 | #include <linux/types.h> |
| 13 | #include <linux/module.h> |
| 14 | #include <linux/moduleparam.h> |
| 15 | #include <linux/kernel.h> |
| 16 | #include <linux/slab.h> |
| 17 | #include <linux/uaccess.h> |
Greg Kroah-Hartman | 45f3678 | 2014-09-14 11:40:35 -0700 | [diff] [blame] | 18 | #include <linux/workqueue.h> |
Greg Kroah-Hartman | de536e3 | 2014-08-31 16:17:04 -0700 | [diff] [blame] | 19 | #include <linux/device.h> |
Greg Kroah-Hartman | b9b2a46 | 2014-08-31 17:43:38 -0700 | [diff] [blame] | 20 | #include "svc_msg.h" |
Alex Elder | 05ad189 | 2014-09-09 13:55:03 -0500 | [diff] [blame] | 21 | #include "greybus_manifest.h" |
Greg Kroah-Hartman | de536e3 | 2014-08-31 16:17:04 -0700 | [diff] [blame] | 22 | #include "greybus.h" |
| 23 | |
Greg Kroah-Hartman | de536e3 | 2014-08-31 16:17:04 -0700 | [diff] [blame] | 24 | struct ap_msg { |
| 25 | u8 *data; |
Greg Kroah-Hartman | 68f1fc4 | 2014-09-07 13:12:11 -0700 | [diff] [blame] | 26 | size_t size; |
| 27 | struct greybus_host_device *hd; |
Greg Kroah-Hartman | 88929c5 | 2014-09-13 11:35:02 -0700 | [diff] [blame] | 28 | struct work_struct event; |
Greg Kroah-Hartman | de536e3 | 2014-08-31 16:17:04 -0700 | [diff] [blame] | 29 | }; |
| 30 | |
Greg Kroah-Hartman | 88929c5 | 2014-09-13 11:35:02 -0700 | [diff] [blame] | 31 | static struct workqueue_struct *ap_workqueue; |
Greg Kroah-Hartman | de536e3 | 2014-08-31 16:17:04 -0700 | [diff] [blame] | 32 | |
Matt Porter | 710ecb0 | 2014-09-18 15:25:41 -0400 | [diff] [blame] | 33 | static struct svc_msg *svc_msg_alloc(enum svc_function_id id) |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 34 | { |
| 35 | struct svc_msg *svc_msg; |
| 36 | |
| 37 | svc_msg = kzalloc((sizeof *svc_msg), GFP_KERNEL); |
| 38 | if (!svc_msg) |
| 39 | return NULL; |
| 40 | |
Matt Porter | 710ecb0 | 2014-09-18 15:25:41 -0400 | [diff] [blame] | 41 | // FIXME - verify we are only sending function IDs we should be |
| 42 | svc_msg->header.function_id = id; |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 43 | return svc_msg; |
| 44 | } |
| 45 | |
| 46 | static void svc_msg_free(struct svc_msg *svc_msg) |
| 47 | { |
| 48 | kfree(svc_msg); |
| 49 | } |
| 50 | |
| 51 | static int svc_msg_send(struct svc_msg *svc_msg, struct greybus_host_device *hd) |
| 52 | { |
| 53 | int retval; |
| 54 | |
| 55 | // FIXME - Do we need to do more than just pass it to the hd and then |
| 56 | // free it? |
Alex Elder | 0db32a6 | 2014-09-24 05:16:14 -0500 | [diff] [blame] | 57 | retval = hd->driver->submit_svc(svc_msg, hd); |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 58 | |
| 59 | svc_msg_free(svc_msg); |
| 60 | return retval; |
| 61 | } |
| 62 | |
| 63 | |
Greg Kroah-Hartman | 1db0a5f | 2014-12-12 17:10:17 -0500 | [diff] [blame] | 64 | int svc_set_route_send(struct gb_bundle *bundle, |
Viresh Kumar | a4040ab | 2014-11-19 17:24:57 +0530 | [diff] [blame] | 65 | struct greybus_host_device *hd) |
| 66 | { |
| 67 | struct svc_msg *svc_msg; |
| 68 | |
| 69 | svc_msg = svc_msg_alloc(SVC_FUNCTION_UNIPRO_NETWORK_MANAGEMENT); |
| 70 | if (!svc_msg) |
| 71 | return -ENOMEM; |
| 72 | |
Viresh Kumar | a4040ab | 2014-11-19 17:24:57 +0530 | [diff] [blame] | 73 | svc_msg->header.message_type = SVC_MSG_DATA; |
| 74 | svc_msg->header.payload_length = |
| 75 | cpu_to_le16(sizeof(struct svc_function_unipro_set_route)); |
Greg Kroah-Hartman | 1db0a5f | 2014-12-12 17:10:17 -0500 | [diff] [blame] | 76 | svc_msg->management.set_route.device_id = bundle->device_id; |
Viresh Kumar | a4040ab | 2014-11-19 17:24:57 +0530 | [diff] [blame] | 77 | |
| 78 | return svc_msg_send(svc_msg, hd); |
| 79 | } |
| 80 | |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 81 | static void svc_handshake(struct svc_function_handshake *handshake, |
Greg Kroah-Hartman | 00c52e4 | 2014-09-21 18:19:54 -0700 | [diff] [blame] | 82 | int payload_length, struct greybus_host_device *hd) |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 83 | { |
| 84 | struct svc_msg *svc_msg; |
| 85 | |
Viresh Kumar | 64e6929 | 2014-11-19 17:24:58 +0530 | [diff] [blame] | 86 | if (payload_length != sizeof(*handshake)) { |
Greg Kroah-Hartman | 00c52e4 | 2014-09-21 18:19:54 -0700 | [diff] [blame] | 87 | dev_err(hd->parent, |
| 88 | "Illegal size of svc handshake message %d\n", |
| 89 | payload_length); |
| 90 | return; |
| 91 | } |
| 92 | |
Matt Porter | e94e171 | 2014-09-18 15:25:42 -0400 | [diff] [blame] | 93 | /* A new SVC communication channel, let's verify a supported version */ |
Johan Hovold | 0b7534b | 2015-03-19 16:46:14 +0100 | [diff] [blame] | 94 | if ((handshake->version_major != GREYBUS_VERSION_MAJOR) || |
Matt Porter | e94e171 | 2014-09-18 15:25:42 -0400 | [diff] [blame] | 95 | (handshake->version_minor != GREYBUS_VERSION_MINOR)) { |
Johan Hovold | 0b7534b | 2015-03-19 16:46:14 +0100 | [diff] [blame] | 96 | dev_warn(hd->parent, |
| 97 | "received invalid greybus version %u.%u\n", |
Matt Porter | e94e171 | 2014-09-18 15:25:42 -0400 | [diff] [blame] | 98 | handshake->version_major, handshake->version_minor); |
| 99 | return; |
| 100 | } |
| 101 | |
| 102 | /* Validate that the handshake came from the SVC */ |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 103 | if (handshake->handshake_type != SVC_HANDSHAKE_SVC_HELLO) { |
| 104 | /* we don't know what to do with this, log it and return */ |
Greg Kroah-Hartman | 772149b | 2014-09-14 12:27:28 -0700 | [diff] [blame] | 105 | dev_dbg(hd->parent, "received invalid handshake type %d\n", |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 106 | handshake->handshake_type); |
| 107 | return; |
| 108 | } |
| 109 | |
| 110 | /* Send back a AP_HELLO message */ |
| 111 | svc_msg = svc_msg_alloc(SVC_FUNCTION_HANDSHAKE); |
| 112 | if (!svc_msg) |
| 113 | return; |
| 114 | |
Matt Porter | be5064c | 2014-09-22 15:51:49 -0400 | [diff] [blame] | 115 | svc_msg->header.message_type = SVC_MSG_DATA; |
| 116 | svc_msg->header.payload_length = |
Viresh Kumar | 64e6929 | 2014-11-19 17:24:58 +0530 | [diff] [blame] | 117 | cpu_to_le16(sizeof(*handshake)); |
Matt Porter | be5064c | 2014-09-22 15:51:49 -0400 | [diff] [blame] | 118 | svc_msg->handshake.version_major = GREYBUS_VERSION_MAJOR; |
| 119 | svc_msg->handshake.version_minor = GREYBUS_VERSION_MINOR; |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 120 | svc_msg->handshake.handshake_type = SVC_HANDSHAKE_AP_HELLO; |
Alex Elder | 525f146 | 2014-10-22 02:04:31 -0500 | [diff] [blame] | 121 | |
| 122 | (void)svc_msg_send(svc_msg, hd); |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 123 | } |
| 124 | |
| 125 | static void svc_management(struct svc_function_unipro_management *management, |
Greg Kroah-Hartman | 00c52e4 | 2014-09-21 18:19:54 -0700 | [diff] [blame] | 126 | int payload_length, struct greybus_host_device *hd) |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 127 | { |
Greg Kroah-Hartman | 4ab9b3c | 2014-12-19 14:56:31 -0800 | [diff] [blame] | 128 | struct gb_interface *intf; |
Alex Elder | c41b4f1 | 2014-10-22 02:04:32 -0500 | [diff] [blame] | 129 | int ret; |
Matt Porter | 6232b07 | 2014-10-21 22:43:31 -0400 | [diff] [blame] | 130 | |
Viresh Kumar | 64e6929 | 2014-11-19 17:24:58 +0530 | [diff] [blame] | 131 | if (payload_length != sizeof(*management)) { |
Greg Kroah-Hartman | 00c52e4 | 2014-09-21 18:19:54 -0700 | [diff] [blame] | 132 | dev_err(hd->parent, |
| 133 | "Illegal size of svc management message %d\n", |
| 134 | payload_length); |
| 135 | return; |
| 136 | } |
| 137 | |
Matt Porter | 98f4ab2 | 2014-10-21 01:52:27 -0400 | [diff] [blame] | 138 | switch (management->management_packet_type) { |
Alex Elder | 2d5e4fa | 2014-10-22 05:36:18 -0500 | [diff] [blame] | 139 | case SVC_MANAGEMENT_AP_ID: |
| 140 | hd->device_id = management->ap_id.device_id; |
| 141 | break; |
Matt Porter | 6232b07 | 2014-10-21 22:43:31 -0400 | [diff] [blame] | 142 | case SVC_MANAGEMENT_LINK_UP: |
Viresh Kumar | c9d9d0d | 2015-04-01 20:31:58 +0530 | [diff] [blame] | 143 | intf = gb_interface_find(hd, management->link_up.interface_id); |
Greg Kroah-Hartman | 4ab9b3c | 2014-12-19 14:56:31 -0800 | [diff] [blame] | 144 | if (!intf) { |
Viresh Kumar | c9d9d0d | 2015-04-01 20:31:58 +0530 | [diff] [blame] | 145 | dev_err(hd->parent, "Interface ID %d not found\n", |
| 146 | management->link_up.interface_id); |
Matt Porter | 6232b07 | 2014-10-21 22:43:31 -0400 | [diff] [blame] | 147 | return; |
| 148 | } |
Viresh Kumar | bb97ea8 | 2015-04-01 20:32:01 +0530 | [diff] [blame] | 149 | ret = gb_bundles_init(intf, management->link_up.device_id); |
Johan Hovold | fe4c0e5 | 2015-03-19 16:46:16 +0100 | [diff] [blame] | 150 | if (ret) { |
Greg Kroah-Hartman | 4ab9b3c | 2014-12-19 14:56:31 -0800 | [diff] [blame] | 151 | dev_err(hd->parent, |
Viresh Kumar | c9d9d0d | 2015-04-01 20:31:58 +0530 | [diff] [blame] | 152 | "error %d initializing bundles for interface %hhu\n", |
| 153 | ret, management->link_up.interface_id); |
Johan Hovold | fe4c0e5 | 2015-03-19 16:46:16 +0100 | [diff] [blame] | 154 | return; |
| 155 | } |
Matt Porter | 6232b07 | 2014-10-21 22:43:31 -0400 | [diff] [blame] | 156 | break; |
Matt Porter | 98f4ab2 | 2014-10-21 01:52:27 -0400 | [diff] [blame] | 157 | default: |
| 158 | dev_err(hd->parent, "Unhandled UniPro management message\n"); |
| 159 | } |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 160 | } |
| 161 | |
| 162 | static void svc_hotplug(struct svc_function_hotplug *hotplug, |
Greg Kroah-Hartman | d0cfd10 | 2014-09-21 19:10:39 -0700 | [diff] [blame] | 163 | int payload_length, struct greybus_host_device *hd) |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 164 | { |
Viresh Kumar | c9d9d0d | 2015-04-01 20:31:58 +0530 | [diff] [blame] | 165 | u8 interface_id = hotplug->interface_id; |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 166 | |
| 167 | switch (hotplug->hotplug_event) { |
| 168 | case SVC_HOTPLUG_EVENT: |
Viresh Kumar | c9d9d0d | 2015-04-01 20:31:58 +0530 | [diff] [blame] | 169 | /* Add a new interface to the system */ |
Greg Kroah-Hartman | d0cfd10 | 2014-09-21 19:10:39 -0700 | [diff] [blame] | 170 | if (payload_length < 0x03) { |
Johan Hovold | 69bae89 | 2015-03-19 16:46:15 +0100 | [diff] [blame] | 171 | /* Hotplug message is at least 3 bytes big */ |
Greg Kroah-Hartman | d0cfd10 | 2014-09-21 19:10:39 -0700 | [diff] [blame] | 172 | dev_err(hd->parent, |
| 173 | "Illegal size of svc hotplug message %d\n", |
| 174 | payload_length); |
| 175 | return; |
| 176 | } |
Viresh Kumar | c9d9d0d | 2015-04-01 20:31:58 +0530 | [diff] [blame] | 177 | dev_dbg(hd->parent, "interface id %d added\n", interface_id); |
Viresh Kumar | 51b5d8d | 2015-05-20 17:33:51 +0530 | [diff] [blame] | 178 | gb_interface_add(hd, interface_id, hotplug->data, |
Greg Kroah-Hartman | 13e6aac | 2014-12-19 14:56:35 -0800 | [diff] [blame] | 179 | payload_length - 0x02); |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 180 | break; |
| 181 | |
| 182 | case SVC_HOTUNPLUG_EVENT: |
Viresh Kumar | c9d9d0d | 2015-04-01 20:31:58 +0530 | [diff] [blame] | 183 | /* Remove a interface from the system */ |
Greg Kroah-Hartman | d0cfd10 | 2014-09-21 19:10:39 -0700 | [diff] [blame] | 184 | if (payload_length != 0x02) { |
| 185 | /* Hotunplug message is only 2 bytes big */ |
| 186 | dev_err(hd->parent, |
| 187 | "Illegal size of svc hotunplug message %d\n", |
| 188 | payload_length); |
| 189 | return; |
| 190 | } |
Viresh Kumar | c9d9d0d | 2015-04-01 20:31:58 +0530 | [diff] [blame] | 191 | dev_dbg(hd->parent, "interface id %d removed\n", interface_id); |
Viresh Kumar | 51b5d8d | 2015-05-20 17:33:51 +0530 | [diff] [blame] | 192 | gb_interface_remove(hd, interface_id); |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 193 | break; |
| 194 | |
| 195 | default: |
Greg Kroah-Hartman | 772149b | 2014-09-14 12:27:28 -0700 | [diff] [blame] | 196 | dev_err(hd->parent, |
Greg Kroah-Hartman | d0cfd10 | 2014-09-21 19:10:39 -0700 | [diff] [blame] | 197 | "Received invalid hotplug message type %d\n", |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 198 | hotplug->hotplug_event); |
| 199 | break; |
| 200 | } |
| 201 | } |
| 202 | |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 203 | static void svc_power(struct svc_function_power *power, |
Greg Kroah-Hartman | d0cfd10 | 2014-09-21 19:10:39 -0700 | [diff] [blame] | 204 | int payload_length, struct greybus_host_device *hd) |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 205 | { |
Viresh Kumar | c9d9d0d | 2015-04-01 20:31:58 +0530 | [diff] [blame] | 206 | u8 interface_id = power->interface_id; |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 207 | |
Greg Kroah-Hartman | d0cfd10 | 2014-09-21 19:10:39 -0700 | [diff] [blame] | 208 | /* |
| 209 | * The AP is only allowed to get a Battery Status message, not a Battery |
| 210 | * Status Request |
| 211 | */ |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 212 | if (power->power_type != SVC_POWER_BATTERY_STATUS) { |
Greg Kroah-Hartman | d0cfd10 | 2014-09-21 19:10:39 -0700 | [diff] [blame] | 213 | dev_err(hd->parent, "Received invalid power type %d\n", |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 214 | power->power_type); |
| 215 | return; |
| 216 | } |
| 217 | |
Greg Kroah-Hartman | d0cfd10 | 2014-09-21 19:10:39 -0700 | [diff] [blame] | 218 | /* |
| 219 | * As struct struct svc_function_power_battery_status_request is 0 bytes |
| 220 | * big, we can just check the union of the whole structure to validate |
| 221 | * the size of this message. |
| 222 | */ |
Viresh Kumar | 64e6929 | 2014-11-19 17:24:58 +0530 | [diff] [blame] | 223 | if (payload_length != sizeof(*power)) { |
Greg Kroah-Hartman | d0cfd10 | 2014-09-21 19:10:39 -0700 | [diff] [blame] | 224 | dev_err(hd->parent, |
| 225 | "Illegal size of svc power message %d\n", |
| 226 | payload_length); |
| 227 | return; |
| 228 | } |
| 229 | |
Viresh Kumar | c9d9d0d | 2015-04-01 20:31:58 +0530 | [diff] [blame] | 230 | dev_dbg(hd->parent, "power status for interface id %d is %d\n", |
| 231 | interface_id, power->status.status); |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 232 | |
| 233 | // FIXME - do something with the power information, like update our |
| 234 | // battery information... |
| 235 | } |
| 236 | |
| 237 | static void svc_epm(struct svc_function_epm *epm, |
Greg Kroah-Hartman | d0cfd10 | 2014-09-21 19:10:39 -0700 | [diff] [blame] | 238 | int payload_length, struct greybus_host_device *hd) |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 239 | { |
| 240 | /* What? An AP should not get this message */ |
Greg Kroah-Hartman | 772149b | 2014-09-14 12:27:28 -0700 | [diff] [blame] | 241 | dev_err(hd->parent, "Got an EPM message???\n"); |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 242 | } |
| 243 | |
| 244 | static void svc_suspend(struct svc_function_suspend *suspend, |
Greg Kroah-Hartman | d0cfd10 | 2014-09-21 19:10:39 -0700 | [diff] [blame] | 245 | int payload_length, struct greybus_host_device *hd) |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 246 | { |
| 247 | /* What? An AP should not get this message */ |
Greg Kroah-Hartman | 772149b | 2014-09-14 12:27:28 -0700 | [diff] [blame] | 248 | dev_err(hd->parent, "Got an suspend message???\n"); |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 249 | } |
Greg Kroah-Hartman | 68f1fc4 | 2014-09-07 13:12:11 -0700 | [diff] [blame] | 250 | |
Viresh Kumar | e2dabb7 | 2014-11-19 17:24:56 +0530 | [diff] [blame] | 251 | static struct svc_msg *convert_ap_message(struct ap_msg *ap_msg) |
Greg Kroah-Hartman | 68f1fc4 | 2014-09-07 13:12:11 -0700 | [diff] [blame] | 252 | { |
| 253 | struct svc_msg *svc_msg; |
Greg Kroah-Hartman | 00c52e4 | 2014-09-21 18:19:54 -0700 | [diff] [blame] | 254 | struct svc_msg_header *header; |
Viresh Kumar | e2dabb7 | 2014-11-19 17:24:56 +0530 | [diff] [blame] | 255 | struct greybus_host_device *hd = ap_msg->hd; |
Greg Kroah-Hartman | 68f1fc4 | 2014-09-07 13:12:11 -0700 | [diff] [blame] | 256 | |
| 257 | svc_msg = (struct svc_msg *)ap_msg->data; |
Greg Kroah-Hartman | 00c52e4 | 2014-09-21 18:19:54 -0700 | [diff] [blame] | 258 | header = &svc_msg->header; |
| 259 | |
| 260 | /* Validate the message type */ |
| 261 | if (header->message_type != SVC_MSG_DATA) { |
| 262 | dev_err(hd->parent, "message type %d received?\n", |
| 263 | header->message_type); |
| 264 | return NULL; |
| 265 | } |
| 266 | |
| 267 | /* |
| 268 | * The validation of the size of the message buffer happens in each |
| 269 | * svc_* function, due to the different types of messages, keeping the |
| 270 | * logic for each message only in one place. |
| 271 | */ |
Greg Kroah-Hartman | 43cc32a | 2014-09-07 13:51:12 -0700 | [diff] [blame] | 272 | |
Greg Kroah-Hartman | 68f1fc4 | 2014-09-07 13:12:11 -0700 | [diff] [blame] | 273 | return svc_msg; |
| 274 | } |
| 275 | |
Greg Kroah-Hartman | b57b062 | 2014-09-13 12:18:09 -0700 | [diff] [blame] | 276 | static void ap_process_event(struct work_struct *work) |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 277 | { |
| 278 | struct svc_msg *svc_msg; |
| 279 | struct greybus_host_device *hd; |
Greg Kroah-Hartman | b57b062 | 2014-09-13 12:18:09 -0700 | [diff] [blame] | 280 | struct ap_msg *ap_msg; |
Greg Kroah-Hartman | 00c52e4 | 2014-09-21 18:19:54 -0700 | [diff] [blame] | 281 | int payload_length; |
Greg Kroah-Hartman | b57b062 | 2014-09-13 12:18:09 -0700 | [diff] [blame] | 282 | |
| 283 | ap_msg = container_of(work, struct ap_msg, event); |
| 284 | hd = ap_msg->hd; |
Greg Kroah-Hartman | 68f1fc4 | 2014-09-07 13:12:11 -0700 | [diff] [blame] | 285 | |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 286 | /* Turn the "raw" data into a real message */ |
Viresh Kumar | e2dabb7 | 2014-11-19 17:24:56 +0530 | [diff] [blame] | 287 | svc_msg = convert_ap_message(ap_msg); |
Greg Kroah-Hartman | 00c52e4 | 2014-09-21 18:19:54 -0700 | [diff] [blame] | 288 | if (!svc_msg) |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 289 | return; |
Greg Kroah-Hartman | 00c52e4 | 2014-09-21 18:19:54 -0700 | [diff] [blame] | 290 | |
| 291 | payload_length = le16_to_cpu(svc_msg->header.payload_length); |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 292 | |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 293 | /* Look at the message to figure out what to do with it */ |
Matt Porter | 710ecb0 | 2014-09-18 15:25:41 -0400 | [diff] [blame] | 294 | switch (svc_msg->header.function_id) { |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 295 | case SVC_FUNCTION_HANDSHAKE: |
Greg Kroah-Hartman | 00c52e4 | 2014-09-21 18:19:54 -0700 | [diff] [blame] | 296 | svc_handshake(&svc_msg->handshake, payload_length, hd); |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 297 | break; |
| 298 | case SVC_FUNCTION_UNIPRO_NETWORK_MANAGEMENT: |
Greg Kroah-Hartman | 00c52e4 | 2014-09-21 18:19:54 -0700 | [diff] [blame] | 299 | svc_management(&svc_msg->management, payload_length, hd); |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 300 | break; |
| 301 | case SVC_FUNCTION_HOTPLUG: |
Greg Kroah-Hartman | d0cfd10 | 2014-09-21 19:10:39 -0700 | [diff] [blame] | 302 | svc_hotplug(&svc_msg->hotplug, payload_length, hd); |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 303 | break; |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 304 | case SVC_FUNCTION_POWER: |
Greg Kroah-Hartman | d0cfd10 | 2014-09-21 19:10:39 -0700 | [diff] [blame] | 305 | svc_power(&svc_msg->power, payload_length, hd); |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 306 | break; |
| 307 | case SVC_FUNCTION_EPM: |
Greg Kroah-Hartman | d0cfd10 | 2014-09-21 19:10:39 -0700 | [diff] [blame] | 308 | svc_epm(&svc_msg->epm, payload_length, hd); |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 309 | break; |
| 310 | case SVC_FUNCTION_SUSPEND: |
Greg Kroah-Hartman | d0cfd10 | 2014-09-21 19:10:39 -0700 | [diff] [blame] | 311 | svc_suspend(&svc_msg->suspend, payload_length, hd); |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 312 | break; |
| 313 | default: |
Matt Porter | 710ecb0 | 2014-09-18 15:25:41 -0400 | [diff] [blame] | 314 | dev_err(hd->parent, "received invalid SVC function ID %d\n", |
| 315 | svc_msg->header.function_id); |
Greg Kroah-Hartman | 8c53e07 | 2014-09-12 20:47:11 -0700 | [diff] [blame] | 316 | } |
| 317 | |
Greg Kroah-Hartman | 88929c5 | 2014-09-13 11:35:02 -0700 | [diff] [blame] | 318 | /* clean the message up */ |
| 319 | kfree(ap_msg->data); |
| 320 | kfree(ap_msg); |
Greg Kroah-Hartman | de536e3 | 2014-08-31 16:17:04 -0700 | [diff] [blame] | 321 | } |
| 322 | |
Alex Elder | 51c75fd | 2014-09-26 20:55:35 -0500 | [diff] [blame] | 323 | int greybus_svc_in(struct greybus_host_device *hd, u8 *data, int size) |
Greg Kroah-Hartman | de536e3 | 2014-08-31 16:17:04 -0700 | [diff] [blame] | 324 | { |
| 325 | struct ap_msg *ap_msg; |
Greg Kroah-Hartman | de536e3 | 2014-08-31 16:17:04 -0700 | [diff] [blame] | 326 | |
| 327 | /* |
| 328 | * Totally naive copy the message into a new structure that we slowly |
| 329 | * create and add it to the list. Let's get this working, the odds of |
| 330 | * this being any "slow path" for AP messages is really low at this |
| 331 | * point in time, but you never know, so this comment is here to point |
| 332 | * out that maybe we should use a slab allocator, or even just not copy |
| 333 | * the data, but use it directly and force the urbs to be "new" each |
| 334 | * time. |
| 335 | */ |
| 336 | |
| 337 | /* Note - this can, and will, be called in interrupt context. */ |
| 338 | ap_msg = kmalloc(sizeof(*ap_msg), GFP_ATOMIC); |
| 339 | if (!ap_msg) |
| 340 | return -ENOMEM; |
| 341 | ap_msg->data = kmalloc(size, GFP_ATOMIC); |
| 342 | if (!ap_msg->data) { |
| 343 | kfree(ap_msg); |
| 344 | return -ENOMEM; |
| 345 | } |
| 346 | memcpy(ap_msg->data, data, size); |
| 347 | ap_msg->size = size; |
Greg Kroah-Hartman | 68f1fc4 | 2014-09-07 13:12:11 -0700 | [diff] [blame] | 348 | ap_msg->hd = hd; |
Greg Kroah-Hartman | de536e3 | 2014-08-31 16:17:04 -0700 | [diff] [blame] | 349 | |
Greg Kroah-Hartman | 88929c5 | 2014-09-13 11:35:02 -0700 | [diff] [blame] | 350 | INIT_WORK(&ap_msg->event, ap_process_event); |
| 351 | queue_work(ap_workqueue, &ap_msg->event); |
Greg Kroah-Hartman | de536e3 | 2014-08-31 16:17:04 -0700 | [diff] [blame] | 352 | |
| 353 | return 0; |
| 354 | } |
Alex Elder | 0db32a6 | 2014-09-24 05:16:14 -0500 | [diff] [blame] | 355 | EXPORT_SYMBOL_GPL(greybus_svc_in); |
Greg Kroah-Hartman | d94a44a | 2014-09-01 14:39:34 -0700 | [diff] [blame] | 356 | |
Greg Kroah-Hartman | 45f3678 | 2014-09-14 11:40:35 -0700 | [diff] [blame] | 357 | int gb_ap_init(void) |
Greg Kroah-Hartman | de536e3 | 2014-08-31 16:17:04 -0700 | [diff] [blame] | 358 | { |
Greg Kroah-Hartman | e0b179e | 2015-01-22 20:33:41 +0800 | [diff] [blame] | 359 | ap_workqueue = alloc_ordered_workqueue("greybus_ap", 0); |
Greg Kroah-Hartman | 88929c5 | 2014-09-13 11:35:02 -0700 | [diff] [blame] | 360 | if (!ap_workqueue) |
| 361 | return -ENOMEM; |
Greg Kroah-Hartman | de536e3 | 2014-08-31 16:17:04 -0700 | [diff] [blame] | 362 | |
| 363 | return 0; |
| 364 | } |
| 365 | |
Greg Kroah-Hartman | 45f3678 | 2014-09-14 11:40:35 -0700 | [diff] [blame] | 366 | void gb_ap_exit(void) |
Greg Kroah-Hartman | de536e3 | 2014-08-31 16:17:04 -0700 | [diff] [blame] | 367 | { |
Greg Kroah-Hartman | 88929c5 | 2014-09-13 11:35:02 -0700 | [diff] [blame] | 368 | destroy_workqueue(ap_workqueue); |
Viresh Kumar | f66832da | 2014-11-14 17:25:01 +0530 | [diff] [blame] | 369 | ap_workqueue = NULL; |
Greg Kroah-Hartman | de536e3 | 2014-08-31 16:17:04 -0700 | [diff] [blame] | 370 | } |
| 371 | |
| 372 | |