?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: cpa self-test, WARN_ON()
[wrt350n-kernel.git] / drivers / media / radio / radio-si470x.c
blob8e4bd4769048ccb65dd455e9f763b233db9c3137
1 /*
2 * drivers/media/radio/radio-si470x.c
3 *
4 * Driver for USB radios for the Silicon Labs Si470x FM Radio Receivers:
5 * - Silicon Labs USB FM Radio Reference Design
6 * - ADS/Tech FM Radio Receiver (formerly Instant FM Music) (RDX-155-EF)
7 *
8 * Copyright (c) 2008 Tobias Lorenz <tobias.lorenz@gmx.net>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24
25
26 /*
27 * History:
28 * 2008-01-12 Tobias Lorenz <tobias.lorenz@gmx.net>
29 * Version 1.0.0
30 * - First working version
31 * 2008-01-13 Tobias Lorenz <tobias.lorenz@gmx.net>
32 * Version 1.0.1
33 * - Improved error handling, every function now returns errno
34 * - Improved multi user access (start/mute/stop)
35 * - Channel doesn't get lost anymore after start/mute/stop
36 * - RDS support added (polling mode via interrupt EP 1)
37 * - marked default module parameters with *value*
38 * - switched from bit structs to bit masks
39 * - header file cleaned and integrated
40 * 2008-01-14 Tobias Lorenz <tobias.lorenz@gmx.net>
41 * Version 1.0.2
42 * - hex values are now lower case
43 * - commented USB ID for ADS/Tech moved on todo list
44 * - blacklisted si470x in hid-quirks.c
45 * - rds buffer handling functions integrated into *_work, *_read
46 * - rds_command in si470x_poll exchanged against simple retval
47 * - check for firmware version 15
48 * - code order and prototypes still remain the same
49 * - spacing and bottom of band codes remain the same
50 * 2008-01-16 Tobias Lorenz <tobias.lorenz@gmx.net>
51 * Version 1.0.3
52 * - code reordered to avoid function prototypes
53 * - switch/case defaults are now more user-friendly
54 * - unified comment style
55 * - applied all checkpatch.pl v1.12 suggestions
56 * except the warning about the too long lines with bit comments
57 * - renamed FMRADIO to RADIO to cut line length (checkpatch.pl)
58 * 2008-01-22 Tobias Lorenz <tobias.lorenz@gmx.net>
59 * Version 1.0.4
60 * - avoid poss. locking when doing copy_to_user which may sleep
61 * - RDS is automatically activated on read now
62 * - code cleaned of unnecessary rds_commands
63 * - USB Vendor/Product ID for ADS/Tech FM Radio Receiver verified
64 * (thanks to Guillaume RAMOUSSE)
65 *
66 * ToDo:
67 * - add seeking support
68 * - add firmware download/update support
69 * - RDS support: interrupt mode, instead of polling
70 * - add LED status output (check if that's not already done in firmware)
71 */
72
73
74 /* driver definitions */
75 #define DRIVER_AUTHOR "Tobias Lorenz <tobias.lorenz@gmx.net>"
76 #define DRIVER_NAME "radio-si470x"
77 #define DRIVER_VERSION KERNEL_VERSION(1, 0, 4)
78 #define DRIVER_CARD "Silicon Labs Si470x FM Radio Receiver"
79 #define DRIVER_DESC "USB radio driver for Si470x FM Radio Receivers"
80
81
82 /* kernel includes */
83 #include <linux/kernel.h>
84 #include <linux/module.h>
85 #include <linux/init.h>
86 #include <linux/slab.h>
87 #include <linux/input.h>
88 #include <linux/usb.h>
89 #include <linux/hid.h>
90 #include <linux/version.h>
91 #include <linux/videodev2.h>
92 #include <media/v4l2-common.h>
93 #include <media/rds.h>
94
95
96 /* USB Device ID List */
97 static struct usb_device_id si470x_usb_driver_id_table[] = {
98 /* Silicon Labs USB FM Radio Reference Design */
99 { USB_DEVICE_AND_INTERFACE_INFO(0x10c4, 0x818a, USB_CLASS_HID, 0, 0) },
100 /* ADS/Tech FM Radio Receiver (formerly Instant FM Music) */
101 { USB_DEVICE_AND_INTERFACE_INFO(0x06e1, 0xa155, USB_CLASS_HID, 0, 0) },
102 /* Terminating entry */
103 { }
104 };
105 MODULE_DEVICE_TABLE(usb, si470x_usb_driver_id_table);
106
107
108
109 /**************************************************************************
110 * Module Parameters
111 **************************************************************************/
112
113 /* Radio Nr */
114 static int radio_nr = -1;
115 module_param(radio_nr, int, 0);
116 MODULE_PARM_DESC(radio_nr, "Radio Nr");
117
118 /* Spacing (kHz) */
119 /* 0: 200 kHz (USA, Australia) */
120 /* 1: 100 kHz (Europe, Japan) */
121 /* 2: 50 kHz */
122 static int space = 2;
123 module_param(space, int, 0);
124 MODULE_PARM_DESC(radio_nr, "Spacing: 0=200kHz 1=100kHz *2=50kHz*");
125
126 /* Bottom of Band (MHz) */
127 /* 0: 87.5 - 108 MHz (USA, Europe)*/
128 /* 1: 76 - 108 MHz (Japan wide band) */
129 /* 2: 76 - 90 MHz (Japan) */
130 static int band = 1;
131 module_param(band, int, 0);
132 MODULE_PARM_DESC(radio_nr, "Band: 0=87.5..108MHz *1=76..108MHz* 2=76..90MHz");
133
134 /* De-emphasis */
135 /* 0: 75 us (USA) */
136 /* 1: 50 us (Europe, Australia, Japan) */
137 static int de = 1;
138 module_param(de, int, 0);
139 MODULE_PARM_DESC(radio_nr, "De-emphasis: 0=75us *1=50us*");
140
141 /* USB timeout */
142 static int usb_timeout = 500;
143 module_param(usb_timeout, int, 0);
144 MODULE_PARM_DESC(usb_timeout, "USB timeout (ms): *500*");
145
146 /* Seek retries */
147 static int seek_retries = 100;
148 module_param(seek_retries, int, 0);
149 MODULE_PARM_DESC(seek_retries, "Seek retries: *100*");
150
151 /* RDS buffer blocks */
152 static int rds_buf = 100;
153 module_param(rds_buf, int, 0);
154 MODULE_PARM_DESC(rds_buf, "RDS buffer entries: *100*");
155
156 /* RDS maximum block errors */
157 static int max_rds_errors = 1;
158 /* 0 means 0 errors requiring correction */
159 /* 1 means 1-2 errors requiring correction (used by original USBRadio.exe) */
160 /* 2 means 3-5 errors requiring correction */
161 /* 3 means 6+ errors or errors in checkword, correction not possible */
162 module_param(max_rds_errors, int, 0);
163 MODULE_PARM_DESC(max_rds_errors, "RDS maximum block errors: *1*");
164
165 /* RDS poll frequency */
166 static int rds_poll_time = 40;
167 /* 40 is used by the original USBRadio.exe */
168 /* 50 is used by radio-cadet */
169 /* 75 should be okay */
170 /* 80 is the usual RDS receive interval */
171 module_param(rds_poll_time, int, 0);
172 MODULE_PARM_DESC(rds_poll_time, "RDS poll time (ms): *40*");
173
174
175
176 /**************************************************************************
177 * Register Definitions
178 **************************************************************************/
179 #define RADIO_REGISTER_SIZE 2 /* 16 register bit width */
180 #define RADIO_REGISTER_NUM 16 /* DEVICEID ... RDSD */
181 #define RDS_REGISTER_NUM 6 /* STATUSRSSI ... RDSD */
182
183 #define DEVICEID 0 /* Device ID */
184 #define DEVICEID_PN 0xf000 /* bits 15..12: Part Number */
185 #define DEVICEID_MFGID 0x0fff /* bits 11..00: Manufacturer ID */
186
187 #define CHIPID 1 /* Chip ID */
188 #define CHIPID_REV 0xfc00 /* bits 15..10: Chip Version */
189 #define CHIPID_DEV 0x0200 /* bits 09..09: Device */
190 #define CHIPID_FIRMWARE 0x01ff /* bits 08..00: Firmware Version */
191
192 #define POWERCFG 2 /* Power Configuration */
193 #define POWERCFG_DSMUTE 0x8000 /* bits 15..15: Softmute Disable */
194 #define POWERCFG_DMUTE 0x4000 /* bits 14..14: Mute Disable */
195 #define POWERCFG_MONO 0x2000 /* bits 13..13: Mono Select */
196 #define POWERCFG_RDSM 0x0800 /* bits 11..11: RDS Mode (Si4701 only) */
197 #define POWERCFG_SKMODE 0x0400 /* bits 10..10: Seek Mode */
198 #define POWERCFG_SEEKUP 0x0200 /* bits 09..09: Seek Direction */
199 #define POWERCFG_SEEK 0x0100 /* bits 08..08: Seek */
200 #define POWERCFG_DISABLE 0x0040 /* bits 06..06: Powerup Disable */
201 #define POWERCFG_ENABLE 0x0001 /* bits 00..00: Powerup Enable */
202
203 #define CHANNEL 3 /* Channel */
204 #define CHANNEL_TUNE 0x8000 /* bits 15..15: Tune */
205 #define CHANNEL_CHAN 0x03ff /* bits 09..00: Channel Select */
206
207 #define SYSCONFIG1 4 /* System Configuration 1 */
208 #define SYSCONFIG1_RDSIEN 0x8000 /* bits 15..15: RDS Interrupt Enable (Si4701 only) */
209 #define SYSCONFIG1_STCIEN 0x4000 /* bits 14..14: Seek/Tune Complete Interrupt Enable */
210 #define SYSCONFIG1_RDS 0x1000 /* bits 12..12: RDS Enable (Si4701 only) */
211 #define SYSCONFIG1_DE 0x0800 /* bits 11..11: De-emphasis (0=75us 1=50us) */
212 #define SYSCONFIG1_AGCD 0x0400 /* bits 10..10: AGC Disable */
213 #define SYSCONFIG1_BLNDADJ 0x00c0 /* bits 07..06: Stereo/Mono Blend Level Adjustment */
214 #define SYSCONFIG1_GPIO3 0x0030 /* bits 05..04: General Purpose I/O 3 */
215 #define SYSCONFIG1_GPIO2 0x000c /* bits 03..02: General Purpose I/O 2 */
216 #define SYSCONFIG1_GPIO1 0x0003 /* bits 01..00: General Purpose I/O 1 */
217
218 #define SYSCONFIG2 5 /* System Configuration 2 */
219 #define SYSCONFIG2_SEEKTH 0xff00 /* bits 15..08: RSSI Seek Threshold */
220 #define SYSCONFIG2_BAND 0x0080 /* bits 07..06: Band Select */
221 #define SYSCONFIG2_SPACE 0x0030 /* bits 05..04: Channel Spacing */
222 #define SYSCONFIG2_VOLUME 0x000f /* bits 03..00: Volume */
223
224 #define SYSCONFIG3 6 /* System Configuration 3 */
225 #define SYSCONFIG3_SMUTER 0xc000 /* bits 15..14: Softmute Attack/Recover Rate */
226 #define SYSCONFIG3_SMUTEA 0x3000 /* bits 13..12: Softmute Attenuation */
227 #define SYSCONFIG3_SKSNR 0x00f0 /* bits 07..04: Seek SNR Threshold */
228 #define SYSCONFIG3_SKCNT 0x000f /* bits 03..00: Seek FM Impulse Detection Threshold */
229
230 #define TEST1 7 /* Test 1 */
231 #define TEST1_AHIZEN 0x4000 /* bits 14..14: Audio High-Z Enable */
232
233 #define TEST2 8 /* Test 2 */
234 /* TEST2 only contains reserved bits */
235
236 #define BOOTCONFIG 9 /* Boot Configuration */
237 /* BOOTCONFIG only contains reserved bits */
238
239 #define STATUSRSSI 10 /* Status RSSI */
240 #define STATUSRSSI_RDSR 0x8000 /* bits 15..15: RDS Ready (Si4701 only) */
241 #define STATUSRSSI_STC 0x4000 /* bits 14..14: Seek/Tune Complete */
242 #define STATUSRSSI_SF 0x2000 /* bits 13..13: Seek Fail/Band Limit */
243 #define STATUSRSSI_AFCRL 0x1000 /* bits 12..12: AFC Rail */
244 #define STATUSRSSI_RDSS 0x0800 /* bits 11..11: RDS Synchronized (Si4701 only) */
245 #define STATUSRSSI_BLERA 0x0600 /* bits 10..09: RDS Block A Errors (Si4701 only) */
246 #define STATUSRSSI_ST 0x0100 /* bits 08..08: Stereo Indicator */
247 #define STATUSRSSI_RSSI 0x00ff /* bits 07..00: RSSI (Received Signal Strength Indicator) */
248
249 #define READCHAN 11 /* Read Channel */
250 #define READCHAN_BLERB 0xc000 /* bits 15..14: RDS Block D Errors (Si4701 only) */
251 #define READCHAN_BLERC 0x3000 /* bits 13..12: RDS Block C Errors (Si4701 only) */
252 #define READCHAN_BLERD 0x0c00 /* bits 11..10: RDS Block B Errors (Si4701 only) */
253 #define READCHAN_READCHAN 0x03ff /* bits 09..00: Read Channel */
254
255 #define RDSA 12 /* RDSA */
256 #define RDSA_RDSA 0xffff /* bits 15..00: RDS Block A Data (Si4701 only) */
257
258 #define RDSB 13 /* RDSB */
259 #define RDSB_RDSB 0xffff /* bits 15..00: RDS Block B Data (Si4701 only) */
260
261 #define RDSC 14 /* RDSC */
262 #define RDSC_RDSC 0xffff /* bits 15..00: RDS Block C Data (Si4701 only) */
263
264 #define RDSD 15 /* RDSD */
265 #define RDSD_RDSD 0xffff /* bits 15..00: RDS Block D Data (Si4701 only) */
266
267
268
269 /**************************************************************************
270 * USB HID Reports
271 **************************************************************************/
272
273 /* Reports 1-16 give direct read/write access to the 16 Si470x registers */
274 /* with the (REPORT_ID - 1) corresponding to the register address across USB */
275 /* endpoint 0 using GET_REPORT and SET_REPORT */
276 #define REGISTER_REPORT_SIZE (RADIO_REGISTER_SIZE + 1)
277 #define REGISTER_REPORT(reg) ((reg) + 1)
278
279 /* Report 17 gives direct read/write access to the entire Si470x register */
280 /* map across endpoint 0 using GET_REPORT and SET_REPORT */
281 #define ENTIRE_REPORT_SIZE (RADIO_REGISTER_NUM * RADIO_REGISTER_SIZE + 1)
282 #define ENTIRE_REPORT 17
283
284 /* Report 18 is used to send the lowest 6 Si470x registers up the HID */
285 /* interrupt endpoint 1 to Windows every 20 milliseconds for status */
286 #define RDS_REPORT_SIZE (RDS_REGISTER_NUM * RADIO_REGISTER_SIZE + 1)
287 #define RDS_REPORT 18
288
289 /* Report 19: LED state */
290 #define LED_REPORT_SIZE 3
291 #define LED_REPORT 19
292
293 /* Report 19: stream */
294 #define STREAM_REPORT_SIZE 3
295 #define STREAM_REPORT 19
296
297 /* Report 20: scratch */
298 #define SCRATCH_PAGE_SIZE 63
299 #define SCRATCH_REPORT_SIZE (SCRATCH_PAGE_SIZE + 1)
300 #define SCRATCH_REPORT 20
301
302 /* Reports 19-22: flash upgrade of the C8051F321 */
303 #define WRITE_REPORT 19
304 #define FLASH_REPORT 20
305 #define CRC_REPORT 21
306 #define RESPONSE_REPORT 22
307
308 /* Report 23: currently unused, but can accept 60 byte reports on the HID */
309 /* interrupt out endpoint 2 every 1 millisecond */
310 #define UNUSED_REPORT 23
311
312
313
314 /**************************************************************************
315 * Software/Hardware Versions
316 **************************************************************************/
317 #define RADIO_SW_VERSION_NOT_BOOTLOADABLE 6
318 #define RADIO_SW_VERSION 7
319 #define RADIO_SW_VERSION_CURRENT 15
320 #define RADIO_HW_VERSION 1
321
322 #define SCRATCH_PAGE_SW_VERSION 1
323 #define SCRATCH_PAGE_HW_VERSION 2
324
325
326
327 /**************************************************************************
328 * LED State Definitions
329 **************************************************************************/
330 #define LED_COMMAND 0x35
331
332 #define NO_CHANGE_LED 0x00
333 #define ALL_COLOR_LED 0x01 /* streaming state */
334 #define BLINK_GREEN_LED 0x02 /* connect state */
335 #define BLINK_RED_LED 0x04
336 #define BLINK_ORANGE_LED 0x10 /* disconnect state */
337 #define SOLID_GREEN_LED 0x20 /* tuning/seeking state */
338 #define SOLID_RED_LED 0x40 /* bootload state */
339 #define SOLID_ORANGE_LED 0x80
340
341
342
343 /**************************************************************************
344 * Stream State Definitions
345 **************************************************************************/
346 #define STREAM_COMMAND 0x36
347 #define STREAM_VIDPID 0x00
348 #define STREAM_AUDIO 0xff
349
350
351
352 /**************************************************************************
353 * Bootloader / Flash Commands
354 **************************************************************************/
355
356 /* unique id sent to bootloader and required to put into a bootload state */
357 #define UNIQUE_BL_ID 0x34
358
359 /* mask for the flash data */
360 #define FLASH_DATA_MASK 0x55
361
362 /* bootloader commands */
363 #define GET_SW_VERSION_COMMAND 0x00
364 #define SET_PAGE_COMMAND 0x01
365 #define ERASE_PAGE_COMMAND 0x02
366 #define WRITE_PAGE_COMMAND 0x03
367 #define CRC_ON_PAGE_COMMAND 0x04
368 #define READ_FLASH_BYTE_COMMAND 0x05
369 #define RESET_DEVICE_COMMAND 0x06
370 #define GET_HW_VERSION_COMMAND 0x07
371 #define BLANK 0xff
372
373 /* bootloader command responses */
374 #define COMMAND_OK 0x01
375 #define COMMAND_FAILED 0x02
376 #define COMMAND_PENDING 0x03
377
378 /* buffer sizes */
379 #define COMMAND_BUFFER_SIZE 4
380 #define RESPONSE_BUFFER_SIZE 2
381 #define FLASH_BUFFER_SIZE 64
382 #define CRC_BUFFER_SIZE 3
383
384
385
386 /**************************************************************************
387 * General Driver Definitions
388 **************************************************************************/
389
390 /*
391 * si470x_device - private data
392 */
393 struct si470x_device {
394 /* reference to USB and video device */
395 struct usb_device *usbdev;
396 struct video_device *videodev;
397
398 /* are these really necessary ? */
399 int users;
400
401 /* report buffer (maximum 64 bytes) */
402 unsigned char buf[64];
403
404 /* Silabs internal registers (0..15) */
405 unsigned short registers[RADIO_REGISTER_NUM];
406
407 /* RDS receive buffer */
408 struct work_struct work;
409 wait_queue_head_t read_queue;
410 struct timer_list timer;
411 spinlock_t lock; /* buffer locking */
412 unsigned char *buffer; /* size is always multiple of three */
413 unsigned int buf_size;
414 unsigned int rd_index;
415 unsigned int wr_index;
416 };
417
418
419 /*
420 * The frequency is set in units of 62.5 Hz when using V4L2_TUNER_CAP_LOW,
421 * 62.5 kHz otherwise.
422 * The tuner is able to have a channel spacing of 50, 100 or 200 kHz.
423 * tuner->capability is therefore set to V4L2_TUNER_CAP_LOW
424 * The FREQ_MUL is then: 1 MHz / 62.5 Hz = 16000
425 */
426 #define FREQ_MUL (1000000 / 62.5)
427
428
429
430 /**************************************************************************
431 * General Driver Functions
432 **************************************************************************/
433
434 /*
435 * si470x_get_report - receive a HID report
436 */
437 static int si470x_get_report(struct si470x_device *radio, int size)
438 {
439 return usb_control_msg(radio->usbdev,
440 usb_rcvctrlpipe(radio->usbdev, 0),
441 HID_REQ_GET_REPORT,
442 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
443 radio->buf[0], 2,
444 radio->buf, size, usb_timeout);
445 }
446
447
448 /*
449 * si470x_set_report - send a HID report
450 */
451 static int si470x_set_report(struct si470x_device *radio, int size)
452 {
453 return usb_control_msg(radio->usbdev,
454 usb_sndctrlpipe(radio->usbdev, 0),
455 HID_REQ_SET_REPORT,
456 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
457 radio->buf[0], 2,
458 radio->buf, size, usb_timeout);
459 }
460
461
462 /*
463 * si470x_get_register - read register
464 */
465 static int si470x_get_register(struct si470x_device *radio, int regnr)
466 {
467 int retval;
468
469 radio->buf[0] = REGISTER_REPORT(regnr);
470
471 retval = si470x_get_report(radio, REGISTER_REPORT_SIZE);
472 if (retval >= 0)
473 radio->registers[regnr] = (radio->buf[1] << 8) | radio->buf[2];
474
475 return (retval < 0) ? -EINVAL : 0;
476 }
477
478
479 /*
480 * si470x_set_register - write register
481 */
482 static int si470x_set_register(struct si470x_device *radio, int regnr)
483 {
484 int retval;
485
486 radio->buf[0] = REGISTER_REPORT(regnr);
487 radio->buf[1] = (radio->registers[regnr] & 0xff00) >> 8;
488 radio->buf[2] = (radio->registers[regnr] & 0x00ff);
489
490 retval = si470x_set_report(radio, REGISTER_REPORT_SIZE);
491
492 return (retval < 0) ? -EINVAL : 0;
493 }
494
495
496 /*
497 * si470x_get_all_registers - read entire registers
498 */
499 static int si470x_get_all_registers(struct si470x_device *radio)
500 {
501 int retval;
502 int regnr;
503
504 radio->buf[0] = ENTIRE_REPORT;
505
506 retval = si470x_get_report(radio, ENTIRE_REPORT_SIZE);
507
508 if (retval >= 0)
509 for (regnr = 0; regnr < RADIO_REGISTER_NUM; regnr++)
510 radio->registers[regnr] =
511 (radio->buf[regnr * RADIO_REGISTER_SIZE + 1] << 8) |
512 radio->buf[regnr * RADIO_REGISTER_SIZE + 2];
513
514 return (retval < 0) ? -EINVAL : 0;
515 }
516
517
518 /*
519 * si470x_get_rds_registers - read rds registers
520 */
521 static int si470x_get_rds_registers(struct si470x_device *radio)
522 {
523 int retval;
524 int regnr;
525 int size;
526
527 radio->buf[0] = RDS_REPORT;
528
529 retval = usb_interrupt_msg(radio->usbdev,
530 usb_rcvctrlpipe(radio->usbdev, 1),
531 radio->buf, RDS_REPORT_SIZE, &size, usb_timeout);
532
533 if (retval >= 0)
534 for (regnr = 0; regnr < RDS_REGISTER_NUM; regnr++)
535 radio->registers[STATUSRSSI + regnr] =
536 (radio->buf[regnr * RADIO_REGISTER_SIZE + 1] << 8) |
537 radio->buf[regnr * RADIO_REGISTER_SIZE + 2];
538
539 return (retval < 0) ? -EINVAL : 0;
540 }
541
542
543 /*
544 * si470x_set_chan - set the channel
545 */
546 static int si470x_set_chan(struct si470x_device *radio, int chan)
547 {
548 int retval, i;
549
550 /* start tuning */
551 radio->registers[CHANNEL] &= ~CHANNEL_CHAN;
552 radio->registers[CHANNEL] |= CHANNEL_TUNE | chan;
553 retval = si470x_set_register(radio, CHANNEL);
554 if (retval < 0)
555 return retval;
556
557 /* wait till seek operation has completed */
558 i = 0;
559 do {
560 retval = si470x_get_register(radio, STATUSRSSI);
561 if (retval < 0)
562 return retval;
563 } while ((radio->registers[STATUSRSSI] & STATUSRSSI_STC) &&
564 (++i < seek_retries));
565 if (i >= seek_retries)
566 printk(KERN_WARNING DRIVER_NAME
567 ": seek does not finish after %d tries\n", i);
568
569 /* stop tuning */
570 radio->registers[CHANNEL] &= ~CHANNEL_TUNE;
571 return si470x_set_register(radio, CHANNEL);
572 }
573
574
575 /*
576 * si470x_get_freq - get the frequency
577 */
578 static int si470x_get_freq(struct si470x_device *radio)
579 {
580 int spacing, band_bottom, chan, freq;
581 int retval;
582
583 /* Spacing (kHz) */
584 switch (space) {
585 /* 0: 200 kHz (USA, Australia) */
586 case 0 : spacing = 0.200 * FREQ_MUL; break;
587 /* 1: 100 kHz (Europe, Japan) */
588 case 1 : spacing = 0.100 * FREQ_MUL; break;
589 /* 2: 50 kHz */
590 default: spacing = 0.050 * FREQ_MUL; break;
591 };
592
593 /* Bottom of Band (MHz) */
594 switch (band) {
595 /* 0: 87.5 - 108 MHz (USA, Europe) */
596 case 0 : band_bottom = 87.5 * FREQ_MUL; break;
597 /* 1: 76 - 108 MHz (Japan wide band) */
598 default: band_bottom = 76 * FREQ_MUL; break;
599 /* 2: 76 - 90 MHz (Japan) */
600 case 2 : band_bottom = 76 * FREQ_MUL; break;
601 };
602
603 /* read channel */
604 retval = si470x_get_register(radio, READCHAN);
605 if (retval < 0)
606 return retval;
607 chan = radio->registers[READCHAN] & READCHAN_READCHAN;
608
609 /* Frequency (MHz) = Spacing (kHz) x Channel + Bottom of Band (MHz) */
610 freq = chan * spacing + band_bottom;
611
612 return freq;
613 }
614
615
616 /*
617 * si470x_set_freq - set the frequency
618 */
619 static int si470x_set_freq(struct si470x_device *radio, int freq)
620 {
621 int spacing, band_bottom, chan;
622
623 /* Spacing (kHz) */
624 switch (space) {
625 /* 0: 200 kHz (USA, Australia) */
626 case 0 : spacing = 0.200 * FREQ_MUL; break;
627 /* 1: 100 kHz (Europe, Japan) */
628 case 1 : spacing = 0.100 * FREQ_MUL; break;
629 /* 2: 50 kHz */
630 default: spacing = 0.050 * FREQ_MUL; break;
631 };
632
633 /* Bottom of Band (MHz) */
634 switch (band) {
635 /* 0: 87.5 - 108 MHz (USA, Europe) */
636 case 0 : band_bottom = 87.5 * FREQ_MUL; break;
637 /* 1: 76 - 108 MHz (Japan wide band) */
638 default: band_bottom = 76 * FREQ_MUL; break;
639 /* 2: 76 - 90 MHz (Japan) */
640 case 2 : band_bottom = 76 * FREQ_MUL; break;
641 };
642
643 /* Chan = [ Freq (Mhz) - Bottom of Band (MHz) ] / Spacing (kHz) */
644 chan = (freq - band_bottom) / spacing;
645
646 return si470x_set_chan(radio, chan);
647 }
648
649
650 /*
651 * si470x_start - switch on radio
652 */
653 static int si470x_start(struct si470x_device *radio)
654 {
655 int retval;
656
657 /* powercfg */
658 radio->registers[POWERCFG] =
659 POWERCFG_DMUTE | POWERCFG_ENABLE | POWERCFG_RDSM;
660 retval = si470x_set_register(radio, POWERCFG);
661 if (retval < 0)
662 return retval;
663
664 /* sysconfig 1 */
665 radio->registers[SYSCONFIG1] = SYSCONFIG1_DE;
666 retval = si470x_set_register(radio, SYSCONFIG1);
667 if (retval < 0)
668 return retval;
669
670 /* sysconfig 2 */
671 radio->registers[SYSCONFIG2] =
672 (0x3f << 8) | /* SEEKTH */
673 (band << 6) | /* BAND */
674 (space << 4) | /* SPACE */
675 15; /* VOLUME (max) */
676 retval = si470x_set_register(radio, SYSCONFIG2);
677 if (retval < 0)
678 return retval;
679
680 /* reset last channel */
681 return si470x_set_chan(radio,
682 radio->registers[CHANNEL] & CHANNEL_CHAN);
683 }
684
685
686 /*
687 * si470x_stop - switch off radio
688 */
689 static int si470x_stop(struct si470x_device *radio)
690 {
691 int retval;
692
693 /* sysconfig 1 */
694 radio->registers[SYSCONFIG1] &= ~SYSCONFIG1_RDS;
695 retval = si470x_set_register(radio, SYSCONFIG1);
696 if (retval < 0)
697 return retval;
698
699 /* powercfg */
700 radio->registers[POWERCFG] &= ~POWERCFG_DMUTE;
701 /* POWERCFG_ENABLE has to automatically go low */
702 radio->registers[POWERCFG] |= POWERCFG_ENABLE | POWERCFG_DISABLE;
703 return si470x_set_register(radio, POWERCFG);
704 }
705
706
707 /*
708 * si470x_rds_on - switch on rds reception
709 */
710 static int si470x_rds_on(struct si470x_device *radio)
711 {
712 /* sysconfig 1 */
713 radio->registers[SYSCONFIG1] |= SYSCONFIG1_RDS;
714 return si470x_set_register(radio, SYSCONFIG1);
715 }
716
717
718
719 /**************************************************************************
720 * RDS Driver Functions
721 **************************************************************************/
722
723 /*
724 * si470x_rds - rds processing function
725 */
726 static void si470x_rds(struct si470x_device *radio)
727 {
728 unsigned char tmpbuf[3];
729 unsigned char blocknum;
730 unsigned char bler; /* rds block errors */
731 unsigned short rds;
732 unsigned int i;
733
734 /* get rds blocks */
735 if (si470x_get_rds_registers(radio) < 0)
736 return;
737 if ((radio->registers[STATUSRSSI] & STATUSRSSI_RDSR) == 0) {
738 /* No RDS group ready */
739 return;
740 }
741 if ((radio->registers[STATUSRSSI] & STATUSRSSI_RDSS) == 0) {
742 /* RDS decoder not synchronized */
743 return;
744 }
745
746 /* copy four RDS blocks to internal buffer */
747 if (spin_trylock(&radio->lock)) {
748 /* process each rds block */
749 for (blocknum = 0; blocknum < 4; blocknum++) {
750 switch (blocknum) {
751 default:
752 bler = (radio->registers[STATUSRSSI] &
753 STATUSRSSI_BLERA) >> 9;
754 rds = radio->registers[RDSA];
755 break;
756 case 1:
757 bler = (radio->registers[READCHAN] &
758 READCHAN_BLERB) >> 14;
759 rds = radio->registers[RDSB];
760 break;
761 case 2:
762 bler = (radio->registers[READCHAN] &
763 READCHAN_BLERC) >> 12;
764 rds = radio->registers[RDSC];
765 break;
766 case 3:
767 bler = (radio->registers[READCHAN] &
768 READCHAN_BLERD) >> 10;
769 rds = radio->registers[RDSD];
770 break;
771 };
772
773 /* Fill the V4L2 RDS buffer */
774 tmpbuf[0] = rds & 0x00ff; /* LSB */
775 tmpbuf[1] = (rds & 0xff00) >> 8;/* MSB */
776 tmpbuf[2] = blocknum; /* offset name */
777 tmpbuf[2] |= blocknum << 3; /* received offset */
778 if (bler > max_rds_errors)
779 tmpbuf[2] |= 0x80; /* uncorrectable errors */
780 else if (bler > 0)
781 tmpbuf[2] |= 0x40; /* corrected error(s) */
782
783 /* copy RDS block to internal buffer */
784 for (i = 0; i < 3; i++) {
785 radio->buffer[radio->wr_index] = tmpbuf[i];
786 radio->wr_index++;
787 }
788
789 /* wrap write pointer */
790 if (radio->wr_index >= radio->buf_size)
791 radio->wr_index = 0;
792
793 /* check for overflow */
794 if (radio->wr_index == radio->rd_index) {
795 /* increment and wrap read pointer */
796 radio->rd_index += 3;
797 if (radio->rd_index >= radio->buf_size)
798 radio->rd_index = 0;
799 }
800 }
801 spin_unlock(&radio->lock);
802 }
803
804 /* wake up read queue */
805 if (radio->wr_index != radio->rd_index)
806 wake_up_interruptible(&radio->read_queue);
807 }
808
809
810 /*
811 * si470x_timer - rds timer function
812 */
813 static void si470x_timer(unsigned long data)
814 {
815 struct si470x_device *radio = (struct si470x_device *) data;
816
817 schedule_work(&radio->work);
818 }
819
820
821 /*
822 * si470x_work - rds work function
823 */
824 static void si470x_work(struct work_struct *work)
825 {
826 struct si470x_device *radio = container_of(work, struct si470x_device,
827 work);
828
829 if ((radio->registers[SYSCONFIG1] & SYSCONFIG1_RDS) == 0)
830 return;
831
832 si470x_rds(radio);
833 mod_timer(&radio->timer, jiffies + msecs_to_jiffies(rds_poll_time));
834 }
835
836
837
838 /**************************************************************************
839 * File Operations Interface
840 **************************************************************************/
841
842 /*
843 * si470x_fops_read - read RDS data
844 */
845 static ssize_t si470x_fops_read(struct file *file, char __user *buf,
846 size_t count, loff_t *ppos)
847 {
848 struct si470x_device *radio = video_get_drvdata(video_devdata(file));
849 int retval = 0;
850 unsigned int block_count = 0;
851
852 /* switch on rds reception */
853 if ((radio->registers[SYSCONFIG1] & SYSCONFIG1_RDS) == 0) {
854 si470x_rds_on(radio);
855 schedule_work(&radio->work);
856 }
857
858 /* block if no new data available */
859 while (radio->wr_index == radio->rd_index) {
860 if (file->f_flags & O_NONBLOCK)
861 return -EWOULDBLOCK;
862 interruptible_sleep_on(&radio->read_queue);
863 }
864
865 /* calculate block count from byte count */
866 count /= 3;
867
868 /* copy RDS block out of internal buffer and to user buffer */
869 if (spin_trylock(&radio->lock)) {
870 while (block_count < count) {
871 if (radio->rd_index == radio->wr_index)
872 break;
873
874 /* always transfer rds complete blocks */
875 if (copy_to_user(buf,
876 &radio->buffer[radio->rd_index], 3))
877 /* retval = -EFAULT; */
878 break;
879
880 /* increment and wrap read pointer */
881 radio->rd_index += 3;
882 if (radio->rd_index >= radio->buf_size)
883 radio->rd_index = 0;
884
885 /* increment counters */
886 block_count++;
887 buf += 3;
888 retval += 3;
889 }
890
891 spin_unlock(&radio->lock);
892 }
893
894 return retval;
895 }
896
897
898 /*
899 * si470x_fops_poll - poll RDS data
900 */
901 static unsigned int si470x_fops_poll(struct file *file,
902 struct poll_table_struct *pts)
903 {
904 struct si470x_device *radio = video_get_drvdata(video_devdata(file));
905
906 /* switch on rds reception */
907 if ((radio->registers[SYSCONFIG1] & SYSCONFIG1_RDS) == 0) {
908 si470x_rds_on(radio);
909 schedule_work(&radio->work);
910 }
911
912 poll_wait(file, &radio->read_queue, pts);
913
914 if (radio->rd_index != radio->wr_index)
915 return POLLIN | POLLRDNORM;
916
917 return 0;
918 }
919
920
921 /*
922 * si470x_fops_open - file open
923 */
924 static int si470x_fops_open(struct inode *inode, struct file *file)
925 {
926 struct si470x_device *radio = video_get_drvdata(video_devdata(file));
927
928 radio->users++;
929 if (radio->users == 1)
930 return si470x_start(radio);
931
932 return 0;
933 }
934
935
936 /*
937 * si470x_fops_release - file release
938 */
939 static int si470x_fops_release(struct inode *inode, struct file *file)
940 {
941 struct si470x_device *radio = video_get_drvdata(video_devdata(file));
942
943 if (!radio)
944 return -ENODEV;
945
946 radio->users--;
947 if (radio->users == 0) {
948 /* stop rds reception */
949 del_timer_sync(&radio->timer);
950 flush_scheduled_work();
951
952 /* cancel read processes */
953 wake_up_interruptible(&radio->read_queue);
954
955 return si470x_stop(radio);
956 }
957
958 return 0;
959 }
960
961
962 /*
963 * si470x_fops - file operations interface
964 */
965 static const struct file_operations si470x_fops = {
966 .owner = THIS_MODULE,
967 .llseek = no_llseek,
968 .read = si470x_fops_read,
969 .poll = si470x_fops_poll,
970 .ioctl = video_ioctl2,
971 .compat_ioctl = v4l_compat_ioctl32,
972 .open = si470x_fops_open,
973 .release = si470x_fops_release,
974 };
975
976
977
978 /**************************************************************************
979 * Video4Linux Interface
980 **************************************************************************/
981
982 /*
983 * si470x_v4l2_queryctrl - query control
984 */
985 static struct v4l2_queryctrl si470x_v4l2_queryctrl[] = {
986 /* HINT: the disabled controls are only here to satify kradio and such apps */
987 {
988 .id = V4L2_CID_AUDIO_VOLUME,
989 .type = V4L2_CTRL_TYPE_INTEGER,
990 .name = "Volume",
991 .minimum = 0,
992 .maximum = 15,
993 .step = 1,
994 .default_value = 15,
995 },
996 {
997 .id = V4L2_CID_AUDIO_BALANCE,
998 .flags = V4L2_CTRL_FLAG_DISABLED,
999 },
1000 {
1001 .id = V4L2_CID_AUDIO_BASS,
1002 .flags = V4L2_CTRL_FLAG_DISABLED,
1003 },
1004 {
1005 .id = V4L2_CID_AUDIO_TREBLE,
1006 .flags = V4L2_CTRL_FLAG_DISABLED,
1007 },
1008 {
1009 .id = V4L2_CID_AUDIO_MUTE,
1010 .type = V4L2_CTRL_TYPE_BOOLEAN,
1011 .name = "Mute",
1012 .minimum = 0,
1013 .maximum = 1,
1014 .step = 1,
1015 .default_value = 1,
1016 },
1017 {
1018 .id = V4L2_CID_AUDIO_LOUDNESS,
1019 .flags = V4L2_CTRL_FLAG_DISABLED,
1020 },
1021 };
1022
1023
1024 /*
1025 * si470x_vidioc_querycap - query device capabilities
1026 */
1027 static int si470x_vidioc_querycap(struct file *file, void *priv,
1028 struct v4l2_capability *capability)
1029 {
1030 strlcpy(capability->driver, DRIVER_NAME, sizeof(capability->driver));
1031 strlcpy(capability->card, DRIVER_CARD, sizeof(capability->card));
1032 sprintf(capability->bus_info, "USB");
1033 capability->version = DRIVER_VERSION;
1034 capability->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
1035
1036 return 0;
1037 }
1038
1039
1040 /*
1041 * si470x_vidioc_g_input - get input
1042 */
1043 static int si470x_vidioc_g_input(struct file *filp, void *priv,
1044 unsigned int *i)
1045 {
1046 *i = 0;
1047
1048 return 0;
1049 }
1050
1051
1052 /*
1053 * si470x_vidioc_s_input - set input
1054 */
1055 static int si470x_vidioc_s_input(struct file *filp, void *priv, unsigned int i)
1056 {
1057 if (i != 0)
1058 return -EINVAL;
1059
1060 return 0;
1061 }
1062
1063
1064 /*
1065 * si470x_vidioc_queryctrl - enumerate control items
1066 */
1067 static int si470x_vidioc_queryctrl(struct file *file, void *priv,
1068 struct v4l2_queryctrl *qc)
1069 {
1070 int i;
1071
1072 for (i = 0; i < ARRAY_SIZE(si470x_v4l2_queryctrl); i++) {
1073 if (qc->id && qc->id == si470x_v4l2_queryctrl[i].id) {
1074 memcpy(qc, &(si470x_v4l2_queryctrl[i]), sizeof(*qc));
1075 return 0;
1076 }
1077 }
1078
1079 return -EINVAL;
1080 }
1081
1082
1083 /*
1084 * si470x_vidioc_g_ctrl - get the value of a control
1085 */
1086 static int si470x_vidioc_g_ctrl(struct file *file, void *priv,
1087 struct v4l2_control *ctrl)
1088 {
1089 struct si470x_device *radio = video_get_drvdata(video_devdata(file));
1090
1091 switch (ctrl->id) {
1092 case V4L2_CID_AUDIO_VOLUME:
1093 ctrl->value = radio->registers[SYSCONFIG2] &
1094 SYSCONFIG2_VOLUME;
1095 break;
1096 case V4L2_CID_AUDIO_MUTE:
1097 ctrl->value = ((radio->registers[POWERCFG] &
1098 POWERCFG_DMUTE) == 0) ? 1 : 0;
1099 break;
1100 }
1101
1102 return 0;
1103 }
1104
1105
1106 /*
1107 * si470x_vidioc_s_ctrl - set the value of a control
1108 */
1109 static int si470x_vidioc_s_ctrl(struct file *file, void *priv,
1110 struct v4l2_control *ctrl)
1111 {
1112 struct si470x_device *radio = video_get_drvdata(video_devdata(file));
1113
1114 switch (ctrl->id) {
1115 case V4L2_CID_AUDIO_VOLUME:
1116 radio->registers[SYSCONFIG2] &= ~SYSCONFIG2_VOLUME;
1117 radio->registers[SYSCONFIG2] |= ctrl->value;
1118 return si470x_set_register(radio, SYSCONFIG2);
1119 case V4L2_CID_AUDIO_MUTE:
1120 if (ctrl->value == 1)
1121 radio->registers[POWERCFG] &= ~POWERCFG_DMUTE;
1122 else
1123 radio->registers[POWERCFG] |= POWERCFG_DMUTE;
1124 return si470x_set_register(radio, POWERCFG);
1125 }
1126
1127 return -EINVAL;
1128 }
1129
1130
1131 /*
1132 * si470x_vidioc_g_audio - get audio attributes
1133 */
1134 static int si470x_vidioc_g_audio(struct file *file, void *priv,
1135 struct v4l2_audio *audio)
1136 {
1137 if (audio->index > 1)
1138 return -EINVAL;
1139
1140 strcpy(audio->name, "Radio");
1141 audio->capability = V4L2_AUDCAP_STEREO;
1142
1143 return 0;
1144 }
1145
1146
1147 /*
1148 * si470x_vidioc_s_audio - set audio attributes
1149 */
1150 static int si470x_vidioc_s_audio(struct file *file, void *priv,
1151 struct v4l2_audio *audio)
1152 {
1153 if (audio->index != 0)
1154 return -EINVAL;
1155
1156 return 0;
1157 }
1158
1159
1160 /*
1161 * si470x_vidioc_g_tuner - get tuner attributes
1162 */
1163 static int si470x_vidioc_g_tuner(struct file *file, void *priv,
1164 struct v4l2_tuner *tuner)
1165 {
1166 int retval;
1167 struct si470x_device *radio = video_get_drvdata(video_devdata(file));
1168
1169 if (tuner->index > 0)
1170 return -EINVAL;
1171
1172 /* read status rssi */
1173 retval = si470x_get_register(radio, STATUSRSSI);
1174 if (retval < 0)
1175 return retval;
1176
1177 strcpy(tuner->name, "FM");
1178 tuner->type = V4L2_TUNER_RADIO;
1179 switch (band) {
1180 /* 0: 87.5 - 108 MHz (USA, Europe, default) */
1181 default:
1182 tuner->rangelow = 87.5 * FREQ_MUL;
1183 tuner->rangehigh = 108 * FREQ_MUL;
1184 break;
1185 /* 1: 76 - 108 MHz (Japan wide band) */
1186 case 1 :
1187 tuner->rangelow = 76 * FREQ_MUL;
1188 tuner->rangehigh = 108 * FREQ_MUL;
1189 break;
1190 /* 2: 76 - 90 MHz (Japan) */
1191 case 2 :
1192 tuner->rangelow = 76 * FREQ_MUL;
1193 tuner->rangehigh = 90 * FREQ_MUL;
1194 break;
1195 };
1196 tuner->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1197 tuner->capability = V4L2_TUNER_CAP_LOW;
1198
1199 /* Stereo indicator == Stereo (instead of Mono) */
1200 if ((radio->registers[STATUSRSSI] & STATUSRSSI_ST) == 1)
1201 tuner->audmode = V4L2_TUNER_MODE_STEREO;
1202 else
1203 tuner->audmode = V4L2_TUNER_MODE_MONO;
1204
1205 /* min is worst, max is best; signal:0..0xffff; rssi: 0..0xff */
1206 tuner->signal = (radio->registers[STATUSRSSI] & STATUSRSSI_RSSI)
1207 * 0x0101;
1208
1209 /* automatic frequency control: -1: freq to low, 1 freq to high */
1210 tuner->afc = 0;
1211
1212 return 0;
1213 }
1214
1215
1216 /*
1217 * si470x_vidioc_s_tuner - set tuner attributes
1218 */
1219 static int si470x_vidioc_s_tuner(struct file *file, void *priv,
1220 struct v4l2_tuner *tuner)
1221 {
1222 struct si470x_device *radio = video_get_drvdata(video_devdata(file));
1223
1224 if (tuner->index > 0)
1225 return -EINVAL;
1226
1227 if (tuner->audmode == V4L2_TUNER_MODE_MONO)
1228 radio->registers[POWERCFG] |= POWERCFG_MONO; /* force mono */
1229 else
1230 radio->registers[POWERCFG] &= ~POWERCFG_MONO; /* try stereo */
1231
1232 return si470x_set_register(radio, POWERCFG);
1233 }
1234
1235
1236 /*
1237 * si470x_vidioc_g_frequency - get tuner or modulator radio frequency
1238 */
1239 static int si470x_vidioc_g_frequency(struct file *file, void *priv,
1240 struct v4l2_frequency *freq)
1241 {
1242 struct si470x_device *radio = video_get_drvdata(video_devdata(file));
1243
1244 freq->type = V4L2_TUNER_RADIO;
1245 freq->frequency = si470x_get_freq(radio);
1246
1247 return 0;
1248 }
1249
1250
1251 /*
1252 * si470x_vidioc_s_frequency - set tuner or modulator radio frequency
1253 */
1254 static int si470x_vidioc_s_frequency(struct file *file, void *priv,
1255 struct v4l2_frequency *freq)
1256 {
1257 struct si470x_device *radio = video_get_drvdata(video_devdata(file));
1258
1259 if (freq->type != V4L2_TUNER_RADIO)
1260 return -EINVAL;
1261
1262 return si470x_set_freq(radio, freq->frequency);
1263 }
1264
1265
1266 /*
1267 * si470x_viddev_tamples - video device interface
1268 */
1269 static struct video_device si470x_viddev_template = {
1270 .fops = &si470x_fops,
1271 .name = DRIVER_NAME,
1272 .type = VID_TYPE_TUNER,
1273 .release = video_device_release,
1274 .vidioc_querycap = si470x_vidioc_querycap,
1275 .vidioc_g_input = si470x_vidioc_g_input,
1276 .vidioc_s_input = si470x_vidioc_s_input,
1277 .vidioc_queryctrl = si470x_vidioc_queryctrl,
1278 .vidioc_g_ctrl = si470x_vidioc_g_ctrl,
1279 .vidioc_s_ctrl = si470x_vidioc_s_ctrl,
1280 .vidioc_g_audio = si470x_vidioc_g_audio,
1281 .vidioc_s_audio = si470x_vidioc_s_audio,
1282 .vidioc_g_tuner = si470x_vidioc_g_tuner,
1283 .vidioc_s_tuner = si470x_vidioc_s_tuner,
1284 .vidioc_g_frequency = si470x_vidioc_g_frequency,
1285 .vidioc_s_frequency = si470x_vidioc_s_frequency,
1286 .owner = THIS_MODULE,
1287 };
1288
1289
1290
1291 /**************************************************************************
1292 * USB Interface
1293 **************************************************************************/
1294
1295 /*
1296 * si470x_usb_driver_probe - probe for the device
1297 */
1298 static int si470x_usb_driver_probe(struct usb_interface *intf,
1299 const struct usb_device_id *id)
1300 {
1301 struct si470x_device *radio;
1302
1303 /* memory and interface allocations */
1304 radio = kmalloc(sizeof(struct si470x_device), GFP_KERNEL);
1305 if (!radio)
1306 return -ENOMEM;
1307 radio->videodev = video_device_alloc();
1308 if (!radio->videodev) {
1309 kfree(radio);
1310 return -ENOMEM;
1311 }
1312 memcpy(radio->videodev, &si470x_viddev_template,
1313 sizeof(si470x_viddev_template));
1314 radio->users = 0;
1315 radio->usbdev = interface_to_usbdev(intf);
1316 video_set_drvdata(radio->videodev, radio);
1317 if (video_register_device(radio->videodev, VFL_TYPE_RADIO, radio_nr)) {
1318 printk(KERN_WARNING DRIVER_NAME
1319 ": Could not register video device\n");
1320 video_device_release(radio->videodev);
1321 kfree(radio);
1322 return -EIO;
1323 }
1324 usb_set_intfdata(intf, radio);
1325
1326 /* show some infos about the specific device */
1327 if (si470x_get_all_registers(radio) < 0) {
1328 video_device_release(radio->videodev);
1329 kfree(radio);
1330 return -EIO;
1331 }
1332 printk(KERN_INFO DRIVER_NAME ": DeviceID=0x%4.4x ChipID=0x%4.4x\n",
1333 radio->registers[DEVICEID], radio->registers[CHIPID]);
1334
1335 /* check if firmware is current */
1336 if ((radio->registers[CHIPID] & CHIPID_FIRMWARE)
1337 < RADIO_SW_VERSION_CURRENT)
1338 printk(KERN_WARNING DRIVER_NAME
1339 ": This driver is known to work with chip version %d, "
1340 "but the device has firmware %d.\n"
1341 DRIVER_NAME
1342 "If you have some trouble using this driver, please "
1343 "report to V4L ML at video4linux-list@redhat.com\n",
1344 radio->registers[CHIPID] & CHIPID_FIRMWARE,
1345 RADIO_SW_VERSION_CURRENT);
1346
1347 /* set initial frequency */
1348 si470x_set_freq(radio, 87.5 * FREQ_MUL); /* available in all regions */
1349
1350 /* rds initialization */
1351 radio->buf_size = rds_buf * 3;
1352 radio->buffer = kmalloc(radio->buf_size, GFP_KERNEL);
1353 if (!radio->buffer) {
1354 video_device_release(radio->videodev);
1355 kfree(radio);
1356 return -ENOMEM;
1357 }
1358 radio->wr_index = 0;
1359 radio->rd_index = 0;
1360 init_waitqueue_head(&radio->read_queue);
1361
1362 /* prepare polling via eventd */
1363 INIT_WORK(&radio->work, si470x_work);
1364 init_timer(&radio->timer);
1365 radio->timer.function = si470x_timer;
1366 radio->timer.data = (unsigned long) radio;
1367
1368 return 0;
1369 }
1370
1371
1372 /*
1373 * si470x_usb_driver_disconnect - disconnect the device
1374 */
1375 static void si470x_usb_driver_disconnect(struct usb_interface *intf)
1376 {
1377 struct si470x_device *radio = usb_get_intfdata(intf);
1378
1379 del_timer_sync(&radio->timer);
1380 flush_scheduled_work();
1381
1382 usb_set_intfdata(intf, NULL);
1383 if (radio) {
1384 video_unregister_device(radio->videodev);
1385 kfree(radio->buffer);
1386 kfree(radio);
1387 }
1388 }
1389
1390
1391 /*
1392 * si470x_usb_driver - usb driver interface
1393 */
1394 static struct usb_driver si470x_usb_driver = {
1395 .name = DRIVER_NAME,
1396 .probe = si470x_usb_driver_probe,
1397 .disconnect = si470x_usb_driver_disconnect,
1398 .id_table = si470x_usb_driver_id_table,
1399 };
1400
1401
1402
1403 /**************************************************************************
1404 * Module Interface
1405 **************************************************************************/
1406
1407 /*
1408 * si470x_module_init - module init
1409 */
1410 static int __init si470x_module_init(void)
1411 {
1412 printk(KERN_INFO DRIVER_DESC "\n");
1413 return usb_register(&si470x_usb_driver);
1414 }
1415
1416
1417 /*
1418 * si470x_module_exit - module exit
1419 */
1420 static void __exit si470x_module_exit(void)
1421 {
1422 usb_deregister(&si470x_usb_driver);
1423 }
1424
1425
1426 module_init(si470x_module_init);
1427 module_exit(si470x_module_exit);
1428
1429 MODULE_LICENSE("GPL");
1430 MODULE_AUTHOR(DRIVER_AUTHOR);
1431 MODULE_DESCRIPTION(DRIVER_DESC);
1432 MODULE_VERSION("1.0.4");
WRT350N Kernel Patches