projects/linux·blob master · refs

584 lines · 13.9 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Greybus CPort control protocol.
4 *
5 * Copyright 2015 Google Inc.
6 * Copyright 2015 Linaro Ltd.
7 */
8
9#include <linux/kernel.h>
10#include <linux/module.h>
11#include <linux/slab.h>
12#include <linux/greybus.h>
13
14/* Highest control-protocol version supported */
15#define GB_CONTROL_VERSION_MAJOR 0
16#define GB_CONTROL_VERSION_MINOR 1
17
18static int gb_control_get_version(struct gb_control *control)
19{
20 struct gb_interface *intf = control->connection->intf;
21 struct gb_control_version_request request;
22 struct gb_control_version_response response;
23 int ret;
24
25 request.major = GB_CONTROL_VERSION_MAJOR;
26 request.minor = GB_CONTROL_VERSION_MINOR;
27
28 ret = gb_operation_sync(control->connection,
29 GB_CONTROL_TYPE_VERSION,
30 &request, sizeof(request), &response,
31 sizeof(response));
32 if (ret) {
33 dev_err(&intf->dev,
34 "failed to get control-protocol version: %d\n",
35 ret);
36 return ret;
37 }
38
39 if (response.major > request.major) {
40 dev_err(&intf->dev,
41 "unsupported major control-protocol version (%u > %u)\n",
42 response.major, request.major);
43 return -ENOTSUPP;
44 }
45
46 control->protocol_major = response.major;
47 control->protocol_minor = response.minor;
48
49 dev_dbg(&intf->dev, "%s - %u.%u\n", __func__, response.major,
50 response.minor);
51
52 return 0;
53}
54
55static int gb_control_get_bundle_version(struct gb_control *control,
56 struct gb_bundle *bundle)
57{
58 struct gb_interface *intf = control->connection->intf;
59 struct gb_control_bundle_version_request request;
60 struct gb_control_bundle_version_response response;
61 int ret;
62
63 request.bundle_id = bundle->id;
64
65 ret = gb_operation_sync(control->connection,
66 GB_CONTROL_TYPE_BUNDLE_VERSION,
67 &request, sizeof(request),
68 &response, sizeof(response));
69 if (ret) {
70 dev_err(&intf->dev,
71 "failed to get bundle %u class version: %d\n",
72 bundle->id, ret);
73 return ret;
74 }
75
76 bundle->class_major = response.major;
77 bundle->class_minor = response.minor;
78
79 dev_dbg(&intf->dev, "%s - %u: %u.%u\n", __func__, bundle->id,
80 response.major, response.minor);
81
82 return 0;
83}
84
85int gb_control_get_bundle_versions(struct gb_control *control)
86{
87 struct gb_interface *intf = control->connection->intf;
88 struct gb_bundle *bundle;
89 int ret;
90
91 if (!control->has_bundle_version)
92 return 0;
93
94 list_for_each_entry(bundle, &intf->bundles, links) {
95 ret = gb_control_get_bundle_version(control, bundle);
96 if (ret)
97 return ret;
98 }
99
100 return 0;
101}
102
103/* Get Manifest's size from the interface */
104int gb_control_get_manifest_size_operation(struct gb_interface *intf)
105{
106 struct gb_control_get_manifest_size_response response;
107 struct gb_connection *connection = intf->control->connection;
108 int ret;
109
110 ret = gb_operation_sync(connection, GB_CONTROL_TYPE_GET_MANIFEST_SIZE,
111 NULL, 0, &response, sizeof(response));
112 if (ret) {
113 dev_err(&connection->intf->dev,
114 "failed to get manifest size: %d\n", ret);
115 return ret;
116 }
117
118 return le16_to_cpu(response.size);
119}
120
121/* Reads Manifest from the interface */
122int gb_control_get_manifest_operation(struct gb_interface *intf, void *manifest,
123 size_t size)
124{
125 struct gb_connection *connection = intf->control->connection;
126
127 return gb_operation_sync(connection, GB_CONTROL_TYPE_GET_MANIFEST,
128 NULL, 0, manifest, size);
129}
130
131int gb_control_connected_operation(struct gb_control *control, u16 cport_id)
132{
133 struct gb_control_connected_request request;
134
135 request.cport_id = cpu_to_le16(cport_id);
136 return gb_operation_sync(control->connection, GB_CONTROL_TYPE_CONNECTED,
137 &request, sizeof(request), NULL, 0);
138}
139
140int gb_control_disconnected_operation(struct gb_control *control, u16 cport_id)
141{
142 struct gb_control_disconnected_request request;
143
144 request.cport_id = cpu_to_le16(cport_id);
145 return gb_operation_sync(control->connection,
146 GB_CONTROL_TYPE_DISCONNECTED, &request,
147 sizeof(request), NULL, 0);
148}
149
150int gb_control_disconnecting_operation(struct gb_control *control,
151 u16 cport_id)
152{
153 struct gb_control_disconnecting_request *request;
154 struct gb_operation *operation;
155 int ret;
156
157 operation = gb_operation_create_core(control->connection,
158 GB_CONTROL_TYPE_DISCONNECTING,
159 sizeof(*request), 0, 0,
160 GFP_KERNEL);
161 if (!operation)
162 return -ENOMEM;
163
164 request = operation->request->payload;
165 request->cport_id = cpu_to_le16(cport_id);
166
167 ret = gb_operation_request_send_sync(operation);
168 if (ret) {
169 dev_err(&control->dev, "failed to send disconnecting: %d\n",
170 ret);
171 }
172
173 gb_operation_put(operation);
174
175 return ret;
176}
177
178int gb_control_mode_switch_operation(struct gb_control *control)
179{
180 struct gb_operation *operation;
181 int ret;
182
183 operation = gb_operation_create_core(control->connection,
184 GB_CONTROL_TYPE_MODE_SWITCH,
185 0, 0,
186 GB_OPERATION_FLAG_UNIDIRECTIONAL,
187 GFP_KERNEL);
188 if (!operation)
189 return -ENOMEM;
190
191 ret = gb_operation_request_send_sync(operation);
192 if (ret)
193 dev_err(&control->dev, "failed to send mode switch: %d\n", ret);
194
195 gb_operation_put(operation);
196
197 return ret;
198}
199
200static int gb_control_bundle_pm_status_map(u8 status)
201{
202 switch (status) {
203 case GB_CONTROL_BUNDLE_PM_INVAL:
204 return -EINVAL;
205 case GB_CONTROL_BUNDLE_PM_BUSY:
206 return -EBUSY;
207 case GB_CONTROL_BUNDLE_PM_NA:
208 return -ENOMSG;
209 case GB_CONTROL_BUNDLE_PM_FAIL:
210 default:
211 return -EREMOTEIO;
212 }
213}
214
215int gb_control_bundle_suspend(struct gb_control *control, u8 bundle_id)
216{
217 struct gb_control_bundle_pm_request request;
218 struct gb_control_bundle_pm_response response;
219 int ret;
220
221 request.bundle_id = bundle_id;
222 ret = gb_operation_sync(control->connection,
223 GB_CONTROL_TYPE_BUNDLE_SUSPEND, &request,
224 sizeof(request), &response, sizeof(response));
225 if (ret) {
226 dev_err(&control->dev, "failed to send bundle %u suspend: %d\n",
227 bundle_id, ret);
228 return ret;
229 }
230
231 if (response.status != GB_CONTROL_BUNDLE_PM_OK) {
232 dev_err(&control->dev, "failed to suspend bundle %u: %d\n",
233 bundle_id, response.status);
234 return gb_control_bundle_pm_status_map(response.status);
235 }
236
237 return 0;
238}
239
240int gb_control_bundle_resume(struct gb_control *control, u8 bundle_id)
241{
242 struct gb_control_bundle_pm_request request;
243 struct gb_control_bundle_pm_response response;
244 int ret;
245
246 request.bundle_id = bundle_id;
247 ret = gb_operation_sync(control->connection,
248 GB_CONTROL_TYPE_BUNDLE_RESUME, &request,
249 sizeof(request), &response, sizeof(response));
250 if (ret) {
251 dev_err(&control->dev, "failed to send bundle %u resume: %d\n",
252 bundle_id, ret);
253 return ret;
254 }
255
256 if (response.status != GB_CONTROL_BUNDLE_PM_OK) {
257 dev_err(&control->dev, "failed to resume bundle %u: %d\n",
258 bundle_id, response.status);
259 return gb_control_bundle_pm_status_map(response.status);
260 }
261
262 return 0;
263}
264
265int gb_control_bundle_deactivate(struct gb_control *control, u8 bundle_id)
266{
267 struct gb_control_bundle_pm_request request;
268 struct gb_control_bundle_pm_response response;
269 int ret;
270
271 request.bundle_id = bundle_id;
272 ret = gb_operation_sync(control->connection,
273 GB_CONTROL_TYPE_BUNDLE_DEACTIVATE, &request,
274 sizeof(request), &response, sizeof(response));
275 if (ret) {
276 dev_err(&control->dev,
277 "failed to send bundle %u deactivate: %d\n", bundle_id,
278 ret);
279 return ret;
280 }
281
282 if (response.status != GB_CONTROL_BUNDLE_PM_OK) {
283 dev_err(&control->dev, "failed to deactivate bundle %u: %d\n",
284 bundle_id, response.status);
285 return gb_control_bundle_pm_status_map(response.status);
286 }
287
288 return 0;
289}
290
291int gb_control_bundle_activate(struct gb_control *control, u8 bundle_id)
292{
293 struct gb_control_bundle_pm_request request;
294 struct gb_control_bundle_pm_response response;
295 int ret;
296
297 if (!control->has_bundle_activate)
298 return 0;
299
300 request.bundle_id = bundle_id;
301 ret = gb_operation_sync(control->connection,
302 GB_CONTROL_TYPE_BUNDLE_ACTIVATE, &request,
303 sizeof(request), &response, sizeof(response));
304 if (ret) {
305 dev_err(&control->dev,
306 "failed to send bundle %u activate: %d\n", bundle_id,
307 ret);
308 return ret;
309 }
310
311 if (response.status != GB_CONTROL_BUNDLE_PM_OK) {
312 dev_err(&control->dev, "failed to activate bundle %u: %d\n",
313 bundle_id, response.status);
314 return gb_control_bundle_pm_status_map(response.status);
315 }
316
317 return 0;
318}
319
320static int gb_control_interface_pm_status_map(u8 status)
321{
322 switch (status) {
323 case GB_CONTROL_INTF_PM_BUSY:
324 return -EBUSY;
325 case GB_CONTROL_INTF_PM_NA:
326 return -ENOMSG;
327 default:
328 return -EREMOTEIO;
329 }
330}
331
332int gb_control_interface_suspend_prepare(struct gb_control *control)
333{
334 struct gb_control_intf_pm_response response;
335 int ret;
336
337 ret = gb_operation_sync(control->connection,
338 GB_CONTROL_TYPE_INTF_SUSPEND_PREPARE, NULL, 0,
339 &response, sizeof(response));
340 if (ret) {
341 dev_err(&control->dev,
342 "failed to send interface suspend prepare: %d\n", ret);
343 return ret;
344 }
345
346 if (response.status != GB_CONTROL_INTF_PM_OK) {
347 dev_err(&control->dev, "interface error while preparing suspend: %d\n",
348 response.status);
349 return gb_control_interface_pm_status_map(response.status);
350 }
351
352 return 0;
353}
354
355int gb_control_interface_deactivate_prepare(struct gb_control *control)
356{
357 struct gb_control_intf_pm_response response;
358 int ret;
359
360 ret = gb_operation_sync(control->connection,
361 GB_CONTROL_TYPE_INTF_DEACTIVATE_PREPARE, NULL,
362 0, &response, sizeof(response));
363 if (ret) {
364 dev_err(&control->dev, "failed to send interface deactivate prepare: %d\n",
365 ret);
366 return ret;
367 }
368
369 if (response.status != GB_CONTROL_INTF_PM_OK) {
370 dev_err(&control->dev, "interface error while preparing deactivate: %d\n",
371 response.status);
372 return gb_control_interface_pm_status_map(response.status);
373 }
374
375 return 0;
376}
377
378int gb_control_interface_hibernate_abort(struct gb_control *control)
379{
380 struct gb_control_intf_pm_response response;
381 int ret;
382
383 ret = gb_operation_sync(control->connection,
384 GB_CONTROL_TYPE_INTF_HIBERNATE_ABORT, NULL, 0,
385 &response, sizeof(response));
386 if (ret) {
387 dev_err(&control->dev,
388 "failed to send interface aborting hibernate: %d\n",
389 ret);
390 return ret;
391 }
392
393 if (response.status != GB_CONTROL_INTF_PM_OK) {
394 dev_err(&control->dev, "interface error while aborting hibernate: %d\n",
395 response.status);
396 return gb_control_interface_pm_status_map(response.status);
397 }
398
399 return 0;
400}
401
402static ssize_t vendor_string_show(struct device *dev,
403 struct device_attribute *attr, char *buf)
404{
405 struct gb_control *control = to_gb_control(dev);
406
407 return scnprintf(buf, PAGE_SIZE, "%s\n", control->vendor_string);
408}
409static DEVICE_ATTR_RO(vendor_string);
410
411static ssize_t product_string_show(struct device *dev,
412 struct device_attribute *attr, char *buf)
413{
414 struct gb_control *control = to_gb_control(dev);
415
416 return scnprintf(buf, PAGE_SIZE, "%s\n", control->product_string);
417}
418static DEVICE_ATTR_RO(product_string);
419
420static struct attribute *control_attrs[] = {
421 &dev_attr_vendor_string.attr,
422 &dev_attr_product_string.attr,
423 NULL,
424};
425ATTRIBUTE_GROUPS(control);
426
427static void gb_control_release(struct device *dev)
428{
429 struct gb_control *control = to_gb_control(dev);
430
431 gb_connection_destroy(control->connection);
432
433 kfree(control->vendor_string);
434 kfree(control->product_string);
435
436 kfree(control);
437}
438
439const struct device_type greybus_control_type = {
440 .name = "greybus_control",
441 .release = gb_control_release,
442};
443
444struct gb_control *gb_control_create(struct gb_interface *intf)
445{
446 struct gb_connection *connection;
447 struct gb_control *control;
448
449 control = kzalloc_obj(*control);
450 if (!control)
451 return ERR_PTR(-ENOMEM);
452
453 control->intf = intf;
454
455 connection = gb_connection_create_control(intf);
456 if (IS_ERR(connection)) {
457 dev_err(&intf->dev,
458 "failed to create control connection: %ld\n",
459 PTR_ERR(connection));
460 kfree(control);
461 return ERR_CAST(connection);
462 }
463
464 control->connection = connection;
465
466 control->dev.parent = &intf->dev;
467 control->dev.bus = &greybus_bus_type;
468 control->dev.type = &greybus_control_type;
469 control->dev.groups = control_groups;
470 control->dev.dma_mask = intf->dev.dma_mask;
471 device_initialize(&control->dev);
472 dev_set_name(&control->dev, "%s.ctrl", dev_name(&intf->dev));
473
474 gb_connection_set_data(control->connection, control);
475
476 return control;
477}
478
479int gb_control_enable(struct gb_control *control)
480{
481 int ret;
482
483 dev_dbg(&control->connection->intf->dev, "%s\n", __func__);
484
485 ret = gb_connection_enable_tx(control->connection);
486 if (ret) {
487 dev_err(&control->connection->intf->dev,
488 "failed to enable control connection: %d\n",
489 ret);
490 return ret;
491 }
492
493 ret = gb_control_get_version(control);
494 if (ret)
495 goto err_disable_connection;
496
497 if (control->protocol_major > 0 || control->protocol_minor > 1)
498 control->has_bundle_version = true;
499
500 /* FIXME: use protocol version instead */
501 if (!(control->intf->quirks & GB_INTERFACE_QUIRK_NO_BUNDLE_ACTIVATE))
502 control->has_bundle_activate = true;
503
504 return 0;
505
506err_disable_connection:
507 gb_connection_disable(control->connection);
508
509 return ret;
510}
511
512void gb_control_disable(struct gb_control *control)
513{
514 dev_dbg(&control->connection->intf->dev, "%s\n", __func__);
515
516 if (control->intf->disconnected)
517 gb_connection_disable_forced(control->connection);
518 else
519 gb_connection_disable(control->connection);
520}
521
522int gb_control_suspend(struct gb_control *control)
523{
524 gb_connection_disable(control->connection);
525
526 return 0;
527}
528
529int gb_control_resume(struct gb_control *control)
530{
531 int ret;
532
533 ret = gb_connection_enable_tx(control->connection);
534 if (ret) {
535 dev_err(&control->connection->intf->dev,
536 "failed to enable control connection: %d\n", ret);
537 return ret;
538 }
539
540 return 0;
541}
542
543int gb_control_add(struct gb_control *control)
544{
545 int ret;
546
547 ret = device_add(&control->dev);
548 if (ret) {
549 dev_err(&control->dev,
550 "failed to register control device: %d\n",
551 ret);
552 return ret;
553 }
554
555 return 0;
556}
557
558void gb_control_del(struct gb_control *control)
559{
560 if (device_is_registered(&control->dev))
561 device_del(&control->dev);
562}
563
564struct gb_control *gb_control_get(struct gb_control *control)
565{
566 get_device(&control->dev);
567
568 return control;
569}
570
571void gb_control_put(struct gb_control *control)
572{
573 put_device(&control->dev);
574}
575
576void gb_control_mode_switch_prepare(struct gb_control *control)
577{
578 gb_connection_mode_switch_prepare(control->connection);
579}
580
581void gb_control_mode_switch_complete(struct gb_control *control)
582{
583 gb_connection_mode_switch_complete(control->connection);
584}