2 * Copyright (C) 2005-2006 Micronas USA Inc.
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License (Version 2) as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software Foundation,
15 * Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/delay.h>
21 #include <linux/sched.h>
22 #include <linux/spinlock.h>
23 #include <linux/unistd.h>
24 #include <linux/time.h>
26 #include <linux/vmalloc.h>
27 #include <linux/device.h>
28 #include <linux/i2c.h>
29 #include <linux/firmware.h>
30 #include <linux/mutex.h>
31 #include <linux/uaccess.h>
32 #include <linux/slab.h>
33 #include <asm/system.h>
34 #include <linux/videodev2.h>
35 #include <media/tuner.h>
36 #include <media/v4l2-common.h>
38 #include "go7007-priv.h"
42 * Wait for an interrupt to be delivered from the GO7007SB and return
43 * the associated value and data.
45 * Must be called with the hw_lock held.
47 int go7007_read_interrupt(struct go7007
*go
, u16
*value
, u16
*data
)
49 go
->interrupt_available
= 0;
50 go
->hpi_ops
->read_interrupt(go
);
51 if (wait_event_timeout(go
->interrupt_waitq
,
52 go
->interrupt_available
, 5*HZ
) < 0) {
53 v4l2_err(&go
->v4l2_dev
, "timeout waiting for read interrupt\n");
56 if (!go
->interrupt_available
)
58 go
->interrupt_available
= 0;
59 *value
= go
->interrupt_value
& 0xfffe;
60 *data
= go
->interrupt_data
;
63 EXPORT_SYMBOL(go7007_read_interrupt
);
66 * Read a register/address on the GO7007SB.
68 * Must be called with the hw_lock held.
70 int go7007_read_addr(struct go7007
*go
, u16 addr
, u16
*data
)
75 if (go7007_write_interrupt(go
, 0x0010, addr
) < 0)
78 if (go7007_read_interrupt(go
, &value
, data
) == 0 &&
84 EXPORT_SYMBOL(go7007_read_addr
);
87 * Send the boot firmware to the encoder, which just wakes it up and lets
88 * us talk to the GPIO pins and on-board I2C adapter.
90 * Must be called with the hw_lock held.
92 static int go7007_load_encoder(struct go7007
*go
)
94 const struct firmware
*fw_entry
;
95 char fw_name
[] = "go7007fw.bin";
98 u16 intr_val
, intr_data
;
100 if (request_firmware(&fw_entry
, fw_name
, go
->dev
)) {
101 v4l2_err(go
, "unable to load firmware from file "
102 "\"%s\"\n", fw_name
);
105 if (fw_entry
->size
< 16 || memcmp(fw_entry
->data
, "WISGO7007FW", 11)) {
106 v4l2_err(go
, "file \"%s\" does not appear to be "
107 "go7007 firmware\n", fw_name
);
108 release_firmware(fw_entry
);
111 fw_len
= fw_entry
->size
- 16;
112 bounce
= kmalloc(fw_len
, GFP_KERNEL
);
113 if (bounce
== NULL
) {
114 v4l2_err(go
, "unable to allocate %d bytes for "
115 "firmware transfer\n", fw_len
);
116 release_firmware(fw_entry
);
119 memcpy(bounce
, fw_entry
->data
+ 16, fw_len
);
120 release_firmware(fw_entry
);
121 if (go7007_interface_reset(go
) < 0 ||
122 go7007_send_firmware(go
, bounce
, fw_len
) < 0 ||
123 go7007_read_interrupt(go
, &intr_val
, &intr_data
) < 0 ||
124 (intr_val
& ~0x1) != 0x5a5a) {
125 v4l2_err(go
, "error transferring firmware\n");
132 MODULE_FIRMWARE("go7007fw.bin");
135 * Boot the encoder and register the I2C adapter if requested. Do the
136 * minimum initialization necessary, since the board-specific code may
137 * still need to probe the board ID.
139 * Must NOT be called with the hw_lock held.
141 int go7007_boot_encoder(struct go7007
*go
, int init_i2c
)
145 mutex_lock(&go
->hw_lock
);
146 ret
= go7007_load_encoder(go
);
147 mutex_unlock(&go
->hw_lock
);
152 if (go7007_i2c_init(go
) < 0)
154 go
->i2c_adapter_online
= 1;
157 EXPORT_SYMBOL(go7007_boot_encoder
);
160 * Configure any hardware-related registers in the GO7007, such as GPIO
161 * pins and bus parameters, which are board-specific. This assumes
162 * the boot firmware has already been downloaded.
164 * Must be called with the hw_lock held.
166 static int go7007_init_encoder(struct go7007
*go
)
168 if (go
->board_info
->audio_flags
& GO7007_AUDIO_I2S_MASTER
) {
169 go7007_write_addr(go
, 0x1000, 0x0811);
170 go7007_write_addr(go
, 0x1000, 0x0c11);
172 if (go
->board_id
== GO7007_BOARDID_MATRIX_REV
) {
173 /* Set GPIO pin 0 to be an output (audio clock control) */
174 go7007_write_addr(go
, 0x3c82, 0x0001);
175 go7007_write_addr(go
, 0x3c80, 0x00fe);
181 * Send the boot firmware to the GO7007 and configure the registers. This
182 * is the only way to stop the encoder once it has started streaming video.
184 * Must be called with the hw_lock held.
186 int go7007_reset_encoder(struct go7007
*go
)
188 if (go7007_load_encoder(go
) < 0)
190 return go7007_init_encoder(go
);
194 * Attempt to instantiate an I2C client by ID, probably loading a module.
196 static int init_i2c_module(struct i2c_adapter
*adapter
, const char *type
,
199 struct go7007
*go
= i2c_get_adapdata(adapter
);
200 struct v4l2_device
*v4l2_dev
= &go
->v4l2_dev
;
202 if (v4l2_i2c_new_subdev(v4l2_dev
, adapter
, NULL
, type
, addr
, NULL
))
205 printk(KERN_INFO
"go7007: probing for module i2c:%s failed\n", type
);
210 * Finalize the GO7007 hardware setup, register the on-board I2C adapter
211 * (if used on this board), load the I2C client driver for the sensor
212 * (SAA7115 or whatever) and other devices, and register the ALSA and V4L2
215 * Must NOT be called with the hw_lock held.
217 int go7007_register_encoder(struct go7007
*go
)
221 printk(KERN_INFO
"go7007: registering new %s\n", go
->name
);
223 mutex_lock(&go
->hw_lock
);
224 ret
= go7007_init_encoder(go
);
225 mutex_unlock(&go
->hw_lock
);
229 /* v4l2 init must happen before i2c subdevs */
230 ret
= go7007_v4l2_init(go
);
234 if (!go
->i2c_adapter_online
&&
235 go
->board_info
->flags
& GO7007_BOARD_USE_ONBOARD_I2C
) {
236 if (go7007_i2c_init(go
) < 0)
238 go
->i2c_adapter_online
= 1;
240 if (go
->i2c_adapter_online
) {
241 for (i
= 0; i
< go
->board_info
->num_i2c_devs
; ++i
)
242 init_i2c_module(&go
->i2c_adapter
,
243 go
->board_info
->i2c_devs
[i
].type
,
244 go
->board_info
->i2c_devs
[i
].addr
);
245 if (go
->board_id
== GO7007_BOARDID_ADLINK_MPG24
)
246 i2c_clients_command(&go
->i2c_adapter
,
247 DECODER_SET_CHANNEL
, &go
->channel_number
);
249 if (go
->board_info
->flags
& GO7007_BOARD_HAS_AUDIO
) {
250 go
->audio_enabled
= 1;
255 EXPORT_SYMBOL(go7007_register_encoder
);
258 * Send the encode firmware to the encoder, which will cause it
259 * to immediately start delivering the video and audio streams.
261 * Must be called with the hw_lock held.
263 int go7007_start_encoder(struct go7007
*go
)
266 int fw_len
, rv
= 0, i
;
267 u16 intr_val
, intr_data
;
269 go
->modet_enable
= 0;
271 for (i
= 0; i
< 4; ++i
) {
272 if (go
->modet
[i
].enable
) {
273 go
->modet_enable
= 1;
276 go
->modet
[i
].pixel_threshold
= 32767;
277 go
->modet
[i
].motion_threshold
= 32767;
278 go
->modet
[i
].mb_threshold
= 32767;
281 if (go7007_construct_fw_image(go
, &fw
, &fw_len
) < 0)
284 if (go7007_send_firmware(go
, fw
, fw_len
) < 0 ||
285 go7007_read_interrupt(go
, &intr_val
, &intr_data
) < 0) {
286 v4l2_err(&go
->v4l2_dev
, "error transferring firmware\n");
291 go
->state
= STATE_DATA
;
292 go
->parse_length
= 0;
294 if (go7007_stream_start(go
) < 0) {
295 v4l2_err(&go
->v4l2_dev
, "error starting stream transfer\n");
306 * Store a byte in the current video buffer, if there is one.
308 static inline void store_byte(struct go7007_buffer
*gobuf
, u8 byte
)
310 if (gobuf
!= NULL
&& gobuf
->bytesused
< GO7007_BUF_SIZE
) {
311 unsigned int pgidx
= gobuf
->offset
>> PAGE_SHIFT
;
312 unsigned int pgoff
= gobuf
->offset
& ~PAGE_MASK
;
314 *((u8
*)page_address(gobuf
->pages
[pgidx
]) + pgoff
) = byte
;
321 * Deliver the last video buffer and get a new one to start writing to.
323 static void frame_boundary(struct go7007
*go
)
325 struct go7007_buffer
*gobuf
;
328 if (go
->active_buf
) {
329 if (go
->active_buf
->modet_active
) {
330 if (go
->active_buf
->bytesused
+ 216 < GO7007_BUF_SIZE
) {
331 for (i
= 0; i
< 216; ++i
)
332 store_byte(go
->active_buf
,
334 go
->active_buf
->bytesused
-= 216;
336 go
->active_buf
->modet_active
= 0;
338 go
->active_buf
->state
= BUF_STATE_DONE
;
339 wake_up_interruptible(&go
->frame_waitq
);
340 go
->active_buf
= NULL
;
342 list_for_each_entry(gobuf
, &go
->stream
, stream
)
343 if (gobuf
->state
== BUF_STATE_QUEUED
) {
344 gobuf
->seq
= go
->next_seq
;
345 do_gettimeofday(&gobuf
->timestamp
);
346 go
->active_buf
= gobuf
;
352 static void write_bitmap_word(struct go7007
*go
)
354 int x
, y
, i
, stride
= ((go
->width
>> 4) + 7) >> 3;
356 for (i
= 0; i
< 16; ++i
) {
357 y
= (((go
->parse_length
- 1) << 3) + i
) / (go
->width
>> 4);
358 x
= (((go
->parse_length
- 1) << 3) + i
) % (go
->width
>> 4);
359 if (stride
* y
+ (x
>> 3) < sizeof(go
->active_map
))
360 go
->active_map
[stride
* y
+ (x
>> 3)] |=
361 (go
->modet_word
& 1) << (x
& 0x7);
362 go
->modet_word
>>= 1;
367 * Parse a chunk of the video stream into frames. The frames are not
368 * delimited by the hardware, so we have to parse the frame boundaries
369 * based on the type of video stream we're receiving.
371 void go7007_parse_video_stream(struct go7007
*go
, u8
*buf
, int length
)
373 int i
, seq_start_code
= -1, frame_start_code
= -1;
375 spin_lock(&go
->spinlock
);
377 switch (go
->format
) {
378 case GO7007_FORMAT_MPEG4
:
379 seq_start_code
= 0xB0;
380 frame_start_code
= 0xB6;
382 case GO7007_FORMAT_MPEG1
:
383 case GO7007_FORMAT_MPEG2
:
384 seq_start_code
= 0xB3;
385 frame_start_code
= 0x00;
389 for (i
= 0; i
< length
; ++i
) {
390 if (go
->active_buf
!= NULL
&&
391 go
->active_buf
->bytesused
>= GO7007_BUF_SIZE
- 3) {
392 v4l2_info(&go
->v4l2_dev
, "dropping oversized frame\n");
393 go
->active_buf
->offset
-= go
->active_buf
->bytesused
;
394 go
->active_buf
->bytesused
= 0;
395 go
->active_buf
->modet_active
= 0;
396 go
->active_buf
= NULL
;
403 go
->state
= STATE_00
;
406 go
->state
= STATE_FF
;
409 store_byte(go
->active_buf
, buf
[i
]);
416 go
->state
= STATE_00_00
;
419 store_byte(go
->active_buf
, 0x00);
420 go
->state
= STATE_FF
;
423 store_byte(go
->active_buf
, 0x00);
424 store_byte(go
->active_buf
, buf
[i
]);
425 go
->state
= STATE_DATA
;
432 store_byte(go
->active_buf
, 0x00);
433 /* go->state remains STATE_00_00 */
436 go
->state
= STATE_00_00_01
;
439 store_byte(go
->active_buf
, 0x00);
440 store_byte(go
->active_buf
, 0x00);
441 go
->state
= STATE_FF
;
444 store_byte(go
->active_buf
, 0x00);
445 store_byte(go
->active_buf
, 0x00);
446 store_byte(go
->active_buf
, buf
[i
]);
447 go
->state
= STATE_DATA
;
452 if (buf
[i
] == 0xF8 && go
->modet_enable
== 0) {
453 /* MODET start code, but MODET not enabled */
454 store_byte(go
->active_buf
, 0x00);
455 store_byte(go
->active_buf
, 0x00);
456 store_byte(go
->active_buf
, 0x01);
457 store_byte(go
->active_buf
, 0xF8);
458 go
->state
= STATE_DATA
;
461 /* If this is the start of a new MPEG frame,
462 * get a new buffer */
463 if ((go
->format
== GO7007_FORMAT_MPEG1
||
464 go
->format
== GO7007_FORMAT_MPEG2
||
465 go
->format
== GO7007_FORMAT_MPEG4
) &&
466 (buf
[i
] == seq_start_code
||
467 buf
[i
] == 0xB8 || /* GOP code */
468 buf
[i
] == frame_start_code
)) {
469 if (go
->active_buf
== NULL
|| go
->seen_frame
)
471 if (buf
[i
] == frame_start_code
) {
472 if (go
->active_buf
!= NULL
)
473 go
->active_buf
->frame_offset
=
474 go
->active_buf
->offset
;
480 /* Handle any special chunk types, or just write the
481 * start code to the (potentially new) buffer */
483 case 0xF5: /* timestamp */
484 go
->parse_length
= 12;
485 go
->state
= STATE_UNPARSED
;
488 go
->state
= STATE_VBI_LEN_A
;
490 case 0xF8: /* MD map */
491 go
->parse_length
= 0;
492 memset(go
->active_map
, 0,
493 sizeof(go
->active_map
));
494 go
->state
= STATE_MODET_MAP
;
496 case 0xFF: /* Potential JPEG start code */
497 store_byte(go
->active_buf
, 0x00);
498 store_byte(go
->active_buf
, 0x00);
499 store_byte(go
->active_buf
, 0x01);
500 go
->state
= STATE_FF
;
503 store_byte(go
->active_buf
, 0x00);
504 store_byte(go
->active_buf
, 0x00);
505 store_byte(go
->active_buf
, 0x01);
506 store_byte(go
->active_buf
, buf
[i
]);
507 go
->state
= STATE_DATA
;
514 store_byte(go
->active_buf
, 0xFF);
515 go
->state
= STATE_00
;
518 store_byte(go
->active_buf
, 0xFF);
519 /* go->state remains STATE_FF */
522 if (go
->format
== GO7007_FORMAT_MJPEG
)
526 store_byte(go
->active_buf
, 0xFF);
527 store_byte(go
->active_buf
, buf
[i
]);
528 go
->state
= STATE_DATA
;
532 case STATE_VBI_LEN_A
:
533 go
->parse_length
= buf
[i
] << 8;
534 go
->state
= STATE_VBI_LEN_B
;
536 case STATE_VBI_LEN_B
:
537 go
->parse_length
|= buf
[i
];
538 if (go
->parse_length
> 0)
539 go
->state
= STATE_UNPARSED
;
541 go
->state
= STATE_DATA
;
543 case STATE_MODET_MAP
:
544 if (go
->parse_length
< 204) {
545 if (go
->parse_length
& 1) {
546 go
->modet_word
|= buf
[i
];
547 write_bitmap_word(go
);
549 go
->modet_word
= buf
[i
] << 8;
550 } else if (go
->parse_length
== 207 && go
->active_buf
) {
551 go
->active_buf
->modet_active
= buf
[i
];
553 if (++go
->parse_length
== 208)
554 go
->state
= STATE_DATA
;
557 if (--go
->parse_length
== 0)
558 go
->state
= STATE_DATA
;
563 spin_unlock(&go
->spinlock
);
565 EXPORT_SYMBOL(go7007_parse_video_stream
);
568 * Allocate a new go7007 struct. Used by the hardware-specific probe.
570 struct go7007
*go7007_alloc(struct go7007_board_info
*board
, struct device
*dev
)
575 go
= kmalloc(sizeof(struct go7007
), GFP_KERNEL
);
579 go
->board_info
= board
;
582 go
->channel_number
= 0;
584 mutex_init(&go
->hw_lock
);
585 init_waitqueue_head(&go
->frame_waitq
);
586 spin_lock_init(&go
->spinlock
);
587 go
->video_dev
= NULL
;
589 go
->status
= STATUS_INIT
;
590 memset(&go
->i2c_adapter
, 0, sizeof(go
->i2c_adapter
));
591 go
->i2c_adapter_online
= 0;
592 go
->interrupt_available
= 0;
593 init_waitqueue_head(&go
->interrupt_waitq
);
596 if (board
->sensor_flags
& GO7007_SENSOR_TV
) {
597 go
->standard
= GO7007_STD_NTSC
;
600 go
->sensor_framerate
= 30000;
602 go
->standard
= GO7007_STD_OTHER
;
603 go
->width
= board
->sensor_width
;
604 go
->height
= board
->sensor_height
;
605 go
->sensor_framerate
= board
->sensor_framerate
;
607 go
->encoder_v_offset
= board
->sensor_v_offset
;
608 go
->encoder_h_offset
= board
->sensor_h_offset
;
609 go
->encoder_h_halve
= 0;
610 go
->encoder_v_halve
= 0;
611 go
->encoder_subsample
= 0;
613 go
->format
= GO7007_FORMAT_MJPEG
;
614 go
->bitrate
= 1500000;
617 go
->aspect_ratio
= GO7007_RATIO_1_1
;
621 go
->repeat_seqhead
= 0;
622 go
->seq_header_enable
= 0;
623 go
->gop_header_enable
= 0;
625 go
->interlace_coding
= 0;
626 for (i
= 0; i
< 4; ++i
)
627 go
->modet
[i
].enable
= 0;;
628 for (i
= 0; i
< 1624; ++i
)
629 go
->modet_map
[i
] = 0;
630 go
->audio_deliver
= NULL
;
631 go
->audio_enabled
= 0;
632 INIT_LIST_HEAD(&go
->stream
);
636 EXPORT_SYMBOL(go7007_alloc
);
639 * Detach and unregister the encoder. The go7007 struct won't be freed
640 * until v4l2 finishes releasing its resources and all associated fds are
641 * closed by applications.
643 void go7007_remove(struct go7007
*go
)
645 if (go
->i2c_adapter_online
) {
646 if (i2c_del_adapter(&go
->i2c_adapter
) == 0)
647 go
->i2c_adapter_online
= 0;
649 v4l2_err(&go
->v4l2_dev
,
650 "error removing I2C adapter!\n");
653 if (go
->audio_enabled
)
654 go7007_snd_remove(go
);
655 go7007_v4l2_remove(go
);
657 EXPORT_SYMBOL(go7007_remove
);
659 MODULE_LICENSE("GPL v2");