/kern_oII/drivers/staging/go7007/saa7134-go7007.c

http://omnia2droid.googlecode.com/ · C · 532 lines · 408 code · 81 blank · 43 comment · 41 complexity · f1c445536c165977536f3e974a7fd137 MD5 · raw file 

    

  1. /*
    2. 

  2.  * Copyright (C) 2005-2006 Micronas USA Inc.
    3. 

  3.  *
    4. 

  4.  * This program is free software; you can redistribute it and/or modify
    5. 

  5.  * it under the terms of the GNU General Public License (Version 2) as
    6. 

  6.  * published by the Free Software Foundation.
    7. 

  7.  *
    8. 

  8.  * This program is distributed in the hope that it will be useful,
    9. 

  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    10. 

  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    11. 

  11.  * GNU General Public License for more details.
    12. 

  12.  *
    13. 

  13.  * You should have received a copy of the GNU General Public License
    14. 

  14.  * along with this program; if not, write to the Free Software Foundation,
    15. 

  15.  * Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
    16. 

  16.  */
    17. 

  17. 

  18. #include <linux/module.h>
    19. 

  19. #include <linux/kernel.h>
    20. 

  20. #include <linux/init.h>
    21. 

  21. #include <linux/spinlock.h>
    22. 

  22. #include <linux/wait.h>
    23. 

  23. #include <linux/list.h>
    24. 

  24. #include <linux/slab.h>
    25. 

  25. #include <linux/time.h>
    26. 

  26. #include <linux/mm.h>
    27. 

  27. #include <linux/usb.h>
    28. 

  28. #include <linux/i2c.h>
    29. 

  29. #include <asm/byteorder.h>
    30. 

  30. #include <media/v4l2-common.h>
    31. 

  31. 

  32. #include "saa7134-reg.h"
    33. 

  33. #include "saa7134.h"
    34. 

  34. #include "go7007-priv.h"
    35. 

  35. 

  36. #define GO7007_HPI_DEBUG
    37. 

  37. 

  38. enum hpi_address {
    39. 

  39. 	HPI_ADDR_VIDEO_BUFFER = 0xe4,
    40. 

  40. 	HPI_ADDR_INIT_BUFFER = 0xea,
    41. 

  41. 	HPI_ADDR_INTR_RET_VALUE = 0xee,
    42. 

  42. 	HPI_ADDR_INTR_RET_DATA = 0xec,
    43. 

  43. 	HPI_ADDR_INTR_STATUS = 0xf4,
    44. 

  44. 	HPI_ADDR_INTR_WR_PARAM = 0xf6,
    45. 

  45. 	HPI_ADDR_INTR_WR_INDEX = 0xf8,
    46. 

  46. };
    47. 

  47. 

  48. enum gpio_command {
    49. 

  49. 	GPIO_COMMAND_RESET = 0x00, /* 000b */
    50. 

  50. 	GPIO_COMMAND_REQ1  = 0x04, /* 001b */
    51. 

  51. 	GPIO_COMMAND_WRITE = 0x20, /* 010b */
    52. 

  52. 	GPIO_COMMAND_REQ2  = 0x24, /* 011b */
    53. 

  53. 	GPIO_COMMAND_READ  = 0x80, /* 100b */
    54. 

  54. 	GPIO_COMMAND_VIDEO = 0x84, /* 101b */
    55. 

  55. 	GPIO_COMMAND_IDLE  = 0xA0, /* 110b */
    56. 

  56. 	GPIO_COMMAND_ADDR  = 0xA4, /* 111b */
    57. 

  57. };
    58. 

  58. 

  59. struct saa7134_go7007 {
    60. 

  60. 	struct saa7134_dev *dev;
    61. 

  61. 	u8 *top;
    62. 

  62. 	u8 *bottom;
    63. 

  63. 	dma_addr_t top_dma;
    64. 

  64. 	dma_addr_t bottom_dma;
    65. 

  65. };
    66. 

  66. 

  67. static struct go7007_board_info board_voyager = {
    68. 

  68. 	.firmware	 = "go7007tv.bin",
    69. 

  69. 	.flags		 = 0,
    70. 

  70. 	.sensor_flags	 = GO7007_SENSOR_656 |
    71. 

  71. 				GO7007_SENSOR_VALID_ENABLE |
    72. 

  72. 				GO7007_SENSOR_TV |
    73. 

  73. 				GO7007_SENSOR_VBI,
    74. 

  74. 	.audio_flags	= GO7007_AUDIO_I2S_MODE_1 |
    75. 

  75. 				GO7007_AUDIO_WORD_16,
    76. 

  76. 	.audio_rate	 = 48000,
    77. 

  77. 	.audio_bclk_div	 = 8,
    78. 

  78. 	.audio_main_div	 = 2,
    79. 

  79. 	.hpi_buffer_cap  = 7,
    80. 

  80. 	.num_inputs	 = 1,
    81. 

  81. 	.inputs 	 = {
    82. 

  82. 		{
    83. 

  83. 			.name		= "SAA7134",
    84. 

  84. 		},
    85. 

  85. 	},
    86. 

  86. };
    87. 

  87. 

  88. /********************* Driver for GPIO HPI interface *********************/
    89. 

  89. 

  90. static int gpio_write(struct saa7134_dev *dev, u8 addr, u16 data)
    91. 

  91. {
    92. 

  92. 	saa_writeb(SAA7134_GPIO_GPMODE0, 0xff);
    93. 

  93. 

  94. 	/* Write HPI address */
    95. 

  95. 	saa_writeb(SAA7134_GPIO_GPSTATUS0, addr);
    96. 

  96. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_ADDR);
    97. 

  97. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_IDLE);
    98. 

  98. 

  99. 	/* Write low byte */
    100. 

  100. 	saa_writeb(SAA7134_GPIO_GPSTATUS0, data & 0xff);
    101. 

  101. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_WRITE);
    102. 

  102. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_IDLE);
    103. 

  103. 

  104. 	/* Write high byte */
    105. 

  105. 	saa_writeb(SAA7134_GPIO_GPSTATUS0, data >> 8);
    106. 

  106. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_WRITE);
    107. 

  107. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_IDLE);
    108. 

  108. 

  109. 	return 0;
    110. 

  110. }
    111. 

  111. 

  112. static int gpio_read(struct saa7134_dev *dev, u8 addr, u16 *data)
    113. 

  113. {
    114. 

  114. 	saa_writeb(SAA7134_GPIO_GPMODE0, 0xff);
    115. 

  115. 

  116. 	/* Write HPI address */
    117. 

  117. 	saa_writeb(SAA7134_GPIO_GPSTATUS0, addr);
    118. 

  118. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_ADDR);
    119. 

  119. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_IDLE);
    120. 

  120. 

  121. 	saa_writeb(SAA7134_GPIO_GPMODE0, 0x00);
    122. 

  122. 

  123. 	/* Read low byte */
    124. 

  124. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_READ);
    125. 

  125. 	saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
    126. 

  126. 	saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
    127. 

  127. 	*data = saa_readb(SAA7134_GPIO_GPSTATUS0);
    128. 

  128. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_IDLE);
    129. 

  129. 

  130. 	/* Read high byte */
    131. 

  131. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_READ);
    132. 

  132. 	saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
    133. 

  133. 	saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
    134. 

  134. 	*data |= saa_readb(SAA7134_GPIO_GPSTATUS0) << 8;
    135. 

  135. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_IDLE);
    136. 

  136. 

  137. 	return 0;
    138. 

  138. }
    139. 

  139. 

  140. static int saa7134_go7007_interface_reset(struct go7007 *go)
    141. 

  141. {
    142. 

  142. 	struct saa7134_go7007 *saa = go->hpi_context;
    143. 

  143. 	struct saa7134_dev *dev = saa->dev;
    144. 

  144. 	u32 status;
    145. 

  145. 	u16 intr_val, intr_data;
    146. 

  146. 	int count = 20;
    147. 

  147. 

  148. 	saa_clearb(SAA7134_TS_PARALLEL, 0x80); /* Disable TS interface */
    149. 

  149. 	saa_writeb(SAA7134_GPIO_GPMODE2, 0xa4);
    150. 

  150. 	saa_writeb(SAA7134_GPIO_GPMODE0, 0xff);
    151. 

  151. 

  152. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_REQ1);
    153. 

  153. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_RESET);
    154. 

  154. 	msleep(1);
    155. 

  155. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_REQ1);
    156. 

  156. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_REQ2);
    157. 

  157. 	msleep(10);
    158. 

  158. 

  159. 	saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
    160. 

  160. 	saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
    161. 

  161. 

  162. 	status = saa_readb(SAA7134_GPIO_GPSTATUS2);
    163. 

  163. 	/*printk(KERN_DEBUG "status is %s\n", status & 0x40 ? "OK" : "not OK"); */
    164. 

  164. 

  165. 	/* enter command mode...(?) */
    166. 

  166. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_REQ1);
    167. 

  167. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_REQ2);
    168. 

  168. 

  169. 	do {
    170. 

  170. 		saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
    171. 

  171. 		saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
    172. 

  172. 		status = saa_readb(SAA7134_GPIO_GPSTATUS2);
    173. 

  173. 		/*printk(KERN_INFO "gpio is %08x\n", saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2)); */
    174. 

  174. 	} while (--count > 0);
    175. 

  175. 

  176. 	/* Wait for an interrupt to indicate successful hardware reset */
    177. 

  177. 	if (go7007_read_interrupt(go, &intr_val, &intr_data) < 0 ||
    178. 

  178. 			(intr_val & ~0x1) != 0x55aa) {
    179. 

  179. 		printk(KERN_ERR
    180. 

  180. 			"saa7134-go7007: unable to reset the GO7007\n");
    181. 

  181. 		return -1;
    182. 

  182. 	}
    183. 

  183. 	return 0;
    184. 

  184. }
    185. 

  185. 

  186. static int saa7134_go7007_write_interrupt(struct go7007 *go, int addr, int data)
    187. 

  187. {
    188. 

  188. 	struct saa7134_go7007 *saa = go->hpi_context;
    189. 

  189. 	struct saa7134_dev *dev = saa->dev;
    190. 

  190. 	int i;
    191. 

  191. 	u16 status_reg;
    192. 

  192. 

  193. #ifdef GO7007_HPI_DEBUG
    194. 

  194. 	printk(KERN_DEBUG
    195. 

  195. 		"saa7134-go7007: WriteInterrupt: %04x %04x\n", addr, data);
    196. 

  196. #endif
    197. 

  197. 

  198. 	for (i = 0; i < 100; ++i) {
    199. 

  199. 		gpio_read(dev, HPI_ADDR_INTR_STATUS, &status_reg);
    200. 

  200. 		if (!(status_reg & 0x0010))
    201. 

  201. 			break;
    202. 

  202. 		msleep(10);
    203. 

  203. 	}
    204. 

  204. 	if (i == 100) {
    205. 

  205. 		printk(KERN_ERR
    206. 

  206. 			"saa7134-go7007: device is hung, status reg = 0x%04x\n",
    207. 

  207. 			status_reg);
    208. 

  208. 		return -1;
    209. 

  209. 	}
    210. 

  210. 	gpio_write(dev, HPI_ADDR_INTR_WR_PARAM, data);
    211. 

  211. 	gpio_write(dev, HPI_ADDR_INTR_WR_INDEX, addr);
    212. 

  212. 

  213. 	return 0;
    214. 

  214. }
    215. 

  215. 

  216. static int saa7134_go7007_read_interrupt(struct go7007 *go)
    217. 

  217. {
    218. 

  218. 	struct saa7134_go7007 *saa = go->hpi_context;
    219. 

  219. 	struct saa7134_dev *dev = saa->dev;
    220. 

  220. 

  221. 	/* XXX we need to wait if there is no interrupt available */
    222. 

  222. 	go->interrupt_available = 1;
    223. 

  223. 	gpio_read(dev, HPI_ADDR_INTR_RET_VALUE, &go->interrupt_value);
    224. 

  224. 	gpio_read(dev, HPI_ADDR_INTR_RET_DATA, &go->interrupt_data);
    225. 

  225. #ifdef GO7007_HPI_DEBUG
    226. 

  226. 	printk(KERN_DEBUG "saa7134-go7007: ReadInterrupt: %04x %04x\n",
    227. 

  227. 			go->interrupt_value, go->interrupt_data);
    228. 

  228. #endif
    229. 

  229. 	return 0;
    230. 

  230. }
    231. 

  231. 

  232. static void saa7134_go7007_irq_ts_done(struct saa7134_dev *dev,
    233. 

  233. 						unsigned long status)
    234. 

  234. {
    235. 

  235. 	struct go7007 *go = video_get_drvdata(dev->empress_dev);
    236. 

  236. 	struct saa7134_go7007 *saa = go->hpi_context;
    237. 

  237. 

  238. 	if (!go->streaming)
    239. 

  239. 		return;
    240. 

  240. 	if (0 != (status & 0x000f0000))
    241. 

  241. 		printk(KERN_DEBUG "saa7134-go7007: irq: lost %ld\n",
    242. 

  242. 				(status >> 16) & 0x0f);
    243. 

  243. 	if (status & 0x100000) {
    244. 

  244. 		dma_sync_single(&dev->pci->dev,
    245. 

  245. 				saa->bottom_dma, PAGE_SIZE, DMA_FROM_DEVICE);
    246. 

  246. 		go7007_parse_video_stream(go, saa->bottom, PAGE_SIZE);
    247. 

  247. 		saa_writel(SAA7134_RS_BA2(5), cpu_to_le32(saa->bottom_dma));
    248. 

  248. 	} else {
    249. 

  249. 		dma_sync_single(&dev->pci->dev,
    250. 

  250. 				saa->top_dma, PAGE_SIZE, DMA_FROM_DEVICE);
    251. 

  251. 		go7007_parse_video_stream(go, saa->top, PAGE_SIZE);
    252. 

  252. 		saa_writel(SAA7134_RS_BA1(5), cpu_to_le32(saa->top_dma));
    253. 

  253. 	}
    254. 

  254. }
    255. 

  255. 

  256. static int saa7134_go7007_stream_start(struct go7007 *go)
    257. 

  257. {
    258. 

  258. 	struct saa7134_go7007 *saa = go->hpi_context;
    259. 

  259. 	struct saa7134_dev *dev = saa->dev;
    260. 

  260. 

  261. 	saa->top_dma = dma_map_page(&dev->pci->dev, virt_to_page(saa->top),
    262. 

  262. 			0, PAGE_SIZE, DMA_FROM_DEVICE);
    263. 

  263. 	if (!saa->top_dma)
    264. 

  264. 		return -ENOMEM;
    265. 

  265. 	saa->bottom_dma = dma_map_page(&dev->pci->dev,
    266. 

  266. 			virt_to_page(saa->bottom),
    267. 

  267. 			0, PAGE_SIZE, DMA_FROM_DEVICE);
    268. 

  268. 	if (!saa->bottom_dma) {
    269. 

  269. 		dma_unmap_page(&dev->pci->dev, saa->top_dma, PAGE_SIZE,
    270. 

  270. 				DMA_FROM_DEVICE);
    271. 

  271. 		return -ENOMEM;
    272. 

  272. 	}
    273. 

  273. 

  274. 	saa_writel(SAA7134_VIDEO_PORT_CTRL0 >> 2, 0xA300B000);
    275. 

  275. 	saa_writel(SAA7134_VIDEO_PORT_CTRL4 >> 2, 0x40000200);
    276. 

  276. 

  277. 	/* Set HPI interface for video */
    278. 

  278. 	saa_writeb(SAA7134_GPIO_GPMODE0, 0xff);
    279. 

  279. 	saa_writeb(SAA7134_GPIO_GPSTATUS0, HPI_ADDR_VIDEO_BUFFER);
    280. 

  280. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_ADDR);
    281. 

  281. 	saa_writeb(SAA7134_GPIO_GPMODE0, 0x00);
    282. 

  282. 

  283. 	/* Enable TS interface */
    284. 

  284. 	saa_writeb(SAA7134_TS_PARALLEL, 0xe6);
    285. 

  285. 

  286. 	/* Reset TS interface */
    287. 

  287. 	saa_setb(SAA7134_TS_SERIAL1, 0x01);
    288. 

  288. 	saa_clearb(SAA7134_TS_SERIAL1, 0x01);
    289. 

  289. 

  290. 	/* Set up transfer block size */
    291. 

  291. 	saa_writeb(SAA7134_TS_PARALLEL_SERIAL, 128 - 1);
    292. 

  292. 	saa_writeb(SAA7134_TS_DMA0, (PAGE_SIZE >> 7) - 1);
    293. 

  293. 	saa_writeb(SAA7134_TS_DMA1, 0);
    294. 

  294. 	saa_writeb(SAA7134_TS_DMA2, 0);
    295. 

  295. 

  296. 	/* Enable video streaming mode */
    297. 

  297. 	saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_VIDEO);
    298. 

  298. 

  299. 	saa_writel(SAA7134_RS_BA1(5), cpu_to_le32(saa->top_dma));
    300. 

  300. 	saa_writel(SAA7134_RS_BA2(5), cpu_to_le32(saa->bottom_dma));
    301. 

  301. 	saa_writel(SAA7134_RS_PITCH(5), 128);
    302. 

  302. 	saa_writel(SAA7134_RS_CONTROL(5), SAA7134_RS_CONTROL_BURST_MAX);
    303. 

  303. 

  304. 	/* Enable TS FIFO */
    305. 

  305. 	saa_setl(SAA7134_MAIN_CTRL, SAA7134_MAIN_CTRL_TE5);
    306. 

  306. 

  307. 	/* Enable DMA IRQ */
    308. 

  308. 	saa_setl(SAA7134_IRQ1,
    309. 

  309. 			SAA7134_IRQ1_INTE_RA2_1 | SAA7134_IRQ1_INTE_RA2_0);
    310. 

  310. 

  311. 	return 0;
    312. 

  312. }
    313. 

  313. 

  314. static int saa7134_go7007_stream_stop(struct go7007 *go)
    315. 

  315. {
    316. 

  316. 	struct saa7134_go7007 *saa = go->hpi_context;
    317. 

  317. 	struct saa7134_dev *dev;
    318. 

  318. 

  319. 	if (!saa)
    320. 

  320. 		return -EINVAL;
    321. 

  321. 	dev = saa->dev;
    322. 

  322. 	if (!dev)
    323. 

  323. 		return -EINVAL;
    324. 

  324. 

  325. 	/* Shut down TS FIFO */
    326. 

  326. 	saa_clearl(SAA7134_MAIN_CTRL, SAA7134_MAIN_CTRL_TE5);
    327. 

  327. 

  328. 	/* Disable DMA IRQ */
    329. 

  329. 	saa_clearl(SAA7134_IRQ1,
    330. 

  330. 			SAA7134_IRQ1_INTE_RA2_1 | SAA7134_IRQ1_INTE_RA2_0);
    331. 

  331. 

  332. 	/* Disable TS interface */
    333. 

  333. 	saa_clearb(SAA7134_TS_PARALLEL, 0x80);
    334. 

  334. 

  335. 	dma_unmap_page(&dev->pci->dev, saa->top_dma, PAGE_SIZE,
    336. 

  336. 			DMA_FROM_DEVICE);
    337. 

  337. 	dma_unmap_page(&dev->pci->dev, saa->bottom_dma, PAGE_SIZE,
    338. 

  338. 			DMA_FROM_DEVICE);
    339. 

  339. 

  340. 	return 0;
    341. 

  341. }
    342. 

  342. 

  343. static int saa7134_go7007_send_firmware(struct go7007 *go, u8 *data, int len)
    344. 

  344. {
    345. 

  345. 	struct saa7134_go7007 *saa = go->hpi_context;
    346. 

  346. 	struct saa7134_dev *dev = saa->dev;
    347. 

  347. 	u16 status_reg;
    348. 

  348. 	int i;
    349. 

  349. 

  350. #ifdef GO7007_HPI_DEBUG
    351. 

  351. 	printk(KERN_DEBUG "saa7134-go7007: DownloadBuffer "
    352. 

  352. 			"sending %d bytes\n", len);
    353. 

  353. #endif
    354. 

  354. 

  355. 	while (len > 0) {
    356. 

  356. 		i = len > 64 ? 64 : len;
    357. 

  357. 		saa_writeb(SAA7134_GPIO_GPMODE0, 0xff);
    358. 

  358. 		saa_writeb(SAA7134_GPIO_GPSTATUS0, HPI_ADDR_INIT_BUFFER);
    359. 

  359. 		saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_ADDR);
    360. 

  360. 		saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_IDLE);
    361. 

  361. 		while (i-- > 0) {
    362. 

  362. 			saa_writeb(SAA7134_GPIO_GPSTATUS0, *data);
    363. 

  363. 			saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_WRITE);
    364. 

  364. 			saa_writeb(SAA7134_GPIO_GPSTATUS2, GPIO_COMMAND_IDLE);
    365. 

  365. 			++data;
    366. 

  366. 			--len;
    367. 

  367. 		}
    368. 

  368. 		for (i = 0; i < 100; ++i) {
    369. 

  369. 			gpio_read(dev, HPI_ADDR_INTR_STATUS, &status_reg);
    370. 

  370. 			if (!(status_reg & 0x0002))
    371. 

  371. 				break;
    372. 

  372. 		}
    373. 

  373. 		if (i == 100) {
    374. 

  374. 			printk(KERN_ERR "saa7134-go7007: device is hung, "
    375. 

  375. 					"status reg = 0x%04x\n", status_reg);
    376. 

  376. 			return -1;
    377. 

  377. 		}
    378. 

  378. 	}
    379. 

  379. 	return 0;
    380. 

  380. }
    381. 

  381. 

  382. static int saa7134_go7007_send_command(struct go7007 *go, unsigned int cmd,
    383. 

  383. 					void *arg)
    384. 

  384. {
    385. 

  385. 	struct saa7134_go7007 *saa = go->hpi_context;
    386. 

  386. 	struct saa7134_dev *dev = saa->dev;
    387. 

  387. 

  388. 	switch (cmd) {
    389. 

  389. 	case VIDIOC_S_STD:
    390. 

  390. 	{
    391. 

  391. 		v4l2_std_id *std = arg;
    392. 

  392. 		return saa7134_s_std_internal(dev, NULL, std);
    393. 

  393. 	}
    394. 

  394. 	case VIDIOC_G_STD:
    395. 

  395. 	{
    396. 

  396. 		v4l2_std_id *std = arg;
    397. 

  397. 		*std = dev->tvnorm->id;
    398. 

  398. 		return 0;
    399. 

  399. 	}
    400. 

  400. 	case VIDIOC_QUERYCTRL:
    401. 

  401. 	{
    402. 

  402. 		struct v4l2_queryctrl *ctrl = arg;
    403. 

  403. 		if (V4L2_CTRL_ID2CLASS(ctrl->id) == V4L2_CTRL_CLASS_USER)
    404. 

  404. 			return saa7134_queryctrl(NULL, NULL, ctrl);
    405. 

  405. 	}
    406. 

  406. 	case VIDIOC_G_CTRL:
    407. 

  407. 	{
    408. 

  408. 		struct v4l2_control *ctrl = arg;
    409. 

  409. 		if (V4L2_CTRL_ID2CLASS(ctrl->id) == V4L2_CTRL_CLASS_USER)
    410. 

  410. 			return saa7134_g_ctrl_internal(dev, NULL, ctrl);
    411. 

  411. 	}
    412. 

  412. 	case VIDIOC_S_CTRL:
    413. 

  413. 	{
    414. 

  414. 		struct v4l2_control *ctrl = arg;
    415. 

  415. 		if (V4L2_CTRL_ID2CLASS(ctrl->id) == V4L2_CTRL_CLASS_USER)
    416. 

  416. 			return saa7134_s_ctrl_internal(dev, NULL, ctrl);
    417. 

  417. 	}
    418. 

  418. 	}
    419. 

  419. 	return -EINVAL;
    420. 

  420. 

  421. }
    422. 

  422. 

  423. static struct go7007_hpi_ops saa7134_go7007_hpi_ops = {
    424. 

  424. 	.interface_reset	= saa7134_go7007_interface_reset,
    425. 

  425. 	.write_interrupt	= saa7134_go7007_write_interrupt,
    426. 

  426. 	.read_interrupt		= saa7134_go7007_read_interrupt,
    427. 

  427. 	.stream_start		= saa7134_go7007_stream_start,
    428. 

  428. 	.stream_stop		= saa7134_go7007_stream_stop,
    429. 

  429. 	.send_firmware		= saa7134_go7007_send_firmware,
    430. 

  430. 	.send_command		= saa7134_go7007_send_command,
    431. 

  431. };
    432. 

  432. 

  433. /********************* Add/remove functions *********************/
    434. 

  434. 

  435. static int saa7134_go7007_init(struct saa7134_dev *dev)
    436. 

  436. {
    437. 

  437. 	struct go7007 *go;
    438. 

  438. 	struct saa7134_go7007 *saa;
    439. 

  439. 

  440. 	printk(KERN_DEBUG "saa7134-go7007: probing new SAA713X board\n");
    441. 

  441. 

  442. 	saa = kmalloc(sizeof(struct saa7134_go7007), GFP_KERNEL);
    443. 

  443. 	if (saa == NULL)
    444. 

  444. 		return -ENOMEM;
    445. 

  445. 	memset(saa, 0, sizeof(struct saa7134_go7007));
    446. 

  446. 

  447. 	/* Allocate a couple pages for receiving the compressed stream */
    448. 

  448. 	saa->top = (u8 *)get_zeroed_page(GFP_KERNEL);
    449. 

  449. 	if (!saa->top)
    450. 

  450. 		goto allocfail;
    451. 

  451. 	saa->bottom = (u8 *)get_zeroed_page(GFP_KERNEL);
    452. 

  452. 	if (!saa->bottom)
    453. 

  453. 		goto allocfail;
    454. 

  454. 

  455. 	go = go7007_alloc(&board_voyager, &dev->pci->dev);
    456. 

  456. 	if (go == NULL)
    457. 

  457. 		goto allocfail;
    458. 

  458. 	go->board_id = GO7007_BOARDID_PCI_VOYAGER;
    459. 

  459. 	strncpy(go->name, saa7134_boards[dev->board].name, sizeof(go->name));
    460. 

  460. 	go->hpi_ops = &saa7134_go7007_hpi_ops;
    461. 

  461. 	go->hpi_context = saa;
    462. 

  462. 	saa->dev = dev;
    463. 

  463. 

  464. 	/* Boot the GO7007 */
    465. 

  465. 	if (go7007_boot_encoder(go, go->board_info->flags &
    466. 

  466. 					GO7007_BOARD_USE_ONBOARD_I2C) < 0)
    467. 

  467. 		goto initfail;
    468. 

  468. 

  469. 	/* Do any final GO7007 initialization, then register the
    470. 

  470. 	 * V4L2 and ALSA interfaces */
    471. 

  471. 	if (go7007_register_encoder(go) < 0)
    472. 

  472. 		goto initfail;
    473. 

  473. 	dev->empress_dev = go->video_dev;
    474. 

  474. 	video_set_drvdata(dev->empress_dev, go);
    475. 

  475. 

  476. 	go->status = STATUS_ONLINE;
    477. 

  477. 	return 0;
    478. 

  478. 

  479. initfail:
    480. 

  480. 	go->status = STATUS_SHUTDOWN;
    481. 

  481. 	return 0;
    482. 

  482. 

  483. allocfail:
    484. 

  484. 	if (saa->top)
    485. 

  485. 		free_page((unsigned long)saa->top);
    486. 

  486. 	if (saa->bottom)
    487. 

  487. 		free_page((unsigned long)saa->bottom);
    488. 

  488. 	kfree(saa);
    489. 

  489. 	return -ENOMEM;
    490. 

  490. }
    491. 

  491. 

  492. static int saa7134_go7007_fini(struct saa7134_dev *dev)
    493. 

  493. {
    494. 

  494. 	struct go7007 *go;
    495. 

  495. 	struct saa7134_go7007 *saa;
    496. 

  496. 

  497. 	if (NULL == dev->empress_dev)
    498. 

  498. 		return 0;
    499. 

  499. 

  500. 	go = video_get_drvdata(dev->empress_dev);
    501. 

  501. 	saa = go->hpi_context;
    502. 

  502. 	go->status = STATUS_SHUTDOWN;
    503. 

  503. 	free_page((unsigned long)saa->top);
    504. 

  504. 	free_page((unsigned long)saa->bottom);
    505. 

  505. 	kfree(saa);
    506. 

  506. 	go7007_remove(go);
    507. 

  507. 	dev->empress_dev = NULL;
    508. 

  508. 

  509. 	return 0;
    510. 

  510. }
    511. 

  511. 

  512. static struct saa7134_mpeg_ops saa7134_go7007_ops = {
    513. 

  513. 	.type          = SAA7134_MPEG_GO7007,
    514. 

  514. 	.init          = saa7134_go7007_init,
    515. 

  515. 	.fini          = saa7134_go7007_fini,
    516. 

  516. 	.irq_ts_done   = saa7134_go7007_irq_ts_done,
    517. 

  517. };
    518. 

  518. 

  519. static int __init saa7134_go7007_mod_init(void)
    520. 

  520. {
    521. 

  521. 	return saa7134_ts_register(&saa7134_go7007_ops);
    522. 

  522. }
    523. 

  523. 

  524. static void __exit saa7134_go7007_mod_cleanup(void)
    525. 

  525. {
    526. 

  526. 	saa7134_ts_unregister(&saa7134_go7007_ops);
    527. 

  527. }
    528. 

  528. 

  529. module_init(saa7134_go7007_mod_init);
    530. 

  530. module_exit(saa7134_go7007_mod_cleanup);
    531. 

  531. 

  532. MODULE_LICENSE("GPL v2");
    533.