1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * GPIO Greybus driver.
4  *
5  * Copyright 2014 Google Inc.
6  * Copyright 2014 Linaro Ltd.
7  */
8 
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/slab.h>
12 #include <linux/irq.h>
13 #include <linux/irqdomain.h>
14 #include <linux/gpio/driver.h>
15 #include <linux/mutex.h>
16 #include <linux/greybus.h>
17 
18 #include "gbphy.h"
19 
20 struct gb_gpio_line {
21 	/* The following has to be an array of line_max entries */
22 	/* --> make them just a flags field */
23 	u8			active:    1,
24 				direction: 1,	/* 0 = output, 1 = input */
25 				value:     1;	/* 0 = low, 1 = high */
26 	u16			debounce_usec;
27 
28 	u8			irq_type;
29 	bool			irq_type_pending;
30 	bool			masked;
31 	bool			masked_pending;
32 };
33 
34 struct gb_gpio_controller {
35 	struct gbphy_device	*gbphy_dev;
36 	struct gb_connection	*connection;
37 	u8			line_max;	/* max line number */
38 	struct gb_gpio_line	*lines;
39 
40 	struct gpio_chip	chip;
41 	struct irq_chip		irqc;
42 	struct mutex		irq_lock;
43 };
44 
gpio_chip_to_gb_gpio_controller(struct gpio_chip * chip)45 static inline struct gb_gpio_controller *gpio_chip_to_gb_gpio_controller(struct gpio_chip *chip)
46 {
47 	return container_of(chip, struct gb_gpio_controller, chip);
48 }
49 
irq_data_to_gpio_chip(struct irq_data * d)50 static struct gpio_chip *irq_data_to_gpio_chip(struct irq_data *d)
51 {
52 	return d->domain->host_data;
53 }
54 
gb_gpio_line_count_operation(struct gb_gpio_controller * ggc)55 static int gb_gpio_line_count_operation(struct gb_gpio_controller *ggc)
56 {
57 	struct gb_gpio_line_count_response response;
58 	int ret;
59 
60 	ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_LINE_COUNT,
61 				NULL, 0, &response, sizeof(response));
62 	if (!ret)
63 		ggc->line_max = response.count;
64 	return ret;
65 }
66 
gb_gpio_activate_operation(struct gb_gpio_controller * ggc,u8 which)67 static int gb_gpio_activate_operation(struct gb_gpio_controller *ggc, u8 which)
68 {
69 	struct gb_gpio_activate_request request;
70 	struct gbphy_device *gbphy_dev = ggc->gbphy_dev;
71 	int ret;
72 
73 	ret = gbphy_runtime_get_sync(gbphy_dev);
74 	if (ret)
75 		return ret;
76 
77 	request.which = which;
78 	ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_ACTIVATE,
79 				&request, sizeof(request), NULL, 0);
80 	if (ret) {
81 		gbphy_runtime_put_autosuspend(gbphy_dev);
82 		return ret;
83 	}
84 
85 	ggc->lines[which].active = true;
86 
87 	return 0;
88 }
89 
gb_gpio_deactivate_operation(struct gb_gpio_controller * ggc,u8 which)90 static void gb_gpio_deactivate_operation(struct gb_gpio_controller *ggc,
91 					 u8 which)
92 {
93 	struct gbphy_device *gbphy_dev = ggc->gbphy_dev;
94 	struct device *dev = &gbphy_dev->dev;
95 	struct gb_gpio_deactivate_request request;
96 	int ret;
97 
98 	request.which = which;
99 	ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_DEACTIVATE,
100 				&request, sizeof(request), NULL, 0);
101 	if (ret) {
102 		dev_err(dev, "failed to deactivate gpio %u\n", which);
103 		goto out_pm_put;
104 	}
105 
106 	ggc->lines[which].active = false;
107 
108 out_pm_put:
109 	gbphy_runtime_put_autosuspend(gbphy_dev);
110 }
111 
gb_gpio_get_direction_operation(struct gb_gpio_controller * ggc,u8 which)112 static int gb_gpio_get_direction_operation(struct gb_gpio_controller *ggc,
113 					   u8 which)
114 {
115 	struct device *dev = &ggc->gbphy_dev->dev;
116 	struct gb_gpio_get_direction_request request;
117 	struct gb_gpio_get_direction_response response;
118 	int ret;
119 	u8 direction;
120 
121 	request.which = which;
122 	ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_GET_DIRECTION,
123 				&request, sizeof(request),
124 				&response, sizeof(response));
125 	if (ret)
126 		return ret;
127 
128 	direction = response.direction;
129 	if (direction && direction != 1) {
130 		dev_warn(dev, "gpio %u direction was %u (should be 0 or 1)\n",
131 			 which, direction);
132 	}
133 	ggc->lines[which].direction = direction ? 1 : 0;
134 	return 0;
135 }
136 
gb_gpio_direction_in_operation(struct gb_gpio_controller * ggc,u8 which)137 static int gb_gpio_direction_in_operation(struct gb_gpio_controller *ggc,
138 					  u8 which)
139 {
140 	struct gb_gpio_direction_in_request request;
141 	int ret;
142 
143 	request.which = which;
144 	ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_DIRECTION_IN,
145 				&request, sizeof(request), NULL, 0);
146 	if (!ret)
147 		ggc->lines[which].direction = 1;
148 	return ret;
149 }
150 
gb_gpio_direction_out_operation(struct gb_gpio_controller * ggc,u8 which,bool value_high)151 static int gb_gpio_direction_out_operation(struct gb_gpio_controller *ggc,
152 					   u8 which, bool value_high)
153 {
154 	struct gb_gpio_direction_out_request request;
155 	int ret;
156 
157 	request.which = which;
158 	request.value = value_high ? 1 : 0;
159 	ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_DIRECTION_OUT,
160 				&request, sizeof(request), NULL, 0);
161 	if (!ret)
162 		ggc->lines[which].direction = 0;
163 	return ret;
164 }
165 
gb_gpio_get_value_operation(struct gb_gpio_controller * ggc,u8 which)166 static int gb_gpio_get_value_operation(struct gb_gpio_controller *ggc,
167 				       u8 which)
168 {
169 	struct device *dev = &ggc->gbphy_dev->dev;
170 	struct gb_gpio_get_value_request request;
171 	struct gb_gpio_get_value_response response;
172 	int ret;
173 	u8 value;
174 
175 	request.which = which;
176 	ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_GET_VALUE,
177 				&request, sizeof(request),
178 				&response, sizeof(response));
179 	if (ret) {
180 		dev_err(dev, "failed to get value of gpio %u\n", which);
181 		return ret;
182 	}
183 
184 	value = response.value;
185 	if (value && value != 1) {
186 		dev_warn(dev, "gpio %u value was %u (should be 0 or 1)\n",
187 			 which, value);
188 	}
189 	ggc->lines[which].value = value ? 1 : 0;
190 	return 0;
191 }
192 
gb_gpio_set_value_operation(struct gb_gpio_controller * ggc,u8 which,bool value_high)193 static void gb_gpio_set_value_operation(struct gb_gpio_controller *ggc,
194 					u8 which, bool value_high)
195 {
196 	struct device *dev = &ggc->gbphy_dev->dev;
197 	struct gb_gpio_set_value_request request;
198 	int ret;
199 
200 	if (ggc->lines[which].direction == 1) {
201 		dev_warn(dev, "refusing to set value of input gpio %u\n",
202 			 which);
203 		return;
204 	}
205 
206 	request.which = which;
207 	request.value = value_high ? 1 : 0;
208 	ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_SET_VALUE,
209 				&request, sizeof(request), NULL, 0);
210 	if (ret) {
211 		dev_err(dev, "failed to set value of gpio %u\n", which);
212 		return;
213 	}
214 
215 	ggc->lines[which].value = request.value;
216 }
217 
gb_gpio_set_debounce_operation(struct gb_gpio_controller * ggc,u8 which,u16 debounce_usec)218 static int gb_gpio_set_debounce_operation(struct gb_gpio_controller *ggc,
219 					  u8 which, u16 debounce_usec)
220 {
221 	struct gb_gpio_set_debounce_request request;
222 	int ret;
223 
224 	request.which = which;
225 	request.usec = cpu_to_le16(debounce_usec);
226 	ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_SET_DEBOUNCE,
227 				&request, sizeof(request), NULL, 0);
228 	if (!ret)
229 		ggc->lines[which].debounce_usec = debounce_usec;
230 	return ret;
231 }
232 
_gb_gpio_irq_mask(struct gb_gpio_controller * ggc,u8 hwirq)233 static void _gb_gpio_irq_mask(struct gb_gpio_controller *ggc, u8 hwirq)
234 {
235 	struct device *dev = &ggc->gbphy_dev->dev;
236 	struct gb_gpio_irq_mask_request request;
237 	int ret;
238 
239 	request.which = hwirq;
240 	ret = gb_operation_sync(ggc->connection,
241 				GB_GPIO_TYPE_IRQ_MASK,
242 				&request, sizeof(request), NULL, 0);
243 	if (ret)
244 		dev_err(dev, "failed to mask irq: %d\n", ret);
245 }
246 
_gb_gpio_irq_unmask(struct gb_gpio_controller * ggc,u8 hwirq)247 static void _gb_gpio_irq_unmask(struct gb_gpio_controller *ggc, u8 hwirq)
248 {
249 	struct device *dev = &ggc->gbphy_dev->dev;
250 	struct gb_gpio_irq_unmask_request request;
251 	int ret;
252 
253 	request.which = hwirq;
254 	ret = gb_operation_sync(ggc->connection,
255 				GB_GPIO_TYPE_IRQ_UNMASK,
256 				&request, sizeof(request), NULL, 0);
257 	if (ret)
258 		dev_err(dev, "failed to unmask irq: %d\n", ret);
259 }
260 
_gb_gpio_irq_set_type(struct gb_gpio_controller * ggc,u8 hwirq,u8 type)261 static void _gb_gpio_irq_set_type(struct gb_gpio_controller *ggc,
262 				  u8 hwirq, u8 type)
263 {
264 	struct device *dev = &ggc->gbphy_dev->dev;
265 	struct gb_gpio_irq_type_request request;
266 	int ret;
267 
268 	request.which = hwirq;
269 	request.type = type;
270 
271 	ret = gb_operation_sync(ggc->connection,
272 				GB_GPIO_TYPE_IRQ_TYPE,
273 				&request, sizeof(request), NULL, 0);
274 	if (ret)
275 		dev_err(dev, "failed to set irq type: %d\n", ret);
276 }
277 
gb_gpio_irq_mask(struct irq_data * d)278 static void gb_gpio_irq_mask(struct irq_data *d)
279 {
280 	struct gpio_chip *chip = irq_data_to_gpio_chip(d);
281 	struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
282 	struct gb_gpio_line *line = &ggc->lines[d->hwirq];
283 
284 	line->masked = true;
285 	line->masked_pending = true;
286 }
287 
gb_gpio_irq_unmask(struct irq_data * d)288 static void gb_gpio_irq_unmask(struct irq_data *d)
289 {
290 	struct gpio_chip *chip = irq_data_to_gpio_chip(d);
291 	struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
292 	struct gb_gpio_line *line = &ggc->lines[d->hwirq];
293 
294 	line->masked = false;
295 	line->masked_pending = true;
296 }
297 
gb_gpio_irq_set_type(struct irq_data * d,unsigned int type)298 static int gb_gpio_irq_set_type(struct irq_data *d, unsigned int type)
299 {
300 	struct gpio_chip *chip = irq_data_to_gpio_chip(d);
301 	struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
302 	struct gb_gpio_line *line = &ggc->lines[d->hwirq];
303 	struct device *dev = &ggc->gbphy_dev->dev;
304 	u8 irq_type;
305 
306 	switch (type) {
307 	case IRQ_TYPE_NONE:
308 		irq_type = GB_GPIO_IRQ_TYPE_NONE;
309 		break;
310 	case IRQ_TYPE_EDGE_RISING:
311 		irq_type = GB_GPIO_IRQ_TYPE_EDGE_RISING;
312 		break;
313 	case IRQ_TYPE_EDGE_FALLING:
314 		irq_type = GB_GPIO_IRQ_TYPE_EDGE_FALLING;
315 		break;
316 	case IRQ_TYPE_EDGE_BOTH:
317 		irq_type = GB_GPIO_IRQ_TYPE_EDGE_BOTH;
318 		break;
319 	case IRQ_TYPE_LEVEL_LOW:
320 		irq_type = GB_GPIO_IRQ_TYPE_LEVEL_LOW;
321 		break;
322 	case IRQ_TYPE_LEVEL_HIGH:
323 		irq_type = GB_GPIO_IRQ_TYPE_LEVEL_HIGH;
324 		break;
325 	default:
326 		dev_err(dev, "unsupported irq type: %u\n", type);
327 		return -EINVAL;
328 	}
329 
330 	line->irq_type = irq_type;
331 	line->irq_type_pending = true;
332 
333 	return 0;
334 }
335 
gb_gpio_irq_bus_lock(struct irq_data * d)336 static void gb_gpio_irq_bus_lock(struct irq_data *d)
337 {
338 	struct gpio_chip *chip = irq_data_to_gpio_chip(d);
339 	struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
340 
341 	mutex_lock(&ggc->irq_lock);
342 }
343 
gb_gpio_irq_bus_sync_unlock(struct irq_data * d)344 static void gb_gpio_irq_bus_sync_unlock(struct irq_data *d)
345 {
346 	struct gpio_chip *chip = irq_data_to_gpio_chip(d);
347 	struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
348 	struct gb_gpio_line *line = &ggc->lines[d->hwirq];
349 
350 	if (line->irq_type_pending) {
351 		_gb_gpio_irq_set_type(ggc, d->hwirq, line->irq_type);
352 		line->irq_type_pending = false;
353 	}
354 
355 	if (line->masked_pending) {
356 		if (line->masked)
357 			_gb_gpio_irq_mask(ggc, d->hwirq);
358 		else
359 			_gb_gpio_irq_unmask(ggc, d->hwirq);
360 		line->masked_pending = false;
361 	}
362 
363 	mutex_unlock(&ggc->irq_lock);
364 }
365 
gb_gpio_request_handler(struct gb_operation * op)366 static int gb_gpio_request_handler(struct gb_operation *op)
367 {
368 	struct gb_connection *connection = op->connection;
369 	struct gb_gpio_controller *ggc = gb_connection_get_data(connection);
370 	struct device *dev = &ggc->gbphy_dev->dev;
371 	struct gb_message *request;
372 	struct gb_gpio_irq_event_request *event;
373 	u8 type = op->type;
374 	int irq, ret;
375 
376 	if (type != GB_GPIO_TYPE_IRQ_EVENT) {
377 		dev_err(dev, "unsupported unsolicited request: %u\n", type);
378 		return -EINVAL;
379 	}
380 
381 	request = op->request;
382 
383 	if (request->payload_size < sizeof(*event)) {
384 		dev_err(dev, "short event received (%zu < %zu)\n",
385 			request->payload_size, sizeof(*event));
386 		return -EINVAL;
387 	}
388 
389 	event = request->payload;
390 	if (event->which > ggc->line_max) {
391 		dev_err(dev, "invalid hw irq: %d\n", event->which);
392 		return -EINVAL;
393 	}
394 
395 	irq = irq_find_mapping(ggc->chip.irq.domain, event->which);
396 	if (!irq) {
397 		dev_err(dev, "failed to find IRQ\n");
398 		return -EINVAL;
399 	}
400 
401 	ret = generic_handle_irq_safe(irq);
402 	if (ret)
403 		dev_err(dev, "failed to invoke irq handler\n");
404 
405 	return ret;
406 }
407 
gb_gpio_request(struct gpio_chip * chip,unsigned int offset)408 static int gb_gpio_request(struct gpio_chip *chip, unsigned int offset)
409 {
410 	struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
411 
412 	return gb_gpio_activate_operation(ggc, (u8)offset);
413 }
414 
gb_gpio_free(struct gpio_chip * chip,unsigned int offset)415 static void gb_gpio_free(struct gpio_chip *chip, unsigned int offset)
416 {
417 	struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
418 
419 	gb_gpio_deactivate_operation(ggc, (u8)offset);
420 }
421 
gb_gpio_get_direction(struct gpio_chip * chip,unsigned int offset)422 static int gb_gpio_get_direction(struct gpio_chip *chip, unsigned int offset)
423 {
424 	struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
425 	u8 which;
426 	int ret;
427 
428 	which = (u8)offset;
429 	ret = gb_gpio_get_direction_operation(ggc, which);
430 	if (ret)
431 		return ret;
432 
433 	return ggc->lines[which].direction ? 1 : 0;
434 }
435 
gb_gpio_direction_input(struct gpio_chip * chip,unsigned int offset)436 static int gb_gpio_direction_input(struct gpio_chip *chip, unsigned int offset)
437 {
438 	struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
439 
440 	return gb_gpio_direction_in_operation(ggc, (u8)offset);
441 }
442 
gb_gpio_direction_output(struct gpio_chip * chip,unsigned int offset,int value)443 static int gb_gpio_direction_output(struct gpio_chip *chip, unsigned int offset,
444 				    int value)
445 {
446 	struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
447 
448 	return gb_gpio_direction_out_operation(ggc, (u8)offset, !!value);
449 }
450 
gb_gpio_get(struct gpio_chip * chip,unsigned int offset)451 static int gb_gpio_get(struct gpio_chip *chip, unsigned int offset)
452 {
453 	struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
454 	u8 which;
455 	int ret;
456 
457 	which = (u8)offset;
458 	ret = gb_gpio_get_value_operation(ggc, which);
459 	if (ret)
460 		return ret;
461 
462 	return ggc->lines[which].value;
463 }
464 
gb_gpio_set(struct gpio_chip * chip,unsigned int offset,int value)465 static void gb_gpio_set(struct gpio_chip *chip, unsigned int offset, int value)
466 {
467 	struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
468 
469 	gb_gpio_set_value_operation(ggc, (u8)offset, !!value);
470 }
471 
gb_gpio_set_config(struct gpio_chip * chip,unsigned int offset,unsigned long config)472 static int gb_gpio_set_config(struct gpio_chip *chip, unsigned int offset,
473 			      unsigned long config)
474 {
475 	struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
476 	u32 debounce;
477 
478 	if (pinconf_to_config_param(config) != PIN_CONFIG_INPUT_DEBOUNCE)
479 		return -ENOTSUPP;
480 
481 	debounce = pinconf_to_config_argument(config);
482 	if (debounce > U16_MAX)
483 		return -EINVAL;
484 
485 	return gb_gpio_set_debounce_operation(ggc, (u8)offset, (u16)debounce);
486 }
487 
gb_gpio_controller_setup(struct gb_gpio_controller * ggc)488 static int gb_gpio_controller_setup(struct gb_gpio_controller *ggc)
489 {
490 	int ret;
491 
492 	/* Now find out how many lines there are */
493 	ret = gb_gpio_line_count_operation(ggc);
494 	if (ret)
495 		return ret;
496 
497 	ggc->lines = kcalloc(ggc->line_max + 1, sizeof(*ggc->lines),
498 			     GFP_KERNEL);
499 	if (!ggc->lines)
500 		return -ENOMEM;
501 
502 	return ret;
503 }
504 
gb_gpio_probe(struct gbphy_device * gbphy_dev,const struct gbphy_device_id * id)505 static int gb_gpio_probe(struct gbphy_device *gbphy_dev,
506 			 const struct gbphy_device_id *id)
507 {
508 	struct gb_connection *connection;
509 	struct gb_gpio_controller *ggc;
510 	struct gpio_chip *gpio;
511 	struct gpio_irq_chip *girq;
512 	struct irq_chip *irqc;
513 	int ret;
514 
515 	ggc = kzalloc(sizeof(*ggc), GFP_KERNEL);
516 	if (!ggc)
517 		return -ENOMEM;
518 
519 	connection =
520 		gb_connection_create(gbphy_dev->bundle,
521 				     le16_to_cpu(gbphy_dev->cport_desc->id),
522 				     gb_gpio_request_handler);
523 	if (IS_ERR(connection)) {
524 		ret = PTR_ERR(connection);
525 		goto exit_ggc_free;
526 	}
527 
528 	ggc->connection = connection;
529 	gb_connection_set_data(connection, ggc);
530 	ggc->gbphy_dev = gbphy_dev;
531 	gb_gbphy_set_data(gbphy_dev, ggc);
532 
533 	ret = gb_connection_enable_tx(connection);
534 	if (ret)
535 		goto exit_connection_destroy;
536 
537 	ret = gb_gpio_controller_setup(ggc);
538 	if (ret)
539 		goto exit_connection_disable;
540 
541 	irqc = &ggc->irqc;
542 	irqc->irq_mask = gb_gpio_irq_mask;
543 	irqc->irq_unmask = gb_gpio_irq_unmask;
544 	irqc->irq_set_type = gb_gpio_irq_set_type;
545 	irqc->irq_bus_lock = gb_gpio_irq_bus_lock;
546 	irqc->irq_bus_sync_unlock = gb_gpio_irq_bus_sync_unlock;
547 	irqc->name = "greybus_gpio";
548 
549 	mutex_init(&ggc->irq_lock);
550 
551 	gpio = &ggc->chip;
552 
553 	gpio->label = "greybus_gpio";
554 	gpio->parent = &gbphy_dev->dev;
555 	gpio->owner = THIS_MODULE;
556 
557 	gpio->request = gb_gpio_request;
558 	gpio->free = gb_gpio_free;
559 	gpio->get_direction = gb_gpio_get_direction;
560 	gpio->direction_input = gb_gpio_direction_input;
561 	gpio->direction_output = gb_gpio_direction_output;
562 	gpio->get = gb_gpio_get;
563 	gpio->set = gb_gpio_set;
564 	gpio->set_config = gb_gpio_set_config;
565 	gpio->base = -1;		/* Allocate base dynamically */
566 	gpio->ngpio = ggc->line_max + 1;
567 	gpio->can_sleep = true;
568 
569 	girq = &gpio->irq;
570 	girq->chip = irqc;
571 	/* The event comes from the outside so no parent handler */
572 	girq->parent_handler = NULL;
573 	girq->num_parents = 0;
574 	girq->parents = NULL;
575 	girq->default_type = IRQ_TYPE_NONE;
576 	girq->handler = handle_level_irq;
577 
578 	ret = gb_connection_enable(connection);
579 	if (ret)
580 		goto exit_line_free;
581 
582 	ret = gpiochip_add(gpio);
583 	if (ret) {
584 		dev_err(&gbphy_dev->dev, "failed to add gpio chip: %d\n", ret);
585 		goto exit_line_free;
586 	}
587 
588 	gbphy_runtime_put_autosuspend(gbphy_dev);
589 	return 0;
590 
591 exit_line_free:
592 	kfree(ggc->lines);
593 exit_connection_disable:
594 	gb_connection_disable(connection);
595 exit_connection_destroy:
596 	gb_connection_destroy(connection);
597 exit_ggc_free:
598 	kfree(ggc);
599 	return ret;
600 }
601 
gb_gpio_remove(struct gbphy_device * gbphy_dev)602 static void gb_gpio_remove(struct gbphy_device *gbphy_dev)
603 {
604 	struct gb_gpio_controller *ggc = gb_gbphy_get_data(gbphy_dev);
605 	struct gb_connection *connection = ggc->connection;
606 	int ret;
607 
608 	ret = gbphy_runtime_get_sync(gbphy_dev);
609 	if (ret)
610 		gbphy_runtime_get_noresume(gbphy_dev);
611 
612 	gb_connection_disable_rx(connection);
613 	gpiochip_remove(&ggc->chip);
614 	gb_connection_disable(connection);
615 	gb_connection_destroy(connection);
616 	kfree(ggc->lines);
617 	kfree(ggc);
618 }
619 
620 static const struct gbphy_device_id gb_gpio_id_table[] = {
621 	{ GBPHY_PROTOCOL(GREYBUS_PROTOCOL_GPIO) },
622 	{ },
623 };
624 MODULE_DEVICE_TABLE(gbphy, gb_gpio_id_table);
625 
626 static struct gbphy_driver gpio_driver = {
627 	.name		= "gpio",
628 	.probe		= gb_gpio_probe,
629 	.remove		= gb_gpio_remove,
630 	.id_table	= gb_gpio_id_table,
631 };
632 
633 module_gbphy_driver(gpio_driver);
634 MODULE_LICENSE("GPL v2");
635