1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46#include <linux/module.h>
47#include <linux/pci.h>
48#include <linux/spinlock.h>
49#include <linux/gpio.h>
50#include <linux/slab.h>
51
52
53#include "../media/pci/bt8xx/bt848.h"
54
55
56#define BT8XXGPIO_NR_GPIOS 24
57
58
59struct bt8xxgpio {
60 spinlock_t lock;
61
62 void __iomem *mmio;
63 struct pci_dev *pdev;
64 struct gpio_chip gpio;
65
66#ifdef CONFIG_PM
67 u32 saved_outen;
68 u32 saved_data;
69#endif
70};
71
72#define bgwrite(dat, adr) writel((dat), bg->mmio+(adr))
73#define bgread(adr) readl(bg->mmio+(adr))
74
75
76static int modparam_gpiobase = -1;
77module_param_named(gpiobase, modparam_gpiobase, int, 0444);
78MODULE_PARM_DESC(gpiobase, "The GPIO number base. -1 means dynamic, which is the default.");
79
80
81static int bt8xxgpio_gpio_direction_input(struct gpio_chip *gpio, unsigned nr)
82{
83 struct bt8xxgpio *bg = gpiochip_get_data(gpio);
84 unsigned long flags;
85 u32 outen, data;
86
87 spin_lock_irqsave(&bg->lock, flags);
88
89 data = bgread(BT848_GPIO_DATA);
90 data &= ~(1 << nr);
91 bgwrite(data, BT848_GPIO_DATA);
92
93 outen = bgread(BT848_GPIO_OUT_EN);
94 outen &= ~(1 << nr);
95 bgwrite(outen, BT848_GPIO_OUT_EN);
96
97 spin_unlock_irqrestore(&bg->lock, flags);
98
99 return 0;
100}
101
102static int bt8xxgpio_gpio_get(struct gpio_chip *gpio, unsigned nr)
103{
104 struct bt8xxgpio *bg = gpiochip_get_data(gpio);
105 unsigned long flags;
106 u32 val;
107
108 spin_lock_irqsave(&bg->lock, flags);
109 val = bgread(BT848_GPIO_DATA);
110 spin_unlock_irqrestore(&bg->lock, flags);
111
112 return !!(val & (1 << nr));
113}
114
115static int bt8xxgpio_gpio_direction_output(struct gpio_chip *gpio,
116 unsigned nr, int val)
117{
118 struct bt8xxgpio *bg = gpiochip_get_data(gpio);
119 unsigned long flags;
120 u32 outen, data;
121
122 spin_lock_irqsave(&bg->lock, flags);
123
124 outen = bgread(BT848_GPIO_OUT_EN);
125 outen |= (1 << nr);
126 bgwrite(outen, BT848_GPIO_OUT_EN);
127
128 data = bgread(BT848_GPIO_DATA);
129 if (val)
130 data |= (1 << nr);
131 else
132 data &= ~(1 << nr);
133 bgwrite(data, BT848_GPIO_DATA);
134
135 spin_unlock_irqrestore(&bg->lock, flags);
136
137 return 0;
138}
139
140static void bt8xxgpio_gpio_set(struct gpio_chip *gpio,
141 unsigned nr, int val)
142{
143 struct bt8xxgpio *bg = gpiochip_get_data(gpio);
144 unsigned long flags;
145 u32 data;
146
147 spin_lock_irqsave(&bg->lock, flags);
148
149 data = bgread(BT848_GPIO_DATA);
150 if (val)
151 data |= (1 << nr);
152 else
153 data &= ~(1 << nr);
154 bgwrite(data, BT848_GPIO_DATA);
155
156 spin_unlock_irqrestore(&bg->lock, flags);
157}
158
159static void bt8xxgpio_gpio_setup(struct bt8xxgpio *bg)
160{
161 struct gpio_chip *c = &bg->gpio;
162
163 c->label = dev_name(&bg->pdev->dev);
164 c->owner = THIS_MODULE;
165 c->direction_input = bt8xxgpio_gpio_direction_input;
166 c->get = bt8xxgpio_gpio_get;
167 c->direction_output = bt8xxgpio_gpio_direction_output;
168 c->set = bt8xxgpio_gpio_set;
169 c->dbg_show = NULL;
170 c->base = modparam_gpiobase;
171 c->ngpio = BT8XXGPIO_NR_GPIOS;
172 c->can_sleep = false;
173}
174
175static int bt8xxgpio_probe(struct pci_dev *dev,
176 const struct pci_device_id *pci_id)
177{
178 struct bt8xxgpio *bg;
179 int err;
180
181 bg = devm_kzalloc(&dev->dev, sizeof(struct bt8xxgpio), GFP_KERNEL);
182 if (!bg)
183 return -ENOMEM;
184
185 bg->pdev = dev;
186 spin_lock_init(&bg->lock);
187
188 err = pci_enable_device(dev);
189 if (err) {
190 printk(KERN_ERR "bt8xxgpio: Can't enable device.\n");
191 return err;
192 }
193 if (!devm_request_mem_region(&dev->dev, pci_resource_start(dev, 0),
194 pci_resource_len(dev, 0),
195 "bt8xxgpio")) {
196 printk(KERN_WARNING "bt8xxgpio: Can't request iomem (0x%llx).\n",
197 (unsigned long long)pci_resource_start(dev, 0));
198 err = -EBUSY;
199 goto err_disable;
200 }
201 pci_set_master(dev);
202 pci_set_drvdata(dev, bg);
203
204 bg->mmio = devm_ioremap(&dev->dev, pci_resource_start(dev, 0), 0x1000);
205 if (!bg->mmio) {
206 printk(KERN_ERR "bt8xxgpio: ioremap() failed\n");
207 err = -EIO;
208 goto err_disable;
209 }
210
211
212 bgwrite(0, BT848_INT_MASK);
213
214
215 bgwrite(0, BT848_GPIO_DMA_CTL);
216 bgwrite(0, BT848_GPIO_REG_INP);
217 bgwrite(0, BT848_GPIO_OUT_EN);
218
219 bt8xxgpio_gpio_setup(bg);
220 err = gpiochip_add_data(&bg->gpio, bg);
221 if (err) {
222 printk(KERN_ERR "bt8xxgpio: Failed to register GPIOs\n");
223 goto err_disable;
224 }
225
226 return 0;
227
228err_disable:
229 pci_disable_device(dev);
230
231 return err;
232}
233
234static void bt8xxgpio_remove(struct pci_dev *pdev)
235{
236 struct bt8xxgpio *bg = pci_get_drvdata(pdev);
237
238 gpiochip_remove(&bg->gpio);
239
240 bgwrite(0, BT848_INT_MASK);
241 bgwrite(~0x0, BT848_INT_STAT);
242 bgwrite(0x0, BT848_GPIO_OUT_EN);
243
244 pci_disable_device(pdev);
245}
246
247#ifdef CONFIG_PM
248static int bt8xxgpio_suspend(struct pci_dev *pdev, pm_message_t state)
249{
250 struct bt8xxgpio *bg = pci_get_drvdata(pdev);
251 unsigned long flags;
252
253 spin_lock_irqsave(&bg->lock, flags);
254
255 bg->saved_outen = bgread(BT848_GPIO_OUT_EN);
256 bg->saved_data = bgread(BT848_GPIO_DATA);
257
258 bgwrite(0, BT848_INT_MASK);
259 bgwrite(~0x0, BT848_INT_STAT);
260 bgwrite(0x0, BT848_GPIO_OUT_EN);
261
262 spin_unlock_irqrestore(&bg->lock, flags);
263
264 pci_save_state(pdev);
265 pci_disable_device(pdev);
266 pci_set_power_state(pdev, pci_choose_state(pdev, state));
267
268 return 0;
269}
270
271static int bt8xxgpio_resume(struct pci_dev *pdev)
272{
273 struct bt8xxgpio *bg = pci_get_drvdata(pdev);
274 unsigned long flags;
275 int err;
276
277 pci_set_power_state(pdev, PCI_D0);
278 err = pci_enable_device(pdev);
279 if (err)
280 return err;
281 pci_restore_state(pdev);
282
283 spin_lock_irqsave(&bg->lock, flags);
284
285 bgwrite(0, BT848_INT_MASK);
286 bgwrite(0, BT848_GPIO_DMA_CTL);
287 bgwrite(0, BT848_GPIO_REG_INP);
288 bgwrite(bg->saved_outen, BT848_GPIO_OUT_EN);
289 bgwrite(bg->saved_data & bg->saved_outen,
290 BT848_GPIO_DATA);
291
292 spin_unlock_irqrestore(&bg->lock, flags);
293
294 return 0;
295}
296#else
297#define bt8xxgpio_suspend NULL
298#define bt8xxgpio_resume NULL
299#endif
300
301static const struct pci_device_id bt8xxgpio_pci_tbl[] = {
302 { PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848) },
303 { PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849) },
304 { PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878) },
305 { PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879) },
306 { 0, },
307};
308MODULE_DEVICE_TABLE(pci, bt8xxgpio_pci_tbl);
309
310static struct pci_driver bt8xxgpio_pci_driver = {
311 .name = "bt8xxgpio",
312 .id_table = bt8xxgpio_pci_tbl,
313 .probe = bt8xxgpio_probe,
314 .remove = bt8xxgpio_remove,
315 .suspend = bt8xxgpio_suspend,
316 .resume = bt8xxgpio_resume,
317};
318
319module_pci_driver(bt8xxgpio_pci_driver);
320
321MODULE_LICENSE("GPL");
322MODULE_AUTHOR("Michael Buesch");
323MODULE_DESCRIPTION("Abuse a BT8xx framegrabber card as generic GPIO card");
324
