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

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

嵌入式Linux

开发平台：

Unix_Linux

saa7111.c：源码内容
  1. /* 
  2.     saa7111 - Philips SAA7111A video decoder driver version 0.0.3
  4.     Copyright (C) 1998 Dave Perks <dperks@ibm.net>
  6.     Slight changes for video timing and attachment output by
  7.     Wolfgang Scherr <scherr@net4you.net>
  8.     
  9.     This program is free software; you can redistribute it and/or modify
  10.     it under the terms of the GNU General Public License as published by
  11.     the Free Software Foundation; either version 2 of the License, or
  12.     (at your option) any later version.
  14.     This program is distributed in the hope that it will be useful,
  15.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.     GNU General Public License for more details.
  19.     You should have received a copy of the GNU General Public License
  20.     along with this program; if not, write to the Free Software
  21.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22. */
  23. #include <linux/config.h>
  24. #include <linux/init.h>
  25. #include <linux/module.h>
  26. #include <linux/delay.h>
  27. #include <linux/errno.h>
  28. #include <linux/fs.h>
  29. #include <linux/kernel.h>
  30. #include <linux/major.h>
  31. #include <linux/slab.h>
  32. #include <linux/mm.h>
  33. #include <linux/sched.h>
  35. #include <linux/videodev.h>
  36. #include <linux/version.h>
  37. #include <linux/i2c-old.h>
  39. #include <linux/video_decoder.h>
  41. #define DEBUG(x) /* Debug driver */
  43. /* ----------------------------------------------------------------------- */
  45. struct saa7111 {
  46. struct i2c_bus *bus;
  47. int addr;
  48. unsigned char reg[32];
  50. int norm;
  51. int input;
  52. int enable;
  53. int bright;
  54. int contrast;
  55. int hue;
  56. int sat;
  57. };
  59. #define   I2C_SAA7111        0x48
  61. #define   I2C_DELAY   10
  63. /* ----------------------------------------------------------------------- */
  65. static int saa7111_write(struct saa7111 *dev, unsigned char subaddr,
  66.  unsigned char data)
  67. {
  68. int ack;
  70. LOCK_I2C_BUS(dev->bus);
  71. i2c_start(dev->bus);
  72. i2c_sendbyte(dev->bus, dev->addr, I2C_DELAY);
  73. i2c_sendbyte(dev->bus, subaddr, I2C_DELAY);
  74. ack = i2c_sendbyte(dev->bus, data, I2C_DELAY);
  75. dev->reg[subaddr] = data;
  76. i2c_stop(dev->bus);
  77. UNLOCK_I2C_BUS(dev->bus);
  78. return ack;
  79. }
  81. static int saa7111_write_block(struct saa7111 *dev,
  82.        unsigned const char *data, unsigned int len)
  83. {
  84. int ack = -1;
  85. unsigned subaddr;
  87. while (len > 1) {
  88. LOCK_I2C_BUS(dev->bus);
  89. i2c_start(dev->bus);
  90. i2c_sendbyte(dev->bus, dev->addr, I2C_DELAY);
  91. ack = i2c_sendbyte(dev->bus, (subaddr = *data++), I2C_DELAY);
  92. ack = i2c_sendbyte(dev->bus, (dev->reg[subaddr] = *data++), I2C_DELAY);
  93. len -= 2;
  94. while (len > 1 && *data == ++subaddr) {
  95. data++;
  96. ack =
  97.     i2c_sendbyte(dev->bus,
  98.  (dev->reg[subaddr] =
  99.   *data++), I2C_DELAY);
  100. len -= 2;
  101. }
  102. i2c_stop(dev->bus);
  103. UNLOCK_I2C_BUS(dev->bus);
  104. }
  105. return ack;
  106. }
  108. static int saa7111_read(struct saa7111 *dev, unsigned char subaddr)
  109. {
  110. int data;
  112. LOCK_I2C_BUS(dev->bus);
  113. i2c_start(dev->bus);
  114. i2c_sendbyte(dev->bus, dev->addr, I2C_DELAY);
  115. i2c_sendbyte(dev->bus, subaddr, I2C_DELAY);
  116. i2c_start(dev->bus);
  117. i2c_sendbyte(dev->bus, dev->addr | 1, I2C_DELAY);
  118. data = i2c_readbyte(dev->bus, 1);
  119. i2c_stop(dev->bus);
  120. UNLOCK_I2C_BUS(dev->bus);
  121. return data;
  122. }
  124. /* ----------------------------------------------------------------------- */
  126. static int saa7111_attach(struct i2c_device *device)
  127. {
  128. int i;
  129. struct saa7111 *decoder;
  131. static const unsigned char init[] = {
  132. 0x00, 0x00, /* 00 - ID byte */
  133. 0x01, 0x00, /* 01 - reserved */
  135. /*front end */
  136. 0x02, 0xd0, /* 02 - FUSE=3, GUDL=2, MODE=0 */
  137. 0x03, 0x23, /* 03 - HLNRS=0, VBSL=1, WPOFF=0, HOLDG=0, GAFIX=0, GAI1=256, GAI2=256 */
  138. 0x04, 0x00, /* 04 - GAI1=256 */
  139. 0x05, 0x00, /* 05 - GAI2=256 */
  141. /* decoder */
  142. 0x06, 0xf3, /* 06 - HSB at  13(50Hz) /  17(60Hz) pixels after end of last line */
  143. 0x07, 0x13, /* 07 - HSS at 113(50Hz) / 117(60Hz) pixels after end of last line */
  144. 0x08, 0xc8, /* 08 - AUFD=1, FSEL=1, EXFIL=0, VTRC=1, HPLL=0, VNOI=0 */
  145. 0x09, 0x01, /* 09 - BYPS=0, PREF=0, BPSS=0, VBLB=0, UPTCV=0, APER=1 */
  146. 0x0a, 0x80, /* 0a - BRIG=128 */
  147. 0x0b, 0x47, /* 0b - CONT=1.109 */
  148. 0x0c, 0x40, /* 0c - SATN=1.0 */
  149. 0x0d, 0x00, /* 0d - HUE=0 */
  150. 0x0e, 0x01, /* 0e - CDTO=0, CSTD=0, DCCF=0, FCTC=0, CHBW=1 */
  151. 0x0f, 0x00, /* 0f - reserved */
  152. #ifndef CONFIG_ARCH_NETWINDER
  153. 0x10, 0x48, /* 10 - OFTS=1, HDEL=0, VRLN=1, YDEL=0 */
  154. #else
  155. 0x10, 0xc8, /* 10 - OFTS=YUV-CCIR656, HDEL=0, VLRN=1, YDEL=0 */
  156. #endif
  157. 0x11, 0x1c, /* 11 - GPSW=0, CM99=0, FECO=0, COMPO=1, OEYC=1, OEHV=1, VIPB=0, COLO=0 */
  158. 0x12, 0x00, /* 12 - output control 2 */
  159. 0x13, 0x00, /* 13 - output control 3 */
  160. 0x14, 0x00, /* 14 - reserved */
  161. 0x15, 0x00, /* 15 - VBI */
  162. 0x16, 0x00, /* 16 - VBI */
  163. 0x17, 0x00, /* 17 - VBI */
  164. };
  166. MOD_INC_USE_COUNT;
  168. device->data = decoder = kmalloc(sizeof(struct saa7111), GFP_KERNEL);
  169. if (decoder == NULL)
  170. {
  171. MOD_DEC_USE_COUNT;
  172. return -ENOMEM;
  173. }
  175. memset(decoder, 0, sizeof(struct saa7111));
  176. strcpy(device->name, "saa7111");
  177. decoder->bus = device->bus;
  178. decoder->addr = device->addr;
  179. decoder->norm = VIDEO_MODE_NTSC;
  180. decoder->input = 0;
  181. decoder->enable = 1;
  182. decoder->bright = 32768;
  183. decoder->contrast = 32768;
  184. decoder->hue = 32768;
  185. decoder->sat = 32768;
  187. i = saa7111_write_block(decoder, init, sizeof(init));
  188. if (i < 0) {
  189. printk(KERN_ERR "%s_attach: init status %dn",
  190.        device->name, i);
  191. } else {
  192. printk(KERN_INFO "%s_attach: chip version %xn",
  193.        device->name, saa7111_read(decoder, 0x00) >> 4);
  194. }
  195. return 0;
  196. }
  199. static int saa7111_detach(struct i2c_device *device)
  200. {
  201. kfree(device->data);
  202. MOD_DEC_USE_COUNT;
  203. return 0;
  204. }
  206. static int saa7111_command(struct i2c_device *device, unsigned int cmd,
  207.    void *arg)
  208. {
  209. struct saa7111 *decoder = device->data;
  211. switch (cmd) {
  213. #if defined(DECODER_DUMP)
  214. case DECODER_DUMP:
  215. {
  216. int i;
  218. for (i = 0; i < 32; i += 16) {
  219. int j;
  221. printk("KERN_DEBUG %s: %03x", device->name,
  222.        i);
  223. for (j = 0; j < 16; ++j) {
  224. printk(" %02x",
  225.        saa7111_read(decoder,
  226.     i + j));
  227. }
  228. printk("n");
  229. }
  230. }
  231. break;
  232. #endif /* defined(DECODER_DUMP) */
  234. case DECODER_GET_CAPABILITIES:
  235. {
  236. struct video_decoder_capability *cap = arg;
  238. cap->flags
  239.     = VIDEO_DECODER_PAL
  240.     | VIDEO_DECODER_NTSC
  241.     | VIDEO_DECODER_AUTO | VIDEO_DECODER_CCIR;
  242. cap->inputs = 8;
  243. cap->outputs = 1;
  244. }
  245. break;
  247. case DECODER_GET_STATUS:
  248. {
  249. int *iarg = arg;
  250. int status;
  251. int res;
  253. status = saa7111_read(decoder, 0x1f);
  254. res = 0;
  255. if ((status & (1 << 6)) == 0) {
  256. res |= DECODER_STATUS_GOOD;
  257. }
  258. switch (decoder->norm) {
  259. case VIDEO_MODE_NTSC:
  260. res |= DECODER_STATUS_NTSC;
  261. break;
  262. case VIDEO_MODE_PAL:
  263. res |= DECODER_STATUS_PAL;
  264. break;
  265. default:
  266. case VIDEO_MODE_AUTO:
  267. if ((status & (1 << 5)) != 0) {
  268. res |= DECODER_STATUS_NTSC;
  269. } else {
  270. res |= DECODER_STATUS_PAL;
  271. }
  272. break;
  273. }
  274. if ((status & (1 << 0)) != 0) {
  275. res |= DECODER_STATUS_COLOR;
  276. }
  277. *iarg = res;
  278. }
  279. break;
  281. case DECODER_SET_NORM:
  282. {
  283. int *iarg = arg;
  285. switch (*iarg) {
  287. case VIDEO_MODE_NTSC:
  288. saa7111_write(decoder, 0x08,
  289.       (decoder->
  290.        reg[0x08] & 0x3f) | 0x40);
  291. break;
  293. case VIDEO_MODE_PAL:
  294. saa7111_write(decoder, 0x08,
  295.       (decoder->
  296.        reg[0x08] & 0x3f) | 0x00);
  297. break;
  299. case VIDEO_MODE_AUTO:
  300. saa7111_write(decoder, 0x08,
  301.       (decoder->
  302.        reg[0x08] & 0x3f) | 0x80);
  303. break;
  305. default:
  306. return -EINVAL;
  308. }
  309. decoder->norm = *iarg;
  310. }
  311. break;
  313. case DECODER_SET_INPUT:
  314. {
  315. int *iarg = arg;
  317. if (*iarg < 0 || *iarg > 7) {
  318. return -EINVAL;
  319. }
  321. if (decoder->input != *iarg) {
  322. decoder->input = *iarg;
  323. /* select mode */
  324. saa7111_write(decoder, 0x02,
  325.       (decoder->
  326.        reg[0x02] & 0xf8) |
  327.       decoder->input);
  328. /* bypass chrominance trap for modes 4..7 */
  329. saa7111_write(decoder, 0x09,
  330.       (decoder->
  331.        reg[0x09] & 0x7f) |
  332.       ((decoder->input >
  333. 3) ? 0x80 : 0));
  334. }
  335. }
  336. break;
  338. case DECODER_SET_OUTPUT:
  339. {
  340. int *iarg = arg;
  342. /* not much choice of outputs */
  343. if (*iarg != 0) {
  344. return -EINVAL;
  345. }
  346. }
  347. break;
  349. case DECODER_ENABLE_OUTPUT:
  350. {
  351. int *iarg = arg;
  352. int enable = (*iarg != 0);
  354. if (decoder->enable != enable) {
  355. decoder->enable = enable;
  357. // RJ: If output should be disabled (for playing videos), we also need a open PLL.
  358. //     The input is set to 0 (where no input source is connected), although this
  359. //     is not necessary.
  360. //
  361. //     If output should be enabled, we have to reverse the above.
  363. if (decoder->enable) {
  364. saa7111_write(decoder, 0x02,
  365.       (decoder->
  366.        reg[0x02] & 0xf8) |
  367.       decoder->input);
  368. saa7111_write(decoder, 0x08,
  369.       (decoder->
  370.        reg[0x08] & 0xfb));
  371. saa7111_write(decoder, 0x11,
  372.       (decoder->
  373.        reg[0x11] & 0xf3) |
  374.       0x0c);
  375. } else {
  376. saa7111_write(decoder, 0x02,
  377.       (decoder->
  378.        reg[0x02] & 0xf8));
  379. saa7111_write(decoder, 0x08,
  380.       (decoder->
  381.        reg[0x08] & 0xfb) |
  382.       0x04);
  383. saa7111_write(decoder, 0x11,
  384.       (decoder->
  385.        reg[0x11] & 0xf3));
  386. }
  387. }
  388. }
  389. break;
  391. case DECODER_SET_PICTURE:
  392. {
  393. struct video_picture *pic = arg;
  395. if (decoder->bright != pic->brightness) {
  396. /* We want 0 to 255 we get 0-65535 */
  397. decoder->bright = pic->brightness;
  398. saa7111_write(decoder, 0x0a,
  399.       decoder->bright >> 8);
  400. }
  401. if (decoder->contrast != pic->contrast) {
  402. /* We want 0 to 127 we get 0-65535 */
  403. decoder->contrast = pic->contrast;
  404. saa7111_write(decoder, 0x0b,
  405.       decoder->contrast >> 9);
  406. }
  407. if (decoder->sat != pic->colour) {
  408. /* We want 0 to 127 we get 0-65535 */
  409. decoder->sat = pic->colour;
  410. saa7111_write(decoder, 0x0c,
  411.       decoder->sat >> 9);
  412. }
  413. if (decoder->hue != pic->hue) {
  414. /* We want -128 to 127 we get 0-65535 */
  415. decoder->hue = pic->hue;
  416. saa7111_write(decoder, 0x0d,
  417.       (decoder->hue - 32768) >> 8);
  418. }
  419. }
  420. break;
  422. default:
  423. return -EINVAL;
  424. }
  426. return 0;
  427. }
  429. /* ----------------------------------------------------------------------- */
  431. static struct i2c_driver i2c_driver_saa7111 = {
  432. "saa7111", /* name */
  433. I2C_DRIVERID_VIDEODECODER, /* ID */
  434. I2C_SAA7111, I2C_SAA7111 + 1,
  436. saa7111_attach,
  437. saa7111_detach,
  438. saa7111_command
  439. };
  441. EXPORT_NO_SYMBOLS;
  443. static int saa7111_init(void)
  444. {
  445. return i2c_register_driver(&i2c_driver_saa7111);
  446. }
  448. static void saa7111_exit(void)
  449. {
  450. i2c_unregister_driver(&i2c_driver_saa7111);
  451. }
  453. module_init(saa7111_init);
  454. module_exit(saa7111_exit);
  455. MODULE_LICENSE("GPL");