projects / openwrt / svn-archive / archive.git / blob
? search:


e6fe5fa40fec3dc467a0d932f7b916fecbbd4da3
[openwrt/svn-archive/archive.git] / target / linux / danube / files / drivers / char / danube_gpio.c
1 /*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
15 *
16 * Copyright (C) 2005 infineon
17 * Copyright (C) 2007 John Crispin <blogic@openwrt.org>
18 *
19 */
20
21 #include <linux/module.h>
22 #include <linux/types.h>
23 #include <linux/errno.h>
24 #include <linux/proc_fs.h>
25 #include <linux/init.h>
26 #include <linux/ioctl.h>
27 #include <asm/semaphore.h>
28 #include <asm/uaccess.h>
29 #include <asm/danube/danube.h>
30 #include <asm/danube/danube_ioctl.h>
31
32
33 #define DANUBE_PORT_OUT_REG 0x00000010
34 #define DANUBE_PORT_IN_REG 0x00000014
35 #define DANUBE_PORT_DIR_REG 0x00000018
36 #define DANUBE_PORT_ALTSEL0_REG 0x0000001C
37 #define DANUBE_PORT_ALTSEL1_REG 0x00000020
38 #define DANUBE_PORT_OD_REG 0x00000024
39 #define DANUBE_PORT_STOFF_REG 0x00000028
40 #define DANUBE_PORT_PUDSEL_REG 0x0000002C
41 #define DANUBE_PORT_PUDEN_REG 0x00000030
42
43 #define PORT_MODULE_ID 0xff
44
45 #define PORT_WRITE_REG(reg, value) \
46 *((volatile u32*)(reg)) = (u32)value;
47
48 #define PORT_READ_REG(reg, value) \
49 value = (u32)*((volatile u32*)(reg));
50
51 #define PORT_IOC_CALL(ret,port,pin,func) \
52 ret=danube_port_reserve_pin(port,pin,PORT_MODULE_ID); \
53 if (ret == 0) ret=func(port,pin,PORT_MODULE_ID); \
54 if (ret == 0) ret=danube_port_free_pin(port,pin,PORT_MODULE_ID);
55
56
57 #define MAX_PORTS 2 // Number of ports in system
58 #define PINS_PER_PORT 16 // Number of available pins per port
59
60 static int port_major = 0;
61 static int danube_port_pin_usage[MAX_PORTS][PINS_PER_PORT]; // Map for pin usage
62 static u32 danube_port_bases[MAX_PORTS]
63 = { DANUBE_GPIO,
64 DANUBE_GPIO + 0x00000030
65 }; // Base addresses for ports
66
67 static struct semaphore port_sem;
68
69 int
70 danube_port_reserve_pin (int port, int pin, int module_id)
71 {
72 if (port < 0 || pin < 0)
73 return -EINVAL;
74 if (port > MAX_PORTS || pin > PINS_PER_PORT)
75 return -EINVAL;
76
77 if (danube_port_pin_usage[port][pin] == 0) {
78 danube_port_pin_usage[port][pin] = module_id;
79 }
80 else {
81 return -EBUSY;
82 }
83
84 return 0;
85 }
86
87 int
88 danube_port_free_pin (int port, int pin, int module_id)
89 {
90
91 if (port < 0 || pin < 0)
92 return -EINVAL;
93 if (port > MAX_PORTS || pin > PINS_PER_PORT)
94 return -EINVAL;
95
96 if (danube_port_pin_usage[port][pin] != module_id)
97 return -EBUSY;
98 danube_port_pin_usage[port][pin] = 0;
99
100 return 0;
101 }
102
103 int
104 danube_port_set_open_drain (int port, int pin, int module_id)
105 {
106 u32 reg;
107
108 if (port < 0 || pin < 0)
109 return -EINVAL;
110 if (port > MAX_PORTS || pin > PINS_PER_PORT)
111 return -EINVAL;
112
113 if (danube_port_pin_usage[port][pin] != module_id)
114 return -EBUSY;
115
116 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_OD_REG, reg);
117 reg |= (1 << pin);
118 PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_OD_REG, reg);
119
120 return 0;
121 }
122
123 int
124 danube_port_clear_open_drain (int port, int pin, int module_id)
125 {
126 u32 reg;
127
128 if (port < 0 || pin < 0)
129 return -EINVAL;
130 if (port > MAX_PORTS || pin > PINS_PER_PORT)
131 return -EINVAL;
132
133 if (danube_port_pin_usage[port][pin] != module_id)
134 return -EBUSY;
135
136 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_OD_REG, reg);
137 reg &= ~(1 << pin);
138 PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_OD_REG, reg);
139
140 return 0;
141 }
142
143 int
144 danube_port_set_pudsel (int port, int pin, int module_id)
145 {
146 u32 reg;
147
148 if (port < 0 || pin < 0)
149 return -EINVAL;
150 if (port > MAX_PORTS || pin > PINS_PER_PORT)
151 return -EINVAL;
152
153 if (danube_port_pin_usage[port][pin] != module_id)
154 return -EBUSY;
155
156 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_PUDSEL_REG, reg);
157 reg |= (1 << pin);
158 PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_PUDSEL_REG,
159 reg);
160
161 return 0;
162 }
163
164 int
165 danube_port_clear_pudsel (int port, int pin, int module_id)
166 {
167 u32 reg;
168
169 if (port < 0 || pin < 0)
170 return -EINVAL;
171 if (port > MAX_PORTS || pin > PINS_PER_PORT)
172 return -EINVAL;
173
174 if (danube_port_pin_usage[port][pin] != module_id)
175 return -EBUSY;
176
177 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_PUDSEL_REG, reg);
178 reg &= ~(1 << pin);
179 PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_PUDSEL_REG,
180 reg);
181
182 return 0;
183 }
184
185 int
186 danube_port_set_puden (int port, int pin, int module_id)
187 {
188 u32 reg;
189
190 if (port < 0 || pin < 0)
191 return -EINVAL;
192 if (port > MAX_PORTS || pin > PINS_PER_PORT)
193 return -EINVAL;
194
195 if (danube_port_pin_usage[port][pin] != module_id)
196 return -EBUSY;
197
198 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_PUDEN_REG, reg);
199 reg |= (1 << pin);
200 PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_PUDEN_REG, reg);
201
202 return 0;
203 }
204
205 int
206 danube_port_clear_puden (int port, int pin, int module_id)
207 {
208 u32 reg;
209
210 if (port < 0 || pin < 0)
211 return -EINVAL;
212 if (port > MAX_PORTS || pin > PINS_PER_PORT)
213 return -EINVAL;
214
215 if (danube_port_pin_usage[port][pin] != module_id)
216 return -EBUSY;
217
218 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_PUDEN_REG, reg);
219 reg &= ~(1 << pin);
220 PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_PUDEN_REG, reg);
221
222 return 0;
223 }
224
225 int
226 danube_port_set_stoff (int port, int pin, int module_id)
227 {
228 u32 reg;
229
230 if (port < 0 || pin < 0)
231 return -EINVAL;
232 if (port > MAX_PORTS || pin > PINS_PER_PORT)
233 return -EINVAL;
234
235 if (danube_port_pin_usage[port][pin] != module_id)
236 return -EBUSY;
237
238 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_STOFF_REG, reg);
239 reg |= (1 << pin);
240 PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_STOFF_REG, reg);
241
242 return 0;
243 }
244
245 int
246 danube_port_clear_stoff (int port, int pin, int module_id)
247 {
248 u32 reg;
249
250 if (port < 0 || pin < 0)
251 return -EINVAL;
252 if (port > MAX_PORTS || pin > PINS_PER_PORT)
253 return -EINVAL;
254
255 if (danube_port_pin_usage[port][pin] != module_id)
256 return -EBUSY;
257
258 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_STOFF_REG, reg);
259 reg &= ~(1 << pin);
260 PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_STOFF_REG, reg);
261
262 return 0;
263 }
264
265 int
266 danube_port_set_dir_out (int port, int pin, int module_id)
267 {
268 u32 reg;
269
270 if (port < 0 || pin < 0)
271 return -EINVAL;
272 if (port > MAX_PORTS || pin > PINS_PER_PORT)
273 return -EINVAL;
274
275 if (danube_port_pin_usage[port][pin] != module_id)
276 return -EBUSY;
277
278 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_DIR_REG, reg);
279 reg |= (1 << pin);
280 PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_DIR_REG, reg);
281
282 return 0;
283 }
284
285 int
286 danube_port_set_dir_in (int port, int pin, int module_id)
287 {
288 u32 reg;
289
290 if (port < 0 || pin < 0)
291 return -EINVAL;
292 if (port > MAX_PORTS || pin > PINS_PER_PORT)
293 return -EINVAL;
294
295 if (danube_port_pin_usage[port][pin] != module_id)
296 return -EBUSY;
297
298 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_DIR_REG, reg);
299 reg &= ~(1 << pin);
300 PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_DIR_REG, reg);
301
302 return 0;
303 }
304
305 int
306 danube_port_set_output (int port, int pin, int module_id)
307 {
308 u32 reg;
309
310 if (port < 0 || pin < 0)
311 return -EINVAL;
312 if (port > MAX_PORTS || pin > PINS_PER_PORT)
313 return -EINVAL;
314
315 if (danube_port_pin_usage[port][pin] != module_id)
316 return -EBUSY;
317
318 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_OUT_REG, reg);
319 reg |= (1 << pin);
320 PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_OUT_REG, reg);
321
322 return 0;
323 }
324
325 int
326 danube_port_clear_output (int port, int pin, int module_id)
327 {
328 u32 reg;
329
330 if (port < 0 || pin < 0)
331 return -EINVAL;
332 if (port > MAX_PORTS || pin > PINS_PER_PORT)
333 return -EINVAL;
334
335 if (danube_port_pin_usage[port][pin] != module_id)
336 return -EBUSY;
337
338 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_OUT_REG, reg);
339 reg &= ~(1 << pin);
340 PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_OUT_REG, reg);
341
342 return 0;
343 }
344
345 int
346 danube_port_get_input (int port, int pin, int module_id)
347 {
348 u32 reg;
349
350 if (port < 0 || pin < 0)
351 return -EINVAL;
352 if (port > MAX_PORTS || pin > PINS_PER_PORT)
353 return -EINVAL;
354
355 if (danube_port_pin_usage[port][pin] != module_id)
356 return -EBUSY;
357
358 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_IN_REG, reg);
359 reg &= (1 << pin);
360 if (reg == 0x00)
361 return 0;
362 else
363 return 1;
364 }
365
366 int
367 danube_port_set_altsel0 (int port, int pin, int module_id)
368 {
369 u32 reg;
370
371 if (port < 0 || pin < 0)
372 return -EINVAL;
373 if (port > MAX_PORTS || pin > PINS_PER_PORT)
374 return -EINVAL;
375
376 if (danube_port_pin_usage[port][pin] != module_id)
377 return -EBUSY;
378
379 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL0_REG,
380 reg);
381 reg |= (1 << pin);
382 PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL0_REG,
383 reg);
384
385 return 0;
386 }
387
388 int
389 danube_port_clear_altsel0 (int port, int pin, int module_id)
390 {
391 u32 reg;
392
393 if (port < 0 || pin < 0)
394 return -EINVAL;
395 if (port > MAX_PORTS || pin > PINS_PER_PORT)
396 return -EINVAL;
397
398 if (danube_port_pin_usage[port][pin] != module_id)
399 return -EBUSY;
400
401 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL0_REG,
402 reg);
403 reg &= ~(1 << pin);
404 PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL0_REG,
405 reg);
406
407 return 0;
408 }
409
410 int
411 danube_port_set_altsel1 (int port, int pin, int module_id)
412 {
413 u32 reg;
414
415 if (port < 0 || pin < 0)
416 return -EINVAL;
417 if (port > MAX_PORTS || pin > PINS_PER_PORT)
418 return -EINVAL;
419
420 if (danube_port_pin_usage[port][pin] != module_id)
421 return -EBUSY;
422
423 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL1_REG,
424 reg);
425 reg |= (1 << pin);
426 PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL1_REG,
427 reg);
428
429 return 0;
430 }
431
432 int
433 danube_port_clear_altsel1 (int port, int pin, int module_id)
434 {
435 u32 reg;
436
437 if (port < 0 || pin < 0)
438 return -EINVAL;
439 if (port > MAX_PORTS || pin > PINS_PER_PORT)
440 return -EINVAL;
441
442 if (danube_port_pin_usage[port][pin] != module_id)
443 return -EBUSY;
444
445 PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL1_REG,
446 reg);
447 reg &= ~(1 << pin);
448 PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL1_REG,
449 reg);
450
451 return 0;
452 }
453
454 int
455 danube_port_read_procmem (char *buf, char **start, off_t offset, int count,
456 int *eof, void *data)
457 {
458 long len = 0;
459 int t = 0;
460 u32 bit = 0;
461 u32 reg = 0;
462
463 len = sprintf (buf, "\nDanube Port Settings\n");
464
465 len = len + sprintf (buf + len,
466 " 3 2 1 0\n");
467 len = len + sprintf (buf + len,
468 " 10987654321098765432109876543210\n");
469 len = len + sprintf (buf + len,
470 "----------------------------------------\n");
471
472 len = len + sprintf (buf + len, "\nP0-OUT: ");
473 PORT_READ_REG (DANUBE_GPIO_P0_OUT, reg);
474 bit = 0x80000000;
475 for (t = 0; t < 32; t++) {
476 if ((reg & bit) > 0)
477 len = len + sprintf (buf + len, "X");
478 else
479 len = len + sprintf (buf + len, " ");
480 bit = bit >> 1;
481 }
482
483 len = len + sprintf (buf + len, "\nP1-OUT: ");
484 PORT_READ_REG (DANUBE_GPIO_P1_OUT, reg);
485 bit = 0x80000000;
486 for (t = 0; t < 32; t++) {
487 if ((reg & bit) > 0)
488 len = len + sprintf (buf + len, "X");
489 else
490 len = len + sprintf (buf + len, " ");
491 bit = bit >> 1;
492 }
493
494 len = len + sprintf (buf + len, "\nP0-IN: ");
495 PORT_READ_REG (DANUBE_GPIO_P0_IN, reg);
496 bit = 0x80000000;
497 for (t = 0; t < 32; t++) {
498 if ((reg & bit) > 0)
499 len = len + sprintf (buf + len, "X");
500 else
501 len = len + sprintf (buf + len, " ");
502 bit = bit >> 1;
503 }
504
505 len = len + sprintf (buf + len, "\nP1-IN: ");
506 PORT_READ_REG (DANUBE_GPIO_P1_IN, reg);
507 bit = 0x80000000;
508 for (t = 0; t < 32; t++) {
509 if ((reg & bit) > 0)
510 len = len + sprintf (buf + len, "X");
511 else
512 len = len + sprintf (buf + len, " ");
513 bit = bit >> 1;
514 }
515
516 len = len + sprintf (buf + len, "\nP0-DIR: ");
517 PORT_READ_REG (DANUBE_GPIO_P0_DIR, reg);
518 bit = 0x80000000;
519 for (t = 0; t < 32; t++) {
520 if ((reg & bit) > 0)
521 len = len + sprintf (buf + len, "X");
522 else
523 len = len + sprintf (buf + len, " ");
524 bit = bit >> 1;
525 }
526
527 len = len + sprintf (buf + len, "\nP1-DIR: ");
528 PORT_READ_REG (DANUBE_GPIO_P1_DIR, reg);
529 bit = 0x80000000;
530 for (t = 0; t < 32; t++) {
531 if ((reg & bit) > 0)
532 len = len + sprintf (buf + len, "X");
533 else
534 len = len + sprintf (buf + len, " ");
535 bit = bit >> 1;
536 }
537
538 len = len + sprintf (buf + len, "\nP0-STO: ");
539 PORT_READ_REG (DANUBE_GPIO_P0_STOFF, reg);
540 bit = 0x80000000;
541 for (t = 0; t < 32; t++) {
542 if ((reg & bit) > 0)
543 len = len + sprintf (buf + len, "X");
544 else
545 len = len + sprintf (buf + len, " ");
546 bit = bit >> 1;
547 }
548
549 len = len + sprintf (buf + len, "\nP1-STO: ");
550 PORT_READ_REG (DANUBE_GPIO_P1_STOFF, reg);
551 bit = 0x80000000;
552 for (t = 0; t < 32; t++) {
553 if ((reg & bit) > 0)
554 len = len + sprintf (buf + len, "X");
555 else
556 len = len + sprintf (buf + len, " ");
557 bit = bit >> 1;
558 }
559
560 len = len + sprintf (buf + len, "\nP0-PUDE:");
561 PORT_READ_REG (DANUBE_GPIO_P0_PUDEN, reg);
562 bit = 0x80000000;
563 for (t = 0; t < 32; t++) {
564 if ((reg & bit) > 0)
565 len = len + sprintf (buf + len, "X");
566 else
567 len = len + sprintf (buf + len, " ");
568 bit = bit >> 1;
569 }
570
571 len = len + sprintf (buf + len, "\nP1-PUDE:");
572 PORT_READ_REG (DANUBE_GPIO_P1_PUDEN, reg);
573 bit = 0x80000000;
574 for (t = 0; t < 32; t++) {
575 if ((reg & bit) > 0)
576 len = len + sprintf (buf + len, "X");
577 else
578 len = len + sprintf (buf + len, " ");
579 bit = bit >> 1;
580 }
581
582 len = len + sprintf (buf + len, "\nP0-OD: ");
583 PORT_READ_REG (DANUBE_GPIO_P0_OD, reg);
584 bit = 0x80000000;
585 for (t = 0; t < 32; t++) {
586 if ((reg & bit) > 0)
587 len = len + sprintf (buf + len, "X");
588 else
589 len = len + sprintf (buf + len, " ");
590 bit = bit >> 1;
591 }
592
593 len = len + sprintf (buf + len, "\nP1-OD: ");
594 PORT_READ_REG (DANUBE_GPIO_P1_OD, reg);
595 bit = 0x80000000;
596 for (t = 0; t < 32; t++) {
597 if ((reg & bit) > 0)
598 len = len + sprintf (buf + len, "X");
599 else
600 len = len + sprintf (buf + len, " ");
601 bit = bit >> 1;
602 }
603
604 len = len + sprintf (buf + len, "\nP0-PUDS:");
605 PORT_READ_REG (DANUBE_GPIO_P0_PUDSEL, reg);
606 bit = 0x80000000;
607 for (t = 0; t < 32; t++) {
608 if ((reg & bit) > 0)
609 len = len + sprintf (buf + len, "X");
610 else
611 len = len + sprintf (buf + len, " ");
612 bit = bit >> 1;
613 }
614
615 len = len + sprintf (buf + len, "\nP1-PUDS:");
616 PORT_READ_REG (DANUBE_GPIO_P1_PUDSEL, reg);
617 bit = 0x80000000;
618 for (t = 0; t < 32; t++) {
619 if ((reg & bit) > 0)
620 len = len + sprintf (buf + len, "X");
621 else
622 len = len + sprintf (buf + len, " ");
623 bit = bit >> 1;
624 }
625
626 len = len + sprintf (buf + len, "\nP0_ALT0:");
627 PORT_READ_REG (DANUBE_GPIO_P0_ALTSEL0, reg);
628 bit = 0x80000000;
629 for (t = 0; t < 32; t++) {
630 if ((reg & bit) > 0)
631 len = len + sprintf (buf + len, "X");
632 else
633 len = len + sprintf (buf + len, " ");
634 bit = bit >> 1;
635 }
636
637 len = len + sprintf (buf + len, "\nP0_ALT1:");
638 PORT_READ_REG (DANUBE_GPIO_P0_ALTSEL1, reg);
639 bit = 0x80000000;
640 for (t = 0; t < 32; t++) {
641 if ((reg & bit) > 0)
642 len = len + sprintf (buf + len, "X");
643 else
644 len = len + sprintf (buf + len, " ");
645 bit = bit >> 1;
646 }
647
648 len = len + sprintf (buf + len, "\nP1_ALT0:");
649 PORT_READ_REG (DANUBE_GPIO_P1_ALTSEL0, reg);
650 bit = 0x80000000;
651 for (t = 0; t < 32; t++) {
652 if ((reg & bit) > 0)
653 len = len + sprintf (buf + len, "X");
654 else
655 len = len + sprintf (buf + len, " ");
656 bit = bit >> 1;
657 }
658
659 len = len + sprintf (buf + len, "\nP1_ALT1:");
660 PORT_READ_REG (DANUBE_GPIO_P1_ALTSEL1, reg);
661 bit = 0x80000000;
662 for (t = 0; t < 32; t++) {
663 if ((reg & bit) > 0)
664 len = len + sprintf (buf + len, "X");
665 else
666 len = len + sprintf (buf + len, " ");
667 bit = bit >> 1;
668 }
669
670 len = len + sprintf (buf + len, "\n\n");
671
672 *eof = 1; // No more data available
673 return len;
674 }
675
676 static int
677 danube_port_open (struct inode *inode, struct file *filep)
678 {
679 return 0;
680 }
681
682 static int
683 danube_port_release (struct inode *inode, struct file *filelp)
684 {
685 return 0;
686 }
687
688 static int
689 danube_port_ioctl (struct inode *inode, struct file *filp,
690 unsigned int cmd, unsigned long arg)
691 {
692 int ret = 0;
693 volatile struct danube_port_ioctl_parm parm;
694
695 if (_IOC_TYPE (cmd) != DANUBE_PORT_IOC_MAGIC)
696 return -EINVAL;
697
698 if (_IOC_DIR (cmd) & _IOC_WRITE) {
699 if (!access_ok
700 (VERIFY_READ, arg,
701 sizeof (struct danube_port_ioctl_parm)))
702 return -EFAULT;
703 ret = copy_from_user ((void *) &parm, (void *) arg,
704 sizeof (struct danube_port_ioctl_parm));
705 }
706 if (_IOC_DIR (cmd) & _IOC_READ) {
707 if (!access_ok
708 (VERIFY_WRITE, arg,
709 sizeof (struct danube_port_ioctl_parm)))
710 return -EFAULT;
711 }
712
713 if (down_trylock (&port_sem) != 0)
714 return -EBUSY;
715
716 switch (cmd) {
717 case DANUBE_PORT_IOCOD:
718 if (parm.value == 0x00) {
719 PORT_IOC_CALL (ret, parm.port, parm.pin,
720 danube_port_clear_open_drain);
721 }
722 else {
723 PORT_IOC_CALL (ret, parm.port, parm.pin,
724 danube_port_set_open_drain);
725 }
726 break;
727 case DANUBE_PORT_IOCPUDSEL:
728 if (parm.value == 0x00) {
729 PORT_IOC_CALL (ret, parm.port, parm.pin,
730 danube_port_clear_pudsel);
731 }
732 else {
733 PORT_IOC_CALL (ret, parm.port, parm.pin,
734 danube_port_set_pudsel);
735 }
736 break;
737 case DANUBE_PORT_IOCPUDEN:
738 if (parm.value == 0x00) {
739 PORT_IOC_CALL (ret, parm.port, parm.pin,
740 danube_port_clear_puden);
741 }
742 else {
743 PORT_IOC_CALL (ret, parm.port, parm.pin,
744 danube_port_set_puden);
745 }
746 break;
747 case DANUBE_PORT_IOCSTOFF:
748 if (parm.value == 0x00) {
749 PORT_IOC_CALL (ret, parm.port, parm.pin,
750 danube_port_clear_stoff);
751 }
752 else {
753 PORT_IOC_CALL (ret, parm.port, parm.pin,
754 danube_port_set_stoff);
755 }
756 break;
757 case DANUBE_PORT_IOCDIR:
758 if (parm.value == 0x00) {
759 PORT_IOC_CALL (ret, parm.port, parm.pin,
760 danube_port_set_dir_in);
761 }
762 else {
763 PORT_IOC_CALL (ret, parm.port, parm.pin,
764 danube_port_set_dir_out);
765 }
766 break;
767 case DANUBE_PORT_IOCOUTPUT:
768 if (parm.value == 0x00) {
769 PORT_IOC_CALL (ret, parm.port, parm.pin,
770 danube_port_clear_output);
771 }
772 else {
773 PORT_IOC_CALL (ret, parm.port, parm.pin,
774 danube_port_set_output);
775 }
776 break;
777 case DANUBE_PORT_IOCALTSEL0:
778 if (parm.value == 0x00) {
779 PORT_IOC_CALL (ret, parm.port, parm.pin,
780 danube_port_clear_altsel0);
781 }
782 else {
783 PORT_IOC_CALL (ret, parm.port, parm.pin,
784 danube_port_set_altsel0);
785 }
786 break;
787 case DANUBE_PORT_IOCALTSEL1:
788 if (parm.value == 0x00) {
789 PORT_IOC_CALL (ret, parm.port, parm.pin,
790 danube_port_clear_altsel1);
791 }
792 else {
793 PORT_IOC_CALL (ret, parm.port, parm.pin,
794 danube_port_set_altsel1);
795 }
796 break;
797 case DANUBE_PORT_IOCINPUT:
798 ret = danube_port_reserve_pin (parm.port, parm.pin,
799 PORT_MODULE_ID);
800 if (ret == 0)
801 parm.value =
802 danube_port_get_input (parm.port, parm.pin,
803 PORT_MODULE_ID);
804 ret = danube_port_free_pin (parm.port, parm.pin,
805 PORT_MODULE_ID);
806 copy_to_user ((void *) arg, (void *) &parm,
807 sizeof (struct danube_port_ioctl_parm));
808 break;
809 default:
810 ret = -EINVAL;
811 }
812
813 up (&port_sem);
814
815 return ret;
816 }
817
818 static struct file_operations port_fops = {
819 open:danube_port_open,
820 release:danube_port_release,
821 ioctl:danube_port_ioctl
822 };
823
824 int __init
825 danube_port_init (void)
826 {
827 int t = 0;
828 int i = 0;
829 int err = 0;
830 u32 pins = 0;
831
832 printk ("Danube Port Initialization\n");
833
834 sema_init (&port_sem, 1);
835
836 /* Check ports for available pins */
837 for (t = 0; t < MAX_PORTS; t++) {
838 for (i = 0; i < PINS_PER_PORT; i++)
839 danube_port_pin_usage[t][i] = 0;
840 }
841
842 /* register port device */
843 err = register_chrdev (0, "danube-port", &port_fops);
844 if (err > 0)
845 port_major = err;
846 else {
847 printk ("danube-port: Error! Could not register port device. #%d\n", err);
848 return err;
849 }
850
851 /* Create proc file */
852 create_proc_read_entry ("driver/danube_port", 0, NULL,
853 danube_port_read_procmem, NULL);
854
855 return 0;
856 }
857
858 module_init (danube_port_init);
859
860 EXPORT_SYMBOL (danube_port_reserve_pin);
861 EXPORT_SYMBOL (danube_port_free_pin);
862 EXPORT_SYMBOL (danube_port_set_open_drain);
863 EXPORT_SYMBOL (danube_port_clear_open_drain);
864 EXPORT_SYMBOL (danube_port_set_pudsel);
865 EXPORT_SYMBOL (danube_port_clear_pudsel);
866 EXPORT_SYMBOL (danube_port_set_puden);
867 EXPORT_SYMBOL (danube_port_clear_puden);
868 EXPORT_SYMBOL (danube_port_set_stoff);
869 EXPORT_SYMBOL (danube_port_clear_stoff);
870 EXPORT_SYMBOL (danube_port_set_dir_out);
871 EXPORT_SYMBOL (danube_port_set_dir_in);
872 EXPORT_SYMBOL (danube_port_set_output);
873 EXPORT_SYMBOL (danube_port_clear_output);
874 EXPORT_SYMBOL (danube_port_get_input);
875
876 EXPORT_SYMBOL (danube_port_set_altsel0);
877 EXPORT_SYMBOL (danube_port_clear_altsel0);
878 EXPORT_SYMBOL (danube_port_set_altsel1);
879 EXPORT_SYMBOL (danube_port_clear_altsel1);
OpenWrt SVN history