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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
radio-maestro.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：9k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

radio-maestro.c：源码内容
  1. /* Maestro PCI sound card radio driver for Linux support
  2.  * (c) 2000 A. Tlalka, atlka@pg.gda.pl
  3.  * Notes on the hardware
  4.  *
  5.  *  + Frequency control is done digitally 
  6.  *  + No volume control - only mute/unmute - you have to use Aux line volume
  7.  *  control on Maestro card to set the volume
  8.  *  + Radio status (tuned/not_tuned and stereo/mono) is valid some time after
  9.  *  frequency setting (>100ms) and only when the radio is unmuted.
  10.  *  version 0.02
  11.  *  + io port is automatically detected - only the first radio is used
  12.  *  version 0.03
  13.  *  + thread access locking additions
  14.  *  version 0.04
  15.  * + code improvements
  16.  * + VIDEO_TUNER_LOW is permanent
  17.  */
  19. #include <linux/module.h>
  20. #include <linux/init.h>
  21. #include <linux/ioport.h>
  22. #include <linux/delay.h>
  23. #include <linux/sched.h>
  24. #include <asm/io.h>
  25. #include <asm/uaccess.h>
  26. #include <asm/semaphore.h>
  27. #include <linux/pci.h>
  28. #include <linux/videodev.h>
  30. #define DRIVER_VERSION "0.04"
  32. #define PCI_VENDOR_ESS                  0x125D
  33. #define PCI_DEVICE_ID_ESS_ESS1968       0x1968          /* Maestro 2    */
  34. #define PCI_DEVICE_ID_ESS_ESS1978       0x1978          /* Maestro 2E   */
  36. #define GPIO_DATA       0x60   /* port offset from ESS_IO_BASE */
  38. #define IO_MASK 4      /* mask      register offset from GPIO_DATA
  39. bits 1=unmask write to given bit */
  40. #define IO_DIR 8      /* direction register offset from GPIO_DATA
  41. bits 0/1=read/write direction */
  43. #define GPIO6           0x0040 /* mask bits for GPIO lines */
  44. #define GPIO7           0x0080
  45. #define GPIO8           0x0100
  46. #define GPIO9           0x0200
  48. #define STR_DATA        GPIO6  /* radio TEA5757 pins and GPIO bits */
  49. #define STR_CLK         GPIO7
  50. #define STR_WREN        GPIO8
  51. #define STR_MOST        GPIO9
  53. #define FREQ_LO  50*16000
  54. #define FREQ_HI 150*16000
  56. #define FREQ_IF         171200 /* 10.7*16000   */
  57. #define FREQ_STEP       200    /* 12.5*16      */
  59. #define FREQ2BITS(x) ((((unsigned int)(x)+FREQ_IF+(FREQ_STEP<<1))
  60. /(FREQ_STEP<<2))<<2) /* (x==fmhz*16*1000) -> bits */
  62. #define BITS2FREQ(x) ((x) * FREQ_STEP - FREQ_IF)
  64. static int radio_nr = -1;
  65. MODULE_PARM(radio_nr, "i");
  68. static int radio_open(struct video_device *, int);
  69. static int radio_ioctl(struct video_device *, unsigned int, void *);
  70. static void radio_close(struct video_device *);
  72. static struct video_device maestro_radio=
  73. {
  74. owner: THIS_MODULE,
  75. name: "Maestro radio",
  76. type: VID_TYPE_TUNER,
  77. hardware: VID_HARDWARE_SF16MI,
  78. open: radio_open,
  79. close: radio_close,
  80. ioctl: radio_ioctl,
  81. };
  83. static struct radio_device
  84. {
  85. __u16 io, /* base of Maestro card radio io (GPIO_DATA)*/
  86. muted, /* VIDEO_AUDIO_MUTE */
  87. stereo, /* VIDEO_TUNER_STEREO_ON */
  88. tuned; /* signal strength (0 or 0xffff) */
  89. struct  semaphore lock;
  90. } radio_unit = {0, 0, 0, 0, };
  92. static int users = 0;
  94. static void sleep_125ms(void)
  95. {
  96. current->state = TASK_INTERRUPTIBLE;
  97. schedule_timeout(HZ >> 3);
  98. }
  100. static void udelay2(void)
  101. {
  102. udelay(2);
  103. }
  105. static void udelay4(void)
  106. {
  107. udelay(4);
  108. }
  110. static void udelay16(void)
  111. {
  112. udelay(16);
  113. }
  115. static __u32 radio_bits_get(struct radio_device *dev)
  116. {
  117. register __u16 io=dev->io, l, rdata;
  118. register __u32 data=0;
  119. __u16 omask;
  120. omask = inw(io + IO_MASK);
  121. outw(~(STR_CLK | STR_WREN), io + IO_MASK);
  122. outw(0, io);
  123. udelay16();
  124. for (l=24;l--;) {
  125. outw(STR_CLK, io); /* HI state */
  126. udelay2();
  127. if(!l) 
  128. dev->tuned = inw(io) & STR_MOST ? 0 : 0xffff;
  129. outw(0, io); /* LO state */
  130. udelay2();
  131. data <<= 1; /* shift data */
  132. rdata = inw(io);
  133. if(!l)
  134. dev->stereo =  rdata & STR_MOST ? 
  135. 0 : VIDEO_TUNER_STEREO_ON;
  136. else
  137. if(rdata & STR_DATA)
  138. data++;
  139. udelay2();
  140. }
  141. if(dev->muted)
  142. outw(STR_WREN, io);
  143. udelay4();
  144. outw(omask, io + IO_MASK);
  145. return data & 0x3ffe;
  146. }
  148. static void radio_bits_set(struct radio_device *dev, __u32 data)
  149. {
  150. register __u16 io=dev->io, l, bits;
  151. __u16 omask, odir;
  152. omask = inw(io + IO_MASK);
  153. odir  = (inw(io + IO_DIR) & ~STR_DATA) | (STR_CLK | STR_WREN);
  154. outw(odir | STR_DATA, io + IO_DIR);
  155. outw(~(STR_DATA | STR_CLK | STR_WREN), io + IO_MASK);
  156. udelay16();
  157. for (l=25;l;l--) {
  158. bits = ((data >> 18) & STR_DATA) | STR_WREN ;
  159. data <<= 1; /* shift data */
  160. outw(bits, io); /* start strobe */
  161. udelay2();
  162. outw(bits | STR_CLK, io); /* HI level */
  163. udelay2();   
  164. outw(bits, io); /* LO level */
  165. udelay4();
  166. }
  167. if(!dev->muted)
  168. outw(0, io);
  169. udelay4();
  170. outw(omask, io + IO_MASK);
  171. outw(odir, io + IO_DIR);
  172. sleep_125ms();
  173. }
  175. inline static int radio_function(struct video_device *dev, 
  176.  unsigned int cmd, void *arg)
  177. {
  178. struct radio_device *card=dev->priv;
  179. switch(cmd) {
  180. case VIDIOCGCAP: {
  181. struct video_capability v;
  182. strcpy(v.name, "Maestro radio");
  183. v.type=VID_TYPE_TUNER;
  184. v.channels=v.audios=1;
  185. v.maxwidth=v.maxheight=v.minwidth=v.minheight=0;
  186. if(copy_to_user(arg,&v,sizeof(v)))
  187. return -EFAULT;
  188. return 0;
  189. }
  190. case VIDIOCGTUNER: {
  191. struct video_tuner v;
  192. if(copy_from_user(&v, arg,sizeof(v))!=0)
  193. return -EFAULT;
  194. if(v.tuner)
  195. return -EINVAL;
  196. (void)radio_bits_get(card);
  197. v.flags = VIDEO_TUNER_LOW | card->stereo;
  198. v.signal = card->tuned;
  199. strcpy(v.name, "FM");
  200. v.rangelow = FREQ_LO;
  201. v.rangehigh = FREQ_HI;
  202. v.mode = VIDEO_MODE_AUTO;
  203. if(copy_to_user(arg,&v, sizeof(v)))
  204. return -EFAULT;
  205.         return 0;
  206. }
  207. case VIDIOCSTUNER: {
  208. struct video_tuner v;
  209. if(copy_from_user(&v, arg, sizeof(v)))
  210. return -EFAULT;
  211. if(v.tuner!=0)
  212. return -EINVAL;
  213. return 0;
  214. }
  215. case VIDIOCGFREQ: {
  216. unsigned long tmp=BITS2FREQ(radio_bits_get(card));
  217. if(copy_to_user(arg, &tmp, sizeof(tmp)))
  218. return -EFAULT;
  219. return 0;
  220. }
  221. case VIDIOCSFREQ: {
  222. unsigned long tmp;
  223. if(copy_from_user(&tmp, arg, sizeof(tmp)))
  224. return -EFAULT;
  225. if ( tmp<FREQ_LO || tmp>FREQ_HI )
  226. return -EINVAL;
  227. radio_bits_set(card, FREQ2BITS(tmp));
  228. return 0;
  229. }
  230. case VIDIOCGAUDIO: {
  231. struct video_audio v;
  232. strcpy(v.name, "Radio");
  233. v.audio=v.volume=v.bass=v.treble=v.balance=v.step=0;
  234. v.flags=VIDEO_AUDIO_MUTABLE | card->muted;
  235. v.mode=VIDEO_SOUND_STEREO;
  236. if(copy_to_user(arg,&v, sizeof(v)))
  237. return -EFAULT;
  238. return 0;
  239. }
  240. case VIDIOCSAUDIO: {
  241. struct video_audio v;
  242. if(copy_from_user(&v, arg, sizeof(v)))
  243. return -EFAULT;
  244. if(v.audio)
  245. return -EINVAL;
  246. {
  247. register __u16 io=card->io;
  248. register __u16 omask = inw(io + IO_MASK);
  249. outw(~STR_WREN, io + IO_MASK);
  250. outw((card->muted = v.flags & VIDEO_AUDIO_MUTE)
  251.      ? STR_WREN : 0, io);
  252. udelay4();
  253. outw(omask, io + IO_MASK);
  254. sleep_125ms();
  255. return 0;
  256. }
  257. }
  258. case VIDIOCGUNIT: {
  259. struct video_unit v;
  260. v.video=VIDEO_NO_UNIT;
  261. v.vbi=VIDEO_NO_UNIT;
  262. v.radio=dev->minor;
  263. v.audio=0;
  264. v.teletext=VIDEO_NO_UNIT;
  265. if(copy_to_user(arg, &v, sizeof(v)))
  266. return -EFAULT;
  267. return 0;
  268. }
  269. default: return -ENOIOCTLCMD;
  270. }
  271. }
  273. static int radio_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
  274. {
  275. struct radio_device *card=dev->priv;
  276. int ret;
  277. down(&card->lock);
  278. ret = radio_function(dev, cmd, arg);
  279. up(&card->lock);
  280. return ret;
  281. }
  283. static int radio_open(struct video_device *dev, int flags)
  284. {
  285. if(users)
  286. return -EBUSY;
  287. users++;
  288. return 0;
  289. }
  291. static void radio_close(struct video_device *dev)
  292. {
  293. users--;
  294. }
  297. inline static __u16 radio_install(struct pci_dev *pcidev);
  299. MODULE_AUTHOR("Adam Tlalka, atlka@pg.gda.pl");
  300. MODULE_DESCRIPTION("Radio driver for the Maestro PCI sound card radio.");
  301. MODULE_LICENSE("GPL");
  303. EXPORT_NO_SYMBOLS;
  305. void __exit maestro_radio_exit(void)
  306. {
  307. video_unregister_device(&maestro_radio);
  308. }
  310. int __init maestro_radio_init(void)
  311. {
  312. register __u16 found=0;
  313. struct pci_dev *pcidev = NULL;
  314. if(!pci_present())
  315. return -ENODEV;
  316. while(!found && (pcidev = pci_find_device(PCI_VENDOR_ESS, 
  317.   PCI_DEVICE_ID_ESS_ESS1968,
  318.   pcidev)))
  319. found |= radio_install(pcidev);
  320. while(!found && (pcidev = pci_find_device(PCI_VENDOR_ESS,
  321.   PCI_DEVICE_ID_ESS_ESS1978, 
  322.   pcidev)))
  323. found |= radio_install(pcidev);
  324. if(!found) {
  325. printk(KERN_INFO "radio-maestro: no devices found.n");
  326. return -ENODEV;
  327. }
  328. return 0;
  329. }
  331. module_init(maestro_radio_init);
  332. module_exit(maestro_radio_exit);
  334. inline static __u16 radio_power_on(struct radio_device *dev)
  335. {
  336. register __u16 io=dev->io;
  337. register __u32 ofreq;
  338. __u16 omask, odir;
  339. omask = inw(io + IO_MASK);
  340. odir  = (inw(io + IO_DIR) & ~STR_DATA) | (STR_CLK | STR_WREN);
  341. outw(odir & ~STR_WREN, io + IO_DIR);
  342. dev->muted = inw(io) & STR_WREN ? 0 : VIDEO_AUDIO_MUTE;
  343. outw(odir, io + IO_DIR);
  344. outw(~(STR_WREN | STR_CLK), io + IO_MASK);
  345. outw(dev->muted ? 0 : STR_WREN, io);
  346. udelay16();
  347. outw(omask, io + IO_MASK);
  348. ofreq = radio_bits_get(dev);
  349. if((ofreq<FREQ2BITS(FREQ_LO)) || (ofreq>FREQ2BITS(FREQ_HI)))
  350. ofreq = FREQ2BITS(FREQ_LO);
  351. radio_bits_set(dev, ofreq);
  352. return (ofreq == radio_bits_get(dev));
  353. }
  355. inline static __u16 radio_install(struct pci_dev *pcidev)
  356. {
  357. if(((pcidev->class >> 8) & 0xffff) != PCI_CLASS_MULTIMEDIA_AUDIO)
  358. return 0;
  360. radio_unit.io = pcidev->resource[0].start + GPIO_DATA;
  361. maestro_radio.priv = &radio_unit;
  362. init_MUTEX(&radio_unit.lock);
  364. if(radio_power_on(&radio_unit)) {
  365. if(video_register_device(&maestro_radio, VFL_TYPE_RADIO, radio_nr)==-1) {
  366. printk("radio-maestro: can't register device!");
  367. return 0;
  368. }
  369. printk(KERN_INFO "radio-maestro: version "
  370.        DRIVER_VERSION 
  371.        " time " 
  372.        __TIME__ "  "
  373.        __DATE__
  374.        "n");
  375. printk(KERN_INFO "radio-maestro: radio chip initializedn");
  376. return 1;
  377. } else
  378. return 0;   
  379. }