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