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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
adv7175.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：11k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

adv7175.c：源码内容
  1. #define DEBUGLEVEL 0
  2. /* 
  3.     adv7175 - adv7175a video encoder driver version 0.0.3
  5.     Copyright (C) 1998 Dave Perks <dperks@ibm.net>
  7.     Copyright (C) 1999 Wolfgang Scherr <scherr@net4you.net>
  8.     Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
  9.        - some corrections for Pinnacle Systems Inc. DC10plus card.
  11.     This program is free software; you can redistribute it and/or modify
  12.     it under the terms of the GNU General Public License as published by
  13.     the Free Software Foundation; either version 2 of the License, or
  14.     (at your option) any later version.
  16.     This program is distributed in the hope that it will be useful,
  17.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.     GNU General Public License for more details.
  21.     You should have received a copy of the GNU General Public License
  22.     along with this program; if not, write to the Free Software
  23.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24. */
  26. #include <linux/module.h>
  27. #include <linux/init.h>
  28. #include <linux/delay.h>
  29. #include <linux/errno.h>
  30. #include <linux/fs.h>
  31. #include <linux/kernel.h>
  32. #include <linux/major.h>
  33. #include <linux/slab.h>
  34. #include <linux/mm.h>
  35. #include <linux/pci.h>
  36. #include <linux/signal.h>
  37. #include <asm/io.h>
  38. #include <asm/pgtable.h>
  39. #include <asm/page.h>
  40. #include <linux/sched.h>
  41. #include <asm/segment.h>
  42. #include <linux/types.h>
  43. #include <linux/wrapper.h>
  45. #include <linux/videodev.h>
  46. #include <linux/version.h>
  47. #include <asm/uaccess.h>
  49. #include <linux/i2c-old.h>
  51. #include <linux/video_encoder.h>
  53. #if (DEBUGLEVEL > 0)
  54. #define DEBUG(x...)  x /* Debug driver */
  55. #else
  56. #define DEBUG(x...)
  57. #endif
  59. /* ----------------------------------------------------------------------- */
  61. struct adv7175 {
  62. struct i2c_bus *bus;
  63. int addr;
  64. unsigned char reg[128];
  66. int norm;
  67. int input;
  68. int enable;
  69. int bright;
  70. int contrast;
  71. int hue;
  72. int sat;
  73. };
  75. #define   I2C_ADV7175        0xd4
  76. #define   I2C_ADV7176        0x54
  78. static char adv7175_name[] = "adv7175";
  79. static char adv7176_name[] = "adv7176";
  80. static char unknown_name[] = "UNKNOWN";
  82. #if (DEBUGLEVEL > 0)
  83. static char *inputs[] = { "pass_through", "play_back", "color_bar" };
  84. static char *norms[] = { "PAL", "NTSC", "SECAM->PAL (may not work!)" };
  85. #endif
  87. #define I2C_DELAY   10
  89. /* ----------------------------------------------------------------------- */
  91. static int adv7175_write(struct adv7175 *dev, unsigned char subaddr, unsigned char data)
  92. {
  93. int ack;
  95. LOCK_I2C_BUS(dev->bus);
  97. i2c_start(dev->bus);
  98. i2c_sendbyte(dev->bus, dev->addr, I2C_DELAY);
  99. i2c_sendbyte(dev->bus, subaddr, I2C_DELAY);
  100. ack = i2c_sendbyte(dev->bus, data, I2C_DELAY);
  101. dev->reg[subaddr] = data;
  102. i2c_stop(dev->bus);
  103. UNLOCK_I2C_BUS(dev->bus);
  104. return ack;
  105. }
  107. static unsigned char adv7175_read(struct adv7175 *dev, unsigned char subaddr)
  108. {
  109. unsigned char data;
  111. 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_sendbyte(dev->bus, dev->addr + 1, I2C_DELAY);
  117. data = i2c_readbyte(dev->bus, 1);
  118. dev->reg[subaddr] = data;
  119. i2c_stop(dev->bus);
  120. UNLOCK_I2C_BUS(dev->bus);
  121. return data;
  122. }
  124. static int adv7175_write_block(struct adv7175 *dev,
  125.        unsigned const char *data, unsigned int len)
  126. {
  127. int ack = 0;
  128. unsigned subaddr;
  130. while (len > 1) {
  131. LOCK_I2C_BUS(dev->bus);
  132. i2c_start(dev->bus);
  133. i2c_sendbyte(dev->bus, dev->addr, I2C_DELAY);
  134. ack = i2c_sendbyte(dev->bus, (subaddr = *data++), I2C_DELAY);
  135. ack = i2c_sendbyte(dev->bus, (dev->reg[subaddr] = *data++), I2C_DELAY);
  136. len -= 2;
  137. while (len > 1 && *data == ++subaddr) {
  138. data++;
  139. ack = i2c_sendbyte(dev->bus, (dev->reg[subaddr] = *data++), I2C_DELAY);
  140. len -= 2;
  141. }
  142. i2c_stop(dev->bus);
  143. UNLOCK_I2C_BUS(dev->bus);
  144. }
  145. return ack;
  146. }
  148. /* ----------------------------------------------------------------------- */
  149. // Output filter:  S-Video  Composite
  151. #define MR050       0x11 //0x09
  152. #define MR060       0x14 //0x0c
  154. //---------------------------------------------------------------------------
  156. #define TR0MODE     0x46
  157. #define TR0RST     0x80
  159. #define TR1CAPT     0x80
  160. #define TR1PLAY     0x00
  162. static const unsigned char init_common[] = {
  164. 0x00, MR050, /* MR0, PAL enabled */
  165. 0x01, 0x00, /* MR1 */
  166. 0x02, 0x0c, /* subc. freq. */
  167. 0x03, 0x8c, /* subc. freq. */
  168. 0x04, 0x79, /* subc. freq. */
  169. 0x05, 0x26, /* subc. freq. */
  170. 0x06, 0x40, /* subc. phase */
  172. 0x07, TR0MODE, /* TR0, 16bit */
  173. 0x08, 0x21, /*  */
  174. 0x09, 0x00, /*  */
  175. 0x0a, 0x00, /*  */
  176. 0x0b, 0x00, /*  */
  177. 0x0c, TR1CAPT, /* TR1 */
  178. 0x0d, 0x4f, /* MR2 */
  179. 0x0e, 0x00, /*  */
  180. 0x0f, 0x00, /*  */
  181. 0x10, 0x00, /*  */
  182. 0x11, 0x00, /*  */
  183. 0x12, 0x00, /* MR3 */
  184. 0x24, 0x00, /*  */
  185. };
  187. static const unsigned char init_pal[] = {
  188. 0x00, MR050, /* MR0, PAL enabled */
  189. 0x01, 0x00, /* MR1 */
  190. 0x02, 0x0c, /* subc. freq. */
  191. 0x03, 0x8c, /* subc. freq. */
  192. 0x04, 0x79, /* subc. freq. */
  193. 0x05, 0x26, /* subc. freq. */
  194. 0x06, 0x40, /* subc. phase */
  195. };
  197. static const unsigned char init_ntsc[] = {
  198. 0x00, MR060, /* MR0, NTSC enabled */
  199. 0x01, 0x00, /* MR1 */
  200. 0x02, 0x55, /* subc. freq. */
  201. 0x03, 0x55, /* subc. freq. */
  202. 0x04, 0x55, /* subc. freq. */
  203. 0x05, 0x25, /* subc. freq. */
  204. 0x06, 0x1a, /* subc. phase */
  205. };
  207. static int adv7175_attach(struct i2c_device *device)
  208. {
  209. int i;
  210. struct adv7175 *encoder;
  211. char *dname;
  213. MOD_INC_USE_COUNT;
  215. device->data = encoder = kmalloc(sizeof(struct adv7175), GFP_KERNEL);
  216. if (encoder == NULL) {
  217. MOD_DEC_USE_COUNT;
  218. return -ENOMEM;
  219. }
  222. memset(encoder, 0, sizeof(struct adv7175));
  223. if ((device->addr == I2C_ADV7175) || (device->addr == (I2C_ADV7175 + 2))) {
  224. dname = adv7175_name;
  225. } else if ((device->addr == I2C_ADV7176) || (device->addr == (I2C_ADV7176 + 2))) {
  226. dname = adv7176_name;
  227. } else {
  228. // We should never get here!!!
  229. dname = unknown_name;
  230. }
  231. strcpy(device->name, dname);
  232. encoder->bus = device->bus;
  233. encoder->addr = device->addr;
  234. encoder->norm = VIDEO_MODE_PAL;
  235. encoder->input = 0;
  236. encoder->enable = 1;
  238. i = adv7175_write_block(encoder, init_common, sizeof(init_common));
  239. if (i >= 0) {
  240. i = adv7175_write(encoder, 0x07, TR0MODE | TR0RST);
  241. i = adv7175_write(encoder, 0x07, TR0MODE);
  242. i = adv7175_read(encoder, 0x12);
  243. printk(KERN_INFO "%s_attach: %s rev. %d at 0x%02xn",
  244.        device->name, dname, i & 1, device->addr);
  245. }
  246. if (i < 0) {
  247. printk(KERN_ERR "%s_attach: init error %dn", device->name,
  248.        i);
  249. }
  251. return 0;
  252. }
  255. static int adv7175_detach(struct i2c_device *device)
  256. {
  257. kfree(device->data);
  258. MOD_DEC_USE_COUNT;
  259. return 0;
  260. }
  262. static int adv7175_command(struct i2c_device *device, unsigned int cmd,
  263.    void *arg)
  264. {
  265. struct adv7175 *encoder = device->data;
  267. switch (cmd) {
  269. case ENCODER_GET_CAPABILITIES:
  270. {
  271. struct video_encoder_capability *cap = arg;
  273. cap->flags = VIDEO_ENCODER_PAL | VIDEO_ENCODER_NTSC
  274.     // | VIDEO_ENCODER_SECAM
  275.     // | VIDEO_ENCODER_CCIR
  276.     ;
  277. cap->inputs = 2;
  278. cap->outputs = 1;
  279. }
  280. break;
  282. case ENCODER_SET_NORM:
  283. {
  284. int iarg = *(int *) arg;
  286. if (encoder->norm != iarg) {
  287. switch (iarg) {
  289. case VIDEO_MODE_NTSC:
  290. adv7175_write_block(encoder,
  291.     init_ntsc,
  292.     sizeof
  293.     (init_ntsc));
  294. if (encoder->input == 0)
  295. adv7175_write(encoder, 0x0d, 0x4f); // Enable genlock
  296. adv7175_write(encoder, 0x07,
  297.       TR0MODE | TR0RST);
  298. adv7175_write(encoder, 0x07,
  299.       TR0MODE);
  300. break;
  302. case VIDEO_MODE_PAL:
  303. adv7175_write_block(encoder,
  304.     init_pal,
  305.     sizeof
  306.     (init_pal));
  307. if (encoder->input == 0)
  308. adv7175_write(encoder, 0x0d, 0x4f); // Enable genlock
  309. adv7175_write(encoder, 0x07,
  310.       TR0MODE | TR0RST);
  311. adv7175_write(encoder, 0x07,
  312.       TR0MODE);
  313. break;
  315. case VIDEO_MODE_SECAM: // WARNING! ADV7176 does not support SECAM.
  316. // This is an attempt to convert SECAM->PAL (typically
  317. // it does not work due to genlock: when decoder
  318. // is in SECAM and encoder in in PAL the subcarrier
  319. // can not be syncronized with horizontal frequency)
  320. adv7175_write_block(encoder,
  321.     init_pal,
  322.     sizeof
  323.     (init_pal));
  324. if (encoder->input == 0)
  325. adv7175_write(encoder, 0x0d, 0x49); // Disable genlock
  326. adv7175_write(encoder, 0x07,
  327.       TR0MODE | TR0RST);
  328. adv7175_write(encoder, 0x07,
  329.       TR0MODE);
  330. break;
  331. default:
  332. printk(KERN_ERR
  333.        "%s: illegal norm: %dn",
  334.        device->name, iarg);
  335. return -EINVAL;
  337. }
  338. DEBUG(printk
  339.       (KERN_INFO "%s: switched to %sn",
  340.        device->name, norms[iarg]));
  341. encoder->norm = iarg;
  342. }
  343. }
  344. break;
  346. case ENCODER_SET_INPUT:
  347. {
  348. int iarg = *(int *) arg;
  350. /* RJ: *iarg = 0: input is from SAA7110
  351.    *iarg = 1: input is from ZR36060
  352.    *iarg = 2: color bar */
  354. if (encoder->input != iarg) {
  355. switch (iarg) {
  357. case 0:
  358. adv7175_write(encoder, 0x01, 0x00);
  359. adv7175_write(encoder, 0x0c, TR1CAPT); /* TR1 */
  360. if (encoder->norm ==
  361.     VIDEO_MODE_SECAM)
  362. adv7175_write(encoder, 0x0d, 0x49); // Disable genlock
  363. else
  364. adv7175_write(encoder, 0x0d, 0x4f); // Enable genlock
  365. adv7175_write(encoder, 0x07,
  366.       TR0MODE | TR0RST);
  367. adv7175_write(encoder, 0x07,
  368.       TR0MODE);
  369. //udelay(10);
  370. break;
  372. case 1:
  373. adv7175_write(encoder, 0x01, 0x00);
  374. adv7175_write(encoder, 0x0c, TR1PLAY); /* TR1 */
  375. adv7175_write(encoder, 0x0d, 0x49);
  376. adv7175_write(encoder, 0x07,
  377.       TR0MODE | TR0RST);
  378. adv7175_write(encoder, 0x07,
  379.       TR0MODE);
  380. //udelay(10);
  381. break;
  383. case 2:
  384. adv7175_write(encoder, 0x01, 0x80);
  385. adv7175_write(encoder, 0x0d, 0x49);
  386. adv7175_write(encoder, 0x07,
  387.       TR0MODE | TR0RST);
  388. adv7175_write(encoder, 0x07,
  389.       TR0MODE);
  390. //udelay(10);
  391. break;
  393. default:
  394. printk(KERN_ERR
  395.        "%s: illegal input: %dn",
  396.        device->name, iarg);
  397. return -EINVAL;
  399. }
  400. DEBUG(printk
  401.       (KERN_INFO "%s: switched to %sn",
  402.        device->name, inputs[iarg]));
  403. encoder->input = iarg;
  404. }
  405. }
  406. break;
  408. case ENCODER_SET_OUTPUT:
  409. {
  410. int *iarg = arg;
  412. /* not much choice of outputs */
  413. if (*iarg != 0) {
  414. return -EINVAL;
  415. }
  416. }
  417. break;
  419. case ENCODER_ENABLE_OUTPUT:
  420. {
  421. int *iarg = arg;
  423. encoder->enable = !!*iarg;
  424. adv7175_write(encoder, 0x61,
  425.       (encoder->
  426.        reg[0x61] & 0xbf) | (encoder->
  427.     enable ? 0x00 :
  428.     0x40));
  429. }
  430. break;
  432. default:
  433. return -EINVAL;
  434. }
  436. return 0;
  437. }
  439. /* ----------------------------------------------------------------------- */
  441. static struct i2c_driver i2c_driver_adv7175 = {
  442. "adv7175", /* name */
  443. I2C_DRIVERID_VIDEOENCODER, /* ID */
  444. I2C_ADV7175, I2C_ADV7175 + 3,
  446. adv7175_attach,
  447. adv7175_detach,
  448. adv7175_command
  449. };
  451. static struct i2c_driver i2c_driver_adv7176 = {
  452. "adv7175", /* name */
  453. I2C_DRIVERID_VIDEOENCODER, /* ID */
  454. I2C_ADV7176, I2C_ADV7176 + 3,
  456. adv7175_attach,
  457. adv7175_detach,
  458. adv7175_command
  459. };
  461. EXPORT_NO_SYMBOLS;
  463. static int adv7175_init(void)
  464. {
  465. int res_adv7175 = 0, res_adv7176 = 0;
  466. res_adv7175 = i2c_register_driver(&i2c_driver_adv7175);
  467. res_adv7176 = i2c_register_driver(&i2c_driver_adv7176);
  468. return (res_adv7175 | res_adv7176); // Any idea how to make it better?
  469. }
  471. static void adv7175_exit(void)
  472. {
  473. i2c_unregister_driver(&i2c_driver_adv7176);
  474. i2c_unregister_driver(&i2c_driver_adv7175);
  475. }
  477. module_init(adv7175_init);
  478. module_exit(adv7175_exit);
  479. MODULE_LICENSE("GPL");