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

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

驱动编程

开发平台：

Unix_Linux

radio-si4703.c：源码内容
  1. /* SI4703 Radio Card driver for radio support
  2.  *Author: Beck.He@quantcn.com
  3.  *2007.9.1
  4.  * Card manufacturer:
  5.  * Quanta
  6.  *
  7.  /*
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License version 2 as
  10.  * published by the Free Software Foundation.
  11.  */
  15. #include <linux/module.h> /* Modules                        */
  16. #include <linux/init.h> /* Initdata                       */
  17. #include <linux/ioport.h> /* request_region   */
  18. #include <linux/proc_fs.h> /* radio card status report   */
  19. #include <asm/io.h> /* outb, outb_p                   */
  20. #include <asm/uaccess.h> /* copy to/from user              */
  21. #include <linux/videodev.h> /* kernel radio structs           */
  22. #include <linux/config.h> /* CONFIG_RADIO_SI4703_*         */
  23. #include <linux/types.h>
  24. #include <linux/interrupt.h>
  25. #include <linux/workqueue.h>
  27. #include <asm/arch/gpio.h>
  28. #include "SI4703API.h"
  30. #define BANNER "SI4703 Radio Card driver v0.1n"
  34. #ifndef CONFIG_RADIO_SI4703_MUTEFREQ
  35. #define CONFIG_RADIO_SI4703_MUTEFREQ 0
  36. #endif
  38. #ifndef CONFIG_PROC_FS
  39. #undef CONFIG_RADIO_SI4703_PROC_FS
  40. #endif
  43. #ifndef TRUE
  44. #define TRUE 1
  45. #endif
  46. #ifndef FALSE
  47. #define FALSE 0
  48. #endif
  50. struct SI4703_device {
  51. int users;
  52. int curvol;
  53. int muted;
  54. unsigned long curfreq;
  55. unsigned long mutefreq;
  56. // struct mutex lock;
  57.     __u32 audmode;
  58.     struct RDS_DATA irq_data;
  59. spinlock_t irq_lock;
  60. wait_queue_head_t irq_queue;
  61. // wait_queue_head_t fm_wait;
  62.     struct workqueue_struct *radio_irq_workq;
  63. struct work_struct fm_event_work;
  64. struct fasync_struct *async_queue;
  65. };
  67. static struct SI4703_device SI4703_unit =
  68. {
  70. .curfreq = CONFIG_RADIO_SI4703_MUTEFREQ,
  71. .mutefreq = CONFIG_RADIO_SI4703_MUTEFREQ,
  72. };
  74. static int SI4703_ioctl(struct inode *inode, struct file *file,
  75.  unsigned int cmd, unsigned long arg);
  77. static int SI4703_Read(struct file *file, char __user *arg, size_t count, loff_t *offset);
  79. #ifdef CONFIG_RADIO_SI4703_PROC_FS
  80. static int SI4703_get_info(char *buf, char **start, off_t offset, int len);
  81. #endif
  83. static void query_radio_ctrl(struct v4l2_queryctrl *param);
  84. static void get_radio_ctrl(struct v4l2_control *param);
  85. static void set_radio_ctrl(struct v4l2_control *param);
  86. static int  SI4703_init_irq(void);
  89. static DECLARE_WAIT_QUEUE_HEAD(fm_wait);
  92. static int SI4703_do_ioctl(struct inode *inode, struct file *file,
  93.     unsigned int cmd, void *arg)
  94. {
  95. struct video_device *dev = video_devdata(file);
  96. struct SI4703_device *SI4703 = dev->priv;
  99. switch (cmd) {
  100. case VIDIOC_QUERYCAP:
  101. {
  102. struct v4l2_capability *v = arg;
  103. memset(v,0,sizeof(*v));
  104. v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
  105. strcpy(v->driver, "SI4703");
  106. return 0;
  107. }
  109.     case VIDIOC_RADIO_ON:
  110. {
  111.             printk(KERN_ERR "radio-SI4703: ioctl radio onn");
  112.             FM_SI47XX_PowerUp();
  113. return 0;
  114. }
  115. case VIDIOC_RADIO_OFF:
  116. {
  117.             printk(KERN_ERR "radio-SI4703: ioctl radio offn");
  118.             FM_SI47XX_PowerDown();
  119. return 0;
  120. }
  121. case VIDIOC_G_TUNER:
  122. {
  123. struct v4l2_tuner *v = arg;
  124. // if (v->tuner) /* Only 1 tuner */
  125. // return -EINVAL;
  126.           printk(KERN_ERR "radio-SI4703: ioctl get tunern");
  127. v->rangelow = 875;
  128. v->rangehigh = 1080;
  129. v->type = V4L2_TUNER_RADIO;
  130. v->capability = V4L2_TUNER_CAP_STEREO;
  131. v->signal = FM_SI47XX_ReadRSSI(); /*  get the signal strength */
  132. strcpy(v->name, "SI4703");
  133. return 0;
  134. }
  135. case VIDIOC_S_TUNER:
  136. {
  137. struct v4l2_tuner *v = arg;
  138. // if (v->tuner != 0)
  139. // return -EINVAL;
  140. /* Only 1 tuner so no setting needed ! */
  141.             printk(KERN_ERR "radio-SI4703: ioctl set tunern");
  142.            SI4703->audmode = v->audmode;
  143. return 0;
  144. }
  145. case VIDIOC_G_FREQUENCY:
  146. {
  147. struct v4l2_frequency *freq = arg;
  148.         printk(KERN_ERR "radio-SI4703: ioctl get freqn");
  149. freq->frequency = SI4703->curfreq;
  150.         freq->type = V4L2_TUNER_RADIO;
  151. return 0;
  152. }
  153. case VIDIOC_S_FREQUENCY:
  154. {
  155. struct v4l2_frequency *freq = arg;
  156.          printk(KERN_ERR "radio-SI4703: ioctl set freqn");
  157. SI4703->curfreq = freq->frequency;
  158. FM_SI47XX_Tune(SI4703->curfreq);
  159. return 0;
  160. }
  161.     case VIDIOC_QUERYCTRL:
  162.     {
  163.         struct v4l2_queryctrl *v = arg;
  164.         query_radio_ctrl(v);
  165.         return 0;
  166.     }
  167.     case VIDIOC_G_CTRL:
  168.     {
  169.         struct v4l2_control * v = arg;
  170.         get_radio_ctrl(v);
  171.         return 0;
  173.     }
  174.     case VIDIOC_S_CTRL:
  175.     {
  176.         struct v4l2_control * v = arg;
  177.           printk(KERN_ERR "radio-SI4703: ioctl set ctrln");
  178.         set_radio_ctrl(v);
  179.         return 0;
  180.     }
  181.     case RADIO_SCAN_NEXT:
  182.     {
  183.         struct radio_scan *v = arg;
  184.         if(SEEKUP == v->direction) {
  185.            printk(KERN_ERR "radio-SI4703: ioctl seek upn");
  186.             FM_SI47XX_Seek(SEEKUP,&v->channel, &v->scanok);
  187.         }
  189.         if(SEEKDOWN == v->direction) {
  190.             printk(KERN_ERR "radio-SI4703: ioctl seek downn");
  191.             FM_SI47XX_Seek(SEEKDOWN, &v->channel,&v->scanok);
  192.         }
  194.        return 0;
  195.     }
  196.         
  197. default:
  198. return -ENOIOCTLCMD;
  199. }
  200. }
  202. static void query_radio_ctrl(struct v4l2_queryctrl *param)
  203. {
  205.    struct  v4l2_queryctrl *v = param;
  206.     switch (v->id) {
  207.     case V4L2_CID_AUDIO_VOLUME:
  208.     {
  209.         v->type = V4L2_CTRL_TYPE_INTEGER;
  210.         v->minimum = 0;
  211.         v->maximum = 100;
  212.         v->step =20;
  213.         return;
  215.     }
  216.     case V4L2_CID_AUDIO_MUTE:
  217.     {
  218.        v->type = V4L2_CTRL_TYPE_BOOLEAN;
  220.        return;
  221.     }
  222.     default:
  223.     {
  224.         v->flags = V4L2_CTRL_FLAG_DISABLED;
  225.         return;
  226.     }
  228.     }
  230. }
  232. static void get_radio_ctrl(struct v4l2_control *param)
  233. {
  235.    struct v4l2_control *v = param;
  236.     switch (v->id) {
  237.     case V4L2_CID_AUDIO_VOLUME:
  238.     {
  239.         v->value = SI4703_unit.curvol;
  240.         return;
  241.    
  242.     }
  243.     case V4L2_CID_AUDIO_MUTE:
  244.     {
  245.        v->value = SI4703_unit.muted ;
  246.        return;
  248.     }
  249.     default:
  250.     {
  251.         v->value = -1;
  252.         return;
  253.     }
  255.     }
  257. }
  259. static void set_radio_ctrl(struct v4l2_control *param)
  260. {
  262.     struct v4l2_control *v = param;
  263.     switch (v->id) {
  264.     case V4L2_CID_AUDIO_VOLUME:
  265.     {
  266.      FM_SI47XX_Volume(v->value);
  267.      SI4703_unit.curvol = v->value;
  268.      return;
  270.     }
  271.     case V4L2_CID_AUDIO_MUTE:
  272.     {
  273.         if (1 == v->value) {
  274.             FM_SI47XX_MuteVolume();
  275.             SI4703_unit.muted =1;
  276.         }
  277.         else {
  278.             FM_SI47XX_DMuteVolume();
  279.             SI4703_unit.muted =0;
  280.         }
  281.             
  282.       return;
  284.     }
  285.     default:
  286.     {
  287.         printk(KERN_ERR "radio-SI4703: error controln");
  288.         return;
  289.     }
  290.        
  291.     }
  293. }
  296. static int SI4703_ioctl(struct inode *inode, struct file *file,
  297.  unsigned int cmd, unsigned long arg)
  298. {
  300.     printk(KERN_ERR "radio-SI4703: enter ioctln");
  301.     return video_usercopy(inode, file, cmd, arg, SI4703_do_ioctl);
  302. }
  304. static irqreturn_t si4703_radio_interrupt(int irq, void *dev_id,
  305. struct pt_regs *regs)
  306. {
  307.     int i;
  308.     char buf[24];
  310.     struct SI4703_device *radio = &SI4703_unit;
  311.      printk(KERN_ERR "radio-SI4703: interruptn");
  313.          //beck test
  315.     SI4703_I2C_Read( buf,  24);
  317.     for(i=0;i<24;i++)
  318.    printk("I2C: SI4703 register contents=%xn", buf[i]);
  320.   wake_up_interruptible(&fm_wait);
  321.     
  322. if (ReadRDSR() ==1) {
  323.    
  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(MFP2GPIO(MFP_PIN_GPIO122)));
  333. queue_work(radio->radio_irq_workq, &radio->fm_event_work);
  334. }
  339. return IRQ_HANDLED;
  340. }
  342. static int SI4703_Read(struct file *file, char __user *arg, size_t count, loff_t *offset)
  343. {
  344.     struct SI4703_device *radio = &SI4703_unit;
  346.     DECLARE_WAITQUEUE(wait, current);
  347. struct RDS_DATA data;
  348. ssize_t ret;
  350. //if (count != sizeof(unsigned int) && count < sizeof(unsigned long))
  351. //return -EINVAL;
  353. add_wait_queue(&radio->irq_queue, &wait);
  354. do {
  355. __set_current_state(TASK_INTERRUPTIBLE);
  357. spin_lock_irq(&radio->irq_lock);
  358. data = radio->irq_data;
  359. radio->irq_data.RDSA = 0;
  360. spin_unlock_irq(&radio->irq_lock);
  362. if (data.RDSA != 0) {
  363. ret = 0;
  364. break;
  365. }
  366. if (file->f_flags & O_NONBLOCK) {
  367. ret = -EAGAIN;
  368. break;
  369. }
  370. if (signal_pending(current)) {
  371. ret = -ERESTARTSYS;
  372. break;
  373. }
  374. schedule();
  375. } while (1);
  376. set_current_state(TASK_RUNNING);
  377. remove_wait_queue(&radio->irq_queue, &wait);
  379. /*if (ret == 0) {
  381. if (radio->read_callback)
  382. data = radio->read_callback(rtc->class_dev.dev,
  383.        data);}*/
  385.          
  386.     return  copy_to_user(arg,&data,sizeof(data))? -EFAULT : sizeof(data);
  388.  } 
  390. static unsigned int SI4703_dev_poll(struct file *file, poll_table *wait)
  391. {
  392.  struct SI4703_device *radio = &SI4703_unit;
  393.  struct RDS_DATA data;
  395. poll_wait(file, &radio->irq_queue, wait);
  397. data = radio->irq_data;
  399. return (data.RDSA != 0) ? (POLLIN | POLLRDNORM) : 0;
  400. }
  402. static int SI4703_dev_fasync(int fd, struct file *file, int on)
  403. {
  404. struct SI4703_device *radio = &SI4703_unit;
  405. return fasync_helper(fd, file, on, &radio->async_queue);
  406. }
  408. static void radio_fm_irq_worker(void *ptr) 
  409. {
  410. //spin_lock(&radio->irq_lock);
  411.     struct SI4703_device *radio = ptr;
  412. radio->irq_data.RDSA = ReadRDS_BLOCK(RDSA);
  413.     radio->irq_data.RDSB = ReadRDS_BLOCK(RDSB);
  414.     radio->irq_data.RDSC = ReadRDS_BLOCK(RDSC);
  415.     radio->irq_data.RDSD= ReadRDS_BLOCK(RDSD);
  416.     radio->irq_data.RDSA = 100;
  418.   //printk(KERN_ERR "RDSA=%d,RDSB=%d,RDSC=%d,RDSD=%d,RSSI=%dn",
  419.          //radio->irq_data.RDSA ,radio->irq_data.RDSB ,radio->irq_data.RDSC ,radio->irq_data.RDSD,FM_SI47XX_ReadRSSI);
  421.     wake_up_interruptible(&radio->irq_queue);
  422. kill_fasync(&radio->async_queue, SIGIO, POLL_IN);
  423.     enable_irq(IRQ_GPIO(MFP2GPIO(MFP_PIN_GPIO122)));
  424. //spin_unlock(&radio->irq_lock);
  425. }
  427. static int SI4703_init_irq(void)
  428. {
  430.     struct SI4703_device *radio = &SI4703_unit;
  431.    INIT_WORK(&radio->fm_event_work, radio_fm_irq_worker, radio);
  432. if ((radio->radio_irq_workq = 
  433. create_singlethread_workqueue("si4703radio")) == NULL) {
  434. printk(KERN_ERR"could not create radio irq work queuen"); 
  435. return -EINVAL; 
  436. }
  439.     if(request_irq (IRQ_GPIO(MFP2GPIO(MFP_PIN_GPIO122)), si4703_radio_interrupt, SA_INTERRUPT, "si4703_radio", NULL))
  440.     {
  441.         printk(KERN_ERR "radio-SI4703: error request irqn");
  442.         destroy_workqueue(radio->radio_irq_workq);
  443.         free_irq(IRQ_GPIO(MFP2GPIO(MFP_PIN_GPIO122)),NULL);
  444.         return -EINVAL; 
  445.     }
  446. return 0; 
  448. }
  450. static struct file_operations SI4703_fops = {
  451. .owner = THIS_MODULE,
  452. .open           = video_exclusive_open,
  453.     .read           = SI4703_Read,
  454. .release        = video_exclusive_release,
  455. .ioctl = SI4703_ioctl,
  456.     .poll       = SI4703_dev_poll,
  457.     .fasync = SI4703_dev_fasync,
  458. //.compat_ioctl = v4l_compat_ioctl32,
  459. .llseek         = no_llseek,
  460. };
  462. static struct video_device SI4703_radio =
  463. {
  464. .owner = THIS_MODULE,
  465. .name = "SI4703 Radio",
  466. .type = VID_TYPE_TUNER,
  467. .hardware = VID_HARDWARE_SI4703,
  468. .fops           = &SI4703_fops,
  469. };
  471. #ifdef CONFIG_RADIO_SI4703_PROC_FS
  473. static int SI4703_get_info(char *buf, char **start, off_t offset, int len)
  474. {
  475. char *out = buf;
  477. #ifdef MODULE
  478.     #define MODULEPROCSTRING "Driver loaded as a module"
  479. #else
  480.     #define MODULEPROCSTRING "Driver compiled into kernel"
  481. #endif
  483. /* output must be kept under PAGE_SIZE */
  484. out += sprintf(out, BANNER);
  485. out += sprintf(out, "Load type: " MODULEPROCSTRING "nn");
  486. out += sprintf(out, "frequency = %lu kHzn",
  487. SI4703_unit.curfreq >> 4);
  488. out += sprintf(out, "volume = %dn", SI4703_unit.curvol);
  489. out += sprintf(out, "mute = %sn", SI4703_unit.muted ?
  490. "on" : "off");
  491. out += sprintf(out, "mute frequency = %lu kHzn",
  492. SI4703_unit.mutefreq >> 4);
  493. return out - buf;
  494. }
  496. #endif /* CONFIG_RADIO_SI4703_PROC_FS */
  498. MODULE_AUTHOR("Beck He");
  499. MODULE_DESCRIPTION("A driver for the SI4703 radio card .");
  500. MODULE_LICENSE("GPL");
  503. static int radio_nr = -1;
  506. module_param(radio_nr, int, 0);
  508. #ifdef MODULE
  509. static unsigned long mutefreq = 0;
  510. module_param(mutefreq, ulong, 0);
  511. MODULE_PARM_DESC(mutefreq, "Frequency used when muting the card (in kHz)");
  512. #endif
  515. void si4703_fm_wait_timeout()
  516. {
  517.      wait_event_timeout(fm_wait, ReadSTC() ==1, msecs_to_jiffies(4000));
  518. }
  521. static int __init SI4703_init(void)
  522. {
  524.      struct SI4703_device *radio = &SI4703_unit;
  525. #ifdef MODULE
  528. if (mutefreq < 87000 || mutefreq > 108500) {
  529. printk(KERN_ERR "radio-SI4703: You must set a frequency (in kHz) used when muting the card,n");
  530. printk(KERN_ERR "radio-SI4703: e.g. with "mutefreq=87500" (87000 <= mutefreq <= 108500)n");
  531. return -EINVAL;
  532. }
  533. SI4703_unit.mutefreq = mutefreq;
  534. #endif /* MODULE */
  536. printk(KERN_INFO BANNER);
  537. // mutex_init(&radio->lock);
  538.     spin_lock_init(&radio->irq_lock);
  539.     init_waitqueue_head(&radio->irq_queue);
  544.     SI4703_radio.priv = &SI4703_unit;
  545. if (video_register_device(&SI4703_radio, VFL_TYPE_RADIO, radio_nr) == -1)
  546. {
  548. return -EINVAL;
  549. }
  551.     FM_SI47XX_Init();
  553.     SI4703_init_irq();
  556. //printk(KERN_INFO "radio-SI4703: mute frequency is %lu kHz.n",
  557. //       SI4703_unit.mutefreq);
  558. //SI4703_unit.mutefreq <<= 4;
  560. /* mute card - prevents noisy bootups */
  561. // SI4703_mute(&SI4703_unit);
  563. #ifdef CONFIG_RADIO_SI4703_PROC_FS
  564. if (!create_proc_info_entry("driver/radio-SI4703", 0, NULL,
  565.     SI4703_get_info)) 
  566.      printk(KERN_ERR "radio-SI4703: registering /proc/driver/radio-SI4703 failedn");
  567. #endif
  569. return 0;
  570. }
  572. static void __exit SI4703_cleanup_module(void)
  573. {
  575. #ifdef CONFIG_RADIO_SI4703_PROC_FS
  576. remove_proc_entry("driver/radio-SI4703", NULL);
  577. #endif
  578.     free_irq(IRQ_GPIO(MFP2GPIO(MFP_PIN_GPIO122)),NULL);
  579. video_unregister_device(&SI4703_radio);
  581. }
  585. module_init(SI4703_init);
  586. module_exit(SI4703_cleanup_module);
  587. EXPORT_SYMBOL(si4703_fm_wait_timeout);