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