开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 驱动编程 > 查看源码
radio-si4703.c
资源名称：fmradio.zip　[点击查看]
上传用户：ledjyj
上传日期：2014-08-27
资源大小：2639k
文件大小：14k
源码类别：

驱动编程

开发平台：

Unix_Linux

radio-si4703.c：源码内容
  1. /* SI4703 Radio Card driver for radio support
  2.  * (c) 1999 Dr. Henrik Seidel <Henrik.Seidel@gmx.de>
  3.  *
  4.  * Card manufacturer:
  5.  * http://194.18.155.92/idc/prod2.idc?nr=50753&lang=e
  6.  *
  7.  * Notes on the hardware
  8.  *
  9.  * This card has two output sockets, one for speakers and one for line.
  10.  * The speaker output has volume control, but only in four discrete
  11.  * steps. The line output has neither volume control nor mute.
  12.  *
  13.  * The card has auto-stereo according to its manual, although it all
  14.  * sounds mono to me (even with the Win/DOS drivers). Maybe it's my
  15.  * antenna - I really don't know for sure.
  16.  *
  17.  * Frequency control is done digitally.
  18.  *
  19.  * Volume control is done digitally, but there are only four different
  20.  * possible values. So you should better always turn the volume up and
  21.  * use line control. I got the best results by connecting line output
  22.  * to the sound card microphone input. For such a configuration the
  23.  * volume control has no effect, since volume control only influences
  24.  * the speaker output.
  25.  *
  26.  * There is no explicit mute/unmute. So I set the radio frequency to a
  27.  * value where I do expect just noise and turn the speaker volume down.
  28.  * The frequency change is necessary since the card never seems to be
  29.  * completely silent.
  30.  */
  32. #include <linux/module.h> /* Modules                        */
  33. #include <linux/init.h> /* Initdata                       */
  34. #include <linux/ioport.h> /* request_region   */
  35. #include <linux/proc_fs.h> /* radio card status report   */
  36. #include <asm/io.h> /* outb, outb_p                   */
  37. #include <asm/uaccess.h> /* copy to/from user              */
  38. #include <linux/videodev.h> /* kernel radio structs           */
  39. #include <linux/config.h> /* CONFIG_RADIO_SI4703_*         */
  40. #include <linux/types.h>
  41. #include <linux/interrupt.h>
  42. #include <linux/workqueue.h>
  44. #include "SI4703API.h"
  46. #define BANNER "SI4703 Radio Card driver v0.1n"
  50. #ifndef CONFIG_RADIO_SI4703_MUTEFREQ
  51. #define CONFIG_RADIO_SI4703_MUTEFREQ 0
  52. #endif
  54. #ifndef CONFIG_PROC_FS
  55. #undef CONFIG_RADIO_SI4703_PROC_FS
  56. #endif
  59. #ifndef TRUE
  60. #define TRUE 1
  61. #endif
  62. #ifndef FALSE
  63. #define FALSE 0
  64. #endif
  66. struct SI4703_device {
  67. int users;
  68. int curvol;
  69. int muted;
  70. unsigned long curfreq;
  71. unsigned long mutefreq;
  72. struct mutex lock;
  73.     __u32 audmode;
  74.     struct RDS_DATA irq_data;
  75. spinlock_t irq_lock;
  76. wait_queue_head_t irq_queue;
  77.     struct workqueue_struct *radio_irq_workq;
  78. struct work_struct fm_event_work;
  79. struct fasync_struct *async_queue;
  80. };
  82. static struct SI4703_device SI4703_unit =
  83. {
  85. .curfreq = CONFIG_RADIO_SI4703_MUTEFREQ,
  86. .mutefreq = CONFIG_RADIO_SI4703_MUTEFREQ,
  87. };
  89. static int SI4703_ioctl(struct inode *inode, struct file *file,
  90.  unsigned int cmd, unsigned long arg);
  92. static int SI4703_Read(struct file *file, char __user *arg, size_t count, loff_t *offset);
  94. #ifdef CONFIG_RADIO_SI4703_PROC_FS
  95. static int SI4703_get_info(char *buf, char **start, off_t offset, int len);
  96. #endif
  98. static void query_radio_ctrl(struct v4l2_queryctrl *param);
  99. static void get_radio_ctrl(struct v4l2_control *param);
  100. static void set_radio_ctrl(struct v4l2_control *param);
  101. static int  SI4703_init_irq(void);
  106. static int SI4703_do_ioctl(struct inode *inode, struct file *file,
  107.     unsigned int cmd, void *arg)
  108. {
  109. struct video_device *dev = video_devdata(file);
  110. struct SI4703_device *SI4703 = dev->priv;
  112. switch (cmd) {
  113. case VIDIOC_QUERYCAP:
  114. {
  115. struct v4l2_capability *v = arg;
  116. memset(v,0,sizeof(*v));
  117. v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
  118. strcpy(v->driver, "SI4703");
  119. return 0;
  120. }
  122.     case VIDIOC_RADIO_ON:
  123. {
  124.             printk(KERN_ERR "radio-SI4703: ioctl radio onn");
  125.             FM_SI47XX_PowerUp();
  126. return 0;
  127. }
  128. case VIDIOC_RADIO_OFF:
  129. {
  130.             printk(KERN_ERR "radio-SI4703: ioctl radio offn");
  131.             FM_SI47XX_PowerDown();
  132. return 0;
  133. }
  134. case VIDIOC_G_TUNER:
  135. {
  136. struct v4l2_tuner *v = arg;
  137. // if (v->tuner) /* Only 1 tuner */
  138. // return -EINVAL;
  139.           printk(KERN_ERR "radio-SI4703: ioctl get tunern");
  140. v->rangelow = 8750;
  141. v->rangehigh = 10800;
  142. v->type = V4L2_TUNER_RADIO;
  143. v->capability = V4L2_TUNER_CAP_STEREO;
  144. v->signal = FM_SI47XX_ReadRSSI(); /*  get the signal strength */
  145. strcpy(v->name, "SI4703");
  146. return 0;
  147. }
  148. case VIDIOC_S_TUNER:
  149. {
  150. struct v4l2_tuner *v = arg;
  151. // if (v->tuner != 0)
  152. // return -EINVAL;
  153. /* Only 1 tuner so no setting needed ! */
  154.             printk(KERN_ERR "radio-SI4703: ioctl set tunern");
  155.            SI4703->audmode = v->audmode;
  156. return 0;
  157. }
  158. case VIDIOC_G_FREQUENCY:
  159. {
  160. struct v4l2_frequency *freq = arg;
  161.         printk(KERN_ERR "radio-SI4703: ioctl get freqn");
  162. freq->frequency = SI4703->curfreq;
  163.         freq->type = V4L2_TUNER_RADIO;
  164. return 0;
  165. }
  166. case VIDIOC_S_FREQUENCY:
  167. {
  168. struct v4l2_frequency *freq = arg;
  169.          printk(KERN_ERR "radio-SI4703: ioctl set freqn");
  170. SI4703->curfreq = freq->frequency;
  171. FM_SI47XX_Tune(SI4703->curfreq);
  172. return 0;
  173. }
  174.     case VIDIOC_QUERYCTRL:
  175.     {
  176.         struct v4l2_queryctrl *v = arg;
  177.         query_radio_ctrl(v);
  178.         return 0;
  179.     }
  180.     case VIDIOC_G_CTRL:
  181.     {
  182.         struct v4l2_control * v = arg;
  183.         get_radio_ctrl(v);
  184.         return 0;
  186.     }
  187.     case VIDIOC_S_CTRL:
  188.     {
  189.         struct v4l2_control * v = arg;
  190.           printk(KERN_ERR "radio-SI4703: ioctl set ctrln");
  191.         set_radio_ctrl(v);
  192.         return 0;
  193.     }
  194.     case RADIO_SCAN_NEXT:
  195.     {
  196.         struct radio_scan *v = arg;
  197.         if(SEEKUP == v->direction) {
  198.            printk(KERN_ERR "radio-SI4703: ioctl seek upn");
  199.             FM_SI47XX_Seek(SEEKUP,&v->channel, &v->scanok);
  200.         }
  202.         if(SEEKDOWN == v->direction) {
  203.             printk(KERN_ERR "radio-SI4703: ioctl seek downn");
  204.             FM_SI47XX_Seek(SEEKDOWN, &v->channel,&v->scanok);
  205.         }
  207.        return 0;
  208.     }
  209.         
  210. default:
  211. return -ENOIOCTLCMD;
  212. }
  213. }
  215. static void query_radio_ctrl(struct v4l2_queryctrl *param)
  216. {
  218.    struct  v4l2_queryctrl *v = param;
  219.     switch (v->id) {
  220.     case V4L2_CID_AUDIO_VOLUME:
  221.     {
  222.         v->type = V4L2_CTRL_TYPE_INTEGER;
  223.         v->minimum = 0;
  224.         v->maximum = 100;
  225.         v->step =20;
  226.         return;
  228.     }
  229.     case V4L2_CID_AUDIO_MUTE:
  230.     {
  231.        v->type = V4L2_CTRL_TYPE_BOOLEAN;
  233.        return;
  234.     }
  235.     default:
  236.     {
  237.         v->flags = V4L2_CTRL_FLAG_DISABLED;
  238.         return;
  239.     }
  241.     }
  243. }
  245. static void get_radio_ctrl(struct v4l2_control *param)
  246. {
  248.    struct v4l2_control *v = param;
  249.     switch (v->id) {
  250.     case V4L2_CID_AUDIO_VOLUME:
  251.     {
  252.         v->value = SI4703_unit.curvol;
  253.         return;
  254.    
  255.     }
  256.     case V4L2_CID_AUDIO_MUTE:
  257.     {
  258.        v->value = SI4703_unit.muted ;
  259.        return;
  261.     }
  262.     default:
  263.     {
  264.         v->value = -1;
  265.         return;
  266.     }
  268.     }
  270. }
  272. static void set_radio_ctrl(struct v4l2_control *param)
  273. {
  275.     struct v4l2_control *v = param;
  276.     switch (v->id) {
  277.     case V4L2_CID_AUDIO_VOLUME:
  278.     {
  279.      FM_SI47XX_Volume(v->value);
  280.      SI4703_unit.curvol = v->value;
  281.      return;
  283.     }
  284.     case V4L2_CID_AUDIO_MUTE:
  285.     {
  286.         if (1 == v->value) {
  287.             FM_SI47XX_MuteVolume();
  288.             SI4703_unit.muted =1;
  289.         }
  290.         else {
  291.             FM_SI47XX_DMuteVolume();
  292.             SI4703_unit.muted =0;
  293.         }
  294.             
  295.       return;
  297.     }
  298.     default:
  299.     {
  300.         printk(KERN_ERR "radio-SI4703: error controln");
  301.         return;
  302.     }
  303.        
  304.     }
  306. }
  309. static int SI4703_ioctl(struct inode *inode, struct file *file,
  310.  unsigned int cmd, unsigned long arg)
  311. {
  313.     printk(KERN_ERR "radio-SI4703: enter ioctln");
  314.     return video_usercopy(inode, file, cmd, arg, SI4703_do_ioctl);
  315. }
  317. static irqreturn_t si4703_radio_interrupt(int irq, void *dev_id,
  318. struct pt_regs *regs)
  319. {
  320.      struct SI4703_device *radio = &SI4703_unit;
  323.     printk(KERN_ERR "radio-SI4703: interruptn");
  324.    //spin_lock(&radio->irq_lock);
  325. // radio->irq_data.RDSA = ReadRDS_BLOCK(RDSA);
  326.    // radio->irq_data.RDSB = ReadRDS_BLOCK(RDSB);
  327.    // radio->irq_data.RDSC = ReadRDS_BLOCK(RDSC);
  328.   //  radio->irq_data.RDSD= ReadRDS_BLOCK(RDSD);
  329.    // radio->irq_data.RDSA = 100;
  330. //spin_unlock(&radio->irq_lock);
  332.     disable_irq(IRQ_GPIO(113));
  333. queue_work(radio->radio_irq_workq, &radio->fm_event_work);
  337. return IRQ_HANDLED;
  338. }
  340. static int SI4703_Read(struct file *file, char __user *arg, size_t count, loff_t *offset)
  341. {
  342.     struct SI4703_device *radio = &SI4703_unit;
  344.     DECLARE_WAITQUEUE(wait, current);
  345. struct RDS_DATA data;
  346. ssize_t ret;
  348. //if (count != sizeof(unsigned int) && count < sizeof(unsigned long))
  349. //return -EINVAL;
  351. add_wait_queue(&radio->irq_queue, &wait);
  352. do {
  353. __set_current_state(TASK_INTERRUPTIBLE);
  355. spin_lock_irq(&radio->irq_lock);
  356. data = radio->irq_data;
  357. radio->irq_data.RDSA = 0;
  358. spin_unlock_irq(&radio->irq_lock);
  360. if (data.RDSA != 0) {
  361. ret = 0;
  362. break;
  363. }
  364. if (file->f_flags & O_NONBLOCK) {
  365. ret = -EAGAIN;
  366. break;
  367. }
  368. if (signal_pending(current)) {
  369. ret = -ERESTARTSYS;
  370. break;
  371. }
  372. schedule();
  373. } while (1);
  374. set_current_state(TASK_RUNNING);
  375. remove_wait_queue(&radio->irq_queue, &wait);
  377. /*if (ret == 0) {
  379. if (radio->read_callback)
  380. data = radio->read_callback(rtc->class_dev.dev,
  381.        data);}*/
  383.          
  384.     return  copy_to_user(arg,&data,sizeof(data))? -EFAULT : sizeof(data);
  386.  }
  388. static unsigned int SI4703_dev_poll(struct file *file, poll_table *wait)
  389. {
  390.  struct SI4703_device *radio = &SI4703_unit;
  391.  struct RDS_DATA data;
  393. poll_wait(file, &radio->irq_queue, wait);
  395. data = radio->irq_data;
  397. return (data.RDSA != 0) ? (POLLIN | POLLRDNORM) : 0;
  398. }
  400. static int SI4703_dev_fasync(int fd, struct file *file, int on)
  401. {
  402. struct SI4703_device *radio = &SI4703_unit;
  403. return fasync_helper(fd, file, on, &radio->async_queue);
  404. }
  406. static void radio_fm_irq_worker(void *ptr) 
  407. {
  408. //spin_lock(&radio->irq_lock);
  409.     struct SI4703_device *radio = ptr;
  410. radio->irq_data.RDSA = ReadRDS_BLOCK(RDSA);
  411.     radio->irq_data.RDSB = ReadRDS_BLOCK(RDSB);
  412.     radio->irq_data.RDSC = ReadRDS_BLOCK(RDSC);
  413.     radio->irq_data.RDSD= ReadRDS_BLOCK(RDSD);
  414.     radio->irq_data.RDSA = 100;
  416.     wake_up_interruptible(&radio->irq_queue);
  417. kill_fasync(&radio->async_queue, SIGIO, POLL_IN);
  418.     enable_irq(IRQ_GPIO(113));
  419. //spin_unlock(&radio->irq_lock);
  420. }
  422. static int SI4703_init_irq(void)
  423. {
  425.     struct SI4703_device *radio = &SI4703_unit;
  426.    INIT_WORK(&radio->fm_event_work, radio_fm_irq_worker, radio);
  427. if ((radio->radio_irq_workq = 
  428. create_singlethread_workqueue("si4703radio")) == NULL) {
  429. printk(KERN_ERR"could not create radio irq work queuen"); 
  430. return -EINVAL; 
  431. }
  434.     if(request_irq (IRQ_GPIO(113), si4703_radio_interrupt, SA_INTERRUPT, "si4703_radio", NULL))
  435.     {
  436.         printk(KERN_ERR "radio-SI4703: error request irqn");
  437.         destroy_workqueue(radio->radio_irq_workq);
  438.         free_irq(IRQ_GPIO(113),NULL);
  439.         return -EINVAL; 
  440.     }
  441. return 0; 
  443. }
  445. static struct file_operations SI4703_fops = {
  446. .owner = THIS_MODULE,
  447. .open           = video_exclusive_open,
  448.     .read           = SI4703_Read,
  449. .release        = video_exclusive_release,
  450. .ioctl = SI4703_ioctl,
  451.     .poll       = SI4703_dev_poll,
  452.     .fasync = SI4703_dev_fasync,
  453. .compat_ioctl = v4l_compat_ioctl32,
  454. .llseek         = no_llseek,
  455. };
  457. static struct video_device SI4703_radio =
  458. {
  459. .owner = THIS_MODULE,
  460. .name = "SI4703 Radio",
  461. .type = VID_TYPE_TUNER,
  462. .hardware = VID_HARDWARE_SI4703,
  463. .fops           = &SI4703_fops,
  464. };
  466. #ifdef CONFIG_RADIO_SI4703_PROC_FS
  468. static int SI4703_get_info(char *buf, char **start, off_t offset, int len)
  469. {
  470. char *out = buf;
  472. #ifdef MODULE
  473.     #define MODULEPROCSTRING "Driver loaded as a module"
  474. #else
  475.     #define MODULEPROCSTRING "Driver compiled into kernel"
  476. #endif
  478. /* output must be kept under PAGE_SIZE */
  479. out += sprintf(out, BANNER);
  480. out += sprintf(out, "Load type: " MODULEPROCSTRING "nn");
  481. out += sprintf(out, "frequency = %lu kHzn",
  482. SI4703_unit.curfreq >> 4);
  483. out += sprintf(out, "volume = %dn", SI4703_unit.curvol);
  484. out += sprintf(out, "mute = %sn", SI4703_unit.muted ?
  485. "on" : "off");
  486. out += sprintf(out, "mute frequency = %lu kHzn",
  487. SI4703_unit.mutefreq >> 4);
  488. return out - buf;
  489. }
  491. #endif /* CONFIG_RADIO_SI4703_PROC_FS */
  493. MODULE_AUTHOR("Beck He");
  494. MODULE_DESCRIPTION("A driver for the SI4703 radio card .");
  495. MODULE_LICENSE("GPL");
  498. static int radio_nr = -1;
  501. module_param(radio_nr, int, 0);
  503. #ifdef MODULE
  504. static unsigned long mutefreq = 0;
  505. module_param(mutefreq, ulong, 0);
  506. MODULE_PARM_DESC(mutefreq, "Frequency used when muting the card (in kHz)");
  507. #endif
  512. static int __init SI4703_init(void)
  513. {
  515.      struct SI4703_device *radio = &SI4703_unit;
  516. #ifdef MODULE
  519. if (mutefreq < 87000 || mutefreq > 108500) {
  520. printk(KERN_ERR "radio-SI4703: You must set a frequency (in kHz) used when muting the card,n");
  521. printk(KERN_ERR "radio-SI4703: e.g. with "mutefreq=87500" (87000 <= mutefreq <= 108500)n");
  522. return -EINVAL;
  523. }
  524. SI4703_unit.mutefreq = mutefreq;
  525. #endif /* MODULE */
  527. printk(KERN_INFO BANNER);
  528. mutex_init(&radio->lock);
  529.     spin_lock_init(&radio->irq_lock);
  530.     init_waitqueue_head(&radio->irq_queue);
  534. SI4703_radio.priv = &SI4703_unit;
  535. if (video_register_device(&SI4703_radio, VFL_TYPE_RADIO, radio_nr) == -1)
  536. {
  538. return -EINVAL;
  539. }
  541.     FM_SI47XX_Init();
  543.     SI4703_init_irq();
  546. //printk(KERN_INFO "radio-SI4703: mute frequency is %lu kHz.n",
  547. //       SI4703_unit.mutefreq);
  548. //SI4703_unit.mutefreq <<= 4;
  550. /* mute card - prevents noisy bootups */
  551. // SI4703_mute(&SI4703_unit);
  553. #ifdef CONFIG_RADIO_SI4703_PROC_FS
  554. if (!create_proc_info_entry("driver/radio-SI4703", 0, NULL,
  555.     SI4703_get_info)) 
  556.      printk(KERN_ERR "radio-SI4703: registering /proc/driver/radio-SI4703 failedn");
  557. #endif
  559. return 0;
  560. }
  562. static void __exit SI4703_cleanup_module(void)
  563. {
  565. #ifdef CONFIG_RADIO_SI4703_PROC_FS
  566. remove_proc_entry("driver/radio-SI4703", NULL);
  567. #endif
  568.     free_irq(IRQ_GPIO(113),NULL);
  569. video_unregister_device(&SI4703_radio);
  571. }
  575. module_init(SI4703_init);
  576. module_exit(SI4703_cleanup_module);