V4L/DVB (4043): Miropcm20: fix sub-optimal header inclusion for sound/oss/aci.h
[linux-2.6.git] / drivers / media / radio / miropcm20-rds-core.c
1 /*
2  *  Many thanks to Fred Seidel <seidel@metabox.de>, the
3  *  designer of the RDS decoder hardware. With his help
4  *  I was able to code this driver.
5  *  Thanks also to Norberto Pellicci, Dominic Mounteney
6  *  <DMounteney@pinnaclesys.com> and www.teleauskunft.de
7  *  for good hints on finding Fred. It was somewhat hard
8  *  to locate him here in Germany... [:
9  *
10  * Revision history:
11  *
12  *   2000-08-09  Robert Siemer <Robert.Siemer@gmx.de>
13  *        RDS support for MiroSound PCM20 radio
14  */
15
16 #include <linux/module.h>
17 #include <linux/errno.h>
18 #include <linux/string.h>
19 #include <linux/init.h>
20 #include <linux/slab.h>
21 #include <linux/mutex.h>
22
23 #include <asm/io.h>
24 #include "oss/aci.h"
25 #include "miropcm20-rds-core.h"
26
27 #define DEBUG 0
28
29 static struct mutex aci_rds_mutex;
30
31 #define RDS_DATASHIFT          2   /* Bit 2 */
32 #define RDS_DATAMASK        (1 << RDS_DATASHIFT)
33 #define RDS_BUSYMASK        0x10   /* Bit 4 */
34 #define RDS_CLOCKMASK       0x08   /* Bit 3 */
35
36 #define RDS_DATA(x)         (((x) >> RDS_DATASHIFT) & 1)
37
38
39 #if DEBUG
40 static void print_matrix(char array[], unsigned int length)
41 {
42         int i, j;
43
44         for (i=0; i<length; i++) {
45                 printk(KERN_DEBUG "aci-rds: ");
46                 for (j=7; j>=0; j--) {
47                         printk("%d", (array[i] >> j) & 0x1);
48                 }
49                 if (i%8 == 0)
50                         printk(" byte-border\n");
51                 else
52                         printk("\n");
53         }
54 }
55 #endif /* DEBUG */
56
57 static int byte2trans(unsigned char byte, unsigned char sendbuffer[], int size)
58 {
59         int i;
60
61         if (size != 8)
62                 return -1;
63         for (i = 7; i >= 0; i--)
64                 sendbuffer[7-i] = (byte & (1 << i)) ? RDS_DATAMASK : 0;
65         sendbuffer[0] |= RDS_CLOCKMASK;
66
67         return 0;
68 }
69
70 static int rds_waitread(void)
71 {
72         unsigned char byte;
73         int i=2000;
74
75         do {
76                 byte=inb(RDS_REGISTER);
77                 i--;
78         }
79         while ((byte & RDS_BUSYMASK) && i);
80
81         if (i) {
82                 #if DEBUG
83                 printk(KERN_DEBUG "rds_waitread()");
84                 print_matrix(&byte, 1);
85                 #endif
86                 return (byte);
87         } else {
88                 printk(KERN_WARNING "aci-rds: rds_waitread() timeout...\n");
89                 return -1;
90         }
91 }
92
93 /* don't use any ..._nowait() function if you are not sure what you do... */
94
95 static inline void rds_rawwrite_nowait(unsigned char byte)
96 {
97         #if DEBUG
98         printk(KERN_DEBUG "rds_rawwrite()");
99         print_matrix(&byte, 1);
100         #endif
101         outb(byte, RDS_REGISTER);
102 }
103
104 static int rds_rawwrite(unsigned char byte)
105 {
106         if (rds_waitread() >= 0) {
107                 rds_rawwrite_nowait(byte);
108                 return 0;
109         } else
110                 return -1;
111 }
112
113 static int rds_write(unsigned char cmd)
114 {
115         unsigned char sendbuffer[8];
116         int i;
117
118         if (byte2trans(cmd, sendbuffer, 8) != 0){
119                 return -1;
120         } else {
121                 for (i=0; i<8; i++) {
122                         rds_rawwrite(sendbuffer[i]);
123                 }
124         }
125         return 0;
126 }
127
128 static int rds_readcycle_nowait(void)
129 {
130         rds_rawwrite_nowait(0);
131         return rds_waitread();
132 }
133
134 static int rds_readcycle(void)
135 {
136         if (rds_rawwrite(0) < 0)
137                 return -1;
138         return rds_waitread();
139 }
140
141 static int rds_read(unsigned char databuffer[], int datasize)
142 {
143         #define READSIZE (8*datasize)
144
145         int i,j;
146
147         if (datasize < 1)  /* nothing to read */
148                 return 0;
149
150         /* to be able to use rds_readcycle_nowait()
151            I have to waitread() here */
152         if (rds_waitread() < 0)
153                 return -1;
154
155         memset(databuffer, 0, datasize);
156
157         for (i=0; i< READSIZE; i++)
158                 if((j=rds_readcycle_nowait()) < 0) {
159                         return -1;
160                 } else {
161                         databuffer[i/8]|=(RDS_DATA(j) << (7-(i%8)));
162                 }
163
164         return 0;
165 }
166
167 static int rds_ack(void)
168 {
169         int i=rds_readcycle();
170
171         if (i < 0)
172                 return -1;
173         if (i & RDS_DATAMASK) {
174                 return 0;  /* ACK  */
175         } else {
176                 printk(KERN_DEBUG "aci-rds: NACK\n");
177                 return 1;  /* NACK */
178         }
179 }
180
181 int aci_rds_cmd(unsigned char cmd, unsigned char databuffer[], int datasize)
182 {
183         int ret;
184
185         if (mutex_lock_interruptible(&aci_rds_mutex))
186                 return -EINTR;
187
188         rds_write(cmd);
189
190         /* RDS_RESET doesn't need further processing */
191         if (cmd!=RDS_RESET && (rds_ack() || rds_read(databuffer, datasize)))
192                 ret = -1;
193         else
194                 ret = 0;
195
196         mutex_unlock(&aci_rds_mutex);
197
198         return ret;
199 }
200 EXPORT_SYMBOL(aci_rds_cmd);
201
202 int __init attach_aci_rds(void)
203 {
204         mutex_init(&aci_rds_mutex);
205         return 0;
206 }
207
208 void __exit unload_aci_rds(void)
209 {
210 }
211 MODULE_LICENSE("GPL");