1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * GPIO Testing Device Driver |
4 | * |
5 | * Copyright (C) 2014 Kamlakant Patel <kamlakant.patel@broadcom.com> |
6 | * Copyright (C) 2015-2016 Bamvor Jian Zhang <bamv2005@gmail.com> |
7 | * Copyright (C) 2017 Bartosz Golaszewski <brgl@bgdev.pl> |
8 | */ |
9 | |
10 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
11 | |
12 | #include <linux/cleanup.h> |
13 | #include <linux/debugfs.h> |
14 | #include <linux/device.h> |
15 | #include <linux/gpio/driver.h> |
16 | #include <linux/interrupt.h> |
17 | #include <linux/irq.h> |
18 | #include <linux/irq_sim.h> |
19 | #include <linux/irqdomain.h> |
20 | #include <linux/mod_devicetable.h> |
21 | #include <linux/module.h> |
22 | #include <linux/platform_device.h> |
23 | #include <linux/property.h> |
24 | #include <linux/seq_file.h> |
25 | #include <linux/slab.h> |
26 | #include <linux/string_helpers.h> |
27 | #include <linux/uaccess.h> |
28 | |
29 | #define GPIO_MOCKUP_MAX_GC 10 |
30 | /* |
31 | * We're storing two values per chip: the GPIO base and the number |
32 | * of GPIO lines. |
33 | */ |
34 | #define GPIO_MOCKUP_MAX_RANGES (GPIO_MOCKUP_MAX_GC * 2) |
35 | /* Maximum of four properties + the sentinel. */ |
36 | #define GPIO_MOCKUP_MAX_PROP 5 |
37 | |
38 | /* |
39 | * struct gpio_pin_status - structure describing a GPIO status |
40 | * @dir: Configures direction of gpio as "in" or "out" |
41 | * @value: Configures status of the gpio as 0(low) or 1(high) |
42 | * @pull: Configures the current pull of the GPIO as 0 (pull-down) or |
43 | * 1 (pull-up) |
44 | * @requested: Request status of this GPIO |
45 | */ |
46 | struct gpio_mockup_line_status { |
47 | int dir; |
48 | int value; |
49 | int pull; |
50 | bool requested; |
51 | }; |
52 | |
53 | struct gpio_mockup_chip { |
54 | struct gpio_chip gc; |
55 | struct gpio_mockup_line_status *lines; |
56 | struct irq_domain *irq_sim_domain; |
57 | struct dentry *dbg_dir; |
58 | struct mutex lock; |
59 | }; |
60 | |
61 | struct gpio_mockup_dbgfs_private { |
62 | struct gpio_mockup_chip *chip; |
63 | unsigned int offset; |
64 | }; |
65 | |
66 | static int gpio_mockup_ranges[GPIO_MOCKUP_MAX_RANGES]; |
67 | static int gpio_mockup_num_ranges; |
68 | module_param_array(gpio_mockup_ranges, int, &gpio_mockup_num_ranges, 0400); |
69 | |
70 | static bool gpio_mockup_named_lines; |
71 | module_param_named(gpio_mockup_named_lines, |
72 | gpio_mockup_named_lines, bool, 0400); |
73 | |
74 | static struct dentry *gpio_mockup_dbg_dir; |
75 | |
76 | static int gpio_mockup_range_base(unsigned int index) |
77 | { |
78 | return gpio_mockup_ranges[index * 2]; |
79 | } |
80 | |
81 | static int gpio_mockup_range_ngpio(unsigned int index) |
82 | { |
83 | return gpio_mockup_ranges[index * 2 + 1]; |
84 | } |
85 | |
86 | static int __gpio_mockup_get(struct gpio_mockup_chip *chip, |
87 | unsigned int offset) |
88 | { |
89 | return chip->lines[offset].value; |
90 | } |
91 | |
92 | static int gpio_mockup_get(struct gpio_chip *gc, unsigned int offset) |
93 | { |
94 | struct gpio_mockup_chip *chip = gpiochip_get_data(gc); |
95 | int val; |
96 | |
97 | scoped_guard(mutex, &chip->lock) |
98 | val = __gpio_mockup_get(chip, offset); |
99 | |
100 | return val; |
101 | } |
102 | |
103 | static int gpio_mockup_get_multiple(struct gpio_chip *gc, |
104 | unsigned long *mask, unsigned long *bits) |
105 | { |
106 | struct gpio_mockup_chip *chip = gpiochip_get_data(gc); |
107 | unsigned int bit, val; |
108 | |
109 | scoped_guard(mutex, &chip->lock) { |
110 | for_each_set_bit(bit, mask, gc->ngpio) { |
111 | val = __gpio_mockup_get(chip, offset: bit); |
112 | __assign_bit(nr: bit, addr: bits, value: val); |
113 | } |
114 | } |
115 | |
116 | return 0; |
117 | } |
118 | |
119 | static void __gpio_mockup_set(struct gpio_mockup_chip *chip, |
120 | unsigned int offset, int value) |
121 | { |
122 | chip->lines[offset].value = !!value; |
123 | } |
124 | |
125 | static void gpio_mockup_set(struct gpio_chip *gc, |
126 | unsigned int offset, int value) |
127 | { |
128 | struct gpio_mockup_chip *chip = gpiochip_get_data(gc); |
129 | |
130 | guard(mutex)(T: &chip->lock); |
131 | |
132 | __gpio_mockup_set(chip, offset, value); |
133 | } |
134 | |
135 | static void gpio_mockup_set_multiple(struct gpio_chip *gc, |
136 | unsigned long *mask, unsigned long *bits) |
137 | { |
138 | struct gpio_mockup_chip *chip = gpiochip_get_data(gc); |
139 | unsigned int bit; |
140 | |
141 | guard(mutex)(T: &chip->lock); |
142 | |
143 | for_each_set_bit(bit, mask, gc->ngpio) |
144 | __gpio_mockup_set(chip, offset: bit, test_bit(bit, bits)); |
145 | } |
146 | |
147 | static int gpio_mockup_apply_pull(struct gpio_mockup_chip *chip, |
148 | unsigned int offset, int value) |
149 | { |
150 | struct gpio_mockup_line_status *line = &chip->lines[offset]; |
151 | int curr, irq, irq_type, ret = 0; |
152 | |
153 | guard(mutex)(T: &chip->lock); |
154 | |
155 | if (line->requested && line->dir == GPIO_LINE_DIRECTION_IN) { |
156 | curr = __gpio_mockup_get(chip, offset); |
157 | if (curr == value) |
158 | goto out; |
159 | |
160 | irq = irq_find_mapping(domain: chip->irq_sim_domain, hwirq: offset); |
161 | if (!irq) |
162 | /* |
163 | * This is fine - it just means, nobody is listening |
164 | * for interrupts on this line, otherwise |
165 | * irq_create_mapping() would have been called from |
166 | * the to_irq() callback. |
167 | */ |
168 | goto set_value; |
169 | |
170 | irq_type = irq_get_trigger_type(irq); |
171 | |
172 | if ((value == 1 && (irq_type & IRQ_TYPE_EDGE_RISING)) || |
173 | (value == 0 && (irq_type & IRQ_TYPE_EDGE_FALLING))) { |
174 | ret = irq_set_irqchip_state(irq, which: IRQCHIP_STATE_PENDING, |
175 | state: true); |
176 | if (ret) |
177 | goto out; |
178 | } |
179 | } |
180 | |
181 | set_value: |
182 | /* Change the value unless we're actively driving the line. */ |
183 | if (!line->requested || line->dir == GPIO_LINE_DIRECTION_IN) |
184 | __gpio_mockup_set(chip, offset, value); |
185 | |
186 | out: |
187 | chip->lines[offset].pull = value; |
188 | return ret; |
189 | } |
190 | |
191 | static int gpio_mockup_set_config(struct gpio_chip *gc, |
192 | unsigned int offset, unsigned long config) |
193 | { |
194 | struct gpio_mockup_chip *chip = gpiochip_get_data(gc); |
195 | |
196 | switch (pinconf_to_config_param(config)) { |
197 | case PIN_CONFIG_BIAS_PULL_UP: |
198 | return gpio_mockup_apply_pull(chip, offset, value: 1); |
199 | case PIN_CONFIG_BIAS_PULL_DOWN: |
200 | return gpio_mockup_apply_pull(chip, offset, value: 0); |
201 | default: |
202 | break; |
203 | } |
204 | return -ENOTSUPP; |
205 | } |
206 | |
207 | static int gpio_mockup_dirout(struct gpio_chip *gc, |
208 | unsigned int offset, int value) |
209 | { |
210 | struct gpio_mockup_chip *chip = gpiochip_get_data(gc); |
211 | |
212 | scoped_guard(mutex, &chip->lock) { |
213 | chip->lines[offset].dir = GPIO_LINE_DIRECTION_OUT; |
214 | __gpio_mockup_set(chip, offset, value); |
215 | } |
216 | |
217 | return 0; |
218 | } |
219 | |
220 | static int gpio_mockup_dirin(struct gpio_chip *gc, unsigned int offset) |
221 | { |
222 | struct gpio_mockup_chip *chip = gpiochip_get_data(gc); |
223 | |
224 | scoped_guard(mutex, &chip->lock) |
225 | chip->lines[offset].dir = GPIO_LINE_DIRECTION_IN; |
226 | |
227 | return 0; |
228 | } |
229 | |
230 | static int gpio_mockup_get_direction(struct gpio_chip *gc, unsigned int offset) |
231 | { |
232 | struct gpio_mockup_chip *chip = gpiochip_get_data(gc); |
233 | int direction; |
234 | |
235 | scoped_guard(mutex, &chip->lock) |
236 | direction = chip->lines[offset].dir; |
237 | |
238 | return direction; |
239 | } |
240 | |
241 | static int gpio_mockup_to_irq(struct gpio_chip *gc, unsigned int offset) |
242 | { |
243 | struct gpio_mockup_chip *chip = gpiochip_get_data(gc); |
244 | |
245 | return irq_create_mapping(host: chip->irq_sim_domain, hwirq: offset); |
246 | } |
247 | |
248 | static int gpio_mockup_request(struct gpio_chip *gc, unsigned int offset) |
249 | { |
250 | struct gpio_mockup_chip *chip = gpiochip_get_data(gc); |
251 | |
252 | scoped_guard(mutex, &chip->lock) |
253 | chip->lines[offset].requested = true; |
254 | |
255 | return 0; |
256 | } |
257 | |
258 | static void gpio_mockup_free(struct gpio_chip *gc, unsigned int offset) |
259 | { |
260 | struct gpio_mockup_chip *chip = gpiochip_get_data(gc); |
261 | |
262 | guard(mutex)(T: &chip->lock); |
263 | |
264 | chip->lines[offset].requested = false; |
265 | __gpio_mockup_set(chip, offset, value: chip->lines[offset].pull); |
266 | } |
267 | |
268 | static ssize_t gpio_mockup_debugfs_read(struct file *file, |
269 | char __user *usr_buf, |
270 | size_t size, loff_t *ppos) |
271 | { |
272 | struct gpio_mockup_dbgfs_private *priv; |
273 | struct gpio_mockup_chip *chip; |
274 | struct seq_file *sfile; |
275 | struct gpio_chip *gc; |
276 | int val, cnt; |
277 | char buf[3]; |
278 | |
279 | if (*ppos != 0) |
280 | return 0; |
281 | |
282 | sfile = file->private_data; |
283 | priv = sfile->private; |
284 | chip = priv->chip; |
285 | gc = &chip->gc; |
286 | |
287 | val = gpio_mockup_get(gc, offset: priv->offset); |
288 | cnt = snprintf(buf, size: sizeof(buf), fmt: "%d\n" , val); |
289 | |
290 | return simple_read_from_buffer(to: usr_buf, count: size, ppos, from: buf, available: cnt); |
291 | } |
292 | |
293 | static ssize_t gpio_mockup_debugfs_write(struct file *file, |
294 | const char __user *usr_buf, |
295 | size_t size, loff_t *ppos) |
296 | { |
297 | struct gpio_mockup_dbgfs_private *priv; |
298 | int rv, val; |
299 | struct seq_file *sfile; |
300 | |
301 | if (*ppos != 0) |
302 | return -EINVAL; |
303 | |
304 | rv = kstrtoint_from_user(s: usr_buf, count: size, base: 0, res: &val); |
305 | if (rv) |
306 | return rv; |
307 | if (val != 0 && val != 1) |
308 | return -EINVAL; |
309 | |
310 | sfile = file->private_data; |
311 | priv = sfile->private; |
312 | rv = gpio_mockup_apply_pull(chip: priv->chip, offset: priv->offset, value: val); |
313 | if (rv) |
314 | return rv; |
315 | |
316 | return size; |
317 | } |
318 | |
319 | static int gpio_mockup_debugfs_open(struct inode *inode, struct file *file) |
320 | { |
321 | return single_open(file, NULL, inode->i_private); |
322 | } |
323 | |
324 | /* |
325 | * Each mockup chip is represented by a directory named after the chip's device |
326 | * name under /sys/kernel/debug/gpio-mockup/. Each line is represented by |
327 | * a file using the line's offset as the name under the chip's directory. |
328 | * |
329 | * Reading from the line's file yields the current *value*, writing to the |
330 | * line's file changes the current *pull*. Default pull for mockup lines is |
331 | * down. |
332 | * |
333 | * Examples: |
334 | * - when a line pulled down is requested in output mode and driven high, its |
335 | * value will return to 0 once it's released |
336 | * - when the line is requested in output mode and driven high, writing 0 to |
337 | * the corresponding debugfs file will change the pull to down but the |
338 | * reported value will still be 1 until the line is released |
339 | * - line requested in input mode always reports the same value as its pull |
340 | * configuration |
341 | * - when the line is requested in input mode and monitored for events, writing |
342 | * the same value to the debugfs file will be a noop, while writing the |
343 | * opposite value will generate a dummy interrupt with an appropriate edge |
344 | */ |
345 | static const struct file_operations gpio_mockup_debugfs_ops = { |
346 | .owner = THIS_MODULE, |
347 | .open = gpio_mockup_debugfs_open, |
348 | .read = gpio_mockup_debugfs_read, |
349 | .write = gpio_mockup_debugfs_write, |
350 | .llseek = no_llseek, |
351 | .release = single_release, |
352 | }; |
353 | |
354 | static void gpio_mockup_debugfs_setup(struct device *dev, |
355 | struct gpio_mockup_chip *chip) |
356 | { |
357 | struct gpio_mockup_dbgfs_private *priv; |
358 | struct gpio_chip *gc; |
359 | const char *devname; |
360 | char *name; |
361 | int i; |
362 | |
363 | gc = &chip->gc; |
364 | |
365 | /* |
366 | * There can only be a single GPIO device per platform device in |
367 | * gpio-mockup so using device_find_any_child() is OK. |
368 | */ |
369 | struct device *child __free(put_device) = device_find_any_child(parent: dev); |
370 | if (!child) |
371 | return; |
372 | |
373 | devname = dev_name(dev: child); |
374 | chip->dbg_dir = debugfs_create_dir(name: devname, parent: gpio_mockup_dbg_dir); |
375 | |
376 | for (i = 0; i < gc->ngpio; i++) { |
377 | name = devm_kasprintf(dev, GFP_KERNEL, fmt: "%d" , i); |
378 | if (!name) |
379 | return; |
380 | |
381 | priv = devm_kzalloc(dev, size: sizeof(*priv), GFP_KERNEL); |
382 | if (!priv) |
383 | return; |
384 | |
385 | priv->chip = chip; |
386 | priv->offset = i; |
387 | |
388 | debugfs_create_file(name, mode: 0600, parent: chip->dbg_dir, data: priv, |
389 | fops: &gpio_mockup_debugfs_ops); |
390 | } |
391 | } |
392 | |
393 | static void gpio_mockup_debugfs_cleanup(void *data) |
394 | { |
395 | struct gpio_mockup_chip *chip = data; |
396 | |
397 | debugfs_remove_recursive(dentry: chip->dbg_dir); |
398 | } |
399 | |
400 | static void gpio_mockup_dispose_mappings(void *data) |
401 | { |
402 | struct gpio_mockup_chip *chip = data; |
403 | struct gpio_chip *gc = &chip->gc; |
404 | int i, irq; |
405 | |
406 | for (i = 0; i < gc->ngpio; i++) { |
407 | irq = irq_find_mapping(domain: chip->irq_sim_domain, hwirq: i); |
408 | if (irq) |
409 | irq_dispose_mapping(virq: irq); |
410 | } |
411 | } |
412 | |
413 | static int gpio_mockup_probe(struct platform_device *pdev) |
414 | { |
415 | struct gpio_mockup_chip *chip; |
416 | struct gpio_chip *gc; |
417 | struct device *dev; |
418 | const char *name; |
419 | int rv, base, i; |
420 | u16 ngpio; |
421 | |
422 | dev = &pdev->dev; |
423 | |
424 | rv = device_property_read_u32(dev, propname: "gpio-base" , val: &base); |
425 | if (rv) |
426 | base = -1; |
427 | |
428 | rv = device_property_read_u16(dev, propname: "nr-gpios" , val: &ngpio); |
429 | if (rv) |
430 | return rv; |
431 | |
432 | rv = device_property_read_string(dev, propname: "chip-label" , val: &name); |
433 | if (rv) |
434 | name = dev_name(dev); |
435 | |
436 | chip = devm_kzalloc(dev, size: sizeof(*chip), GFP_KERNEL); |
437 | if (!chip) |
438 | return -ENOMEM; |
439 | |
440 | mutex_init(&chip->lock); |
441 | |
442 | gc = &chip->gc; |
443 | gc->base = base; |
444 | gc->ngpio = ngpio; |
445 | gc->label = name; |
446 | gc->owner = THIS_MODULE; |
447 | gc->parent = dev; |
448 | gc->get = gpio_mockup_get; |
449 | gc->set = gpio_mockup_set; |
450 | gc->get_multiple = gpio_mockup_get_multiple; |
451 | gc->set_multiple = gpio_mockup_set_multiple; |
452 | gc->direction_output = gpio_mockup_dirout; |
453 | gc->direction_input = gpio_mockup_dirin; |
454 | gc->get_direction = gpio_mockup_get_direction; |
455 | gc->set_config = gpio_mockup_set_config; |
456 | gc->to_irq = gpio_mockup_to_irq; |
457 | gc->request = gpio_mockup_request; |
458 | gc->free = gpio_mockup_free; |
459 | |
460 | chip->lines = devm_kcalloc(dev, n: gc->ngpio, |
461 | size: sizeof(*chip->lines), GFP_KERNEL); |
462 | if (!chip->lines) |
463 | return -ENOMEM; |
464 | |
465 | for (i = 0; i < gc->ngpio; i++) |
466 | chip->lines[i].dir = GPIO_LINE_DIRECTION_IN; |
467 | |
468 | chip->irq_sim_domain = devm_irq_domain_create_sim(dev, NULL, |
469 | num_irqs: gc->ngpio); |
470 | if (IS_ERR(ptr: chip->irq_sim_domain)) |
471 | return PTR_ERR(ptr: chip->irq_sim_domain); |
472 | |
473 | rv = devm_add_action_or_reset(dev, gpio_mockup_dispose_mappings, chip); |
474 | if (rv) |
475 | return rv; |
476 | |
477 | rv = devm_gpiochip_add_data(dev, &chip->gc, chip); |
478 | if (rv) |
479 | return rv; |
480 | |
481 | gpio_mockup_debugfs_setup(dev, chip); |
482 | |
483 | return devm_add_action_or_reset(dev, gpio_mockup_debugfs_cleanup, chip); |
484 | } |
485 | |
486 | static const struct of_device_id gpio_mockup_of_match[] = { |
487 | { .compatible = "gpio-mockup" , }, |
488 | {}, |
489 | }; |
490 | MODULE_DEVICE_TABLE(of, gpio_mockup_of_match); |
491 | |
492 | static struct platform_driver gpio_mockup_driver = { |
493 | .driver = { |
494 | .name = "gpio-mockup" , |
495 | .of_match_table = gpio_mockup_of_match, |
496 | }, |
497 | .probe = gpio_mockup_probe, |
498 | }; |
499 | |
500 | static struct platform_device *gpio_mockup_pdevs[GPIO_MOCKUP_MAX_GC]; |
501 | |
502 | static void gpio_mockup_unregister_pdevs(void) |
503 | { |
504 | struct platform_device *pdev; |
505 | struct fwnode_handle *fwnode; |
506 | int i; |
507 | |
508 | for (i = 0; i < GPIO_MOCKUP_MAX_GC; i++) { |
509 | pdev = gpio_mockup_pdevs[i]; |
510 | if (!pdev) |
511 | continue; |
512 | |
513 | fwnode = dev_fwnode(&pdev->dev); |
514 | platform_device_unregister(pdev); |
515 | fwnode_remove_software_node(fwnode); |
516 | } |
517 | } |
518 | |
519 | static int __init gpio_mockup_register_chip(int idx) |
520 | { |
521 | struct property_entry properties[GPIO_MOCKUP_MAX_PROP]; |
522 | struct platform_device_info pdevinfo; |
523 | struct platform_device *pdev; |
524 | struct fwnode_handle *fwnode; |
525 | char **line_names = NULL; |
526 | char chip_label[32]; |
527 | int prop = 0, base; |
528 | u16 ngpio; |
529 | |
530 | memset(properties, 0, sizeof(properties)); |
531 | memset(&pdevinfo, 0, sizeof(pdevinfo)); |
532 | |
533 | snprintf(buf: chip_label, size: sizeof(chip_label), fmt: "gpio-mockup-%c" , idx + 'A'); |
534 | properties[prop++] = PROPERTY_ENTRY_STRING("chip-label" , chip_label); |
535 | |
536 | base = gpio_mockup_range_base(index: idx); |
537 | if (base >= 0) |
538 | properties[prop++] = PROPERTY_ENTRY_U32("gpio-base" , base); |
539 | |
540 | ngpio = base < 0 ? gpio_mockup_range_ngpio(index: idx) |
541 | : gpio_mockup_range_ngpio(index: idx) - base; |
542 | properties[prop++] = PROPERTY_ENTRY_U16("nr-gpios" , ngpio); |
543 | |
544 | if (gpio_mockup_named_lines) { |
545 | line_names = kasprintf_strarray(GFP_KERNEL, prefix: chip_label, n: ngpio); |
546 | if (!line_names) |
547 | return -ENOMEM; |
548 | |
549 | properties[prop++] = PROPERTY_ENTRY_STRING_ARRAY_LEN( |
550 | "gpio-line-names" , line_names, ngpio); |
551 | } |
552 | |
553 | fwnode = fwnode_create_software_node(properties, NULL); |
554 | if (IS_ERR(ptr: fwnode)) { |
555 | kfree_strarray(array: line_names, n: ngpio); |
556 | return PTR_ERR(ptr: fwnode); |
557 | } |
558 | |
559 | pdevinfo.name = "gpio-mockup" ; |
560 | pdevinfo.id = idx; |
561 | pdevinfo.fwnode = fwnode; |
562 | |
563 | pdev = platform_device_register_full(pdevinfo: &pdevinfo); |
564 | kfree_strarray(array: line_names, n: ngpio); |
565 | if (IS_ERR(ptr: pdev)) { |
566 | fwnode_remove_software_node(fwnode); |
567 | pr_err("error registering device" ); |
568 | return PTR_ERR(ptr: pdev); |
569 | } |
570 | |
571 | gpio_mockup_pdevs[idx] = pdev; |
572 | |
573 | return 0; |
574 | } |
575 | |
576 | static int __init gpio_mockup_init(void) |
577 | { |
578 | int i, num_chips, err; |
579 | |
580 | if ((gpio_mockup_num_ranges % 2) || |
581 | (gpio_mockup_num_ranges > GPIO_MOCKUP_MAX_RANGES)) |
582 | return -EINVAL; |
583 | |
584 | /* Each chip is described by two values. */ |
585 | num_chips = gpio_mockup_num_ranges / 2; |
586 | |
587 | /* |
588 | * The second value in the <base GPIO - number of GPIOS> pair must |
589 | * always be greater than 0. |
590 | */ |
591 | for (i = 0; i < num_chips; i++) { |
592 | if (gpio_mockup_range_ngpio(index: i) < 0) |
593 | return -EINVAL; |
594 | } |
595 | |
596 | gpio_mockup_dbg_dir = debugfs_create_dir(name: "gpio-mockup" , NULL); |
597 | |
598 | err = platform_driver_register(&gpio_mockup_driver); |
599 | if (err) { |
600 | pr_err("error registering platform driver\n" ); |
601 | debugfs_remove_recursive(dentry: gpio_mockup_dbg_dir); |
602 | return err; |
603 | } |
604 | |
605 | for (i = 0; i < num_chips; i++) { |
606 | err = gpio_mockup_register_chip(idx: i); |
607 | if (err) { |
608 | platform_driver_unregister(&gpio_mockup_driver); |
609 | gpio_mockup_unregister_pdevs(); |
610 | debugfs_remove_recursive(dentry: gpio_mockup_dbg_dir); |
611 | return err; |
612 | } |
613 | } |
614 | |
615 | return 0; |
616 | } |
617 | |
618 | static void __exit gpio_mockup_exit(void) |
619 | { |
620 | gpio_mockup_unregister_pdevs(); |
621 | debugfs_remove_recursive(dentry: gpio_mockup_dbg_dir); |
622 | platform_driver_unregister(&gpio_mockup_driver); |
623 | } |
624 | |
625 | module_init(gpio_mockup_init); |
626 | module_exit(gpio_mockup_exit); |
627 | |
628 | MODULE_AUTHOR("Kamlakant Patel <kamlakant.patel@broadcom.com>" ); |
629 | MODULE_AUTHOR("Bamvor Jian Zhang <bamv2005@gmail.com>" ); |
630 | MODULE_AUTHOR("Bartosz Golaszewski <brgl@bgdev.pl>" ); |
631 | MODULE_DESCRIPTION("GPIO Testing driver" ); |
632 | MODULE_LICENSE("GPL v2" ); |
633 | |