Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * GPIO interface for IT87xx Super I/O chips
4 *
5 * Author: Diego Elio Pettenò <flameeyes@flameeyes.eu>
6 * Copyright (c) 2017 Google, Inc.
7 *
8 * Based on it87_wdt.c by Oliver Schuster
9 * gpio-it8761e.c by Denis Turischev
10 * gpio-stmpe.c by Rabin Vincent
11 */
12
13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
15#include <linux/init.h>
16#include <linux/kernel.h>
17#include <linux/module.h>
18#include <linux/io.h>
19#include <linux/errno.h>
20#include <linux/ioport.h>
21#include <linux/slab.h>
22#include <linux/gpio/driver.h>
23
24/* Chip Id numbers */
25#define NO_DEV_ID 0xffff
26#define IT8613_ID 0x8613
27#define IT8620_ID 0x8620
28#define IT8628_ID 0x8628
29#define IT8718_ID 0x8718
30#define IT8728_ID 0x8728
31#define IT8732_ID 0x8732
32#define IT8761_ID 0x8761
33#define IT8772_ID 0x8772
34#define IT8786_ID 0x8786
35
36/* IO Ports */
37#define REG 0x2e
38#define VAL 0x2f
39
40/* Logical device Numbers LDN */
41#define GPIO 0x07
42
43/* Configuration Registers and Functions */
44#define LDNREG 0x07
45#define CHIPID 0x20
46#define CHIPREV 0x22
47
48/**
49 * struct it87_gpio - it87-specific GPIO chip
50 * @chip: the underlying gpio_chip structure
51 * @lock: a lock to avoid races between operations
52 * @io_base: base address for gpio ports
53 * @io_size: size of the port rage starting from io_base.
54 * @output_base: Super I/O register address for Output Enable register
55 * @simple_base: Super I/O 'Simple I/O' Enable register
56 * @simple_size: Super IO 'Simple I/O' Enable register size; this is
57 * required because IT87xx chips might only provide Simple I/O
58 * switches on a subset of lines, whereas the others keep the
59 * same status all time.
60 */
61struct it87_gpio {
62 struct gpio_chip chip;
63 spinlock_t lock;
64 u16 io_base;
65 u16 io_size;
66 u8 output_base;
67 u8 simple_base;
68 u8 simple_size;
69};
70
71static struct it87_gpio it87_gpio_chip = {
72 .lock = __SPIN_LOCK_UNLOCKED(it87_gpio_chip.lock),
73};
74
75/* Superio chip access functions; copied from wdt_it87 */
76
77static inline int superio_enter(void)
78{
79 /*
80 * Try to reserve REG and REG + 1 for exclusive access.
81 */
82 if (!request_muxed_region(REG, 2, KBUILD_MODNAME))
83 return -EBUSY;
84
85 outb(0x87, REG);
86 outb(0x01, REG);
87 outb(0x55, REG);
88 outb(0x55, REG);
89 return 0;
90}
91
92static inline void superio_exit(void)
93{
94 outb(0x02, REG);
95 outb(0x02, VAL);
96 release_region(REG, 2);
97}
98
99static inline void superio_select(int ldn)
100{
101 outb(LDNREG, REG);
102 outb(ldn, VAL);
103}
104
105static inline int superio_inb(int reg)
106{
107 outb(reg, REG);
108 return inb(VAL);
109}
110
111static inline void superio_outb(int val, int reg)
112{
113 outb(reg, REG);
114 outb(val, VAL);
115}
116
117static inline int superio_inw(int reg)
118{
119 int val;
120
121 outb(reg++, REG);
122 val = inb(VAL) << 8;
123 outb(reg, REG);
124 val |= inb(VAL);
125 return val;
126}
127
128static inline void superio_outw(int val, int reg)
129{
130 outb(reg++, REG);
131 outb(val >> 8, VAL);
132 outb(reg, REG);
133 outb(val, VAL);
134}
135
136static inline void superio_set_mask(int mask, int reg)
137{
138 u8 curr_val = superio_inb(reg);
139 u8 new_val = curr_val | mask;
140
141 if (curr_val != new_val)
142 superio_outb(new_val, reg);
143}
144
145static inline void superio_clear_mask(int mask, int reg)
146{
147 u8 curr_val = superio_inb(reg);
148 u8 new_val = curr_val & ~mask;
149
150 if (curr_val != new_val)
151 superio_outb(new_val, reg);
152}
153
154static int it87_gpio_request(struct gpio_chip *chip, unsigned gpio_num)
155{
156 u8 mask, group;
157 int rc = 0;
158 struct it87_gpio *it87_gpio = gpiochip_get_data(chip);
159
160 mask = 1 << (gpio_num % 8);
161 group = (gpio_num / 8);
162
163 spin_lock(&it87_gpio->lock);
164
165 rc = superio_enter();
166 if (rc)
167 goto exit;
168
169 /* not all the IT87xx chips support Simple I/O and not all of
170 * them allow all the lines to be set/unset to Simple I/O.
171 */
172 if (group < it87_gpio->simple_size)
173 superio_set_mask(mask, group + it87_gpio->simple_base);
174
175 /* clear output enable, setting the pin to input, as all the
176 * newly-exported GPIO interfaces are set to input.
177 */
178 superio_clear_mask(mask, group + it87_gpio->output_base);
179
180 superio_exit();
181
182exit:
183 spin_unlock(&it87_gpio->lock);
184 return rc;
185}
186
187static int it87_gpio_get(struct gpio_chip *chip, unsigned gpio_num)
188{
189 u16 reg;
190 u8 mask;
191 struct it87_gpio *it87_gpio = gpiochip_get_data(chip);
192
193 mask = 1 << (gpio_num % 8);
194 reg = (gpio_num / 8) + it87_gpio->io_base;
195
196 return !!(inb(reg) & mask);
197}
198
199static int it87_gpio_direction_in(struct gpio_chip *chip, unsigned gpio_num)
200{
201 u8 mask, group;
202 int rc = 0;
203 struct it87_gpio *it87_gpio = gpiochip_get_data(chip);
204
205 mask = 1 << (gpio_num % 8);
206 group = (gpio_num / 8);
207
208 spin_lock(&it87_gpio->lock);
209
210 rc = superio_enter();
211 if (rc)
212 goto exit;
213
214 /* clear the output enable bit */
215 superio_clear_mask(mask, group + it87_gpio->output_base);
216
217 superio_exit();
218
219exit:
220 spin_unlock(&it87_gpio->lock);
221 return rc;
222}
223
224static void it87_gpio_set(struct gpio_chip *chip,
225 unsigned gpio_num, int val)
226{
227 u8 mask, curr_vals;
228 u16 reg;
229 struct it87_gpio *it87_gpio = gpiochip_get_data(chip);
230
231 mask = 1 << (gpio_num % 8);
232 reg = (gpio_num / 8) + it87_gpio->io_base;
233
234 curr_vals = inb(reg);
235 if (val)
236 outb(curr_vals | mask, reg);
237 else
238 outb(curr_vals & ~mask, reg);
239}
240
241static int it87_gpio_direction_out(struct gpio_chip *chip,
242 unsigned gpio_num, int val)
243{
244 u8 mask, group;
245 int rc = 0;
246 struct it87_gpio *it87_gpio = gpiochip_get_data(chip);
247
248 mask = 1 << (gpio_num % 8);
249 group = (gpio_num / 8);
250
251 spin_lock(&it87_gpio->lock);
252
253 rc = superio_enter();
254 if (rc)
255 goto exit;
256
257 /* set the output enable bit */
258 superio_set_mask(mask, group + it87_gpio->output_base);
259
260 it87_gpio_set(chip, gpio_num, val);
261
262 superio_exit();
263
264exit:
265 spin_unlock(&it87_gpio->lock);
266 return rc;
267}
268
269static const struct gpio_chip it87_template_chip = {
270 .label = KBUILD_MODNAME,
271 .owner = THIS_MODULE,
272 .request = it87_gpio_request,
273 .get = it87_gpio_get,
274 .direction_input = it87_gpio_direction_in,
275 .set = it87_gpio_set,
276 .direction_output = it87_gpio_direction_out,
277 .base = -1
278};
279
280static int __init it87_gpio_init(void)
281{
282 int rc = 0, i;
283 u16 chip_type;
284 u8 chip_rev, gpio_ba_reg;
285 char *labels, **labels_table;
286
287 struct it87_gpio *it87_gpio = &it87_gpio_chip;
288
289 rc = superio_enter();
290 if (rc)
291 return rc;
292
293 chip_type = superio_inw(CHIPID);
294 chip_rev = superio_inb(CHIPREV) & 0x0f;
295 superio_exit();
296
297 it87_gpio->chip = it87_template_chip;
298
299 switch (chip_type) {
300 case IT8613_ID:
301 gpio_ba_reg = 0x62;
302 it87_gpio->io_size = 8; /* it8613 only needs 6, use 8 for alignment */
303 it87_gpio->output_base = 0xc8;
304 it87_gpio->simple_base = 0xc0;
305 it87_gpio->simple_size = 6;
306 it87_gpio->chip.ngpio = 64; /* has 48, use 64 for convenient calc */
307 break;
308 case IT8620_ID:
309 case IT8628_ID:
310 gpio_ba_reg = 0x62;
311 it87_gpio->io_size = 11;
312 it87_gpio->output_base = 0xc8;
313 it87_gpio->simple_size = 0;
314 it87_gpio->chip.ngpio = 64;
315 break;
316 case IT8718_ID:
317 case IT8728_ID:
318 case IT8732_ID:
319 case IT8772_ID:
320 case IT8786_ID:
321 gpio_ba_reg = 0x62;
322 it87_gpio->io_size = 8;
323 it87_gpio->output_base = 0xc8;
324 it87_gpio->simple_base = 0xc0;
325 it87_gpio->simple_size = 5;
326 it87_gpio->chip.ngpio = 64;
327 break;
328 case IT8761_ID:
329 gpio_ba_reg = 0x60;
330 it87_gpio->io_size = 4;
331 it87_gpio->output_base = 0xf0;
332 it87_gpio->simple_size = 0;
333 it87_gpio->chip.ngpio = 16;
334 break;
335 case NO_DEV_ID:
336 pr_err("no device\n");
337 return -ENODEV;
338 default:
339 pr_err("Unknown Chip found, Chip %04x Revision %x\n",
340 chip_type, chip_rev);
341 return -ENODEV;
342 }
343
344 rc = superio_enter();
345 if (rc)
346 return rc;
347
348 superio_select(GPIO);
349
350 /* fetch GPIO base address */
351 it87_gpio->io_base = superio_inw(gpio_ba_reg);
352
353 superio_exit();
354
355 pr_info("Found Chip IT%04x rev %x. %u GPIO lines starting at %04xh\n",
356 chip_type, chip_rev, it87_gpio->chip.ngpio,
357 it87_gpio->io_base);
358
359 if (!request_region(it87_gpio->io_base, it87_gpio->io_size,
360 KBUILD_MODNAME))
361 return -EBUSY;
362
363 /* Set up aliases for the GPIO connection.
364 *
365 * ITE documentation for recent chips such as the IT8728F
366 * refers to the GPIO lines as GPxy, with a coordinates system
367 * where x is the GPIO group (starting from 1) and y is the
368 * bit within the group.
369 *
370 * By creating these aliases, we make it easier to understand
371 * to which GPIO pin we're referring to.
372 */
373 labels = kcalloc(it87_gpio->chip.ngpio, sizeof("it87_gpXY"),
374 GFP_KERNEL);
375 labels_table = kcalloc(it87_gpio->chip.ngpio, sizeof(const char *),
376 GFP_KERNEL);
377
378 if (!labels || !labels_table) {
379 rc = -ENOMEM;
380 goto labels_free;
381 }
382
383 for (i = 0; i < it87_gpio->chip.ngpio; i++) {
384 char *label = &labels[i * sizeof("it87_gpXY")];
385
386 sprintf(label, "it87_gp%u%u", 1+(i/8), i%8);
387 labels_table[i] = label;
388 }
389
390 it87_gpio->chip.names = (const char *const*)labels_table;
391
392 rc = gpiochip_add_data(&it87_gpio->chip, it87_gpio);
393 if (rc)
394 goto labels_free;
395
396 return 0;
397
398labels_free:
399 kfree(labels_table);
400 kfree(labels);
401 release_region(it87_gpio->io_base, it87_gpio->io_size);
402 return rc;
403}
404
405static void __exit it87_gpio_exit(void)
406{
407 struct it87_gpio *it87_gpio = &it87_gpio_chip;
408
409 gpiochip_remove(&it87_gpio->chip);
410 release_region(it87_gpio->io_base, it87_gpio->io_size);
411 kfree(it87_gpio->chip.names[0]);
412 kfree(it87_gpio->chip.names);
413}
414
415module_init(it87_gpio_init);
416module_exit(it87_gpio_exit);
417
418MODULE_AUTHOR("Diego Elio Pettenò <flameeyes@flameeyes.eu>");
419MODULE_DESCRIPTION("GPIO interface for IT87xx Super I/O chips");
420MODULE_LICENSE("GPL");
1/*
2 * GPIO interface for IT87xx Super I/O chips
3 *
4 * Author: Diego Elio Pettenò <flameeyes@flameeyes.eu>
5 * Copyright (c) 2017 Google, Inc.
6 *
7 * Based on it87_wdt.c by Oliver Schuster
8 * gpio-it8761e.c by Denis Turischev
9 * gpio-stmpe.c by Rabin Vincent
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License 2 as published
13 * by the Free Software Foundation.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; see the file COPYING. If not, write to
22 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26
27#include <linux/init.h>
28#include <linux/kernel.h>
29#include <linux/module.h>
30#include <linux/io.h>
31#include <linux/errno.h>
32#include <linux/ioport.h>
33#include <linux/slab.h>
34#include <linux/gpio/driver.h>
35
36/* Chip Id numbers */
37#define NO_DEV_ID 0xffff
38#define IT8620_ID 0x8620
39#define IT8628_ID 0x8628
40#define IT8728_ID 0x8728
41#define IT8732_ID 0x8732
42#define IT8761_ID 0x8761
43#define IT8772_ID 0x8772
44
45/* IO Ports */
46#define REG 0x2e
47#define VAL 0x2f
48
49/* Logical device Numbers LDN */
50#define GPIO 0x07
51
52/* Configuration Registers and Functions */
53#define LDNREG 0x07
54#define CHIPID 0x20
55#define CHIPREV 0x22
56
57/**
58 * struct it87_gpio - it87-specific GPIO chip
59 * @chip the underlying gpio_chip structure
60 * @lock a lock to avoid races between operations
61 * @io_base base address for gpio ports
62 * @io_size size of the port rage starting from io_base.
63 * @output_base Super I/O register address for Output Enable register
64 * @simple_base Super I/O 'Simple I/O' Enable register
65 * @simple_size Super IO 'Simple I/O' Enable register size; this is
66 * required because IT87xx chips might only provide Simple I/O
67 * switches on a subset of lines, whereas the others keep the
68 * same status all time.
69 */
70struct it87_gpio {
71 struct gpio_chip chip;
72 spinlock_t lock;
73 u16 io_base;
74 u16 io_size;
75 u8 output_base;
76 u8 simple_base;
77 u8 simple_size;
78};
79
80static struct it87_gpio it87_gpio_chip = {
81 .lock = __SPIN_LOCK_UNLOCKED(it87_gpio_chip.lock),
82};
83
84/* Superio chip access functions; copied from wdt_it87 */
85
86static inline int superio_enter(void)
87{
88 /*
89 * Try to reserve REG and REG + 1 for exclusive access.
90 */
91 if (!request_muxed_region(REG, 2, KBUILD_MODNAME))
92 return -EBUSY;
93
94 outb(0x87, REG);
95 outb(0x01, REG);
96 outb(0x55, REG);
97 outb(0x55, REG);
98 return 0;
99}
100
101static inline void superio_exit(void)
102{
103 outb(0x02, REG);
104 outb(0x02, VAL);
105 release_region(REG, 2);
106}
107
108static inline void superio_select(int ldn)
109{
110 outb(LDNREG, REG);
111 outb(ldn, VAL);
112}
113
114static inline int superio_inb(int reg)
115{
116 outb(reg, REG);
117 return inb(VAL);
118}
119
120static inline void superio_outb(int val, int reg)
121{
122 outb(reg, REG);
123 outb(val, VAL);
124}
125
126static inline int superio_inw(int reg)
127{
128 int val;
129
130 outb(reg++, REG);
131 val = inb(VAL) << 8;
132 outb(reg, REG);
133 val |= inb(VAL);
134 return val;
135}
136
137static inline void superio_outw(int val, int reg)
138{
139 outb(reg++, REG);
140 outb(val >> 8, VAL);
141 outb(reg, REG);
142 outb(val, VAL);
143}
144
145static inline void superio_set_mask(int mask, int reg)
146{
147 u8 curr_val = superio_inb(reg);
148 u8 new_val = curr_val | mask;
149
150 if (curr_val != new_val)
151 superio_outb(new_val, reg);
152}
153
154static inline void superio_clear_mask(int mask, int reg)
155{
156 u8 curr_val = superio_inb(reg);
157 u8 new_val = curr_val & ~mask;
158
159 if (curr_val != new_val)
160 superio_outb(new_val, reg);
161}
162
163static int it87_gpio_request(struct gpio_chip *chip, unsigned gpio_num)
164{
165 u8 mask, group;
166 int rc = 0;
167 struct it87_gpio *it87_gpio = gpiochip_get_data(chip);
168
169 mask = 1 << (gpio_num % 8);
170 group = (gpio_num / 8);
171
172 spin_lock(&it87_gpio->lock);
173
174 rc = superio_enter();
175 if (rc)
176 goto exit;
177
178 /* not all the IT87xx chips support Simple I/O and not all of
179 * them allow all the lines to be set/unset to Simple I/O.
180 */
181 if (group < it87_gpio->simple_size)
182 superio_set_mask(mask, group + it87_gpio->simple_base);
183
184 /* clear output enable, setting the pin to input, as all the
185 * newly-exported GPIO interfaces are set to input.
186 */
187 superio_clear_mask(mask, group + it87_gpio->output_base);
188
189 superio_exit();
190
191exit:
192 spin_unlock(&it87_gpio->lock);
193 return rc;
194}
195
196static int it87_gpio_get(struct gpio_chip *chip, unsigned gpio_num)
197{
198 u16 reg;
199 u8 mask;
200 struct it87_gpio *it87_gpio = gpiochip_get_data(chip);
201
202 mask = 1 << (gpio_num % 8);
203 reg = (gpio_num / 8) + it87_gpio->io_base;
204
205 return !!(inb(reg) & mask);
206}
207
208static int it87_gpio_direction_in(struct gpio_chip *chip, unsigned gpio_num)
209{
210 u8 mask, group;
211 int rc = 0;
212 struct it87_gpio *it87_gpio = gpiochip_get_data(chip);
213
214 mask = 1 << (gpio_num % 8);
215 group = (gpio_num / 8);
216
217 spin_lock(&it87_gpio->lock);
218
219 rc = superio_enter();
220 if (rc)
221 goto exit;
222
223 /* clear the output enable bit */
224 superio_clear_mask(mask, group + it87_gpio->output_base);
225
226 superio_exit();
227
228exit:
229 spin_unlock(&it87_gpio->lock);
230 return rc;
231}
232
233static void it87_gpio_set(struct gpio_chip *chip,
234 unsigned gpio_num, int val)
235{
236 u8 mask, curr_vals;
237 u16 reg;
238 struct it87_gpio *it87_gpio = gpiochip_get_data(chip);
239
240 mask = 1 << (gpio_num % 8);
241 reg = (gpio_num / 8) + it87_gpio->io_base;
242
243 curr_vals = inb(reg);
244 if (val)
245 outb(curr_vals | mask, reg);
246 else
247 outb(curr_vals & ~mask, reg);
248}
249
250static int it87_gpio_direction_out(struct gpio_chip *chip,
251 unsigned gpio_num, int val)
252{
253 u8 mask, group;
254 int rc = 0;
255 struct it87_gpio *it87_gpio = gpiochip_get_data(chip);
256
257 mask = 1 << (gpio_num % 8);
258 group = (gpio_num / 8);
259
260 spin_lock(&it87_gpio->lock);
261
262 rc = superio_enter();
263 if (rc)
264 goto exit;
265
266 /* set the output enable bit */
267 superio_set_mask(mask, group + it87_gpio->output_base);
268
269 it87_gpio_set(chip, gpio_num, val);
270
271 superio_exit();
272
273exit:
274 spin_unlock(&it87_gpio->lock);
275 return rc;
276}
277
278static const struct gpio_chip it87_template_chip = {
279 .label = KBUILD_MODNAME,
280 .owner = THIS_MODULE,
281 .request = it87_gpio_request,
282 .get = it87_gpio_get,
283 .direction_input = it87_gpio_direction_in,
284 .set = it87_gpio_set,
285 .direction_output = it87_gpio_direction_out,
286 .base = -1
287};
288
289static int __init it87_gpio_init(void)
290{
291 int rc = 0, i;
292 u16 chip_type;
293 u8 chip_rev, gpio_ba_reg;
294 char *labels, **labels_table;
295
296 struct it87_gpio *it87_gpio = &it87_gpio_chip;
297
298 rc = superio_enter();
299 if (rc)
300 return rc;
301
302 chip_type = superio_inw(CHIPID);
303 chip_rev = superio_inb(CHIPREV) & 0x0f;
304 superio_exit();
305
306 it87_gpio->chip = it87_template_chip;
307
308 switch (chip_type) {
309 case IT8620_ID:
310 case IT8628_ID:
311 gpio_ba_reg = 0x62;
312 it87_gpio->io_size = 11;
313 it87_gpio->output_base = 0xc8;
314 it87_gpio->simple_size = 0;
315 it87_gpio->chip.ngpio = 64;
316 break;
317 case IT8728_ID:
318 case IT8732_ID:
319 case IT8772_ID:
320 gpio_ba_reg = 0x62;
321 it87_gpio->io_size = 8;
322 it87_gpio->output_base = 0xc8;
323 it87_gpio->simple_base = 0xc0;
324 it87_gpio->simple_size = 5;
325 it87_gpio->chip.ngpio = 64;
326 break;
327 case IT8761_ID:
328 gpio_ba_reg = 0x60;
329 it87_gpio->io_size = 4;
330 it87_gpio->output_base = 0xf0;
331 it87_gpio->simple_size = 0;
332 it87_gpio->chip.ngpio = 16;
333 break;
334 case NO_DEV_ID:
335 pr_err("no device\n");
336 return -ENODEV;
337 default:
338 pr_err("Unknown Chip found, Chip %04x Revision %x\n",
339 chip_type, chip_rev);
340 return -ENODEV;
341 }
342
343 rc = superio_enter();
344 if (rc)
345 return rc;
346
347 superio_select(GPIO);
348
349 /* fetch GPIO base address */
350 it87_gpio->io_base = superio_inw(gpio_ba_reg);
351
352 superio_exit();
353
354 pr_info("Found Chip IT%04x rev %x. %u GPIO lines starting at %04xh\n",
355 chip_type, chip_rev, it87_gpio->chip.ngpio,
356 it87_gpio->io_base);
357
358 if (!request_region(it87_gpio->io_base, it87_gpio->io_size,
359 KBUILD_MODNAME))
360 return -EBUSY;
361
362 /* Set up aliases for the GPIO connection.
363 *
364 * ITE documentation for recent chips such as the IT8728F
365 * refers to the GPIO lines as GPxy, with a coordinates system
366 * where x is the GPIO group (starting from 1) and y is the
367 * bit within the group.
368 *
369 * By creating these aliases, we make it easier to understand
370 * to which GPIO pin we're referring to.
371 */
372 labels = kcalloc(it87_gpio->chip.ngpio, sizeof("it87_gpXY"),
373 GFP_KERNEL);
374 labels_table = kcalloc(it87_gpio->chip.ngpio, sizeof(const char *),
375 GFP_KERNEL);
376
377 if (!labels || !labels_table) {
378 rc = -ENOMEM;
379 goto labels_free;
380 }
381
382 for (i = 0; i < it87_gpio->chip.ngpio; i++) {
383 char *label = &labels[i * sizeof("it87_gpXY")];
384
385 sprintf(label, "it87_gp%u%u", 1+(i/8), i%8);
386 labels_table[i] = label;
387 }
388
389 it87_gpio->chip.names = (const char *const*)labels_table;
390
391 rc = gpiochip_add_data(&it87_gpio->chip, it87_gpio);
392 if (rc)
393 goto labels_free;
394
395 return 0;
396
397labels_free:
398 kfree(labels_table);
399 kfree(labels);
400 release_region(it87_gpio->io_base, it87_gpio->io_size);
401 return rc;
402}
403
404static void __exit it87_gpio_exit(void)
405{
406 struct it87_gpio *it87_gpio = &it87_gpio_chip;
407
408 gpiochip_remove(&it87_gpio->chip);
409 release_region(it87_gpio->io_base, it87_gpio->io_size);
410 kfree(it87_gpio->chip.names[0]);
411 kfree(it87_gpio->chip.names);
412}
413
414module_init(it87_gpio_init);
415module_exit(it87_gpio_exit);
416
417MODULE_AUTHOR("Diego Elio Pettenò <flameeyes@flameeyes.eu>");
418MODULE_DESCRIPTION("GPIO interface for IT87xx Super I/O chips");
419MODULE_LICENSE("GPL");