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/semaphore.h>
31 #include <linux/uaccess.h>
32 #include <asm/system.h>
33 #include <linux/videodev2.h>
34 #include <media/tuner.h>
35 #include <media/v4l2-common.h>
37 #include "go7007-priv.h"
41 * Wait for an interrupt to be delivered from the GO7007SB and return
42 * the associated value and data.
44 * Must be called with the hw_lock held.
46 int go7007_read_interrupt(struct go7007 *go, u16 *value, u16 *data)
48 go->interrupt_available = 0;
49 go->hpi_ops->read_interrupt(go);
50 if (wait_event_timeout(go->interrupt_waitq,
51 go->interrupt_available, 5*HZ) < 0) {
52 printk(KERN_ERR "go7007: timeout waiting for read interrupt\n");
55 if (!go->interrupt_available)
57 go->interrupt_available = 0;
58 *value = go->interrupt_value & 0xfffe;
59 *data = go->interrupt_data;
62 EXPORT_SYMBOL(go7007_read_interrupt);
65 * Read a register/address on the GO7007SB.
67 * Must be called with the hw_lock held.
69 int go7007_read_addr(struct go7007 *go, u16 addr, u16 *data)
74 if (go7007_write_interrupt(go, 0x0010, addr) < 0)
77 if (go7007_read_interrupt(go, &value, data) == 0 &&
83 EXPORT_SYMBOL(go7007_read_addr);
86 * Send the boot firmware to the encoder, which just wakes it up and lets
87 * us talk to the GPIO pins and on-board I2C adapter.
89 * Must be called with the hw_lock held.
91 static int go7007_load_encoder(struct go7007 *go)
93 const struct firmware *fw_entry;
94 char fw_name[] = "go7007fw.bin";
97 u16 intr_val, intr_data;
99 if (request_firmware(&fw_entry, fw_name, go->dev)) {
101 "go7007: unable to load firmware from file \"%s\"\n",
105 if (fw_entry->size < 16 || memcmp(fw_entry->data, "WISGO7007FW", 11)) {
106 printk(KERN_ERR "go7007: 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 printk(KERN_ERR "go7007: 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 printk(KERN_ERR "go7007: error transferring firmware\n");
133 * Boot the encoder and register the I2C adapter if requested. Do the
134 * minimum initialization necessary, since the board-specific code may
135 * still need to probe the board ID.
137 * Must NOT be called with the hw_lock held.
139 int go7007_boot_encoder(struct go7007 *go, int init_i2c)
144 ret = go7007_load_encoder(go);
150 if (go7007_i2c_init(go) < 0)
152 go->i2c_adapter_online = 1;
155 EXPORT_SYMBOL(go7007_boot_encoder);
158 * Configure any hardware-related registers in the GO7007, such as GPIO
159 * pins and bus parameters, which are board-specific. This assumes
160 * the boot firmware has already been downloaded.
162 * Must be called with the hw_lock held.
164 static int go7007_init_encoder(struct go7007 *go)
166 if (go->board_info->audio_flags & GO7007_AUDIO_I2S_MASTER) {
167 go7007_write_addr(go, 0x1000, 0x0811);
168 go7007_write_addr(go, 0x1000, 0x0c11);
170 if (go->board_id == GO7007_BOARDID_MATRIX_REV) {
171 /* Set GPIO pin 0 to be an output (audio clock control) */
172 go7007_write_addr(go, 0x3c82, 0x0001);
173 go7007_write_addr(go, 0x3c80, 0x00fe);
179 * Send the boot firmware to the GO7007 and configure the registers. This
180 * is the only way to stop the encoder once it has started streaming video.
182 * Must be called with the hw_lock held.
184 int go7007_reset_encoder(struct go7007 *go)
186 if (go7007_load_encoder(go) < 0)
188 return go7007_init_encoder(go);
192 * Attempt to instantiate an I2C client by ID, probably loading a module.
194 static int init_i2c_module(struct i2c_adapter *adapter, int id, int addr)
199 case I2C_DRIVERID_WIS_SAA7115:
200 modname = "wis-saa7115";
202 case I2C_DRIVERID_WIS_SAA7113:
203 modname = "wis-saa7113";
205 case I2C_DRIVERID_WIS_UDA1342:
206 modname = "wis-uda1342";
208 case I2C_DRIVERID_WIS_SONY_TUNER:
209 modname = "wis-sony-tuner";
211 case I2C_DRIVERID_WIS_TW9903:
212 modname = "wis-tw9903";
214 case I2C_DRIVERID_WIS_TW2804:
215 modname = "wis-tw2804";
217 case I2C_DRIVERID_WIS_OV7640:
218 modname = "wis-ov7640";
220 case I2C_DRIVERID_S2250:
221 modname = "s2250-board";
228 request_module(modname);
229 if (wis_i2c_probe_device(adapter, id, addr) == 1)
233 "go7007: probing for module %s failed\n", modname);
236 "go7007: sensor %u seems to be unsupported!\n", id);
241 * Finalize the GO7007 hardware setup, register the on-board I2C adapter
242 * (if used on this board), load the I2C client driver for the sensor
243 * (SAA7115 or whatever) and other devices, and register the ALSA and V4L2
246 * Must NOT be called with the hw_lock held.
248 int go7007_register_encoder(struct go7007 *go)
252 printk(KERN_INFO "go7007: registering new %s\n", go->name);
255 ret = go7007_init_encoder(go);
260 if (!go->i2c_adapter_online &&
261 go->board_info->flags & GO7007_BOARD_USE_ONBOARD_I2C) {
262 if (go7007_i2c_init(go) < 0)
264 go->i2c_adapter_online = 1;
266 if (go->i2c_adapter_online) {
267 for (i = 0; i < go->board_info->num_i2c_devs; ++i)
268 init_i2c_module(&go->i2c_adapter,
269 go->board_info->i2c_devs[i].id,
270 go->board_info->i2c_devs[i].addr);
271 if (go->board_id == GO7007_BOARDID_ADLINK_MPG24)
272 i2c_clients_command(&go->i2c_adapter,
273 DECODER_SET_CHANNEL, &go->channel_number);
275 if (go->board_info->flags & GO7007_BOARD_HAS_AUDIO) {
276 go->audio_enabled = 1;
279 return go7007_v4l2_init(go);
281 EXPORT_SYMBOL(go7007_register_encoder);
284 * Send the encode firmware to the encoder, which will cause it
285 * to immediately start delivering the video and audio streams.
287 * Must be called with the hw_lock held.
289 int go7007_start_encoder(struct go7007 *go)
292 int fw_len, rv = 0, i;
293 u16 intr_val, intr_data;
295 go->modet_enable = 0;
297 for (i = 0; i < 4; ++i) {
298 if (go->modet[i].enable) {
299 go->modet_enable = 1;
302 go->modet[i].pixel_threshold = 32767;
303 go->modet[i].motion_threshold = 32767;
304 go->modet[i].mb_threshold = 32767;
307 if (go7007_construct_fw_image(go, &fw, &fw_len) < 0)
310 if (go7007_send_firmware(go, fw, fw_len) < 0 ||
311 go7007_read_interrupt(go, &intr_val, &intr_data) < 0) {
312 printk(KERN_ERR "go7007: error transferring firmware\n");
317 go->state = STATE_DATA;
318 go->parse_length = 0;
320 if (go7007_stream_start(go) < 0) {
321 printk(KERN_ERR "go7007: error starting stream transfer\n");
332 * Store a byte in the current video buffer, if there is one.
334 static inline void store_byte(struct go7007_buffer *gobuf, u8 byte)
336 if (gobuf != NULL && gobuf->bytesused < GO7007_BUF_SIZE) {
337 unsigned int pgidx = gobuf->offset >> PAGE_SHIFT;
338 unsigned int pgoff = gobuf->offset & ~PAGE_MASK;
340 *((u8 *)page_address(gobuf->pages[pgidx]) + pgoff) = byte;
347 * Deliver the last video buffer and get a new one to start writing to.
349 static void frame_boundary(struct go7007 *go)
351 struct go7007_buffer *gobuf;
354 if (go->active_buf) {
355 if (go->active_buf->modet_active) {
356 if (go->active_buf->bytesused + 216 < GO7007_BUF_SIZE) {
357 for (i = 0; i < 216; ++i)
358 store_byte(go->active_buf,
360 go->active_buf->bytesused -= 216;
362 go->active_buf->modet_active = 0;
364 go->active_buf->state = BUF_STATE_DONE;
365 wake_up_interruptible(&go->frame_waitq);
366 go->active_buf = NULL;
368 list_for_each_entry(gobuf, &go->stream, stream)
369 if (gobuf->state == BUF_STATE_QUEUED) {
370 gobuf->seq = go->next_seq;
371 do_gettimeofday(&gobuf->timestamp);
372 go->active_buf = gobuf;
378 static void write_bitmap_word(struct go7007 *go)
380 int x, y, i, stride = ((go->width >> 4) + 7) >> 3;
382 for (i = 0; i < 16; ++i) {
383 y = (((go->parse_length - 1) << 3) + i) / (go->width >> 4);
384 x = (((go->parse_length - 1) << 3) + i) % (go->width >> 4);
385 go->active_map[stride * y + (x >> 3)] |=
386 (go->modet_word & 1) << (x & 0x7);
387 go->modet_word >>= 1;
392 * Parse a chunk of the video stream into frames. The frames are not
393 * delimited by the hardware, so we have to parse the frame boundaries
394 * based on the type of video stream we're receiving.
396 void go7007_parse_video_stream(struct go7007 *go, u8 *buf, int length)
398 int i, seq_start_code = -1, frame_start_code = -1;
400 spin_lock(&go->spinlock);
402 switch (go->format) {
403 case GO7007_FORMAT_MPEG4:
404 seq_start_code = 0xB0;
405 frame_start_code = 0xB6;
407 case GO7007_FORMAT_MPEG1:
408 case GO7007_FORMAT_MPEG2:
409 seq_start_code = 0xB3;
410 frame_start_code = 0x00;
414 for (i = 0; i < length; ++i) {
415 if (go->active_buf != NULL &&
416 go->active_buf->bytesused >= GO7007_BUF_SIZE - 3) {
417 printk(KERN_DEBUG "go7007: dropping oversized frame\n");
418 go->active_buf->offset -= go->active_buf->bytesused;
419 go->active_buf->bytesused = 0;
420 go->active_buf->modet_active = 0;
421 go->active_buf = NULL;
428 go->state = STATE_00;
431 go->state = STATE_FF;
434 store_byte(go->active_buf, buf[i]);
441 go->state = STATE_00_00;
444 store_byte(go->active_buf, 0x00);
445 go->state = STATE_FF;
448 store_byte(go->active_buf, 0x00);
449 store_byte(go->active_buf, buf[i]);
450 go->state = STATE_DATA;
457 store_byte(go->active_buf, 0x00);
458 /* go->state remains STATE_00_00 */
461 go->state = STATE_00_00_01;
464 store_byte(go->active_buf, 0x00);
465 store_byte(go->active_buf, 0x00);
466 go->state = STATE_FF;
469 store_byte(go->active_buf, 0x00);
470 store_byte(go->active_buf, 0x00);
471 store_byte(go->active_buf, buf[i]);
472 go->state = STATE_DATA;
477 /* If this is the start of a new MPEG frame,
478 * get a new buffer */
479 if ((go->format == GO7007_FORMAT_MPEG1 ||
480 go->format == GO7007_FORMAT_MPEG2 ||
481 go->format == GO7007_FORMAT_MPEG4) &&
482 (buf[i] == seq_start_code ||
483 buf[i] == 0xB8 || /* GOP code */
484 buf[i] == frame_start_code)) {
485 if (go->active_buf == NULL || go->seen_frame)
487 if (buf[i] == frame_start_code) {
488 if (go->active_buf != NULL)
489 go->active_buf->frame_offset =
490 go->active_buf->offset;
496 /* Handle any special chunk types, or just write the
497 * start code to the (potentially new) buffer */
499 case 0xF5: /* timestamp */
500 go->parse_length = 12;
501 go->state = STATE_UNPARSED;
504 go->state = STATE_VBI_LEN_A;
506 case 0xF8: /* MD map */
507 go->parse_length = 0;
508 memset(go->active_map, 0,
509 sizeof(go->active_map));
510 go->state = STATE_MODET_MAP;
512 case 0xFF: /* Potential JPEG start code */
513 store_byte(go->active_buf, 0x00);
514 store_byte(go->active_buf, 0x00);
515 store_byte(go->active_buf, 0x01);
516 go->state = STATE_FF;
519 store_byte(go->active_buf, 0x00);
520 store_byte(go->active_buf, 0x00);
521 store_byte(go->active_buf, 0x01);
522 store_byte(go->active_buf, buf[i]);
523 go->state = STATE_DATA;
530 store_byte(go->active_buf, 0xFF);
531 go->state = STATE_00;
534 store_byte(go->active_buf, 0xFF);
535 /* go->state remains STATE_FF */
538 if (go->format == GO7007_FORMAT_MJPEG)
542 store_byte(go->active_buf, 0xFF);
543 store_byte(go->active_buf, buf[i]);
544 go->state = STATE_DATA;
548 case STATE_VBI_LEN_A:
549 go->parse_length = buf[i] << 8;
550 go->state = STATE_VBI_LEN_B;
552 case STATE_VBI_LEN_B:
553 go->parse_length |= buf[i];
554 if (go->parse_length > 0)
555 go->state = STATE_UNPARSED;
557 go->state = STATE_DATA;
559 case STATE_MODET_MAP:
560 if (go->parse_length < 204) {
561 if (go->parse_length & 1) {
562 go->modet_word |= buf[i];
563 write_bitmap_word(go);
565 go->modet_word = buf[i] << 8;
566 } else if (go->parse_length == 207 && go->active_buf) {
567 go->active_buf->modet_active = buf[i];
569 if (++go->parse_length == 208)
570 go->state = STATE_DATA;
573 if (--go->parse_length == 0)
574 go->state = STATE_DATA;
579 spin_unlock(&go->spinlock);
581 EXPORT_SYMBOL(go7007_parse_video_stream);
584 * Allocate a new go7007 struct. Used by the hardware-specific probe.
586 struct go7007 *go7007_alloc(struct go7007_board_info *board, struct device *dev)
591 go = kmalloc(sizeof(struct go7007), GFP_KERNEL);
595 go->board_info = board;
598 go->channel_number = 0;
600 init_MUTEX(&go->hw_lock);
601 init_waitqueue_head(&go->frame_waitq);
602 spin_lock_init(&go->spinlock);
603 go->video_dev = NULL;
605 go->status = STATUS_INIT;
606 memset(&go->i2c_adapter, 0, sizeof(go->i2c_adapter));
607 go->i2c_adapter_online = 0;
608 go->interrupt_available = 0;
609 init_waitqueue_head(&go->interrupt_waitq);
612 if (board->sensor_flags & GO7007_SENSOR_TV) {
613 go->standard = GO7007_STD_NTSC;
616 go->sensor_framerate = 30000;
618 go->standard = GO7007_STD_OTHER;
619 go->width = board->sensor_width;
620 go->height = board->sensor_height;
621 go->sensor_framerate = board->sensor_framerate;
623 go->encoder_v_offset = board->sensor_v_offset;
624 go->encoder_h_offset = board->sensor_h_offset;
625 go->encoder_h_halve = 0;
626 go->encoder_v_halve = 0;
627 go->encoder_subsample = 0;
629 go->format = GO7007_FORMAT_MJPEG;
630 go->bitrate = 1500000;
633 go->aspect_ratio = GO7007_RATIO_1_1;
637 go->repeat_seqhead = 0;
638 go->seq_header_enable = 0;
639 go->gop_header_enable = 0;
641 go->interlace_coding = 0;
642 for (i = 0; i < 4; ++i)
643 go->modet[i].enable = 0;;
644 for (i = 0; i < 1624; ++i)
645 go->modet_map[i] = 0;
646 go->audio_deliver = NULL;
647 go->audio_enabled = 0;
648 INIT_LIST_HEAD(&go->stream);
652 EXPORT_SYMBOL(go7007_alloc);
655 * Detach and unregister the encoder. The go7007 struct won't be freed
656 * until v4l2 finishes releasing its resources and all associated fds are
657 * closed by applications.
659 void go7007_remove(struct go7007 *go)
661 if (go->i2c_adapter_online) {
662 if (i2c_del_adapter(&go->i2c_adapter) == 0)
663 go->i2c_adapter_online = 0;
666 "go7007: error removing I2C adapter!\n");
669 if (go->audio_enabled)
670 go7007_snd_remove(go);
671 go7007_v4l2_remove(go);
673 EXPORT_SYMBOL(go7007_remove);
675 MODULE_LICENSE("GPL v2");