1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * SVC Greybus driver.
4 *
5 * Copyright 2015 Google Inc.
6 * Copyright 2015 Linaro Ltd.
7 */
8
9 #include <linux/debugfs.h>
10 #include <linux/kstrtox.h>
11 #include <linux/workqueue.h>
12 #include <linux/greybus.h>
13 #include <linux/string_choices.h>
14
15 #define SVC_INTF_EJECT_TIMEOUT 9000
16 #define SVC_INTF_ACTIVATE_TIMEOUT 6000
17 #define SVC_INTF_RESUME_TIMEOUT 3000
18
19 struct gb_svc_deferred_request {
20 struct work_struct work;
21 struct gb_operation *operation;
22 };
23
24 static int gb_svc_queue_deferred_request(struct gb_operation *operation);
25
endo_id_show(struct device * dev,struct device_attribute * attr,char * buf)26 static ssize_t endo_id_show(struct device *dev,
27 struct device_attribute *attr, char *buf)
28 {
29 struct gb_svc *svc = to_gb_svc(dev);
30
31 return sprintf(buf, "0x%04x\n", svc->endo_id);
32 }
33 static DEVICE_ATTR_RO(endo_id);
34
ap_intf_id_show(struct device * dev,struct device_attribute * attr,char * buf)35 static ssize_t ap_intf_id_show(struct device *dev,
36 struct device_attribute *attr, char *buf)
37 {
38 struct gb_svc *svc = to_gb_svc(dev);
39
40 return sprintf(buf, "%u\n", svc->ap_intf_id);
41 }
42 static DEVICE_ATTR_RO(ap_intf_id);
43
44 // FIXME
45 // This is a hack, we need to do this "right" and clean the interface up
46 // properly, not just forcibly yank the thing out of the system and hope for the
47 // best. But for now, people want their modules to come out without having to
48 // throw the thing to the ground or get out a screwdriver.
intf_eject_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)49 static ssize_t intf_eject_store(struct device *dev,
50 struct device_attribute *attr, const char *buf,
51 size_t len)
52 {
53 struct gb_svc *svc = to_gb_svc(dev);
54 unsigned short intf_id;
55 int ret;
56
57 ret = kstrtou16(buf, 10, &intf_id);
58 if (ret < 0)
59 return ret;
60
61 dev_warn(dev, "Forcibly trying to eject interface %d\n", intf_id);
62
63 ret = gb_svc_intf_eject(svc, intf_id);
64 if (ret < 0)
65 return ret;
66
67 return len;
68 }
69 static DEVICE_ATTR_WO(intf_eject);
70
watchdog_show(struct device * dev,struct device_attribute * attr,char * buf)71 static ssize_t watchdog_show(struct device *dev, struct device_attribute *attr,
72 char *buf)
73 {
74 struct gb_svc *svc = to_gb_svc(dev);
75
76 return sprintf(buf, "%s\n",
77 str_enabled_disabled(gb_svc_watchdog_enabled(svc)));
78 }
79
watchdog_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)80 static ssize_t watchdog_store(struct device *dev,
81 struct device_attribute *attr, const char *buf,
82 size_t len)
83 {
84 struct gb_svc *svc = to_gb_svc(dev);
85 int retval;
86 bool user_request;
87
88 retval = kstrtobool(buf, &user_request);
89 if (retval)
90 return retval;
91
92 if (user_request)
93 retval = gb_svc_watchdog_enable(svc);
94 else
95 retval = gb_svc_watchdog_disable(svc);
96 if (retval)
97 return retval;
98 return len;
99 }
100 static DEVICE_ATTR_RW(watchdog);
101
watchdog_action_show(struct device * dev,struct device_attribute * attr,char * buf)102 static ssize_t watchdog_action_show(struct device *dev,
103 struct device_attribute *attr, char *buf)
104 {
105 struct gb_svc *svc = to_gb_svc(dev);
106
107 if (svc->action == GB_SVC_WATCHDOG_BITE_PANIC_KERNEL)
108 return sprintf(buf, "panic\n");
109 else if (svc->action == GB_SVC_WATCHDOG_BITE_RESET_UNIPRO)
110 return sprintf(buf, "reset\n");
111
112 return -EINVAL;
113 }
114
watchdog_action_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)115 static ssize_t watchdog_action_store(struct device *dev,
116 struct device_attribute *attr,
117 const char *buf, size_t len)
118 {
119 struct gb_svc *svc = to_gb_svc(dev);
120
121 if (sysfs_streq(buf, "panic"))
122 svc->action = GB_SVC_WATCHDOG_BITE_PANIC_KERNEL;
123 else if (sysfs_streq(buf, "reset"))
124 svc->action = GB_SVC_WATCHDOG_BITE_RESET_UNIPRO;
125 else
126 return -EINVAL;
127
128 return len;
129 }
130 static DEVICE_ATTR_RW(watchdog_action);
131
gb_svc_pwrmon_rail_count_get(struct gb_svc * svc,u8 * value)132 static int gb_svc_pwrmon_rail_count_get(struct gb_svc *svc, u8 *value)
133 {
134 struct gb_svc_pwrmon_rail_count_get_response response;
135 int ret;
136
137 ret = gb_operation_sync(svc->connection,
138 GB_SVC_TYPE_PWRMON_RAIL_COUNT_GET, NULL, 0,
139 &response, sizeof(response));
140 if (ret) {
141 dev_err(&svc->dev, "failed to get rail count: %d\n", ret);
142 return ret;
143 }
144
145 *value = response.rail_count;
146
147 return 0;
148 }
149
gb_svc_pwrmon_rail_names_get(struct gb_svc * svc,struct gb_svc_pwrmon_rail_names_get_response * response,size_t bufsize)150 static int gb_svc_pwrmon_rail_names_get(struct gb_svc *svc,
151 struct gb_svc_pwrmon_rail_names_get_response *response,
152 size_t bufsize)
153 {
154 int ret;
155
156 ret = gb_operation_sync(svc->connection,
157 GB_SVC_TYPE_PWRMON_RAIL_NAMES_GET, NULL, 0,
158 response, bufsize);
159 if (ret) {
160 dev_err(&svc->dev, "failed to get rail names: %d\n", ret);
161 return ret;
162 }
163
164 if (response->status != GB_SVC_OP_SUCCESS) {
165 dev_err(&svc->dev,
166 "SVC error while getting rail names: %u\n",
167 response->status);
168 return -EREMOTEIO;
169 }
170
171 return 0;
172 }
173
gb_svc_pwrmon_sample_get(struct gb_svc * svc,u8 rail_id,u8 measurement_type,u32 * value)174 static int gb_svc_pwrmon_sample_get(struct gb_svc *svc, u8 rail_id,
175 u8 measurement_type, u32 *value)
176 {
177 struct gb_svc_pwrmon_sample_get_request request;
178 struct gb_svc_pwrmon_sample_get_response response;
179 int ret;
180
181 request.rail_id = rail_id;
182 request.measurement_type = measurement_type;
183
184 ret = gb_operation_sync(svc->connection, GB_SVC_TYPE_PWRMON_SAMPLE_GET,
185 &request, sizeof(request),
186 &response, sizeof(response));
187 if (ret) {
188 dev_err(&svc->dev, "failed to get rail sample: %d\n", ret);
189 return ret;
190 }
191
192 if (response.result) {
193 dev_err(&svc->dev,
194 "UniPro error while getting rail power sample (%d %d): %d\n",
195 rail_id, measurement_type, response.result);
196 switch (response.result) {
197 case GB_SVC_PWRMON_GET_SAMPLE_INVAL:
198 return -EINVAL;
199 case GB_SVC_PWRMON_GET_SAMPLE_NOSUPP:
200 return -ENOMSG;
201 default:
202 return -EREMOTEIO;
203 }
204 }
205
206 *value = le32_to_cpu(response.measurement);
207
208 return 0;
209 }
210
gb_svc_pwrmon_intf_sample_get(struct gb_svc * svc,u8 intf_id,u8 measurement_type,u32 * value)211 int gb_svc_pwrmon_intf_sample_get(struct gb_svc *svc, u8 intf_id,
212 u8 measurement_type, u32 *value)
213 {
214 struct gb_svc_pwrmon_intf_sample_get_request request;
215 struct gb_svc_pwrmon_intf_sample_get_response response;
216 int ret;
217
218 request.intf_id = intf_id;
219 request.measurement_type = measurement_type;
220
221 ret = gb_operation_sync(svc->connection,
222 GB_SVC_TYPE_PWRMON_INTF_SAMPLE_GET,
223 &request, sizeof(request),
224 &response, sizeof(response));
225 if (ret) {
226 dev_err(&svc->dev, "failed to get intf sample: %d\n", ret);
227 return ret;
228 }
229
230 if (response.result) {
231 dev_err(&svc->dev,
232 "UniPro error while getting intf power sample (%d %d): %d\n",
233 intf_id, measurement_type, response.result);
234 switch (response.result) {
235 case GB_SVC_PWRMON_GET_SAMPLE_INVAL:
236 return -EINVAL;
237 case GB_SVC_PWRMON_GET_SAMPLE_NOSUPP:
238 return -ENOMSG;
239 default:
240 return -EREMOTEIO;
241 }
242 }
243
244 *value = le32_to_cpu(response.measurement);
245
246 return 0;
247 }
248
249 static struct attribute *svc_attrs[] = {
250 &dev_attr_endo_id.attr,
251 &dev_attr_ap_intf_id.attr,
252 &dev_attr_intf_eject.attr,
253 &dev_attr_watchdog.attr,
254 &dev_attr_watchdog_action.attr,
255 NULL,
256 };
257 ATTRIBUTE_GROUPS(svc);
258
gb_svc_intf_device_id(struct gb_svc * svc,u8 intf_id,u8 device_id)259 int gb_svc_intf_device_id(struct gb_svc *svc, u8 intf_id, u8 device_id)
260 {
261 struct gb_svc_intf_device_id_request request;
262
263 request.intf_id = intf_id;
264 request.device_id = device_id;
265
266 return gb_operation_sync(svc->connection, GB_SVC_TYPE_INTF_DEVICE_ID,
267 &request, sizeof(request), NULL, 0);
268 }
269
gb_svc_intf_eject(struct gb_svc * svc,u8 intf_id)270 int gb_svc_intf_eject(struct gb_svc *svc, u8 intf_id)
271 {
272 struct gb_svc_intf_eject_request request;
273 int ret;
274
275 request.intf_id = intf_id;
276
277 /*
278 * The pulse width for module release in svc is long so we need to
279 * increase the timeout so the operation will not return to soon.
280 */
281 ret = gb_operation_sync_timeout(svc->connection,
282 GB_SVC_TYPE_INTF_EJECT, &request,
283 sizeof(request), NULL, 0,
284 SVC_INTF_EJECT_TIMEOUT);
285 if (ret) {
286 dev_err(&svc->dev, "failed to eject interface %u\n", intf_id);
287 return ret;
288 }
289
290 return 0;
291 }
292
gb_svc_intf_vsys_set(struct gb_svc * svc,u8 intf_id,bool enable)293 int gb_svc_intf_vsys_set(struct gb_svc *svc, u8 intf_id, bool enable)
294 {
295 struct gb_svc_intf_vsys_request request;
296 struct gb_svc_intf_vsys_response response;
297 int type, ret;
298
299 request.intf_id = intf_id;
300
301 if (enable)
302 type = GB_SVC_TYPE_INTF_VSYS_ENABLE;
303 else
304 type = GB_SVC_TYPE_INTF_VSYS_DISABLE;
305
306 ret = gb_operation_sync(svc->connection, type,
307 &request, sizeof(request),
308 &response, sizeof(response));
309 if (ret < 0)
310 return ret;
311 if (response.result_code != GB_SVC_INTF_VSYS_OK)
312 return -EREMOTEIO;
313 return 0;
314 }
315
gb_svc_intf_refclk_set(struct gb_svc * svc,u8 intf_id,bool enable)316 int gb_svc_intf_refclk_set(struct gb_svc *svc, u8 intf_id, bool enable)
317 {
318 struct gb_svc_intf_refclk_request request;
319 struct gb_svc_intf_refclk_response response;
320 int type, ret;
321
322 request.intf_id = intf_id;
323
324 if (enable)
325 type = GB_SVC_TYPE_INTF_REFCLK_ENABLE;
326 else
327 type = GB_SVC_TYPE_INTF_REFCLK_DISABLE;
328
329 ret = gb_operation_sync(svc->connection, type,
330 &request, sizeof(request),
331 &response, sizeof(response));
332 if (ret < 0)
333 return ret;
334 if (response.result_code != GB_SVC_INTF_REFCLK_OK)
335 return -EREMOTEIO;
336 return 0;
337 }
338
gb_svc_intf_unipro_set(struct gb_svc * svc,u8 intf_id,bool enable)339 int gb_svc_intf_unipro_set(struct gb_svc *svc, u8 intf_id, bool enable)
340 {
341 struct gb_svc_intf_unipro_request request;
342 struct gb_svc_intf_unipro_response response;
343 int type, ret;
344
345 request.intf_id = intf_id;
346
347 if (enable)
348 type = GB_SVC_TYPE_INTF_UNIPRO_ENABLE;
349 else
350 type = GB_SVC_TYPE_INTF_UNIPRO_DISABLE;
351
352 ret = gb_operation_sync(svc->connection, type,
353 &request, sizeof(request),
354 &response, sizeof(response));
355 if (ret < 0)
356 return ret;
357 if (response.result_code != GB_SVC_INTF_UNIPRO_OK)
358 return -EREMOTEIO;
359 return 0;
360 }
361
gb_svc_intf_activate(struct gb_svc * svc,u8 intf_id,u8 * intf_type)362 int gb_svc_intf_activate(struct gb_svc *svc, u8 intf_id, u8 *intf_type)
363 {
364 struct gb_svc_intf_activate_request request;
365 struct gb_svc_intf_activate_response response;
366 int ret;
367
368 request.intf_id = intf_id;
369
370 ret = gb_operation_sync_timeout(svc->connection,
371 GB_SVC_TYPE_INTF_ACTIVATE,
372 &request, sizeof(request),
373 &response, sizeof(response),
374 SVC_INTF_ACTIVATE_TIMEOUT);
375 if (ret < 0)
376 return ret;
377 if (response.status != GB_SVC_OP_SUCCESS) {
378 dev_err(&svc->dev, "failed to activate interface %u: %u\n",
379 intf_id, response.status);
380 return -EREMOTEIO;
381 }
382
383 *intf_type = response.intf_type;
384
385 return 0;
386 }
387
gb_svc_intf_resume(struct gb_svc * svc,u8 intf_id)388 int gb_svc_intf_resume(struct gb_svc *svc, u8 intf_id)
389 {
390 struct gb_svc_intf_resume_request request;
391 struct gb_svc_intf_resume_response response;
392 int ret;
393
394 request.intf_id = intf_id;
395
396 ret = gb_operation_sync_timeout(svc->connection,
397 GB_SVC_TYPE_INTF_RESUME,
398 &request, sizeof(request),
399 &response, sizeof(response),
400 SVC_INTF_RESUME_TIMEOUT);
401 if (ret < 0) {
402 dev_err(&svc->dev, "failed to send interface resume %u: %d\n",
403 intf_id, ret);
404 return ret;
405 }
406
407 if (response.status != GB_SVC_OP_SUCCESS) {
408 dev_err(&svc->dev, "failed to resume interface %u: %u\n",
409 intf_id, response.status);
410 return -EREMOTEIO;
411 }
412
413 return 0;
414 }
415
gb_svc_dme_peer_get(struct gb_svc * svc,u8 intf_id,u16 attr,u16 selector,u32 * value)416 int gb_svc_dme_peer_get(struct gb_svc *svc, u8 intf_id, u16 attr, u16 selector,
417 u32 *value)
418 {
419 struct gb_svc_dme_peer_get_request request;
420 struct gb_svc_dme_peer_get_response response;
421 u16 result;
422 int ret;
423
424 request.intf_id = intf_id;
425 request.attr = cpu_to_le16(attr);
426 request.selector = cpu_to_le16(selector);
427
428 ret = gb_operation_sync(svc->connection, GB_SVC_TYPE_DME_PEER_GET,
429 &request, sizeof(request),
430 &response, sizeof(response));
431 if (ret) {
432 dev_err(&svc->dev, "failed to get DME attribute (%u 0x%04x %u): %d\n",
433 intf_id, attr, selector, ret);
434 return ret;
435 }
436
437 result = le16_to_cpu(response.result_code);
438 if (result) {
439 dev_err(&svc->dev, "UniPro error while getting DME attribute (%u 0x%04x %u): %u\n",
440 intf_id, attr, selector, result);
441 return -EREMOTEIO;
442 }
443
444 if (value)
445 *value = le32_to_cpu(response.attr_value);
446
447 return 0;
448 }
449
gb_svc_dme_peer_set(struct gb_svc * svc,u8 intf_id,u16 attr,u16 selector,u32 value)450 int gb_svc_dme_peer_set(struct gb_svc *svc, u8 intf_id, u16 attr, u16 selector,
451 u32 value)
452 {
453 struct gb_svc_dme_peer_set_request request;
454 struct gb_svc_dme_peer_set_response response;
455 u16 result;
456 int ret;
457
458 request.intf_id = intf_id;
459 request.attr = cpu_to_le16(attr);
460 request.selector = cpu_to_le16(selector);
461 request.value = cpu_to_le32(value);
462
463 ret = gb_operation_sync(svc->connection, GB_SVC_TYPE_DME_PEER_SET,
464 &request, sizeof(request),
465 &response, sizeof(response));
466 if (ret) {
467 dev_err(&svc->dev, "failed to set DME attribute (%u 0x%04x %u %u): %d\n",
468 intf_id, attr, selector, value, ret);
469 return ret;
470 }
471
472 result = le16_to_cpu(response.result_code);
473 if (result) {
474 dev_err(&svc->dev, "UniPro error while setting DME attribute (%u 0x%04x %u %u): %u\n",
475 intf_id, attr, selector, value, result);
476 return -EREMOTEIO;
477 }
478
479 return 0;
480 }
481
gb_svc_connection_create(struct gb_svc * svc,u8 intf1_id,u16 cport1_id,u8 intf2_id,u16 cport2_id,u8 cport_flags)482 int gb_svc_connection_create(struct gb_svc *svc,
483 u8 intf1_id, u16 cport1_id,
484 u8 intf2_id, u16 cport2_id,
485 u8 cport_flags)
486 {
487 struct gb_svc_conn_create_request request;
488
489 request.intf1_id = intf1_id;
490 request.cport1_id = cpu_to_le16(cport1_id);
491 request.intf2_id = intf2_id;
492 request.cport2_id = cpu_to_le16(cport2_id);
493 request.tc = 0; /* TC0 */
494 request.flags = cport_flags;
495
496 return gb_operation_sync(svc->connection, GB_SVC_TYPE_CONN_CREATE,
497 &request, sizeof(request), NULL, 0);
498 }
499
gb_svc_connection_destroy(struct gb_svc * svc,u8 intf1_id,u16 cport1_id,u8 intf2_id,u16 cport2_id)500 void gb_svc_connection_destroy(struct gb_svc *svc, u8 intf1_id, u16 cport1_id,
501 u8 intf2_id, u16 cport2_id)
502 {
503 struct gb_svc_conn_destroy_request request;
504 struct gb_connection *connection = svc->connection;
505 int ret;
506
507 request.intf1_id = intf1_id;
508 request.cport1_id = cpu_to_le16(cport1_id);
509 request.intf2_id = intf2_id;
510 request.cport2_id = cpu_to_le16(cport2_id);
511
512 ret = gb_operation_sync(connection, GB_SVC_TYPE_CONN_DESTROY,
513 &request, sizeof(request), NULL, 0);
514 if (ret) {
515 dev_err(&svc->dev, "failed to destroy connection (%u:%u %u:%u): %d\n",
516 intf1_id, cport1_id, intf2_id, cport2_id, ret);
517 }
518 }
519
520 /* Creates bi-directional routes between the devices */
gb_svc_route_create(struct gb_svc * svc,u8 intf1_id,u8 dev1_id,u8 intf2_id,u8 dev2_id)521 int gb_svc_route_create(struct gb_svc *svc, u8 intf1_id, u8 dev1_id,
522 u8 intf2_id, u8 dev2_id)
523 {
524 struct gb_svc_route_create_request request;
525
526 request.intf1_id = intf1_id;
527 request.dev1_id = dev1_id;
528 request.intf2_id = intf2_id;
529 request.dev2_id = dev2_id;
530
531 return gb_operation_sync(svc->connection, GB_SVC_TYPE_ROUTE_CREATE,
532 &request, sizeof(request), NULL, 0);
533 }
534
535 /* Destroys bi-directional routes between the devices */
gb_svc_route_destroy(struct gb_svc * svc,u8 intf1_id,u8 intf2_id)536 void gb_svc_route_destroy(struct gb_svc *svc, u8 intf1_id, u8 intf2_id)
537 {
538 struct gb_svc_route_destroy_request request;
539 int ret;
540
541 request.intf1_id = intf1_id;
542 request.intf2_id = intf2_id;
543
544 ret = gb_operation_sync(svc->connection, GB_SVC_TYPE_ROUTE_DESTROY,
545 &request, sizeof(request), NULL, 0);
546 if (ret) {
547 dev_err(&svc->dev, "failed to destroy route (%u %u): %d\n",
548 intf1_id, intf2_id, ret);
549 }
550 }
551
gb_svc_intf_set_power_mode(struct gb_svc * svc,u8 intf_id,u8 hs_series,u8 tx_mode,u8 tx_gear,u8 tx_nlanes,u8 tx_amplitude,u8 tx_hs_equalizer,u8 rx_mode,u8 rx_gear,u8 rx_nlanes,u8 flags,u32 quirks,struct gb_svc_l2_timer_cfg * local,struct gb_svc_l2_timer_cfg * remote)552 int gb_svc_intf_set_power_mode(struct gb_svc *svc, u8 intf_id, u8 hs_series,
553 u8 tx_mode, u8 tx_gear, u8 tx_nlanes,
554 u8 tx_amplitude, u8 tx_hs_equalizer,
555 u8 rx_mode, u8 rx_gear, u8 rx_nlanes,
556 u8 flags, u32 quirks,
557 struct gb_svc_l2_timer_cfg *local,
558 struct gb_svc_l2_timer_cfg *remote)
559 {
560 struct gb_svc_intf_set_pwrm_request request;
561 struct gb_svc_intf_set_pwrm_response response;
562 int ret;
563 u16 result_code;
564
565 memset(&request, 0, sizeof(request));
566
567 request.intf_id = intf_id;
568 request.hs_series = hs_series;
569 request.tx_mode = tx_mode;
570 request.tx_gear = tx_gear;
571 request.tx_nlanes = tx_nlanes;
572 request.tx_amplitude = tx_amplitude;
573 request.tx_hs_equalizer = tx_hs_equalizer;
574 request.rx_mode = rx_mode;
575 request.rx_gear = rx_gear;
576 request.rx_nlanes = rx_nlanes;
577 request.flags = flags;
578 request.quirks = cpu_to_le32(quirks);
579 if (local)
580 request.local_l2timerdata = *local;
581 if (remote)
582 request.remote_l2timerdata = *remote;
583
584 ret = gb_operation_sync(svc->connection, GB_SVC_TYPE_INTF_SET_PWRM,
585 &request, sizeof(request),
586 &response, sizeof(response));
587 if (ret < 0)
588 return ret;
589
590 result_code = response.result_code;
591 if (result_code != GB_SVC_SETPWRM_PWR_LOCAL) {
592 dev_err(&svc->dev, "set power mode = %d\n", result_code);
593 return -EIO;
594 }
595
596 return 0;
597 }
598 EXPORT_SYMBOL_GPL(gb_svc_intf_set_power_mode);
599
gb_svc_intf_set_power_mode_hibernate(struct gb_svc * svc,u8 intf_id)600 int gb_svc_intf_set_power_mode_hibernate(struct gb_svc *svc, u8 intf_id)
601 {
602 struct gb_svc_intf_set_pwrm_request request;
603 struct gb_svc_intf_set_pwrm_response response;
604 int ret;
605 u16 result_code;
606
607 memset(&request, 0, sizeof(request));
608
609 request.intf_id = intf_id;
610 request.hs_series = GB_SVC_UNIPRO_HS_SERIES_A;
611 request.tx_mode = GB_SVC_UNIPRO_HIBERNATE_MODE;
612 request.rx_mode = GB_SVC_UNIPRO_HIBERNATE_MODE;
613
614 ret = gb_operation_sync(svc->connection, GB_SVC_TYPE_INTF_SET_PWRM,
615 &request, sizeof(request),
616 &response, sizeof(response));
617 if (ret < 0) {
618 dev_err(&svc->dev,
619 "failed to send set power mode operation to interface %u: %d\n",
620 intf_id, ret);
621 return ret;
622 }
623
624 result_code = response.result_code;
625 if (result_code != GB_SVC_SETPWRM_PWR_OK) {
626 dev_err(&svc->dev,
627 "failed to hibernate the link for interface %u: %u\n",
628 intf_id, result_code);
629 return -EIO;
630 }
631
632 return 0;
633 }
634
gb_svc_ping(struct gb_svc * svc)635 int gb_svc_ping(struct gb_svc *svc)
636 {
637 return gb_operation_sync_timeout(svc->connection, GB_SVC_TYPE_PING,
638 NULL, 0, NULL, 0,
639 GB_OPERATION_TIMEOUT_DEFAULT * 2);
640 }
641
gb_svc_version_request(struct gb_operation * op)642 static int gb_svc_version_request(struct gb_operation *op)
643 {
644 struct gb_connection *connection = op->connection;
645 struct gb_svc *svc = gb_connection_get_data(connection);
646 struct gb_svc_version_request *request;
647 struct gb_svc_version_response *response;
648
649 if (op->request->payload_size < sizeof(*request)) {
650 dev_err(&svc->dev, "short version request (%zu < %zu)\n",
651 op->request->payload_size,
652 sizeof(*request));
653 return -EINVAL;
654 }
655
656 request = op->request->payload;
657
658 if (request->major > GB_SVC_VERSION_MAJOR) {
659 dev_warn(&svc->dev, "unsupported major version (%u > %u)\n",
660 request->major, GB_SVC_VERSION_MAJOR);
661 return -ENOTSUPP;
662 }
663
664 svc->protocol_major = request->major;
665 svc->protocol_minor = request->minor;
666
667 if (!gb_operation_response_alloc(op, sizeof(*response), GFP_KERNEL))
668 return -ENOMEM;
669
670 response = op->response->payload;
671 response->major = svc->protocol_major;
672 response->minor = svc->protocol_minor;
673
674 return 0;
675 }
676
pwr_debugfs_voltage_read(struct file * file,char __user * buf,size_t len,loff_t * offset)677 static ssize_t pwr_debugfs_voltage_read(struct file *file, char __user *buf,
678 size_t len, loff_t *offset)
679 {
680 struct svc_debugfs_pwrmon_rail *pwrmon_rails =
681 file_inode(file)->i_private;
682 struct gb_svc *svc = pwrmon_rails->svc;
683 int ret, desc;
684 u32 value;
685 char buff[16];
686
687 ret = gb_svc_pwrmon_sample_get(svc, pwrmon_rails->id,
688 GB_SVC_PWRMON_TYPE_VOL, &value);
689 if (ret) {
690 dev_err(&svc->dev,
691 "failed to get voltage sample %u: %d\n",
692 pwrmon_rails->id, ret);
693 return ret;
694 }
695
696 desc = scnprintf(buff, sizeof(buff), "%u\n", value);
697
698 return simple_read_from_buffer(buf, len, offset, buff, desc);
699 }
700
pwr_debugfs_current_read(struct file * file,char __user * buf,size_t len,loff_t * offset)701 static ssize_t pwr_debugfs_current_read(struct file *file, char __user *buf,
702 size_t len, loff_t *offset)
703 {
704 struct svc_debugfs_pwrmon_rail *pwrmon_rails =
705 file_inode(file)->i_private;
706 struct gb_svc *svc = pwrmon_rails->svc;
707 int ret, desc;
708 u32 value;
709 char buff[16];
710
711 ret = gb_svc_pwrmon_sample_get(svc, pwrmon_rails->id,
712 GB_SVC_PWRMON_TYPE_CURR, &value);
713 if (ret) {
714 dev_err(&svc->dev,
715 "failed to get current sample %u: %d\n",
716 pwrmon_rails->id, ret);
717 return ret;
718 }
719
720 desc = scnprintf(buff, sizeof(buff), "%u\n", value);
721
722 return simple_read_from_buffer(buf, len, offset, buff, desc);
723 }
724
pwr_debugfs_power_read(struct file * file,char __user * buf,size_t len,loff_t * offset)725 static ssize_t pwr_debugfs_power_read(struct file *file, char __user *buf,
726 size_t len, loff_t *offset)
727 {
728 struct svc_debugfs_pwrmon_rail *pwrmon_rails =
729 file_inode(file)->i_private;
730 struct gb_svc *svc = pwrmon_rails->svc;
731 int ret, desc;
732 u32 value;
733 char buff[16];
734
735 ret = gb_svc_pwrmon_sample_get(svc, pwrmon_rails->id,
736 GB_SVC_PWRMON_TYPE_PWR, &value);
737 if (ret) {
738 dev_err(&svc->dev, "failed to get power sample %u: %d\n",
739 pwrmon_rails->id, ret);
740 return ret;
741 }
742
743 desc = scnprintf(buff, sizeof(buff), "%u\n", value);
744
745 return simple_read_from_buffer(buf, len, offset, buff, desc);
746 }
747
748 static const struct file_operations pwrmon_debugfs_voltage_fops = {
749 .read = pwr_debugfs_voltage_read,
750 };
751
752 static const struct file_operations pwrmon_debugfs_current_fops = {
753 .read = pwr_debugfs_current_read,
754 };
755
756 static const struct file_operations pwrmon_debugfs_power_fops = {
757 .read = pwr_debugfs_power_read,
758 };
759
gb_svc_pwrmon_debugfs_init(struct gb_svc * svc)760 static void gb_svc_pwrmon_debugfs_init(struct gb_svc *svc)
761 {
762 int i;
763 size_t bufsize;
764 struct dentry *dent;
765 struct gb_svc_pwrmon_rail_names_get_response *rail_names;
766 u8 rail_count;
767
768 dent = debugfs_create_dir("pwrmon", svc->debugfs_dentry);
769 if (IS_ERR_OR_NULL(dent))
770 return;
771
772 if (gb_svc_pwrmon_rail_count_get(svc, &rail_count))
773 goto err_pwrmon_debugfs;
774
775 if (!rail_count || rail_count > GB_SVC_PWRMON_MAX_RAIL_COUNT)
776 goto err_pwrmon_debugfs;
777
778 bufsize = sizeof(*rail_names) +
779 GB_SVC_PWRMON_RAIL_NAME_BUFSIZE * rail_count;
780
781 rail_names = kzalloc(bufsize, GFP_KERNEL);
782 if (!rail_names)
783 goto err_pwrmon_debugfs;
784
785 svc->pwrmon_rails = kcalloc(rail_count, sizeof(*svc->pwrmon_rails),
786 GFP_KERNEL);
787 if (!svc->pwrmon_rails)
788 goto err_pwrmon_debugfs_free;
789
790 if (gb_svc_pwrmon_rail_names_get(svc, rail_names, bufsize))
791 goto err_pwrmon_debugfs_free;
792
793 for (i = 0; i < rail_count; i++) {
794 struct dentry *dir;
795 struct svc_debugfs_pwrmon_rail *rail = &svc->pwrmon_rails[i];
796 char fname[GB_SVC_PWRMON_RAIL_NAME_BUFSIZE];
797
798 snprintf(fname, sizeof(fname), "%s",
799 (char *)&rail_names->name[i]);
800
801 rail->id = i;
802 rail->svc = svc;
803
804 dir = debugfs_create_dir(fname, dent);
805 debugfs_create_file("voltage_now", 0444, dir, rail,
806 &pwrmon_debugfs_voltage_fops);
807 debugfs_create_file("current_now", 0444, dir, rail,
808 &pwrmon_debugfs_current_fops);
809 debugfs_create_file("power_now", 0444, dir, rail,
810 &pwrmon_debugfs_power_fops);
811 }
812
813 kfree(rail_names);
814 return;
815
816 err_pwrmon_debugfs_free:
817 kfree(rail_names);
818 kfree(svc->pwrmon_rails);
819 svc->pwrmon_rails = NULL;
820
821 err_pwrmon_debugfs:
822 debugfs_remove(dent);
823 }
824
gb_svc_debugfs_init(struct gb_svc * svc)825 static void gb_svc_debugfs_init(struct gb_svc *svc)
826 {
827 svc->debugfs_dentry = debugfs_create_dir(dev_name(&svc->dev),
828 gb_debugfs_get());
829 gb_svc_pwrmon_debugfs_init(svc);
830 }
831
gb_svc_debugfs_exit(struct gb_svc * svc)832 static void gb_svc_debugfs_exit(struct gb_svc *svc)
833 {
834 debugfs_remove_recursive(svc->debugfs_dentry);
835 kfree(svc->pwrmon_rails);
836 svc->pwrmon_rails = NULL;
837 }
838
gb_svc_hello(struct gb_operation * op)839 static int gb_svc_hello(struct gb_operation *op)
840 {
841 struct gb_connection *connection = op->connection;
842 struct gb_svc *svc = gb_connection_get_data(connection);
843 struct gb_svc_hello_request *hello_request;
844 int ret;
845
846 if (op->request->payload_size < sizeof(*hello_request)) {
847 dev_warn(&svc->dev, "short hello request (%zu < %zu)\n",
848 op->request->payload_size,
849 sizeof(*hello_request));
850 return -EINVAL;
851 }
852
853 hello_request = op->request->payload;
854 svc->endo_id = le16_to_cpu(hello_request->endo_id);
855 svc->ap_intf_id = hello_request->interface_id;
856
857 ret = device_add(&svc->dev);
858 if (ret) {
859 dev_err(&svc->dev, "failed to register svc device: %d\n", ret);
860 return ret;
861 }
862
863 ret = gb_svc_watchdog_create(svc);
864 if (ret) {
865 dev_err(&svc->dev, "failed to create watchdog: %d\n", ret);
866 goto err_deregister_svc;
867 }
868
869 /*
870 * FIXME: This is a temporary hack to reconfigure the link at HELLO
871 * (which abuses the deferred request processing mechanism).
872 */
873 ret = gb_svc_queue_deferred_request(op);
874 if (ret)
875 goto err_destroy_watchdog;
876
877 gb_svc_debugfs_init(svc);
878
879 return 0;
880
881 err_destroy_watchdog:
882 gb_svc_watchdog_destroy(svc);
883 err_deregister_svc:
884 device_del(&svc->dev);
885
886 return ret;
887 }
888
gb_svc_interface_lookup(struct gb_svc * svc,u8 intf_id)889 static struct gb_interface *gb_svc_interface_lookup(struct gb_svc *svc,
890 u8 intf_id)
891 {
892 struct gb_host_device *hd = svc->hd;
893 struct gb_module *module;
894 size_t num_interfaces;
895 u8 module_id;
896
897 list_for_each_entry(module, &hd->modules, hd_node) {
898 module_id = module->module_id;
899 num_interfaces = module->num_interfaces;
900
901 if (intf_id >= module_id &&
902 intf_id < module_id + num_interfaces) {
903 return module->interfaces[intf_id - module_id];
904 }
905 }
906
907 return NULL;
908 }
909
gb_svc_module_lookup(struct gb_svc * svc,u8 module_id)910 static struct gb_module *gb_svc_module_lookup(struct gb_svc *svc, u8 module_id)
911 {
912 struct gb_host_device *hd = svc->hd;
913 struct gb_module *module;
914
915 list_for_each_entry(module, &hd->modules, hd_node) {
916 if (module->module_id == module_id)
917 return module;
918 }
919
920 return NULL;
921 }
922
gb_svc_process_hello_deferred(struct gb_operation * operation)923 static void gb_svc_process_hello_deferred(struct gb_operation *operation)
924 {
925 struct gb_connection *connection = operation->connection;
926 struct gb_svc *svc = gb_connection_get_data(connection);
927 int ret;
928
929 /*
930 * XXX This is a hack/work-around to reconfigure the APBridgeA-Switch
931 * link to PWM G2, 1 Lane, Slow Auto, so that it has sufficient
932 * bandwidth for 3 audio streams plus boot-over-UniPro of a hot-plugged
933 * module.
934 *
935 * The code should be removed once SW-2217, Heuristic for UniPro
936 * Power Mode Changes is resolved.
937 */
938 ret = gb_svc_intf_set_power_mode(svc, svc->ap_intf_id,
939 GB_SVC_UNIPRO_HS_SERIES_A,
940 GB_SVC_UNIPRO_SLOW_AUTO_MODE,
941 2, 1,
942 GB_SVC_SMALL_AMPLITUDE,
943 GB_SVC_NO_DE_EMPHASIS,
944 GB_SVC_UNIPRO_SLOW_AUTO_MODE,
945 2, 1,
946 0, 0,
947 NULL, NULL);
948
949 if (ret)
950 dev_warn(&svc->dev,
951 "power mode change failed on AP to switch link: %d\n",
952 ret);
953 }
954
gb_svc_process_module_inserted(struct gb_operation * operation)955 static void gb_svc_process_module_inserted(struct gb_operation *operation)
956 {
957 struct gb_svc_module_inserted_request *request;
958 struct gb_connection *connection = operation->connection;
959 struct gb_svc *svc = gb_connection_get_data(connection);
960 struct gb_host_device *hd = svc->hd;
961 struct gb_module *module;
962 size_t num_interfaces;
963 u8 module_id;
964 u16 flags;
965 int ret;
966
967 /* The request message size has already been verified. */
968 request = operation->request->payload;
969 module_id = request->primary_intf_id;
970 num_interfaces = request->intf_count;
971 flags = le16_to_cpu(request->flags);
972
973 dev_dbg(&svc->dev, "%s - id = %u, num_interfaces = %zu, flags = 0x%04x\n",
974 __func__, module_id, num_interfaces, flags);
975
976 if (flags & GB_SVC_MODULE_INSERTED_FLAG_NO_PRIMARY) {
977 dev_warn(&svc->dev, "no primary interface detected on module %u\n",
978 module_id);
979 }
980
981 module = gb_svc_module_lookup(svc, module_id);
982 if (module) {
983 dev_warn(&svc->dev, "unexpected module-inserted event %u\n",
984 module_id);
985 return;
986 }
987
988 module = gb_module_create(hd, module_id, num_interfaces);
989 if (!module) {
990 dev_err(&svc->dev, "failed to create module\n");
991 return;
992 }
993
994 ret = gb_module_add(module);
995 if (ret) {
996 gb_module_put(module);
997 return;
998 }
999
1000 list_add(&module->hd_node, &hd->modules);
1001 }
1002
gb_svc_process_module_removed(struct gb_operation * operation)1003 static void gb_svc_process_module_removed(struct gb_operation *operation)
1004 {
1005 struct gb_svc_module_removed_request *request;
1006 struct gb_connection *connection = operation->connection;
1007 struct gb_svc *svc = gb_connection_get_data(connection);
1008 struct gb_module *module;
1009 u8 module_id;
1010
1011 /* The request message size has already been verified. */
1012 request = operation->request->payload;
1013 module_id = request->primary_intf_id;
1014
1015 dev_dbg(&svc->dev, "%s - id = %u\n", __func__, module_id);
1016
1017 module = gb_svc_module_lookup(svc, module_id);
1018 if (!module) {
1019 dev_warn(&svc->dev, "unexpected module-removed event %u\n",
1020 module_id);
1021 return;
1022 }
1023
1024 module->disconnected = true;
1025
1026 gb_module_del(module);
1027 list_del(&module->hd_node);
1028 gb_module_put(module);
1029 }
1030
gb_svc_process_intf_oops(struct gb_operation * operation)1031 static void gb_svc_process_intf_oops(struct gb_operation *operation)
1032 {
1033 struct gb_svc_intf_oops_request *request;
1034 struct gb_connection *connection = operation->connection;
1035 struct gb_svc *svc = gb_connection_get_data(connection);
1036 struct gb_interface *intf;
1037 u8 intf_id;
1038 u8 reason;
1039
1040 /* The request message size has already been verified. */
1041 request = operation->request->payload;
1042 intf_id = request->intf_id;
1043 reason = request->reason;
1044
1045 intf = gb_svc_interface_lookup(svc, intf_id);
1046 if (!intf) {
1047 dev_warn(&svc->dev, "unexpected interface-oops event %u\n",
1048 intf_id);
1049 return;
1050 }
1051
1052 dev_info(&svc->dev, "Deactivating interface %u, interface oops reason = %u\n",
1053 intf_id, reason);
1054
1055 mutex_lock(&intf->mutex);
1056 intf->disconnected = true;
1057 gb_interface_disable(intf);
1058 gb_interface_deactivate(intf);
1059 mutex_unlock(&intf->mutex);
1060 }
1061
gb_svc_process_intf_mailbox_event(struct gb_operation * operation)1062 static void gb_svc_process_intf_mailbox_event(struct gb_operation *operation)
1063 {
1064 struct gb_svc_intf_mailbox_event_request *request;
1065 struct gb_connection *connection = operation->connection;
1066 struct gb_svc *svc = gb_connection_get_data(connection);
1067 struct gb_interface *intf;
1068 u8 intf_id;
1069 u16 result_code;
1070 u32 mailbox;
1071
1072 /* The request message size has already been verified. */
1073 request = operation->request->payload;
1074 intf_id = request->intf_id;
1075 result_code = le16_to_cpu(request->result_code);
1076 mailbox = le32_to_cpu(request->mailbox);
1077
1078 dev_dbg(&svc->dev, "%s - id = %u, result = 0x%04x, mailbox = 0x%08x\n",
1079 __func__, intf_id, result_code, mailbox);
1080
1081 intf = gb_svc_interface_lookup(svc, intf_id);
1082 if (!intf) {
1083 dev_warn(&svc->dev, "unexpected mailbox event %u\n", intf_id);
1084 return;
1085 }
1086
1087 gb_interface_mailbox_event(intf, result_code, mailbox);
1088 }
1089
gb_svc_process_deferred_request(struct work_struct * work)1090 static void gb_svc_process_deferred_request(struct work_struct *work)
1091 {
1092 struct gb_svc_deferred_request *dr;
1093 struct gb_operation *operation;
1094 struct gb_svc *svc;
1095 u8 type;
1096
1097 dr = container_of(work, struct gb_svc_deferred_request, work);
1098 operation = dr->operation;
1099 svc = gb_connection_get_data(operation->connection);
1100 type = operation->request->header->type;
1101
1102 switch (type) {
1103 case GB_SVC_TYPE_SVC_HELLO:
1104 gb_svc_process_hello_deferred(operation);
1105 break;
1106 case GB_SVC_TYPE_MODULE_INSERTED:
1107 gb_svc_process_module_inserted(operation);
1108 break;
1109 case GB_SVC_TYPE_MODULE_REMOVED:
1110 gb_svc_process_module_removed(operation);
1111 break;
1112 case GB_SVC_TYPE_INTF_MAILBOX_EVENT:
1113 gb_svc_process_intf_mailbox_event(operation);
1114 break;
1115 case GB_SVC_TYPE_INTF_OOPS:
1116 gb_svc_process_intf_oops(operation);
1117 break;
1118 default:
1119 dev_err(&svc->dev, "bad deferred request type: 0x%02x\n", type);
1120 }
1121
1122 gb_operation_put(operation);
1123 kfree(dr);
1124 }
1125
gb_svc_queue_deferred_request(struct gb_operation * operation)1126 static int gb_svc_queue_deferred_request(struct gb_operation *operation)
1127 {
1128 struct gb_svc *svc = gb_connection_get_data(operation->connection);
1129 struct gb_svc_deferred_request *dr;
1130
1131 dr = kmalloc(sizeof(*dr), GFP_KERNEL);
1132 if (!dr)
1133 return -ENOMEM;
1134
1135 gb_operation_get(operation);
1136
1137 dr->operation = operation;
1138 INIT_WORK(&dr->work, gb_svc_process_deferred_request);
1139
1140 queue_work(svc->wq, &dr->work);
1141
1142 return 0;
1143 }
1144
gb_svc_intf_reset_recv(struct gb_operation * op)1145 static int gb_svc_intf_reset_recv(struct gb_operation *op)
1146 {
1147 struct gb_svc *svc = gb_connection_get_data(op->connection);
1148 struct gb_message *request = op->request;
1149 struct gb_svc_intf_reset_request *reset;
1150
1151 if (request->payload_size < sizeof(*reset)) {
1152 dev_warn(&svc->dev, "short reset request received (%zu < %zu)\n",
1153 request->payload_size, sizeof(*reset));
1154 return -EINVAL;
1155 }
1156 reset = request->payload;
1157
1158 /* FIXME Reset the interface here */
1159
1160 return 0;
1161 }
1162
gb_svc_module_inserted_recv(struct gb_operation * op)1163 static int gb_svc_module_inserted_recv(struct gb_operation *op)
1164 {
1165 struct gb_svc *svc = gb_connection_get_data(op->connection);
1166 struct gb_svc_module_inserted_request *request;
1167
1168 if (op->request->payload_size < sizeof(*request)) {
1169 dev_warn(&svc->dev, "short module-inserted request received (%zu < %zu)\n",
1170 op->request->payload_size, sizeof(*request));
1171 return -EINVAL;
1172 }
1173
1174 request = op->request->payload;
1175
1176 dev_dbg(&svc->dev, "%s - id = %u\n", __func__,
1177 request->primary_intf_id);
1178
1179 return gb_svc_queue_deferred_request(op);
1180 }
1181
gb_svc_module_removed_recv(struct gb_operation * op)1182 static int gb_svc_module_removed_recv(struct gb_operation *op)
1183 {
1184 struct gb_svc *svc = gb_connection_get_data(op->connection);
1185 struct gb_svc_module_removed_request *request;
1186
1187 if (op->request->payload_size < sizeof(*request)) {
1188 dev_warn(&svc->dev, "short module-removed request received (%zu < %zu)\n",
1189 op->request->payload_size, sizeof(*request));
1190 return -EINVAL;
1191 }
1192
1193 request = op->request->payload;
1194
1195 dev_dbg(&svc->dev, "%s - id = %u\n", __func__,
1196 request->primary_intf_id);
1197
1198 return gb_svc_queue_deferred_request(op);
1199 }
1200
gb_svc_intf_oops_recv(struct gb_operation * op)1201 static int gb_svc_intf_oops_recv(struct gb_operation *op)
1202 {
1203 struct gb_svc *svc = gb_connection_get_data(op->connection);
1204 struct gb_svc_intf_oops_request *request;
1205
1206 if (op->request->payload_size < sizeof(*request)) {
1207 dev_warn(&svc->dev, "short intf-oops request received (%zu < %zu)\n",
1208 op->request->payload_size, sizeof(*request));
1209 return -EINVAL;
1210 }
1211
1212 return gb_svc_queue_deferred_request(op);
1213 }
1214
gb_svc_intf_mailbox_event_recv(struct gb_operation * op)1215 static int gb_svc_intf_mailbox_event_recv(struct gb_operation *op)
1216 {
1217 struct gb_svc *svc = gb_connection_get_data(op->connection);
1218 struct gb_svc_intf_mailbox_event_request *request;
1219
1220 if (op->request->payload_size < sizeof(*request)) {
1221 dev_warn(&svc->dev, "short mailbox request received (%zu < %zu)\n",
1222 op->request->payload_size, sizeof(*request));
1223 return -EINVAL;
1224 }
1225
1226 request = op->request->payload;
1227
1228 dev_dbg(&svc->dev, "%s - id = %u\n", __func__, request->intf_id);
1229
1230 return gb_svc_queue_deferred_request(op);
1231 }
1232
gb_svc_request_handler(struct gb_operation * op)1233 static int gb_svc_request_handler(struct gb_operation *op)
1234 {
1235 struct gb_connection *connection = op->connection;
1236 struct gb_svc *svc = gb_connection_get_data(connection);
1237 u8 type = op->type;
1238 int ret = 0;
1239
1240 /*
1241 * SVC requests need to follow a specific order (at least initially) and
1242 * below code takes care of enforcing that. The expected order is:
1243 * - PROTOCOL_VERSION
1244 * - SVC_HELLO
1245 * - Any other request, but the earlier two.
1246 *
1247 * Incoming requests are guaranteed to be serialized and so we don't
1248 * need to protect 'state' for any races.
1249 */
1250 switch (type) {
1251 case GB_SVC_TYPE_PROTOCOL_VERSION:
1252 if (svc->state != GB_SVC_STATE_RESET)
1253 ret = -EINVAL;
1254 break;
1255 case GB_SVC_TYPE_SVC_HELLO:
1256 if (svc->state != GB_SVC_STATE_PROTOCOL_VERSION)
1257 ret = -EINVAL;
1258 break;
1259 default:
1260 if (svc->state != GB_SVC_STATE_SVC_HELLO)
1261 ret = -EINVAL;
1262 break;
1263 }
1264
1265 if (ret) {
1266 dev_warn(&svc->dev, "unexpected request 0x%02x received (state %u)\n",
1267 type, svc->state);
1268 return ret;
1269 }
1270
1271 switch (type) {
1272 case GB_SVC_TYPE_PROTOCOL_VERSION:
1273 ret = gb_svc_version_request(op);
1274 if (!ret)
1275 svc->state = GB_SVC_STATE_PROTOCOL_VERSION;
1276 return ret;
1277 case GB_SVC_TYPE_SVC_HELLO:
1278 ret = gb_svc_hello(op);
1279 if (!ret)
1280 svc->state = GB_SVC_STATE_SVC_HELLO;
1281 return ret;
1282 case GB_SVC_TYPE_INTF_RESET:
1283 return gb_svc_intf_reset_recv(op);
1284 case GB_SVC_TYPE_MODULE_INSERTED:
1285 return gb_svc_module_inserted_recv(op);
1286 case GB_SVC_TYPE_MODULE_REMOVED:
1287 return gb_svc_module_removed_recv(op);
1288 case GB_SVC_TYPE_INTF_MAILBOX_EVENT:
1289 return gb_svc_intf_mailbox_event_recv(op);
1290 case GB_SVC_TYPE_INTF_OOPS:
1291 return gb_svc_intf_oops_recv(op);
1292 default:
1293 dev_warn(&svc->dev, "unsupported request 0x%02x\n", type);
1294 return -EINVAL;
1295 }
1296 }
1297
gb_svc_release(struct device * dev)1298 static void gb_svc_release(struct device *dev)
1299 {
1300 struct gb_svc *svc = to_gb_svc(dev);
1301
1302 if (svc->connection)
1303 gb_connection_destroy(svc->connection);
1304 ida_destroy(&svc->device_id_map);
1305 destroy_workqueue(svc->wq);
1306 kfree(svc);
1307 }
1308
1309 const struct device_type greybus_svc_type = {
1310 .name = "greybus_svc",
1311 .release = gb_svc_release,
1312 };
1313
gb_svc_create(struct gb_host_device * hd)1314 struct gb_svc *gb_svc_create(struct gb_host_device *hd)
1315 {
1316 struct gb_svc *svc;
1317
1318 svc = kzalloc(sizeof(*svc), GFP_KERNEL);
1319 if (!svc)
1320 return NULL;
1321
1322 svc->wq = alloc_ordered_workqueue("%s:svc", 0, dev_name(&hd->dev));
1323 if (!svc->wq) {
1324 kfree(svc);
1325 return NULL;
1326 }
1327
1328 svc->dev.parent = &hd->dev;
1329 svc->dev.bus = &greybus_bus_type;
1330 svc->dev.type = &greybus_svc_type;
1331 svc->dev.groups = svc_groups;
1332 svc->dev.dma_mask = svc->dev.parent->dma_mask;
1333 device_initialize(&svc->dev);
1334
1335 dev_set_name(&svc->dev, "%d-svc", hd->bus_id);
1336
1337 ida_init(&svc->device_id_map);
1338 svc->state = GB_SVC_STATE_RESET;
1339 svc->hd = hd;
1340
1341 svc->connection = gb_connection_create_static(hd, GB_SVC_CPORT_ID,
1342 gb_svc_request_handler);
1343 if (IS_ERR(svc->connection)) {
1344 dev_err(&svc->dev, "failed to create connection: %ld\n",
1345 PTR_ERR(svc->connection));
1346 goto err_put_device;
1347 }
1348
1349 gb_connection_set_data(svc->connection, svc);
1350
1351 return svc;
1352
1353 err_put_device:
1354 put_device(&svc->dev);
1355 return NULL;
1356 }
1357
gb_svc_add(struct gb_svc * svc)1358 int gb_svc_add(struct gb_svc *svc)
1359 {
1360 int ret;
1361
1362 /*
1363 * The SVC protocol is currently driven by the SVC, so the SVC device
1364 * is added from the connection request handler when enough
1365 * information has been received.
1366 */
1367 ret = gb_connection_enable(svc->connection);
1368 if (ret)
1369 return ret;
1370
1371 return 0;
1372 }
1373
gb_svc_remove_modules(struct gb_svc * svc)1374 static void gb_svc_remove_modules(struct gb_svc *svc)
1375 {
1376 struct gb_host_device *hd = svc->hd;
1377 struct gb_module *module, *tmp;
1378
1379 list_for_each_entry_safe(module, tmp, &hd->modules, hd_node) {
1380 gb_module_del(module);
1381 list_del(&module->hd_node);
1382 gb_module_put(module);
1383 }
1384 }
1385
gb_svc_del(struct gb_svc * svc)1386 void gb_svc_del(struct gb_svc *svc)
1387 {
1388 gb_connection_disable_rx(svc->connection);
1389
1390 /*
1391 * The SVC device may have been registered from the request handler.
1392 */
1393 if (device_is_registered(&svc->dev)) {
1394 gb_svc_debugfs_exit(svc);
1395 gb_svc_watchdog_destroy(svc);
1396 device_del(&svc->dev);
1397 }
1398
1399 flush_workqueue(svc->wq);
1400
1401 gb_svc_remove_modules(svc);
1402
1403 gb_connection_disable(svc->connection);
1404 }
1405
gb_svc_put(struct gb_svc * svc)1406 void gb_svc_put(struct gb_svc *svc)
1407 {
1408 put_device(&svc->dev);
1409 }
1410