xref: /openbmc/linux/drivers/greybus/control.c (revision ee7da21a) 
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 
18 static 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 
55 static 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 
85 int 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 */
104 int 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 */
122 int 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 
131 int 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 
140 int 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 
150 int 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 
178 int 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 
200 static 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 
215 int 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 
240 int 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 
265 int 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 
291 int 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 
320 static 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 
332 int 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 
355 int 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 
378 int 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 
402 static 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 }
409 static DEVICE_ATTR_RO(vendor_string);
410 
411 static 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 }
418 static DEVICE_ATTR_RO(product_string);
419 
420 static struct attribute *control_attrs[] = {
421 	&dev_attr_vendor_string.attr,
422 	&dev_attr_product_string.attr,
423 	NULL,
424 };
425 ATTRIBUTE_GROUPS(control);
426 
427 static 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 
439 struct device_type greybus_control_type = {
440 	.name =		"greybus_control",
441 	.release =	gb_control_release,
442 };
443 
444 struct gb_control *gb_control_create(struct gb_interface *intf)
445 {
446 	struct gb_connection *connection;
447 	struct gb_control *control;
448 
449 	control = kzalloc(sizeof(*control), GFP_KERNEL);
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 
479 int 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 
506 err_disable_connection:
507 	gb_connection_disable(control->connection);
508 
509 	return ret;
510 }
511 
512 void 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 
522 int gb_control_suspend(struct gb_control *control)
523 {
524 	gb_connection_disable(control->connection);
525 
526 	return 0;
527 }
528 
529 int 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 
543 int 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 
558 void gb_control_del(struct gb_control *control)
559 {
560 	if (device_is_registered(&control->dev))
561 		device_del(&control->dev);
562 }
563 
564 struct gb_control *gb_control_get(struct gb_control *control)
565 {
566 	get_device(&control->dev);
567 
568 	return control;
569 }
570 
571 void gb_control_put(struct gb_control *control)
572 {
573 	put_device(&control->dev);
574 }
575 
576 void gb_control_mode_switch_prepare(struct gb_control *control)
577 {
578 	gb_connection_mode_switch_prepare(control->connection);
579 }
580 
581 void gb_control_mode_switch_complete(struct gb_control *control)
582 {
583 	gb_connection_mode_switch_complete(control->connection);
584 }
585