]>
Commit | Line | Data |
---|---|---|
ead6db08 MG |
1 | /* |
2 | * 74Hx164 - Generic serial-in/parallel-out 8-bits shift register GPIO driver | |
3 | * | |
4 | * Copyright (C) 2010 Gabor Juhos <juhosg@openwrt.org> | |
5 | * Copyright (C) 2010 Miguel Gaio <miguel.gaio@efixo.com> | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License version 2 as | |
9 | * published by the Free Software Foundation. | |
10 | */ | |
11 | ||
12 | #include <linux/init.h> | |
13 | #include <linux/mutex.h> | |
14 | #include <linux/spi/spi.h> | |
15 | #include <linux/spi/74x164.h> | |
16 | #include <linux/gpio.h> | |
17 | #include <linux/slab.h> | |
bb207ef1 | 18 | #include <linux/module.h> |
ead6db08 | 19 | |
ead6db08 MG |
20 | struct gen_74x164_chip { |
21 | struct spi_device *spi; | |
22 | struct gpio_chip gpio_chip; | |
23 | struct mutex lock; | |
24 | u8 port_config; | |
25 | }; | |
26 | ||
12610be3 | 27 | static struct gen_74x164_chip *gpio_to_74x164_chip(struct gpio_chip *gc) |
ead6db08 MG |
28 | { |
29 | return container_of(gc, struct gen_74x164_chip, gpio_chip); | |
30 | } | |
31 | ||
32 | static int __gen_74x164_write_config(struct gen_74x164_chip *chip) | |
33 | { | |
34 | return spi_write(chip->spi, | |
35 | &chip->port_config, sizeof(chip->port_config)); | |
36 | } | |
37 | ||
ead6db08 MG |
38 | static int gen_74x164_get_value(struct gpio_chip *gc, unsigned offset) |
39 | { | |
12610be3 | 40 | struct gen_74x164_chip *chip = gpio_to_74x164_chip(gc); |
ead6db08 MG |
41 | int ret; |
42 | ||
43 | mutex_lock(&chip->lock); | |
44 | ret = (chip->port_config >> offset) & 0x1; | |
45 | mutex_unlock(&chip->lock); | |
46 | ||
47 | return ret; | |
48 | } | |
49 | ||
50 | static void gen_74x164_set_value(struct gpio_chip *gc, | |
51 | unsigned offset, int val) | |
52 | { | |
12610be3 | 53 | struct gen_74x164_chip *chip = gpio_to_74x164_chip(gc); |
ead6db08 MG |
54 | |
55 | mutex_lock(&chip->lock); | |
56 | if (val) | |
57 | chip->port_config |= (1 << offset); | |
58 | else | |
59 | chip->port_config &= ~(1 << offset); | |
60 | ||
61 | __gen_74x164_write_config(chip); | |
62 | mutex_unlock(&chip->lock); | |
63 | } | |
64 | ||
a3cc68c3 HS |
65 | static int gen_74x164_direction_output(struct gpio_chip *gc, |
66 | unsigned offset, int val) | |
67 | { | |
68 | gen_74x164_set_value(gc, offset, val); | |
69 | return 0; | |
70 | } | |
71 | ||
ead6db08 MG |
72 | static int __devinit gen_74x164_probe(struct spi_device *spi) |
73 | { | |
74 | struct gen_74x164_chip *chip; | |
75 | struct gen_74x164_chip_platform_data *pdata; | |
76 | int ret; | |
77 | ||
ead6db08 MG |
78 | /* |
79 | * bits_per_word cannot be configured in platform data | |
80 | */ | |
81 | spi->bits_per_word = 8; | |
82 | ||
83 | ret = spi_setup(spi); | |
84 | if (ret < 0) | |
85 | return ret; | |
86 | ||
72eac302 | 87 | chip = devm_kzalloc(&spi->dev, sizeof(*chip), GFP_KERNEL); |
ead6db08 MG |
88 | if (!chip) |
89 | return -ENOMEM; | |
90 | ||
061505fd MR |
91 | pdata = spi->dev.platform_data; |
92 | if (pdata && pdata->base) | |
93 | chip->gpio_chip.base = pdata->base; | |
94 | else | |
95 | chip->gpio_chip.base = -1; | |
96 | ||
ead6db08 MG |
97 | mutex_init(&chip->lock); |
98 | ||
99 | dev_set_drvdata(&spi->dev, chip); | |
100 | ||
101 | chip->spi = spi; | |
102 | ||
a3cc68c3 HS |
103 | chip->gpio_chip.label = spi->modalias; |
104 | chip->gpio_chip.direction_output = gen_74x164_direction_output; | |
ead6db08 MG |
105 | chip->gpio_chip.get = gen_74x164_get_value; |
106 | chip->gpio_chip.set = gen_74x164_set_value; | |
a3cc68c3 | 107 | chip->gpio_chip.ngpio = 8; |
ead6db08 MG |
108 | chip->gpio_chip.can_sleep = 1; |
109 | chip->gpio_chip.dev = &spi->dev; | |
110 | chip->gpio_chip.owner = THIS_MODULE; | |
111 | ||
112 | ret = __gen_74x164_write_config(chip); | |
113 | if (ret) { | |
114 | dev_err(&spi->dev, "Failed writing: %d\n", ret); | |
115 | goto exit_destroy; | |
116 | } | |
117 | ||
118 | ret = gpiochip_add(&chip->gpio_chip); | |
119 | if (ret) | |
120 | goto exit_destroy; | |
121 | ||
122 | return ret; | |
123 | ||
124 | exit_destroy: | |
125 | dev_set_drvdata(&spi->dev, NULL); | |
126 | mutex_destroy(&chip->lock); | |
ead6db08 MG |
127 | return ret; |
128 | } | |
129 | ||
fc1599f7 | 130 | static int __devexit gen_74x164_remove(struct spi_device *spi) |
ead6db08 MG |
131 | { |
132 | struct gen_74x164_chip *chip; | |
133 | int ret; | |
134 | ||
135 | chip = dev_get_drvdata(&spi->dev); | |
136 | if (chip == NULL) | |
137 | return -ENODEV; | |
138 | ||
139 | dev_set_drvdata(&spi->dev, NULL); | |
140 | ||
141 | ret = gpiochip_remove(&chip->gpio_chip); | |
72eac302 | 142 | if (!ret) |
ead6db08 | 143 | mutex_destroy(&chip->lock); |
72eac302 | 144 | else |
ead6db08 MG |
145 | dev_err(&spi->dev, "Failed to remove the GPIO controller: %d\n", |
146 | ret); | |
147 | ||
148 | return ret; | |
149 | } | |
150 | ||
0a90a9fb MR |
151 | static const struct of_device_id gen_74x164_dt_ids[] = { |
152 | { .compatible = "fairchild,74hc595" }, | |
153 | {}, | |
154 | }; | |
155 | MODULE_DEVICE_TABLE(of, gen_74x164_dt_ids); | |
156 | ||
ead6db08 MG |
157 | static struct spi_driver gen_74x164_driver = { |
158 | .driver = { | |
a3cc68c3 | 159 | .name = "74x164", |
ead6db08 | 160 | .owner = THIS_MODULE, |
0a90a9fb | 161 | .of_match_table = of_match_ptr(gen_74x164_dt_ids), |
ead6db08 MG |
162 | }, |
163 | .probe = gen_74x164_probe, | |
164 | .remove = __devexit_p(gen_74x164_remove), | |
165 | }; | |
ab3b8782 | 166 | module_spi_driver(gen_74x164_driver); |
ead6db08 MG |
167 | |
168 | MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>"); | |
169 | MODULE_AUTHOR("Miguel Gaio <miguel.gaio@efixo.com>"); | |
170 | MODULE_DESCRIPTION("GPIO expander driver for 74X164 8-bits shift register"); | |
171 | MODULE_LICENSE("GPL v2"); |