1/*
2 * GE PIO2 6U VME I/O Driver
3 *
4 * Author: Martyn Welch <martyn.welch@ge.com>
5 * Copyright 2009 GE Intelligent Platforms Embedded Systems, Inc.
6 *
7 * This program is free software; you can redistribute  it and/or modify it
8 * under  the terms of  the GNU General  Public License as published by the
9 * Free Software Foundation;  either version 2 of the  License, or (at your
10 * option) any later version.
11 */
12
13#include <linux/version.h>
14#include <linux/module.h>
15#include <linux/moduleparam.h>
16#include <linux/types.h>
17#include <linux/kernel.h>
18#include <linux/errno.h>
19#include <linux/device.h>
20#include <linux/ctype.h>
21#include <linux/gpio.h>
22#include <linux/slab.h>
23
24#include "../vme.h"
25#include "vme_pio2.h"
26
27
28static const char driver_name[] = "pio2";
29
30static int bus[PIO2_CARDS_MAX];
31static int bus_num;
32static long base[PIO2_CARDS_MAX];
33static int base_num;
34static int vector[PIO2_CARDS_MAX];
35static int vector_num;
36static int level[PIO2_CARDS_MAX];
37static int level_num;
38static char *variant[PIO2_CARDS_MAX];
39static int variant_num;
40
41static bool loopback;
42
43static int pio2_match(struct vme_dev *);
44static int __devinit pio2_probe(struct vme_dev *);
45static int __devexit pio2_remove(struct vme_dev *);
46
47static int pio2_get_led(struct pio2_card *card)
48{
49	/* Can't read hardware, state saved in structure */
50	return card->led;
51}
52
53static int pio2_set_led(struct pio2_card *card, int state)
54{
55	u8 reg;
56	int retval;
57
58	reg = card->irq_level;
59
60	/* Register state inverse of led state */
61	if (!state)
62		reg |= PIO2_LED;
63
64	if (loopback)
65		reg |= PIO2_LOOP;
66
67	retval = vme_master_write(card->window, &reg, 1, PIO2_REGS_CTRL);
68	if (retval < 0)
69		return retval;
70
71	card->led = state ? 1 : 0;
72
73	return 0;
74}
75
76static void pio2_int(int level, int vector, void *ptr)
77{
78	int vec, i, channel, retval;
79	u8 reg;
80	struct pio2_card *card  = ptr;
81
82	vec = vector & ~PIO2_VME_VECTOR_MASK;
83
84	switch (vec) {
85	case 0:
86		dev_warn(&card->vdev->dev, "Spurious Interrupt\n");
87		break;
88	case 1:
89	case 2:
90	case 3:
91	case 4:
92		/* Channels 0 to 7 */
93		retval = vme_master_read(card->window, &reg, 1,
94			PIO2_REGS_INT_STAT[vec - 1]);
95		if (retval < 0) {
96			dev_err(&card->vdev->dev,
97				"Unable to read IRQ status register\n");
98			return;
99		}
100		for (i = 0; i < 8; i++) {
101			channel = ((vec - 1) * 8) + i;
102			if (reg & PIO2_CHANNEL_BIT[channel])
103				dev_info(&card->vdev->dev,
104					"Interrupt on I/O channel %d\n",
105					channel);
106		}
107		break;
108	case 5:
109	case 6:
110	case 7:
111	case 8:
112	case 9:
113	case 10:
114		/* Counters are dealt with by their own handler */
115		dev_err(&card->vdev->dev,
116			"Counter interrupt\n");
117		break;
118	}
119}
120
121
122/*
123 * We return whether this has been successful - this is used in the probe to
124 * ensure we have a valid card.
125 */
126static int pio2_reset_card(struct pio2_card *card)
127{
128	int retval = 0;
129	u8 data = 0;
130
131	/* Clear main register*/
132	retval = vme_master_write(card->window, &data, 1, PIO2_REGS_CTRL);
133	if (retval < 0)
134		return retval;
135
136	/* Clear VME vector */
137	retval = vme_master_write(card->window, &data, 1, PIO2_REGS_VME_VECTOR);
138	if (retval < 0)
139		return retval;
140
141	/* Reset GPIO */
142	retval = pio2_gpio_reset(card);
143	if (retval < 0)
144		return retval;
145
146	/* Reset counters */
147	retval = pio2_cntr_reset(card);
148	if (retval < 0)
149		return retval;
150
151	return 0;
152}
153
154static struct vme_driver pio2_driver = {
155	.name = driver_name,
156	.match = pio2_match,
157	.probe = pio2_probe,
158	.remove = __devexit_p(pio2_remove),
159};
160
161
162static int __init pio2_init(void)
163{
164	int retval = 0;
165
166	if (bus_num == 0) {
167		printk(KERN_ERR "%s: No cards, skipping registration\n",
168			driver_name);
169		goto err_nocard;
170	}
171
172	if (bus_num > PIO2_CARDS_MAX) {
173		printk(KERN_ERR
174			"%s: Driver only able to handle %d PIO2 Cards\n",
175			driver_name, PIO2_CARDS_MAX);
176		bus_num = PIO2_CARDS_MAX;
177	}
178
179	/* Register the PIO2 driver */
180	retval = vme_register_driver(&pio2_driver, bus_num);
181	if (retval != 0)
182		goto err_reg;
183
184	return retval;
185
186err_reg:
187err_nocard:
188	return retval;
189}
190
191static int pio2_match(struct vme_dev *vdev)
192{
193
194	if (vdev->num >= bus_num) {
195		dev_err(&vdev->dev,
196			"The enumeration of the VMEbus to which the board is connected must be specified");
197		return 0;
198	}
199
200	if (vdev->num >= base_num) {
201		dev_err(&vdev->dev,
202			"The VME address for the cards registers must be specified");
203		return 0;
204	}
205
206	if (vdev->num >= vector_num) {
207		dev_err(&vdev->dev,
208			"The IRQ vector used by the card must be specified");
209		return 0;
210	}
211
212	if (vdev->num >= level_num) {
213		dev_err(&vdev->dev,
214			"The IRQ level used by the card must be specified");
215		return 0;
216	}
217
218	if (vdev->num >= variant_num) {
219		dev_err(&vdev->dev, "The variant of the card must be specified");
220		return 0;
221	}
222
223	return 1;
224}
225
226static int __devinit pio2_probe(struct vme_dev *vdev)
227{
228	struct pio2_card *card;
229	int retval;
230	int i;
231	u8 reg;
232	int vec;
233
234	card = kzalloc(sizeof(struct pio2_card), GFP_KERNEL);
235	if (card == NULL) {
236		dev_err(&vdev->dev, "Unable to allocate card structure\n");
237		retval = -ENOMEM;
238		goto err_struct;
239	}
240
241	card->id = vdev->num;
242	card->bus = bus[card->id];
243	card->base = base[card->id];
244	card->irq_vector = vector[card->id];
245	card->irq_level = level[card->id] & PIO2_VME_INT_MASK;
246	strncpy(card->variant, variant[card->id], PIO2_VARIANT_LENGTH);
247	card->vdev = vdev;
248
249	for (i = 0; i < PIO2_VARIANT_LENGTH; i++) {
250
251		if (isdigit(card->variant[i]) == 0) {
252			dev_err(&card->vdev->dev, "Variant invalid\n");
253			retval = -EINVAL;
254			goto err_variant;
255		}
256	}
257
258	/*
259	 * Bottom 4 bits of VME interrupt vector used to determine source,
260	 * provided vector should only use upper 4 bits.
261	 */
262	if (card->irq_vector & ~PIO2_VME_VECTOR_MASK) {
263		dev_err(&card->vdev->dev,
264			"Invalid VME IRQ Vector, vector must not use lower 4 bits\n");
265		retval = -EINVAL;
266		goto err_vector;
267	}
268
269	/*
270	 * There is no way to determine the build variant or whether each bank
271	 * is input, output or both at run time. The inputs are also inverted
272	 * if configured as both.
273	 *
274	 * We pass in the board variant and use that to determine the
275	 * configuration of the banks.
276	 */
277	for (i = 1; i < PIO2_VARIANT_LENGTH; i++) {
278		switch (card->variant[i]) {
279		case '0':
280			card->bank[i-1].config = NOFIT;
281			break;
282		case '1':
283		case '2':
284		case '3':
285		case '4':
286			card->bank[i-1].config = INPUT;
287			break;
288		case '5':
289			card->bank[i-1].config = OUTPUT;
290			break;
291		case '6':
292		case '7':
293		case '8':
294		case '9':
295			card->bank[i-1].config = BOTH;
296			break;
297		}
298	}
299
300	/* Get a master window and position over regs */
301	card->window = vme_master_request(vdev, VME_A24, VME_SCT, VME_D16);
302	if (card->window == NULL) {
303		dev_err(&card->vdev->dev,
304			"Unable to assign VME master resource\n");
305		retval = -EIO;
306		goto err_window;
307	}
308
309	retval = vme_master_set(card->window, 1, card->base, 0x10000, VME_A24,
310		(VME_SCT | VME_USER | VME_DATA), VME_D16);
311	if (retval) {
312		dev_err(&card->vdev->dev,
313			"Unable to configure VME master resource\n");
314		goto err_set;
315	}
316
317	/*
318	 * There is also no obvious register which we can probe to determine
319	 * whether the provided base is valid. If we can read the "ID Register"
320	 * offset and the reset function doesn't error, assume we have a valid
321	 * location.
322	 */
323	retval = vme_master_read(card->window, &reg, 1, PIO2_REGS_ID);
324	if (retval < 0) {
325		dev_err(&card->vdev->dev, "Unable to read from device\n");
326		goto err_read;
327	}
328
329	dev_dbg(&card->vdev->dev, "ID Register:%x\n", reg);
330
331	/*
332	 * Ensure all the I/O is cleared. We can't read back the states, so
333	 * this is the only method we have to ensure that the I/O is in a known
334	 * state.
335	 */
336	retval = pio2_reset_card(card);
337	if (retval) {
338		dev_err(&card->vdev->dev,
339			"Failed to reset card, is location valid?");
340		retval = -ENODEV;
341		goto err_reset;
342	}
343
344	/* Configure VME Interrupts */
345	reg = card->irq_level;
346	if (pio2_get_led(card))
347		reg |= PIO2_LED;
348	if (loopback)
349		reg |= PIO2_LOOP;
350	retval = vme_master_write(card->window, &reg, 1, PIO2_REGS_CTRL);
351	if (retval < 0)
352		return retval;
353
354	/* Set VME vector */
355	retval = vme_master_write(card->window, &card->irq_vector, 1,
356		PIO2_REGS_VME_VECTOR);
357	if (retval < 0)
358		return retval;
359
360	/* Attach spurious interrupt handler. */
361	vec = card->irq_vector | PIO2_VME_VECTOR_SPUR;
362
363	retval = vme_irq_request(vdev, card->irq_level, vec,
364		&pio2_int, (void *)card);
365	if (retval < 0) {
366		dev_err(&card->vdev->dev,
367			"Unable to attach VME interrupt vector0x%x, level 0x%x\n",
368			 vec, card->irq_level);
369		goto err_irq;
370	}
371
372	/* Attach GPIO interrupt handlers. */
373	for (i = 0; i < 4; i++) {
374		vec = card->irq_vector | PIO2_VECTOR_BANK[i];
375
376		retval = vme_irq_request(vdev, card->irq_level, vec,
377			&pio2_int, (void *)card);
378		if (retval < 0) {
379			dev_err(&card->vdev->dev,
380				"Unable to attach VME interrupt vector0x%x, level 0x%x\n",
381				 vec, card->irq_level);
382			goto err_gpio_irq;
383		}
384	}
385
386	/* Attach counter interrupt handlers. */
387	for (i = 0; i < 6; i++) {
388		vec = card->irq_vector | PIO2_VECTOR_CNTR[i];
389
390		retval = vme_irq_request(vdev, card->irq_level, vec,
391			&pio2_int, (void *)card);
392		if (retval < 0) {
393			dev_err(&card->vdev->dev,
394				"Unable to attach VME interrupt vector0x%x, level 0x%x\n",
395				vec, card->irq_level);
396			goto err_cntr_irq;
397		}
398	}
399
400	/* Register IO */
401	retval = pio2_gpio_init(card);
402	if (retval < 0) {
403		dev_err(&card->vdev->dev,
404			"Unable to register with GPIO framework\n");
405		goto err_gpio;
406	}
407
408	/* Set LED - This also sets interrupt level */
409	retval = pio2_set_led(card, 0);
410	if (retval < 0) {
411		dev_err(&card->vdev->dev, "Unable to set LED\n");
412		goto err_led;
413	}
414
415	dev_set_drvdata(&card->vdev->dev, card);
416
417	dev_info(&card->vdev->dev,
418		"PIO2 (variant %s) configured at 0x%lx\n", card->variant,
419		card->base);
420
421	return 0;
422
423err_led:
424	pio2_gpio_exit(card);
425err_gpio:
426	i = 6;
427err_cntr_irq:
428	while (i > 0) {
429		i--;
430		vec = card->irq_vector | PIO2_VECTOR_CNTR[i];
431		vme_irq_free(vdev, card->irq_level, vec);
432	}
433
434	i = 4;
435err_gpio_irq:
436	while (i > 0) {
437		i--;
438		vec = card->irq_vector | PIO2_VECTOR_BANK[i];
439		vme_irq_free(vdev, card->irq_level, vec);
440	}
441
442	vec = (card->irq_vector & PIO2_VME_VECTOR_MASK) | PIO2_VME_VECTOR_SPUR;
443	vme_irq_free(vdev, card->irq_level, vec);
444err_irq:
445	 pio2_reset_card(card);
446err_reset:
447err_read:
448	vme_master_set(card->window, 0, 0, 0, VME_A16, 0, VME_D16);
449err_set:
450	vme_master_free(card->window);
451err_window:
452err_vector:
453err_variant:
454	kfree(card);
455err_struct:
456	return retval;
457}
458
459static int __devexit pio2_remove(struct vme_dev *vdev)
460{
461	int vec;
462	int i;
463
464	struct pio2_card *card = dev_get_drvdata(&vdev->dev);
465
466	pio2_gpio_exit(card);
467
468	for (i = 0; i < 6; i++) {
469		vec = card->irq_vector | PIO2_VECTOR_CNTR[i];
470		vme_irq_free(vdev, card->irq_level, vec);
471	}
472
473	for (i = 0; i < 4; i++) {
474		vec = card->irq_vector | PIO2_VECTOR_BANK[i];
475		vme_irq_free(vdev, card->irq_level, vec);
476	}
477
478	vec = (card->irq_vector & PIO2_VME_VECTOR_MASK) | PIO2_VME_VECTOR_SPUR;
479	vme_irq_free(vdev, card->irq_level, vec);
480
481	pio2_reset_card(card);
482
483	vme_master_set(card->window, 0, 0, 0, VME_A16, 0, VME_D16);
484
485	vme_master_free(card->window);
486
487	kfree(card);
488
489	return 0;
490}
491
492static void __exit pio2_exit(void)
493{
494	vme_unregister_driver(&pio2_driver);
495}
496
497
498/* These are required for each board */
499MODULE_PARM_DESC(bus, "Enumeration of VMEbus to which the board is connected");
500module_param_array(bus, int, &bus_num, S_IRUGO);
501
502MODULE_PARM_DESC(base, "Base VME address for PIO2 Registers");
503module_param_array(base, long, &base_num, S_IRUGO);
504
505MODULE_PARM_DESC(vector, "VME IRQ Vector (Lower 4 bits masked)");
506module_param_array(vector, int, &vector_num, S_IRUGO);
507
508MODULE_PARM_DESC(level, "VME IRQ Level");
509module_param_array(level, int, &level_num, S_IRUGO);
510
511MODULE_PARM_DESC(variant, "Last 4 characters of PIO2 board variant");
512module_param_array(variant, charp, &variant_num, S_IRUGO);
513
514/* This is for debugging */
515MODULE_PARM_DESC(loopback, "Enable loopback mode on all cards");
516module_param(loopback, bool, S_IRUGO);
517
518MODULE_DESCRIPTION("GE PIO2 6U VME I/O Driver");
519MODULE_AUTHOR("Martyn Welch <martyn.welch@ge.com");
520MODULE_LICENSE("GPL");
521
522module_init(pio2_init);
523module_exit(pio2_exit);
524
525