Linux 5.6-rc2
[sfrench/cifs-2.6.git] / drivers / media / pci / cx23885 / cx23885-417.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *
4  *  Support for a cx23417 mpeg encoder via cx23885 host port.
5  *
6  *    (c) 2004 Jelle Foks <jelle@foks.us>
7  *    (c) 2004 Gerd Knorr <kraxel@bytesex.org>
8  *    (c) 2008 Steven Toth <stoth@linuxtv.org>
9  *      - CX23885/7/8 support
10  *
11  *  Includes parts from the ivtv driver <http://sourceforge.net/projects/ivtv/>
12  */
13
14 #include "cx23885.h"
15 #include "cx23885-ioctl.h"
16
17 #include <linux/module.h>
18 #include <linux/moduleparam.h>
19 #include <linux/init.h>
20 #include <linux/fs.h>
21 #include <linux/delay.h>
22 #include <linux/device.h>
23 #include <linux/firmware.h>
24 #include <linux/slab.h>
25 #include <media/v4l2-common.h>
26 #include <media/v4l2-ioctl.h>
27 #include <media/drv-intf/cx2341x.h>
28
29 #define CX23885_FIRM_IMAGE_SIZE 376836
30 #define CX23885_FIRM_IMAGE_NAME "v4l-cx23885-enc.fw"
31
32 static unsigned int mpegbufs = 32;
33 module_param(mpegbufs, int, 0644);
34 MODULE_PARM_DESC(mpegbufs, "number of mpeg buffers, range 2-32");
35 static unsigned int mpeglines = 32;
36 module_param(mpeglines, int, 0644);
37 MODULE_PARM_DESC(mpeglines, "number of lines in an MPEG buffer, range 2-32");
38 static unsigned int mpeglinesize = 512;
39 module_param(mpeglinesize, int, 0644);
40 MODULE_PARM_DESC(mpeglinesize,
41         "number of bytes in each line of an MPEG buffer, range 512-1024");
42
43 static unsigned int v4l_debug;
44 module_param(v4l_debug, int, 0644);
45 MODULE_PARM_DESC(v4l_debug, "enable V4L debug messages");
46
47 #define dprintk(level, fmt, arg...)\
48         do { if (v4l_debug >= level) \
49                 printk(KERN_DEBUG pr_fmt("%s: 417:" fmt), \
50                         __func__, ##arg); \
51         } while (0)
52
53 static struct cx23885_tvnorm cx23885_tvnorms[] = {
54         {
55                 .name      = "NTSC-M",
56                 .id        = V4L2_STD_NTSC_M,
57         }, {
58                 .name      = "NTSC-JP",
59                 .id        = V4L2_STD_NTSC_M_JP,
60         }, {
61                 .name      = "PAL-BG",
62                 .id        = V4L2_STD_PAL_BG,
63         }, {
64                 .name      = "PAL-DK",
65                 .id        = V4L2_STD_PAL_DK,
66         }, {
67                 .name      = "PAL-I",
68                 .id        = V4L2_STD_PAL_I,
69         }, {
70                 .name      = "PAL-M",
71                 .id        = V4L2_STD_PAL_M,
72         }, {
73                 .name      = "PAL-N",
74                 .id        = V4L2_STD_PAL_N,
75         }, {
76                 .name      = "PAL-Nc",
77                 .id        = V4L2_STD_PAL_Nc,
78         }, {
79                 .name      = "PAL-60",
80                 .id        = V4L2_STD_PAL_60,
81         }, {
82                 .name      = "SECAM-L",
83                 .id        = V4L2_STD_SECAM_L,
84         }, {
85                 .name      = "SECAM-DK",
86                 .id        = V4L2_STD_SECAM_DK,
87         }
88 };
89
90 /* ------------------------------------------------------------------ */
91 enum cx23885_capture_type {
92         CX23885_MPEG_CAPTURE,
93         CX23885_RAW_CAPTURE,
94         CX23885_RAW_PASSTHRU_CAPTURE
95 };
96 enum cx23885_capture_bits {
97         CX23885_RAW_BITS_NONE             = 0x00,
98         CX23885_RAW_BITS_YUV_CAPTURE      = 0x01,
99         CX23885_RAW_BITS_PCM_CAPTURE      = 0x02,
100         CX23885_RAW_BITS_VBI_CAPTURE      = 0x04,
101         CX23885_RAW_BITS_PASSTHRU_CAPTURE = 0x08,
102         CX23885_RAW_BITS_TO_HOST_CAPTURE  = 0x10
103 };
104 enum cx23885_capture_end {
105         CX23885_END_AT_GOP, /* stop at the end of gop, generate irq */
106         CX23885_END_NOW, /* stop immediately, no irq */
107 };
108 enum cx23885_framerate {
109         CX23885_FRAMERATE_NTSC_30, /* NTSC: 30fps */
110         CX23885_FRAMERATE_PAL_25   /* PAL: 25fps */
111 };
112 enum cx23885_stream_port {
113         CX23885_OUTPUT_PORT_MEMORY,
114         CX23885_OUTPUT_PORT_STREAMING,
115         CX23885_OUTPUT_PORT_SERIAL
116 };
117 enum cx23885_data_xfer_status {
118         CX23885_MORE_BUFFERS_FOLLOW,
119         CX23885_LAST_BUFFER,
120 };
121 enum cx23885_picture_mask {
122         CX23885_PICTURE_MASK_NONE,
123         CX23885_PICTURE_MASK_I_FRAMES,
124         CX23885_PICTURE_MASK_I_P_FRAMES = 0x3,
125         CX23885_PICTURE_MASK_ALL_FRAMES = 0x7,
126 };
127 enum cx23885_vbi_mode_bits {
128         CX23885_VBI_BITS_SLICED,
129         CX23885_VBI_BITS_RAW,
130 };
131 enum cx23885_vbi_insertion_bits {
132         CX23885_VBI_BITS_INSERT_IN_XTENSION_USR_DATA,
133         CX23885_VBI_BITS_INSERT_IN_PRIVATE_PACKETS = 0x1 << 1,
134         CX23885_VBI_BITS_SEPARATE_STREAM = 0x2 << 1,
135         CX23885_VBI_BITS_SEPARATE_STREAM_USR_DATA = 0x4 << 1,
136         CX23885_VBI_BITS_SEPARATE_STREAM_PRV_DATA = 0x5 << 1,
137 };
138 enum cx23885_dma_unit {
139         CX23885_DMA_BYTES,
140         CX23885_DMA_FRAMES,
141 };
142 enum cx23885_dma_transfer_status_bits {
143         CX23885_DMA_TRANSFER_BITS_DONE = 0x01,
144         CX23885_DMA_TRANSFER_BITS_ERROR = 0x04,
145         CX23885_DMA_TRANSFER_BITS_LL_ERROR = 0x10,
146 };
147 enum cx23885_pause {
148         CX23885_PAUSE_ENCODING,
149         CX23885_RESUME_ENCODING,
150 };
151 enum cx23885_copyright {
152         CX23885_COPYRIGHT_OFF,
153         CX23885_COPYRIGHT_ON,
154 };
155 enum cx23885_notification_type {
156         CX23885_NOTIFICATION_REFRESH,
157 };
158 enum cx23885_notification_status {
159         CX23885_NOTIFICATION_OFF,
160         CX23885_NOTIFICATION_ON,
161 };
162 enum cx23885_notification_mailbox {
163         CX23885_NOTIFICATION_NO_MAILBOX = -1,
164 };
165 enum cx23885_field1_lines {
166         CX23885_FIELD1_SAA7114 = 0x00EF, /* 239 */
167         CX23885_FIELD1_SAA7115 = 0x00F0, /* 240 */
168         CX23885_FIELD1_MICRONAS = 0x0105, /* 261 */
169 };
170 enum cx23885_field2_lines {
171         CX23885_FIELD2_SAA7114 = 0x00EF, /* 239 */
172         CX23885_FIELD2_SAA7115 = 0x00F0, /* 240 */
173         CX23885_FIELD2_MICRONAS = 0x0106, /* 262 */
174 };
175 enum cx23885_custom_data_type {
176         CX23885_CUSTOM_EXTENSION_USR_DATA,
177         CX23885_CUSTOM_PRIVATE_PACKET,
178 };
179 enum cx23885_mute {
180         CX23885_UNMUTE,
181         CX23885_MUTE,
182 };
183 enum cx23885_mute_video_mask {
184         CX23885_MUTE_VIDEO_V_MASK = 0x0000FF00,
185         CX23885_MUTE_VIDEO_U_MASK = 0x00FF0000,
186         CX23885_MUTE_VIDEO_Y_MASK = 0xFF000000,
187 };
188 enum cx23885_mute_video_shift {
189         CX23885_MUTE_VIDEO_V_SHIFT = 8,
190         CX23885_MUTE_VIDEO_U_SHIFT = 16,
191         CX23885_MUTE_VIDEO_Y_SHIFT = 24,
192 };
193
194 /* defines below are from ivtv-driver.h */
195 #define IVTV_CMD_HW_BLOCKS_RST 0xFFFFFFFF
196
197 /* Firmware API commands */
198 #define IVTV_API_STD_TIMEOUT 500
199
200 /* Registers */
201 /* IVTV_REG_OFFSET */
202 #define IVTV_REG_ENC_SDRAM_REFRESH (0x07F8)
203 #define IVTV_REG_ENC_SDRAM_PRECHARGE (0x07FC)
204 #define IVTV_REG_SPU (0x9050)
205 #define IVTV_REG_HW_BLOCKS (0x9054)
206 #define IVTV_REG_VPU (0x9058)
207 #define IVTV_REG_APU (0xA064)
208
209 /**** Bit definitions for MC417_RWD and MC417_OEN registers  ***
210   bits 31-16
211 +-----------+
212 | Reserved  |
213 +-----------+
214   bit 15  bit 14  bit 13 bit 12  bit 11  bit 10  bit 9   bit 8
215 +-------+-------+-------+-------+-------+-------+-------+-------+
216 | MIWR# | MIRD# | MICS# |MIRDY# |MIADDR3|MIADDR2|MIADDR1|MIADDR0|
217 +-------+-------+-------+-------+-------+-------+-------+-------+
218  bit 7   bit 6   bit 5   bit 4   bit 3   bit 2   bit 1   bit 0
219 +-------+-------+-------+-------+-------+-------+-------+-------+
220 |MIDATA7|MIDATA6|MIDATA5|MIDATA4|MIDATA3|MIDATA2|MIDATA1|MIDATA0|
221 +-------+-------+-------+-------+-------+-------+-------+-------+
222 ***/
223 #define MC417_MIWR      0x8000
224 #define MC417_MIRD      0x4000
225 #define MC417_MICS      0x2000
226 #define MC417_MIRDY     0x1000
227 #define MC417_MIADDR    0x0F00
228 #define MC417_MIDATA    0x00FF
229
230 /* MIADDR* nibble definitions */
231 #define  MCI_MEMORY_DATA_BYTE0          0x000
232 #define  MCI_MEMORY_DATA_BYTE1          0x100
233 #define  MCI_MEMORY_DATA_BYTE2          0x200
234 #define  MCI_MEMORY_DATA_BYTE3          0x300
235 #define  MCI_MEMORY_ADDRESS_BYTE2       0x400
236 #define  MCI_MEMORY_ADDRESS_BYTE1       0x500
237 #define  MCI_MEMORY_ADDRESS_BYTE0       0x600
238 #define  MCI_REGISTER_DATA_BYTE0        0x800
239 #define  MCI_REGISTER_DATA_BYTE1        0x900
240 #define  MCI_REGISTER_DATA_BYTE2        0xA00
241 #define  MCI_REGISTER_DATA_BYTE3        0xB00
242 #define  MCI_REGISTER_ADDRESS_BYTE0     0xC00
243 #define  MCI_REGISTER_ADDRESS_BYTE1     0xD00
244 #define  MCI_REGISTER_MODE              0xE00
245
246 /* Read and write modes */
247 #define  MCI_MODE_REGISTER_READ         0
248 #define  MCI_MODE_REGISTER_WRITE        1
249 #define  MCI_MODE_MEMORY_READ           0
250 #define  MCI_MODE_MEMORY_WRITE          0x40
251
252 /*** Bit definitions for MC417_CTL register ****
253  bits 31-6   bits 5-4   bit 3    bits 2-1       Bit 0
254 +--------+-------------+--------+--------------+------------+
255 |Reserved|MC417_SPD_CTL|Reserved|MC417_GPIO_SEL|UART_GPIO_EN|
256 +--------+-------------+--------+--------------+------------+
257 ***/
258 #define MC417_SPD_CTL(x)        (((x) << 4) & 0x00000030)
259 #define MC417_GPIO_SEL(x)       (((x) << 1) & 0x00000006)
260 #define MC417_UART_GPIO_EN      0x00000001
261
262 /* Values for speed control */
263 #define MC417_SPD_CTL_SLOW      0x1
264 #define MC417_SPD_CTL_MEDIUM    0x0
265 #define MC417_SPD_CTL_FAST      0x3     /* b'1x, but we use b'11 */
266
267 /* Values for GPIO select */
268 #define MC417_GPIO_SEL_GPIO3    0x3
269 #define MC417_GPIO_SEL_GPIO2    0x2
270 #define MC417_GPIO_SEL_GPIO1    0x1
271 #define MC417_GPIO_SEL_GPIO0    0x0
272
273 void cx23885_mc417_init(struct cx23885_dev *dev)
274 {
275         u32 regval;
276
277         dprintk(2, "%s()\n", __func__);
278
279         /* Configure MC417_CTL register to defaults. */
280         regval = MC417_SPD_CTL(MC417_SPD_CTL_FAST)      |
281                  MC417_GPIO_SEL(MC417_GPIO_SEL_GPIO3)   |
282                  MC417_UART_GPIO_EN;
283         cx_write(MC417_CTL, regval);
284
285         /* Configure MC417_OEN to defaults. */
286         regval = MC417_MIRDY;
287         cx_write(MC417_OEN, regval);
288
289         /* Configure MC417_RWD to defaults. */
290         regval = MC417_MIWR | MC417_MIRD | MC417_MICS;
291         cx_write(MC417_RWD, regval);
292 }
293
294 static int mc417_wait_ready(struct cx23885_dev *dev)
295 {
296         u32 mi_ready;
297         unsigned long timeout = jiffies + msecs_to_jiffies(1);
298
299         for (;;) {
300                 mi_ready = cx_read(MC417_RWD) & MC417_MIRDY;
301                 if (mi_ready != 0)
302                         return 0;
303                 if (time_after(jiffies, timeout))
304                         return -1;
305                 udelay(1);
306         }
307 }
308
309 int mc417_register_write(struct cx23885_dev *dev, u16 address, u32 value)
310 {
311         u32 regval;
312
313         /* Enable MC417 GPIO outputs except for MC417_MIRDY,
314          * which is an input.
315          */
316         cx_write(MC417_OEN, MC417_MIRDY);
317
318         /* Write data byte 0 */
319         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_DATA_BYTE0 |
320                 (value & 0x000000FF);
321         cx_write(MC417_RWD, regval);
322
323         /* Transition CS/WR to effect write transaction across bus. */
324         regval |= MC417_MICS | MC417_MIWR;
325         cx_write(MC417_RWD, regval);
326
327         /* Write data byte 1 */
328         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_DATA_BYTE1 |
329                 ((value >> 8) & 0x000000FF);
330         cx_write(MC417_RWD, regval);
331         regval |= MC417_MICS | MC417_MIWR;
332         cx_write(MC417_RWD, regval);
333
334         /* Write data byte 2 */
335         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_DATA_BYTE2 |
336                 ((value >> 16) & 0x000000FF);
337         cx_write(MC417_RWD, regval);
338         regval |= MC417_MICS | MC417_MIWR;
339         cx_write(MC417_RWD, regval);
340
341         /* Write data byte 3 */
342         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_DATA_BYTE3 |
343                 ((value >> 24) & 0x000000FF);
344         cx_write(MC417_RWD, regval);
345         regval |= MC417_MICS | MC417_MIWR;
346         cx_write(MC417_RWD, regval);
347
348         /* Write address byte 0 */
349         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_ADDRESS_BYTE0 |
350                 (address & 0xFF);
351         cx_write(MC417_RWD, regval);
352         regval |= MC417_MICS | MC417_MIWR;
353         cx_write(MC417_RWD, regval);
354
355         /* Write address byte 1 */
356         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_ADDRESS_BYTE1 |
357                 ((address >> 8) & 0xFF);
358         cx_write(MC417_RWD, regval);
359         regval |= MC417_MICS | MC417_MIWR;
360         cx_write(MC417_RWD, regval);
361
362         /* Indicate that this is a write. */
363         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_MODE |
364                 MCI_MODE_REGISTER_WRITE;
365         cx_write(MC417_RWD, regval);
366         regval |= MC417_MICS | MC417_MIWR;
367         cx_write(MC417_RWD, regval);
368
369         /* Wait for the trans to complete (MC417_MIRDY asserted). */
370         return mc417_wait_ready(dev);
371 }
372
373 int mc417_register_read(struct cx23885_dev *dev, u16 address, u32 *value)
374 {
375         int retval;
376         u32 regval;
377         u32 tempval;
378         u32 dataval;
379
380         /* Enable MC417 GPIO outputs except for MC417_MIRDY,
381          * which is an input.
382          */
383         cx_write(MC417_OEN, MC417_MIRDY);
384
385         /* Write address byte 0 */
386         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_ADDRESS_BYTE0 |
387                 ((address & 0x00FF));
388         cx_write(MC417_RWD, regval);
389         regval |= MC417_MICS | MC417_MIWR;
390         cx_write(MC417_RWD, regval);
391
392         /* Write address byte 1 */
393         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_ADDRESS_BYTE1 |
394                 ((address >> 8) & 0xFF);
395         cx_write(MC417_RWD, regval);
396         regval |= MC417_MICS | MC417_MIWR;
397         cx_write(MC417_RWD, regval);
398
399         /* Indicate that this is a register read. */
400         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_MODE |
401                 MCI_MODE_REGISTER_READ;
402         cx_write(MC417_RWD, regval);
403         regval |= MC417_MICS | MC417_MIWR;
404         cx_write(MC417_RWD, regval);
405
406         /* Wait for the trans to complete (MC417_MIRDY asserted). */
407         retval = mc417_wait_ready(dev);
408
409         /* switch the DAT0-7 GPIO[10:3] to input mode */
410         cx_write(MC417_OEN, MC417_MIRDY | MC417_MIDATA);
411
412         /* Read data byte 0 */
413         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_DATA_BYTE0;
414         cx_write(MC417_RWD, regval);
415
416         /* Transition RD to effect read transaction across bus.
417          * Transition 0x5000 -> 0x9000 correct (RD/RDY -> WR/RDY)?
418          * Should it be 0x9000 -> 0xF000 (also why is RDY being set, its
419          * input only...)
420          */
421         regval = MC417_MIWR | MC417_MIRDY | MCI_REGISTER_DATA_BYTE0;
422         cx_write(MC417_RWD, regval);
423
424         /* Collect byte */
425         tempval = cx_read(MC417_RWD);
426         dataval = tempval & 0x000000FF;
427
428         /* Bring CS and RD high. */
429         regval = MC417_MIWR | MC417_MIRD | MC417_MICS | MC417_MIRDY;
430         cx_write(MC417_RWD, regval);
431
432         /* Read data byte 1 */
433         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_DATA_BYTE1;
434         cx_write(MC417_RWD, regval);
435         regval = MC417_MIWR | MC417_MIRDY | MCI_REGISTER_DATA_BYTE1;
436         cx_write(MC417_RWD, regval);
437         tempval = cx_read(MC417_RWD);
438         dataval |= ((tempval & 0x000000FF) << 8);
439         regval = MC417_MIWR | MC417_MIRD | MC417_MICS | MC417_MIRDY;
440         cx_write(MC417_RWD, regval);
441
442         /* Read data byte 2 */
443         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_DATA_BYTE2;
444         cx_write(MC417_RWD, regval);
445         regval = MC417_MIWR | MC417_MIRDY | MCI_REGISTER_DATA_BYTE2;
446         cx_write(MC417_RWD, regval);
447         tempval = cx_read(MC417_RWD);
448         dataval |= ((tempval & 0x000000FF) << 16);
449         regval = MC417_MIWR | MC417_MIRD | MC417_MICS | MC417_MIRDY;
450         cx_write(MC417_RWD, regval);
451
452         /* Read data byte 3 */
453         regval = MC417_MIRD | MC417_MIRDY | MCI_REGISTER_DATA_BYTE3;
454         cx_write(MC417_RWD, regval);
455         regval = MC417_MIWR | MC417_MIRDY | MCI_REGISTER_DATA_BYTE3;
456         cx_write(MC417_RWD, regval);
457         tempval = cx_read(MC417_RWD);
458         dataval |= ((tempval & 0x000000FF) << 24);
459         regval = MC417_MIWR | MC417_MIRD | MC417_MICS | MC417_MIRDY;
460         cx_write(MC417_RWD, regval);
461
462         *value  = dataval;
463
464         return retval;
465 }
466
467 int mc417_memory_write(struct cx23885_dev *dev, u32 address, u32 value)
468 {
469         u32 regval;
470
471         /* Enable MC417 GPIO outputs except for MC417_MIRDY,
472          * which is an input.
473          */
474         cx_write(MC417_OEN, MC417_MIRDY);
475
476         /* Write data byte 0 */
477         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_DATA_BYTE0 |
478                 (value & 0x000000FF);
479         cx_write(MC417_RWD, regval);
480
481         /* Transition CS/WR to effect write transaction across bus. */
482         regval |= MC417_MICS | MC417_MIWR;
483         cx_write(MC417_RWD, regval);
484
485         /* Write data byte 1 */
486         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_DATA_BYTE1 |
487                 ((value >> 8) & 0x000000FF);
488         cx_write(MC417_RWD, regval);
489         regval |= MC417_MICS | MC417_MIWR;
490         cx_write(MC417_RWD, regval);
491
492         /* Write data byte 2 */
493         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_DATA_BYTE2 |
494                 ((value >> 16) & 0x000000FF);
495         cx_write(MC417_RWD, regval);
496         regval |= MC417_MICS | MC417_MIWR;
497         cx_write(MC417_RWD, regval);
498
499         /* Write data byte 3 */
500         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_DATA_BYTE3 |
501                 ((value >> 24) & 0x000000FF);
502         cx_write(MC417_RWD, regval);
503         regval |= MC417_MICS | MC417_MIWR;
504         cx_write(MC417_RWD, regval);
505
506         /* Write address byte 2 */
507         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_ADDRESS_BYTE2 |
508                 MCI_MODE_MEMORY_WRITE | ((address >> 16) & 0x3F);
509         cx_write(MC417_RWD, regval);
510         regval |= MC417_MICS | MC417_MIWR;
511         cx_write(MC417_RWD, regval);
512
513         /* Write address byte 1 */
514         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_ADDRESS_BYTE1 |
515                 ((address >> 8) & 0xFF);
516         cx_write(MC417_RWD, regval);
517         regval |= MC417_MICS | MC417_MIWR;
518         cx_write(MC417_RWD, regval);
519
520         /* Write address byte 0 */
521         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_ADDRESS_BYTE0 |
522                 (address & 0xFF);
523         cx_write(MC417_RWD, regval);
524         regval |= MC417_MICS | MC417_MIWR;
525         cx_write(MC417_RWD, regval);
526
527         /* Wait for the trans to complete (MC417_MIRDY asserted). */
528         return mc417_wait_ready(dev);
529 }
530
531 int mc417_memory_read(struct cx23885_dev *dev, u32 address, u32 *value)
532 {
533         int retval;
534         u32 regval;
535         u32 tempval;
536         u32 dataval;
537
538         /* Enable MC417 GPIO outputs except for MC417_MIRDY,
539          * which is an input.
540          */
541         cx_write(MC417_OEN, MC417_MIRDY);
542
543         /* Write address byte 2 */
544         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_ADDRESS_BYTE2 |
545                 MCI_MODE_MEMORY_READ | ((address >> 16) & 0x3F);
546         cx_write(MC417_RWD, regval);
547         regval |= MC417_MICS | MC417_MIWR;
548         cx_write(MC417_RWD, regval);
549
550         /* Write address byte 1 */
551         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_ADDRESS_BYTE1 |
552                 ((address >> 8) & 0xFF);
553         cx_write(MC417_RWD, regval);
554         regval |= MC417_MICS | MC417_MIWR;
555         cx_write(MC417_RWD, regval);
556
557         /* Write address byte 0 */
558         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_ADDRESS_BYTE0 |
559                 (address & 0xFF);
560         cx_write(MC417_RWD, regval);
561         regval |= MC417_MICS | MC417_MIWR;
562         cx_write(MC417_RWD, regval);
563
564         /* Wait for the trans to complete (MC417_MIRDY asserted). */
565         retval = mc417_wait_ready(dev);
566
567         /* switch the DAT0-7 GPIO[10:3] to input mode */
568         cx_write(MC417_OEN, MC417_MIRDY | MC417_MIDATA);
569
570         /* Read data byte 3 */
571         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_DATA_BYTE3;
572         cx_write(MC417_RWD, regval);
573
574         /* Transition RD to effect read transaction across bus. */
575         regval = MC417_MIWR | MC417_MIRDY | MCI_MEMORY_DATA_BYTE3;
576         cx_write(MC417_RWD, regval);
577
578         /* Collect byte */
579         tempval = cx_read(MC417_RWD);
580         dataval = ((tempval & 0x000000FF) << 24);
581
582         /* Bring CS and RD high. */
583         regval = MC417_MIWR | MC417_MIRD | MC417_MICS | MC417_MIRDY;
584         cx_write(MC417_RWD, regval);
585
586         /* Read data byte 2 */
587         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_DATA_BYTE2;
588         cx_write(MC417_RWD, regval);
589         regval = MC417_MIWR | MC417_MIRDY | MCI_MEMORY_DATA_BYTE2;
590         cx_write(MC417_RWD, regval);
591         tempval = cx_read(MC417_RWD);
592         dataval |= ((tempval & 0x000000FF) << 16);
593         regval = MC417_MIWR | MC417_MIRD | MC417_MICS | MC417_MIRDY;
594         cx_write(MC417_RWD, regval);
595
596         /* Read data byte 1 */
597         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_DATA_BYTE1;
598         cx_write(MC417_RWD, regval);
599         regval = MC417_MIWR | MC417_MIRDY | MCI_MEMORY_DATA_BYTE1;
600         cx_write(MC417_RWD, regval);
601         tempval = cx_read(MC417_RWD);
602         dataval |= ((tempval & 0x000000FF) << 8);
603         regval = MC417_MIWR | MC417_MIRD | MC417_MICS | MC417_MIRDY;
604         cx_write(MC417_RWD, regval);
605
606         /* Read data byte 0 */
607         regval = MC417_MIRD | MC417_MIRDY | MCI_MEMORY_DATA_BYTE0;
608         cx_write(MC417_RWD, regval);
609         regval = MC417_MIWR | MC417_MIRDY | MCI_MEMORY_DATA_BYTE0;
610         cx_write(MC417_RWD, regval);
611         tempval = cx_read(MC417_RWD);
612         dataval |= (tempval & 0x000000FF);
613         regval = MC417_MIWR | MC417_MIRD | MC417_MICS | MC417_MIRDY;
614         cx_write(MC417_RWD, regval);
615
616         *value  = dataval;
617
618         return retval;
619 }
620
621 void mc417_gpio_set(struct cx23885_dev *dev, u32 mask)
622 {
623         u32 val;
624
625         /* Set the gpio value */
626         mc417_register_read(dev, 0x900C, &val);
627         val |= (mask & 0x000ffff);
628         mc417_register_write(dev, 0x900C, val);
629 }
630
631 void mc417_gpio_clear(struct cx23885_dev *dev, u32 mask)
632 {
633         u32 val;
634
635         /* Clear the gpio value */
636         mc417_register_read(dev, 0x900C, &val);
637         val &= ~(mask & 0x0000ffff);
638         mc417_register_write(dev, 0x900C, val);
639 }
640
641 void mc417_gpio_enable(struct cx23885_dev *dev, u32 mask, int asoutput)
642 {
643         u32 val;
644
645         /* Enable GPIO direction bits */
646         mc417_register_read(dev, 0x9020, &val);
647         if (asoutput)
648                 val |= (mask & 0x0000ffff);
649         else
650                 val &= ~(mask & 0x0000ffff);
651
652         mc417_register_write(dev, 0x9020, val);
653 }
654 /* ------------------------------------------------------------------ */
655
656 /* MPEG encoder API */
657 static char *cmd_to_str(int cmd)
658 {
659         switch (cmd) {
660         case CX2341X_ENC_PING_FW:
661                 return  "PING_FW";
662         case CX2341X_ENC_START_CAPTURE:
663                 return  "START_CAPTURE";
664         case CX2341X_ENC_STOP_CAPTURE:
665                 return  "STOP_CAPTURE";
666         case CX2341X_ENC_SET_AUDIO_ID:
667                 return  "SET_AUDIO_ID";
668         case CX2341X_ENC_SET_VIDEO_ID:
669                 return  "SET_VIDEO_ID";
670         case CX2341X_ENC_SET_PCR_ID:
671                 return  "SET_PCR_ID";
672         case CX2341X_ENC_SET_FRAME_RATE:
673                 return  "SET_FRAME_RATE";
674         case CX2341X_ENC_SET_FRAME_SIZE:
675                 return  "SET_FRAME_SIZE";
676         case CX2341X_ENC_SET_BIT_RATE:
677                 return  "SET_BIT_RATE";
678         case CX2341X_ENC_SET_GOP_PROPERTIES:
679                 return  "SET_GOP_PROPERTIES";
680         case CX2341X_ENC_SET_ASPECT_RATIO:
681                 return  "SET_ASPECT_RATIO";
682         case CX2341X_ENC_SET_DNR_FILTER_MODE:
683                 return  "SET_DNR_FILTER_MODE";
684         case CX2341X_ENC_SET_DNR_FILTER_PROPS:
685                 return  "SET_DNR_FILTER_PROPS";
686         case CX2341X_ENC_SET_CORING_LEVELS:
687                 return  "SET_CORING_LEVELS";
688         case CX2341X_ENC_SET_SPATIAL_FILTER_TYPE:
689                 return  "SET_SPATIAL_FILTER_TYPE";
690         case CX2341X_ENC_SET_VBI_LINE:
691                 return  "SET_VBI_LINE";
692         case CX2341X_ENC_SET_STREAM_TYPE:
693                 return  "SET_STREAM_TYPE";
694         case CX2341X_ENC_SET_OUTPUT_PORT:
695                 return  "SET_OUTPUT_PORT";
696         case CX2341X_ENC_SET_AUDIO_PROPERTIES:
697                 return  "SET_AUDIO_PROPERTIES";
698         case CX2341X_ENC_HALT_FW:
699                 return  "HALT_FW";
700         case CX2341X_ENC_GET_VERSION:
701                 return  "GET_VERSION";
702         case CX2341X_ENC_SET_GOP_CLOSURE:
703                 return  "SET_GOP_CLOSURE";
704         case CX2341X_ENC_GET_SEQ_END:
705                 return  "GET_SEQ_END";
706         case CX2341X_ENC_SET_PGM_INDEX_INFO:
707                 return  "SET_PGM_INDEX_INFO";
708         case CX2341X_ENC_SET_VBI_CONFIG:
709                 return  "SET_VBI_CONFIG";
710         case CX2341X_ENC_SET_DMA_BLOCK_SIZE:
711                 return  "SET_DMA_BLOCK_SIZE";
712         case CX2341X_ENC_GET_PREV_DMA_INFO_MB_10:
713                 return  "GET_PREV_DMA_INFO_MB_10";
714         case CX2341X_ENC_GET_PREV_DMA_INFO_MB_9:
715                 return  "GET_PREV_DMA_INFO_MB_9";
716         case CX2341X_ENC_SCHED_DMA_TO_HOST:
717                 return  "SCHED_DMA_TO_HOST";
718         case CX2341X_ENC_INITIALIZE_INPUT:
719                 return  "INITIALIZE_INPUT";
720         case CX2341X_ENC_SET_FRAME_DROP_RATE:
721                 return  "SET_FRAME_DROP_RATE";
722         case CX2341X_ENC_PAUSE_ENCODER:
723                 return  "PAUSE_ENCODER";
724         case CX2341X_ENC_REFRESH_INPUT:
725                 return  "REFRESH_INPUT";
726         case CX2341X_ENC_SET_COPYRIGHT:
727                 return  "SET_COPYRIGHT";
728         case CX2341X_ENC_SET_EVENT_NOTIFICATION:
729                 return  "SET_EVENT_NOTIFICATION";
730         case CX2341X_ENC_SET_NUM_VSYNC_LINES:
731                 return  "SET_NUM_VSYNC_LINES";
732         case CX2341X_ENC_SET_PLACEHOLDER:
733                 return  "SET_PLACEHOLDER";
734         case CX2341X_ENC_MUTE_VIDEO:
735                 return  "MUTE_VIDEO";
736         case CX2341X_ENC_MUTE_AUDIO:
737                 return  "MUTE_AUDIO";
738         case CX2341X_ENC_MISC:
739                 return  "MISC";
740         default:
741                 return "UNKNOWN";
742         }
743 }
744
745 static int cx23885_mbox_func(void *priv,
746                              u32 command,
747                              int in,
748                              int out,
749                              u32 data[CX2341X_MBOX_MAX_DATA])
750 {
751         struct cx23885_dev *dev = priv;
752         unsigned long timeout;
753         u32 value, flag, retval = 0;
754         int i;
755
756         dprintk(3, "%s: command(0x%X) = %s\n", __func__, command,
757                 cmd_to_str(command));
758
759         /* this may not be 100% safe if we can't read any memory location
760            without side effects */
761         mc417_memory_read(dev, dev->cx23417_mailbox - 4, &value);
762         if (value != 0x12345678) {
763                 pr_err("Firmware and/or mailbox pointer not initialized or corrupted, signature = 0x%x, cmd = %s\n",
764                         value, cmd_to_str(command));
765                 return -1;
766         }
767
768         /* This read looks at 32 bits, but flag is only 8 bits.
769          * Seems we also bail if CMD or TIMEOUT bytes are set???
770          */
771         mc417_memory_read(dev, dev->cx23417_mailbox, &flag);
772         if (flag) {
773                 pr_err("ERROR: Mailbox appears to be in use (%x), cmd = %s\n",
774                        flag, cmd_to_str(command));
775                 return -1;
776         }
777
778         flag |= 1; /* tell 'em we're working on it */
779         mc417_memory_write(dev, dev->cx23417_mailbox, flag);
780
781         /* write command + args + fill remaining with zeros */
782         /* command code */
783         mc417_memory_write(dev, dev->cx23417_mailbox + 1, command);
784         mc417_memory_write(dev, dev->cx23417_mailbox + 3,
785                 IVTV_API_STD_TIMEOUT); /* timeout */
786         for (i = 0; i < in; i++) {
787                 mc417_memory_write(dev, dev->cx23417_mailbox + 4 + i, data[i]);
788                 dprintk(3, "API Input %d = %d\n", i, data[i]);
789         }
790         for (; i < CX2341X_MBOX_MAX_DATA; i++)
791                 mc417_memory_write(dev, dev->cx23417_mailbox + 4 + i, 0);
792
793         flag |= 3; /* tell 'em we're done writing */
794         mc417_memory_write(dev, dev->cx23417_mailbox, flag);
795
796         /* wait for firmware to handle the API command */
797         timeout = jiffies + msecs_to_jiffies(10);
798         for (;;) {
799                 mc417_memory_read(dev, dev->cx23417_mailbox, &flag);
800                 if (0 != (flag & 4))
801                         break;
802                 if (time_after(jiffies, timeout)) {
803                         pr_err("ERROR: API Mailbox timeout\n");
804                         return -1;
805                 }
806                 udelay(10);
807         }
808
809         /* read output values */
810         for (i = 0; i < out; i++) {
811                 mc417_memory_read(dev, dev->cx23417_mailbox + 4 + i, data + i);
812                 dprintk(3, "API Output %d = %d\n", i, data[i]);
813         }
814
815         mc417_memory_read(dev, dev->cx23417_mailbox + 2, &retval);
816         dprintk(3, "API result = %d\n", retval);
817
818         flag = 0;
819         mc417_memory_write(dev, dev->cx23417_mailbox, flag);
820
821         return retval;
822 }
823
824 /* We don't need to call the API often, so using just one
825  * mailbox will probably suffice
826  */
827 static int cx23885_api_cmd(struct cx23885_dev *dev,
828                            u32 command,
829                            u32 inputcnt,
830                            u32 outputcnt,
831                            ...)
832 {
833         u32 data[CX2341X_MBOX_MAX_DATA];
834         va_list vargs;
835         int i, err;
836
837         dprintk(3, "%s() cmds = 0x%08x\n", __func__, command);
838
839         va_start(vargs, outputcnt);
840         for (i = 0; i < inputcnt; i++)
841                 data[i] = va_arg(vargs, int);
842
843         err = cx23885_mbox_func(dev, command, inputcnt, outputcnt, data);
844         for (i = 0; i < outputcnt; i++) {
845                 int *vptr = va_arg(vargs, int *);
846                 *vptr = data[i];
847         }
848         va_end(vargs);
849
850         return err;
851 }
852
853 static int cx23885_api_func(void *priv, u32 cmd, int in, int out, u32 data[CX2341X_MBOX_MAX_DATA])
854 {
855         return cx23885_mbox_func(priv, cmd, in, out, data);
856 }
857
858 static int cx23885_find_mailbox(struct cx23885_dev *dev)
859 {
860         u32 signature[4] = {
861                 0x12345678, 0x34567812, 0x56781234, 0x78123456
862         };
863         int signaturecnt = 0;
864         u32 value;
865         int i;
866
867         dprintk(2, "%s()\n", __func__);
868
869         for (i = 0; i < CX23885_FIRM_IMAGE_SIZE; i++) {
870                 mc417_memory_read(dev, i, &value);
871                 if (value == signature[signaturecnt])
872                         signaturecnt++;
873                 else
874                         signaturecnt = 0;
875                 if (4 == signaturecnt) {
876                         dprintk(1, "Mailbox signature found at 0x%x\n", i+1);
877                         return i+1;
878                 }
879         }
880         pr_err("Mailbox signature values not found!\n");
881         return -1;
882 }
883
884 static int cx23885_load_firmware(struct cx23885_dev *dev)
885 {
886         static const unsigned char magic[8] = {
887                 0xa7, 0x0d, 0x00, 0x00, 0x66, 0xbb, 0x55, 0xaa
888         };
889         const struct firmware *firmware;
890         int i, retval = 0;
891         u32 value = 0;
892         u32 gpio_output = 0;
893         u32 gpio_value;
894         u32 checksum = 0;
895         u32 *dataptr;
896
897         dprintk(2, "%s()\n", __func__);
898
899         /* Save GPIO settings before reset of APU */
900         retval |= mc417_memory_read(dev, 0x9020, &gpio_output);
901         retval |= mc417_memory_read(dev, 0x900C, &gpio_value);
902
903         retval  = mc417_register_write(dev,
904                 IVTV_REG_VPU, 0xFFFFFFED);
905         retval |= mc417_register_write(dev,
906                 IVTV_REG_HW_BLOCKS, IVTV_CMD_HW_BLOCKS_RST);
907         retval |= mc417_register_write(dev,
908                 IVTV_REG_ENC_SDRAM_REFRESH, 0x80000800);
909         retval |= mc417_register_write(dev,
910                 IVTV_REG_ENC_SDRAM_PRECHARGE, 0x1A);
911         retval |= mc417_register_write(dev,
912                 IVTV_REG_APU, 0);
913
914         if (retval != 0) {
915                 pr_err("%s: Error with mc417_register_write\n",
916                         __func__);
917                 return -1;
918         }
919
920         retval = request_firmware(&firmware, CX23885_FIRM_IMAGE_NAME,
921                                   &dev->pci->dev);
922
923         if (retval != 0) {
924                 pr_err("ERROR: Hotplug firmware request failed (%s).\n",
925                        CX23885_FIRM_IMAGE_NAME);
926                 pr_err("Please fix your hotplug setup, the board will not work without firmware loaded!\n");
927                 return -1;
928         }
929
930         if (firmware->size != CX23885_FIRM_IMAGE_SIZE) {
931                 pr_err("ERROR: Firmware size mismatch (have %zu, expected %d)\n",
932                        firmware->size, CX23885_FIRM_IMAGE_SIZE);
933                 release_firmware(firmware);
934                 return -1;
935         }
936
937         if (0 != memcmp(firmware->data, magic, 8)) {
938                 pr_err("ERROR: Firmware magic mismatch, wrong file?\n");
939                 release_firmware(firmware);
940                 return -1;
941         }
942
943         /* transfer to the chip */
944         dprintk(2, "Loading firmware ...\n");
945         dataptr = (u32 *)firmware->data;
946         for (i = 0; i < (firmware->size >> 2); i++) {
947                 value = *dataptr;
948                 checksum += ~value;
949                 if (mc417_memory_write(dev, i, value) != 0) {
950                         pr_err("ERROR: Loading firmware failed!\n");
951                         release_firmware(firmware);
952                         return -1;
953                 }
954                 dataptr++;
955         }
956
957         /* read back to verify with the checksum */
958         dprintk(1, "Verifying firmware ...\n");
959         for (i--; i >= 0; i--) {
960                 if (mc417_memory_read(dev, i, &value) != 0) {
961                         pr_err("ERROR: Reading firmware failed!\n");
962                         release_firmware(firmware);
963                         return -1;
964                 }
965                 checksum -= ~value;
966         }
967         if (checksum) {
968                 pr_err("ERROR: Firmware load failed (checksum mismatch).\n");
969                 release_firmware(firmware);
970                 return -1;
971         }
972         release_firmware(firmware);
973         dprintk(1, "Firmware upload successful.\n");
974
975         retval |= mc417_register_write(dev, IVTV_REG_HW_BLOCKS,
976                 IVTV_CMD_HW_BLOCKS_RST);
977
978         /* F/W power up disturbs the GPIOs, restore state */
979         retval |= mc417_register_write(dev, 0x9020, gpio_output);
980         retval |= mc417_register_write(dev, 0x900C, gpio_value);
981
982         retval |= mc417_register_read(dev, IVTV_REG_VPU, &value);
983         retval |= mc417_register_write(dev, IVTV_REG_VPU, value & 0xFFFFFFE8);
984
985         /* Hardcoded GPIO's here */
986         retval |= mc417_register_write(dev, 0x9020, 0x4000);
987         retval |= mc417_register_write(dev, 0x900C, 0x4000);
988
989         mc417_register_read(dev, 0x9020, &gpio_output);
990         mc417_register_read(dev, 0x900C, &gpio_value);
991
992         if (retval < 0)
993                 pr_err("%s: Error with mc417_register_write\n",
994                         __func__);
995         return 0;
996 }
997
998 void cx23885_417_check_encoder(struct cx23885_dev *dev)
999 {
1000         u32 status, seq;
1001
1002         status = seq = 0;
1003         cx23885_api_cmd(dev, CX2341X_ENC_GET_SEQ_END, 0, 2, &status, &seq);
1004         dprintk(1, "%s() status = %d, seq = %d\n", __func__, status, seq);
1005 }
1006
1007 static void cx23885_codec_settings(struct cx23885_dev *dev)
1008 {
1009         dprintk(1, "%s()\n", __func__);
1010
1011         /* Dynamically change the height based on video standard */
1012         if (dev->encodernorm.id & V4L2_STD_525_60)
1013                 dev->ts1.height = 480;
1014         else
1015                 dev->ts1.height = 576;
1016
1017         /* assign frame size */
1018         cx23885_api_cmd(dev, CX2341X_ENC_SET_FRAME_SIZE, 2, 0,
1019                                 dev->ts1.height, dev->ts1.width);
1020
1021         dev->cxhdl.width = dev->ts1.width;
1022         dev->cxhdl.height = dev->ts1.height;
1023         dev->cxhdl.is_50hz =
1024                 (dev->encodernorm.id & V4L2_STD_625_50) != 0;
1025
1026         cx2341x_handler_setup(&dev->cxhdl);
1027
1028         cx23885_api_cmd(dev, CX2341X_ENC_MISC, 2, 0, 3, 1);
1029         cx23885_api_cmd(dev, CX2341X_ENC_MISC, 2, 0, 4, 1);
1030 }
1031
1032 static int cx23885_initialize_codec(struct cx23885_dev *dev, int startencoder)
1033 {
1034         int version;
1035         int retval;
1036         u32 i, data[7];
1037
1038         dprintk(1, "%s()\n", __func__);
1039
1040         retval = cx23885_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0); /* ping */
1041         if (retval < 0) {
1042                 dprintk(2, "%s() PING OK\n", __func__);
1043                 retval = cx23885_load_firmware(dev);
1044                 if (retval < 0) {
1045                         pr_err("%s() f/w load failed\n", __func__);
1046                         return retval;
1047                 }
1048                 retval = cx23885_find_mailbox(dev);
1049                 if (retval < 0) {
1050                         pr_err("%s() mailbox < 0, error\n",
1051                                 __func__);
1052                         return -1;
1053                 }
1054                 dev->cx23417_mailbox = retval;
1055                 retval = cx23885_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0);
1056                 if (retval < 0) {
1057                         pr_err("ERROR: cx23417 firmware ping failed!\n");
1058                         return -1;
1059                 }
1060                 retval = cx23885_api_cmd(dev, CX2341X_ENC_GET_VERSION, 0, 1,
1061                         &version);
1062                 if (retval < 0) {
1063                         pr_err("ERROR: cx23417 firmware get encoder :version failed!\n");
1064                         return -1;
1065                 }
1066                 dprintk(1, "cx23417 firmware version is 0x%08x\n", version);
1067                 msleep(200);
1068         }
1069
1070         cx23885_codec_settings(dev);
1071         msleep(60);
1072
1073         cx23885_api_cmd(dev, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, 0,
1074                 CX23885_FIELD1_SAA7115, CX23885_FIELD2_SAA7115);
1075         cx23885_api_cmd(dev, CX2341X_ENC_SET_PLACEHOLDER, 12, 0,
1076                 CX23885_CUSTOM_EXTENSION_USR_DATA, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1077                 0, 0);
1078
1079         /* Setup to capture VBI */
1080         data[0] = 0x0001BD00;
1081         data[1] = 1;          /* frames per interrupt */
1082         data[2] = 4;          /* total bufs */
1083         data[3] = 0x91559155; /* start codes */
1084         data[4] = 0x206080C0; /* stop codes */
1085         data[5] = 6;          /* lines */
1086         data[6] = 64;         /* BPL */
1087
1088         cx23885_api_cmd(dev, CX2341X_ENC_SET_VBI_CONFIG, 7, 0, data[0], data[1],
1089                 data[2], data[3], data[4], data[5], data[6]);
1090
1091         for (i = 2; i <= 24; i++) {
1092                 int valid;
1093
1094                 valid = ((i >= 19) && (i <= 21));
1095                 cx23885_api_cmd(dev, CX2341X_ENC_SET_VBI_LINE, 5, 0, i,
1096                                 valid, 0 , 0, 0);
1097                 cx23885_api_cmd(dev, CX2341X_ENC_SET_VBI_LINE, 5, 0,
1098                                 i | 0x80000000, valid, 0, 0, 0);
1099         }
1100
1101         cx23885_api_cmd(dev, CX2341X_ENC_MUTE_AUDIO, 1, 0, CX23885_UNMUTE);
1102         msleep(60);
1103
1104         /* initialize the video input */
1105         cx23885_api_cmd(dev, CX2341X_ENC_INITIALIZE_INPUT, 0, 0);
1106         msleep(60);
1107
1108         /* Enable VIP style pixel invalidation so we work with scaled mode */
1109         mc417_memory_write(dev, 2120, 0x00000080);
1110
1111         /* start capturing to the host interface */
1112         if (startencoder) {
1113                 cx23885_api_cmd(dev, CX2341X_ENC_START_CAPTURE, 2, 0,
1114                         CX23885_MPEG_CAPTURE, CX23885_RAW_BITS_NONE);
1115                 msleep(10);
1116         }
1117
1118         return 0;
1119 }
1120
1121 /* ------------------------------------------------------------------ */
1122
1123 static int queue_setup(struct vb2_queue *q,
1124                            unsigned int *num_buffers, unsigned int *num_planes,
1125                            unsigned int sizes[], struct device *alloc_devs[])
1126 {
1127         struct cx23885_dev *dev = q->drv_priv;
1128
1129         dev->ts1.ts_packet_size  = mpeglinesize;
1130         dev->ts1.ts_packet_count = mpeglines;
1131         *num_planes = 1;
1132         sizes[0] = mpeglinesize * mpeglines;
1133         *num_buffers = mpegbufs;
1134         return 0;
1135 }
1136
1137 static int buffer_prepare(struct vb2_buffer *vb)
1138 {
1139         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1140         struct cx23885_dev *dev = vb->vb2_queue->drv_priv;
1141         struct cx23885_buffer *buf =
1142                 container_of(vbuf, struct cx23885_buffer, vb);
1143
1144         return cx23885_buf_prepare(buf, &dev->ts1);
1145 }
1146
1147 static void buffer_finish(struct vb2_buffer *vb)
1148 {
1149         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1150         struct cx23885_dev *dev = vb->vb2_queue->drv_priv;
1151         struct cx23885_buffer *buf = container_of(vbuf,
1152                 struct cx23885_buffer, vb);
1153
1154         cx23885_free_buffer(dev, buf);
1155 }
1156
1157 static void buffer_queue(struct vb2_buffer *vb)
1158 {
1159         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1160         struct cx23885_dev *dev = vb->vb2_queue->drv_priv;
1161         struct cx23885_buffer   *buf = container_of(vbuf,
1162                 struct cx23885_buffer, vb);
1163
1164         cx23885_buf_queue(&dev->ts1, buf);
1165 }
1166
1167 static int cx23885_start_streaming(struct vb2_queue *q, unsigned int count)
1168 {
1169         struct cx23885_dev *dev = q->drv_priv;
1170         struct cx23885_dmaqueue *dmaq = &dev->ts1.mpegq;
1171         unsigned long flags;
1172         int ret;
1173
1174         ret = cx23885_initialize_codec(dev, 1);
1175         if (ret == 0) {
1176                 struct cx23885_buffer *buf = list_entry(dmaq->active.next,
1177                         struct cx23885_buffer, queue);
1178
1179                 cx23885_start_dma(&dev->ts1, dmaq, buf);
1180                 return 0;
1181         }
1182         spin_lock_irqsave(&dev->slock, flags);
1183         while (!list_empty(&dmaq->active)) {
1184                 struct cx23885_buffer *buf = list_entry(dmaq->active.next,
1185                         struct cx23885_buffer, queue);
1186
1187                 list_del(&buf->queue);
1188                 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_QUEUED);
1189         }
1190         spin_unlock_irqrestore(&dev->slock, flags);
1191         return ret;
1192 }
1193
1194 static void cx23885_stop_streaming(struct vb2_queue *q)
1195 {
1196         struct cx23885_dev *dev = q->drv_priv;
1197
1198         /* stop mpeg capture */
1199         cx23885_api_cmd(dev, CX2341X_ENC_STOP_CAPTURE, 3, 0,
1200                         CX23885_END_NOW, CX23885_MPEG_CAPTURE,
1201                         CX23885_RAW_BITS_NONE);
1202
1203         msleep(500);
1204         cx23885_417_check_encoder(dev);
1205         cx23885_cancel_buffers(&dev->ts1);
1206 }
1207
1208 static const struct vb2_ops cx23885_qops = {
1209         .queue_setup    = queue_setup,
1210         .buf_prepare  = buffer_prepare,
1211         .buf_finish = buffer_finish,
1212         .buf_queue    = buffer_queue,
1213         .wait_prepare = vb2_ops_wait_prepare,
1214         .wait_finish = vb2_ops_wait_finish,
1215         .start_streaming = cx23885_start_streaming,
1216         .stop_streaming = cx23885_stop_streaming,
1217 };
1218
1219 /* ------------------------------------------------------------------ */
1220
1221 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id)
1222 {
1223         struct cx23885_dev *dev = video_drvdata(file);
1224
1225         *id = dev->tvnorm;
1226         return 0;
1227 }
1228
1229 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id id)
1230 {
1231         struct cx23885_dev *dev = video_drvdata(file);
1232         unsigned int i;
1233         int ret;
1234
1235         for (i = 0; i < ARRAY_SIZE(cx23885_tvnorms); i++)
1236                 if (id & cx23885_tvnorms[i].id)
1237                         break;
1238         if (i == ARRAY_SIZE(cx23885_tvnorms))
1239                 return -EINVAL;
1240
1241         ret = cx23885_set_tvnorm(dev, id);
1242         if (!ret)
1243                 dev->encodernorm = cx23885_tvnorms[i];
1244         return ret;
1245 }
1246
1247 static int vidioc_enum_input(struct file *file, void *priv,
1248         struct v4l2_input *i)
1249 {
1250         struct cx23885_dev *dev = video_drvdata(file);
1251         dprintk(1, "%s()\n", __func__);
1252         return cx23885_enum_input(dev, i);
1253 }
1254
1255 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1256 {
1257         return cx23885_get_input(file, priv, i);
1258 }
1259
1260 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1261 {
1262         return cx23885_set_input(file, priv, i);
1263 }
1264
1265 static int vidioc_g_tuner(struct file *file, void *priv,
1266                                 struct v4l2_tuner *t)
1267 {
1268         struct cx23885_dev *dev = video_drvdata(file);
1269
1270         if (dev->tuner_type == TUNER_ABSENT)
1271                 return -EINVAL;
1272         if (0 != t->index)
1273                 return -EINVAL;
1274         strscpy(t->name, "Television", sizeof(t->name));
1275         call_all(dev, tuner, g_tuner, t);
1276
1277         dprintk(1, "VIDIOC_G_TUNER: tuner type %d\n", t->type);
1278
1279         return 0;
1280 }
1281
1282 static int vidioc_s_tuner(struct file *file, void *priv,
1283                                 const struct v4l2_tuner *t)
1284 {
1285         struct cx23885_dev *dev = video_drvdata(file);
1286
1287         if (dev->tuner_type == TUNER_ABSENT)
1288                 return -EINVAL;
1289
1290         /* Update the A/V core */
1291         call_all(dev, tuner, s_tuner, t);
1292
1293         return 0;
1294 }
1295
1296 static int vidioc_g_frequency(struct file *file, void *priv,
1297                                 struct v4l2_frequency *f)
1298 {
1299         struct cx23885_dev *dev = video_drvdata(file);
1300
1301         if (dev->tuner_type == TUNER_ABSENT)
1302                 return -EINVAL;
1303         f->type = V4L2_TUNER_ANALOG_TV;
1304         f->frequency = dev->freq;
1305
1306         call_all(dev, tuner, g_frequency, f);
1307
1308         return 0;
1309 }
1310
1311 static int vidioc_s_frequency(struct file *file, void *priv,
1312         const struct v4l2_frequency *f)
1313 {
1314         return cx23885_set_frequency(file, priv, f);
1315 }
1316
1317 static int vidioc_querycap(struct file *file, void  *priv,
1318                                 struct v4l2_capability *cap)
1319 {
1320         struct cx23885_dev *dev = video_drvdata(file);
1321         struct cx23885_tsport  *tsport = &dev->ts1;
1322
1323         strscpy(cap->driver, dev->name, sizeof(cap->driver));
1324         strscpy(cap->card, cx23885_boards[tsport->dev->board].name,
1325                 sizeof(cap->card));
1326         sprintf(cap->bus_info, "PCIe:%s", pci_name(dev->pci));
1327         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
1328                             V4L2_CAP_STREAMING | V4L2_CAP_VBI_CAPTURE |
1329                             V4L2_CAP_AUDIO | V4L2_CAP_DEVICE_CAPS;
1330         if (dev->tuner_type != TUNER_ABSENT)
1331                 cap->capabilities |= V4L2_CAP_TUNER;
1332
1333         return 0;
1334 }
1335
1336 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
1337                                         struct v4l2_fmtdesc *f)
1338 {
1339         if (f->index != 0)
1340                 return -EINVAL;
1341
1342         f->pixelformat = V4L2_PIX_FMT_MPEG;
1343
1344         return 0;
1345 }
1346
1347 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1348                                 struct v4l2_format *f)
1349 {
1350         struct cx23885_dev *dev = video_drvdata(file);
1351
1352         f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
1353         f->fmt.pix.bytesperline = 0;
1354         f->fmt.pix.sizeimage    =
1355                 dev->ts1.ts_packet_size * dev->ts1.ts_packet_count;
1356         f->fmt.pix.colorspace   = 0;
1357         f->fmt.pix.width        = dev->ts1.width;
1358         f->fmt.pix.height       = dev->ts1.height;
1359         f->fmt.pix.field        = V4L2_FIELD_INTERLACED;
1360         dprintk(1, "VIDIOC_G_FMT: w: %d, h: %d\n",
1361                 dev->ts1.width, dev->ts1.height);
1362         return 0;
1363 }
1364
1365 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1366                                 struct v4l2_format *f)
1367 {
1368         struct cx23885_dev *dev = video_drvdata(file);
1369
1370         f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
1371         f->fmt.pix.bytesperline = 0;
1372         f->fmt.pix.sizeimage    =
1373                 dev->ts1.ts_packet_size * dev->ts1.ts_packet_count;
1374         f->fmt.pix.colorspace   = 0;
1375         f->fmt.pix.field        = V4L2_FIELD_INTERLACED;
1376         dprintk(1, "VIDIOC_TRY_FMT: w: %d, h: %d\n",
1377                 dev->ts1.width, dev->ts1.height);
1378         return 0;
1379 }
1380
1381 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1382                                 struct v4l2_format *f)
1383 {
1384         struct cx23885_dev *dev = video_drvdata(file);
1385
1386         f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
1387         f->fmt.pix.bytesperline = 0;
1388         f->fmt.pix.sizeimage    =
1389                 dev->ts1.ts_packet_size * dev->ts1.ts_packet_count;
1390         f->fmt.pix.colorspace   = 0;
1391         f->fmt.pix.field        = V4L2_FIELD_INTERLACED;
1392         dprintk(1, "VIDIOC_S_FMT: w: %d, h: %d, f: %d\n",
1393                 f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field);
1394         return 0;
1395 }
1396
1397 static int vidioc_log_status(struct file *file, void *priv)
1398 {
1399         struct cx23885_dev *dev = video_drvdata(file);
1400         char name[32 + 2];
1401
1402         snprintf(name, sizeof(name), "%s/2", dev->name);
1403         call_all(dev, core, log_status);
1404         v4l2_ctrl_handler_log_status(&dev->cxhdl.hdl, name);
1405         return 0;
1406 }
1407
1408 static const struct v4l2_file_operations mpeg_fops = {
1409         .owner         = THIS_MODULE,
1410         .open           = v4l2_fh_open,
1411         .release        = vb2_fop_release,
1412         .read           = vb2_fop_read,
1413         .poll           = vb2_fop_poll,
1414         .unlocked_ioctl = video_ioctl2,
1415         .mmap           = vb2_fop_mmap,
1416 };
1417
1418 static const struct v4l2_ioctl_ops mpeg_ioctl_ops = {
1419         .vidioc_g_std            = vidioc_g_std,
1420         .vidioc_s_std            = vidioc_s_std,
1421         .vidioc_enum_input       = vidioc_enum_input,
1422         .vidioc_g_input          = vidioc_g_input,
1423         .vidioc_s_input          = vidioc_s_input,
1424         .vidioc_g_tuner          = vidioc_g_tuner,
1425         .vidioc_s_tuner          = vidioc_s_tuner,
1426         .vidioc_g_frequency      = vidioc_g_frequency,
1427         .vidioc_s_frequency      = vidioc_s_frequency,
1428         .vidioc_querycap         = vidioc_querycap,
1429         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1430         .vidioc_g_fmt_vid_cap    = vidioc_g_fmt_vid_cap,
1431         .vidioc_try_fmt_vid_cap  = vidioc_try_fmt_vid_cap,
1432         .vidioc_s_fmt_vid_cap    = vidioc_s_fmt_vid_cap,
1433         .vidioc_reqbufs       = vb2_ioctl_reqbufs,
1434         .vidioc_prepare_buf   = vb2_ioctl_prepare_buf,
1435         .vidioc_querybuf      = vb2_ioctl_querybuf,
1436         .vidioc_qbuf          = vb2_ioctl_qbuf,
1437         .vidioc_dqbuf         = vb2_ioctl_dqbuf,
1438         .vidioc_streamon      = vb2_ioctl_streamon,
1439         .vidioc_streamoff     = vb2_ioctl_streamoff,
1440         .vidioc_log_status       = vidioc_log_status,
1441 #ifdef CONFIG_VIDEO_ADV_DEBUG
1442         .vidioc_g_chip_info      = cx23885_g_chip_info,
1443         .vidioc_g_register       = cx23885_g_register,
1444         .vidioc_s_register       = cx23885_s_register,
1445 #endif
1446 };
1447
1448 static struct video_device cx23885_mpeg_template = {
1449         .name          = "cx23885",
1450         .fops          = &mpeg_fops,
1451         .ioctl_ops     = &mpeg_ioctl_ops,
1452         .tvnorms       = CX23885_NORMS,
1453 };
1454
1455 void cx23885_417_unregister(struct cx23885_dev *dev)
1456 {
1457         dprintk(1, "%s()\n", __func__);
1458
1459         if (dev->v4l_device) {
1460                 if (video_is_registered(dev->v4l_device))
1461                         video_unregister_device(dev->v4l_device);
1462                 else
1463                         video_device_release(dev->v4l_device);
1464                 v4l2_ctrl_handler_free(&dev->cxhdl.hdl);
1465                 dev->v4l_device = NULL;
1466         }
1467 }
1468
1469 static struct video_device *cx23885_video_dev_alloc(
1470         struct cx23885_tsport *tsport,
1471         struct pci_dev *pci,
1472         struct video_device *template,
1473         char *type)
1474 {
1475         struct video_device *vfd;
1476         struct cx23885_dev *dev = tsport->dev;
1477
1478         dprintk(1, "%s()\n", __func__);
1479
1480         vfd = video_device_alloc();
1481         if (NULL == vfd)
1482                 return NULL;
1483         *vfd = *template;
1484         snprintf(vfd->name, sizeof(vfd->name), "%s (%s)",
1485                 cx23885_boards[tsport->dev->board].name, type);
1486         vfd->v4l2_dev = &dev->v4l2_dev;
1487         vfd->release = video_device_release;
1488         return vfd;
1489 }
1490
1491 int cx23885_417_register(struct cx23885_dev *dev)
1492 {
1493         /* FIXME: Port1 hardcoded here */
1494         int err = -ENODEV;
1495         struct cx23885_tsport *tsport = &dev->ts1;
1496         struct vb2_queue *q;
1497
1498         dprintk(1, "%s()\n", __func__);
1499
1500         if (cx23885_boards[dev->board].portb != CX23885_MPEG_ENCODER)
1501                 return err;
1502
1503         /* Set default TV standard */
1504         dev->encodernorm = cx23885_tvnorms[0];
1505
1506         if (dev->encodernorm.id & V4L2_STD_525_60)
1507                 tsport->height = 480;
1508         else
1509                 tsport->height = 576;
1510
1511         tsport->width = 720;
1512         dev->cxhdl.port = CX2341X_PORT_SERIAL;
1513         err = cx2341x_handler_init(&dev->cxhdl, 50);
1514         if (err)
1515                 return err;
1516         dev->cxhdl.priv = dev;
1517         dev->cxhdl.func = cx23885_api_func;
1518         cx2341x_handler_set_50hz(&dev->cxhdl, tsport->height == 576);
1519         v4l2_ctrl_add_handler(&dev->ctrl_handler, &dev->cxhdl.hdl, NULL, false);
1520
1521         /* Allocate and initialize V4L video device */
1522         dev->v4l_device = cx23885_video_dev_alloc(tsport,
1523                 dev->pci, &cx23885_mpeg_template, "mpeg");
1524         q = &dev->vb2_mpegq;
1525         q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1526         q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1527         q->gfp_flags = GFP_DMA32;
1528         q->min_buffers_needed = 2;
1529         q->drv_priv = dev;
1530         q->buf_struct_size = sizeof(struct cx23885_buffer);
1531         q->ops = &cx23885_qops;
1532         q->mem_ops = &vb2_dma_sg_memops;
1533         q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1534         q->lock = &dev->lock;
1535         q->dev = &dev->pci->dev;
1536
1537         err = vb2_queue_init(q);
1538         if (err < 0)
1539                 return err;
1540         video_set_drvdata(dev->v4l_device, dev);
1541         dev->v4l_device->lock = &dev->lock;
1542         dev->v4l_device->queue = q;
1543         dev->v4l_device->device_caps = V4L2_CAP_VIDEO_CAPTURE |
1544                                        V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
1545         if (dev->tuner_type != TUNER_ABSENT)
1546                 dev->v4l_device->device_caps |= V4L2_CAP_TUNER;
1547         err = video_register_device(dev->v4l_device,
1548                 VFL_TYPE_GRABBER, -1);
1549         if (err < 0) {
1550                 pr_info("%s: can't register mpeg device\n", dev->name);
1551                 return err;
1552         }
1553
1554         pr_info("%s: registered device %s [mpeg]\n",
1555                dev->name, video_device_node_name(dev->v4l_device));
1556
1557         /* ST: Configure the encoder parameters, but don't begin
1558          * encoding, this resolves an issue where the first time the
1559          * encoder is started video can be choppy.
1560          */
1561         cx23885_initialize_codec(dev, 0);
1562
1563         return 0;
1564 }
1565
1566 MODULE_FIRMWARE(CX23885_FIRM_IMAGE_NAME);