On Fri, Mar 15, 2013 at 09:40:35AM -0300, Ezequiel Garcia wrote: > On Thu, Mar 14, 2013 at 03:07:01PM +0100, Jon Arne Jørgensen wrote: > > This file is responsible for all communication with the video hardware > > and also starting and stopping the capture. > > > > It also contains the setup and handling of the usb ISOCHRONOUS transfers. > > > > Signed-off-by: Jon Arne Jørgensen <jonarne@xxxxxxxxxx> > > --- > > drivers/media/usb/smi2021/smi2021_video.c | 543 ++++++++++++++++++++++++++++++ > > 1 file changed, 543 insertions(+) > > create mode 100644 drivers/media/usb/smi2021/smi2021_video.c > > > > diff --git a/drivers/media/usb/smi2021/smi2021_video.c b/drivers/media/usb/smi2021/smi2021_video.c > > new file mode 100644 > > index 0000000..48f3e80 > > --- /dev/null > > +++ b/drivers/media/usb/smi2021/smi2021_video.c > > @@ -0,0 +1,543 @@ > > +/******************************************************************************* > > + * smi2021_video.c * > > + * * > > + * USB Driver for SMI2021 - EasyCAP * > > + * USB ID 1c88:003c * > > + * * > > + * ***************************************************************************** > > + * > > + * Copyright 2011-2013 Jon Arne Jørgensen > > + * <jonjon.arnearne--a.t--gmail.com> > > + * > > + * Copyright 2011, 2012 Tony Brown, Michal Demin, Jeffry Johnston > > + * > > + * This file is part of SMI2021x > > + * http://code.google.com/p/easycap-somagic-linux/ > > + * > > + * This program is free software: you can redistribute it and/or modify > > + * it under the terms of the GNU General Public License as published by > > + * the Free Software Foundation, either version 2 of the License, or > > + * (at your option) any later version. > > + * > > + * This program is distributed in the hope that it will be useful, > > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > > + * GNU General Public License for more details. > > + * > > + * You should have received a copy of the GNU General Public License > > + * along with this program; if not, see <http://www.gnu.org/licenses/>. > > + * > > + * This driver is heavily influensed by the STK1160 driver. > > + * Copyright (C) 2012 Ezequiel Garcia > > + * <elezegarcia--a.t--gmail.com> > > + * > > + */ > > + > > +#include "smi2021.h" > > + > > +static void print_usb_err(struct smi2021_dev *dev, int packet, int status) > > +{ > > + char *errmsg; > > + > > + switch (status) { > > + case -ENOENT: > > + errmsg = "unlinked synchronuously"; > > + break; > > + case -ECONNRESET: > > + errmsg = "unlinked asynchronuously"; > > + break; > > + case -ENOSR: > > + errmsg = "Buffer error (overrun)"; > > + break; > > + case -EPIPE: > > + errmsg = "Stalled (device not responding)"; > > + break; > > + case -EOVERFLOW: > > + errmsg = "Babble (bad cable?)"; > > + break; > > + case -EPROTO: > > + errmsg = "Bit-stuff error (bad cable?)"; > > + break; > > + case -EILSEQ: > > + errmsg = "CRC/Timeout (could be anything)"; > > + break; > > + case -ETIME: > > + errmsg = "Device does not respond"; > > + break; > > + default: > > + errmsg = "Unknown"; > > + } > > + > > + if (packet < 0) { > > + printk_ratelimited(KERN_WARNING "Urb status %d [%s]\n", > > + status, errmsg); > > + } else { > > + printk_ratelimited(KERN_INFO "URB packet %d, status %d [%s]\n", > > + packet, status, errmsg); > > + } > > +} > > + > > +static struct smi2021_buffer *smi2021_next_buffer(struct smi2021_dev *dev) > > +{ > > + struct smi2021_buffer *buf = NULL; > > + unsigned long flags = 0; > > + > > + BUG_ON(dev->isoc_ctl.buf); > > + > > You should replace BUG_ON with WARN_ON. Linus' words: > http://permalink.gmane.org/gmane.linux.kernel/1347333 > Done! > > + spin_lock_irqsave(&dev->buf_lock, flags); > > + if (!list_empty(&dev->avail_bufs)) { > > + buf = list_first_entry(&dev->avail_bufs, struct smi2021_buffer, > > + list); > > + list_del(&buf->list); > > + } > > + spin_unlock_irqrestore(&dev->buf_lock, flags); > > + > > + return buf; > > +} > > + > > +static void smi2021_buffer_done(struct smi2021_dev *dev) > > +{ > > + struct smi2021_buffer *buf = dev->isoc_ctl.buf; > > + > > + dev->buf_count++; > > + > > + buf->vb.v4l2_buf.sequence = dev->buf_count >> 1; > > + buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED; > > + buf->vb.v4l2_buf.bytesused = buf->pos; > > + do_gettimeofday(&buf->vb.v4l2_buf.timestamp); > > + > > + vb2_set_plane_payload(&buf->vb, 0, buf->pos); > > + vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE); > > + > > + dev->isoc_ctl.buf = NULL; > > +} > > + > > +static void copy_video(struct smi2021_dev *dev, u8 p) > > +{ > > + struct smi2021_buffer *buf = dev->isoc_ctl.buf; > > + > > + int lines_per_field = dev->height / 2; > > + int line = 0; > > + int pos_in_line = 0; > > + unsigned int offset = 0; > > + u8 *dst; > > + > > + if (buf == NULL) > > + return; > > + > > + if (buf->in_blank) > > + return; > > + > > + if (buf->pos >= buf->length) { > > + if (buf->second_field == 0) { > > + /* We are probably trying to capture from > > + * a unconnected input > > + */ > > + smi2021_buffer_done(dev); > > + } else { > > + printk_ratelimited(KERN_WARNING > > + "Buffer overflow!, max: %d bytes, av_lines_found: %d, second_field: %d\n", > > + buf->length, buf->trc_av, > > + buf->second_field); > > + } > > + return; > > + } > > + > > + pos_in_line = buf->pos % SMI2021_BYTES_PER_LINE; > > + line = buf->pos / SMI2021_BYTES_PER_LINE; > > + if (line >= lines_per_field) > > + line -= lines_per_field; > > + > > + if (line != buf->trc_av - 1) { > > + /* Keep video synchronized. > > + * The device will sometimes give us to many bytes > > + * for a line, before we get a new TRC. > > + * We just drop these bytes */ > > + return; > > + } > > + > > + if (buf->second_field) > > + offset += SMI2021_BYTES_PER_LINE; > > + > > + offset += (SMI2021_BYTES_PER_LINE * line * 2) + pos_in_line; > > + > > + /* Will this ever happen? */ > > + if (offset >= buf->length) { > > + printk_ratelimited(KERN_INFO > > + "Offset calculation error, field: %d, line: %d, pos_in_line: %d\n", > > + buf->second_field, line, pos_in_line); > > + return; > > + } > > + > > + dst = buf->mem + offset; > > + *dst = p; > > + buf->pos++; > > +} > > + > > +#define is_sav(trc) \ > > + ((trc & SMI2021_TRC_EAV) == 0x00) > > +#define is_field2(trc) \ > > + ((trc & SMI2021_TRC_FIELD_2) == SMI2021_TRC_FIELD_2) > > +#define is_active_video(trc) \ > > + ((trc & SMI2021_TRC_VBI) == 0x00) > > +/* > > + * Parse the TRC. > > + * Grab a new buffer from the queue if don't have one > > + * and we are recieving the start of a video frame. > > + * > > + * Mark video buffers as done if we have one full frame. > > + */ > > +static void parse_trc(struct smi2021_dev *dev, u8 trc) > > +{ > > + struct smi2021_buffer *buf = dev->isoc_ctl.buf; > > + int lines_per_field = dev->height / 2; > > + int line = 0; > > + > > + if (buf == NULL) { > > + if (!is_sav(trc)) > > + return; > > + > > + if (!is_active_video(trc)) > > + return; > > + > > + if (is_field2(trc)) > > + return; > > + > > + buf = smi2021_next_buffer(dev); > > + if (buf == NULL) > > + return; > > + > > + dev->isoc_ctl.buf = buf; > > + } > > + > > + if (is_sav(trc)) { > > + /* Start of VBI or ACTIVE VIDEO */ > > + if (is_active_video(trc)) { > > + buf->in_blank = false; > > + buf->trc_av++; > > + } else { > > + /* VBI */ > > + buf->in_blank = true; > > + } > > + > > + if (!buf->second_field && is_field2(trc)) { > > + line = buf->pos / SMI2021_BYTES_PER_LINE; > > + if (line < lines_per_field) > > + goto buf_done; > > + > > + buf->second_field = true; > > + buf->trc_av = 0; > > + } > > + > > + if (buf->second_field && !is_field2(trc)) > > + goto buf_done; > > + } else { > > + /* End of VBI or ACTIVE VIDEO */ > > + buf->in_blank = true; > > + } > > + > > + return; > > + > > +buf_done: > > + smi2021_buffer_done(dev); > > +} > > + > > +/* > > + * Scan the saa7113 Active video data. > > + * This data is: > > + * 4 bytes header (0xff 0x00 0x00 [TRC/SAV]) > > + * 1440 bytes of UYUV Video data > > + * 4 bytes footer (0xff 0x00 0x00 [TRC/EAV]) > > + * > > + * TRC = Time Reference Code. > > + * SAV = Start Active Video. > > + * EAV = End Active Video. > > + * This is described in the saa7113 datasheet. > > + */ > > +static void parse_video(struct smi2021_dev *dev, u8 *p, int len) > > +{ > > + int i; > > + > > + for (i = 0; i < len; i++) { > > + switch (dev->sync_state) { > > + case HSYNC: > > + if (p[i] == 0xff) > > + dev->sync_state = SYNCZ1; > > + else > > + copy_video(dev, p[i]); > > + break; > > + case SYNCZ1: > > + if (p[i] == 0x00) { > > + dev->sync_state = SYNCZ2; > > + } else { > > + dev->sync_state = HSYNC; > > + copy_video(dev, 0xff); > > + copy_video(dev, p[i]); > > + } > > + break; > > + case SYNCZ2: > > + if (p[i] == 0x00) { > > + dev->sync_state = TRC; > > + } else { > > + dev->sync_state = HSYNC; > > + copy_video(dev, 0xff); > > + copy_video(dev, 0x00); > > + copy_video(dev, p[i]); > > + } > > + break; > > + case TRC: > > + dev->sync_state = HSYNC; > > + parse_trc(dev, p[i]); > > + break; > > + } > > + } > > + > > +} > > +/* > > + * > > + * The device delivers data in chunks of 0x400 bytes. > > + * The four first bytes is a magic header to identify the chunks. > > + * 0xaa 0xaa 0x00 0x00 = saa7113 Active Video Data > > + * 0xaa 0xaa 0x00 0x01 = PCM - 24Bit 2 Channel audio data > > + */ > > +static void process_packet(struct smi2021_dev *dev, u8 *p, int len) > > +{ > > + int i; > > + u32 *header; > > + > > + if (len % 0x400 != 0) { > > + printk_ratelimited(KERN_INFO "smi2021::%s: len: %d\n", > > + __func__, len); > > + return; > > + } > > + > > + for (i = 0; i < len; i += 0x400) { > > + header = (u32 *)(p + i); > > + switch (__cpu_to_be32(*header)) { > > + case 0xaaaa0000: { > > + parse_video(dev, p+i+4, 0x400-4); > > + break; > > + } > > + case 0xaaaa0001: { > > + smi2021_audio(dev, p+i+4, 0x400-4); > > + break; > > + } > > + default: { > > + /* Nothing */ > > + } > > + } > > + } > > +} > > + > > +/* > > + * Interrupt called by URB callback > > + */ > > +static void smi2021_isoc_isr(struct urb *urb) > > +{ > > + int i, rc, status, len; > > + struct smi2021_dev *dev = urb->context; > > + u8 *p; > > + > > + switch (urb->status) { > > + case 0: > > + break; > > + case -ECONNRESET: /* kill */ > > + case -ENOENT: > > + case -ESHUTDOWN: > > + /* uvc driver frees the queue here */ > > + return; > > + default: > > + smi2021_err("urb error! status %d\n", urb->status); > > + return; > > + } > > + > > + if (urb->status < 0) > > + print_usb_err(dev, -1, status); > > + > > + if (dev == NULL) { > > + smi2021_warn("called with null device\n"); > > + return; > > + } > > + > > + for (i = 0; i < urb->number_of_packets; i++) { > > + > > + status = urb->iso_frame_desc[i].status; > > + if (status == -18) { > > + /* This seems to happen when the device > > + * trying to stream from an unconnected input > > + * */ > > + continue; > > + } > > + > > + if (status < 0) { > > + print_usb_err(dev, i, status); > > + continue; > > + } > > + > > + p = urb->transfer_buffer + urb->iso_frame_desc[i].offset; > > + len = urb->iso_frame_desc[i].actual_length; > > + process_packet(dev, p, len); > > + } > > + > > + for (i = 0; i < urb->number_of_packets; i++) { > > + urb->iso_frame_desc[i].status = 0; > > + urb->iso_frame_desc[i].actual_length = 0; > > + } > > + > > + rc = usb_submit_urb(urb, GFP_ATOMIC); > > + if (rc) > > + smi2021_err("urb re-submit failed (%d)\n", rc); > > +} > > + > > +/* > > + * Cancel urbs > > + * This function can not be called in atomic context > > + */ > > +void smi2021_cancel_isoc(struct smi2021_dev *dev) > > +{ > > + int i, num_bufs = dev->isoc_ctl.num_bufs; > > + if (!num_bufs) > > + return; > > + > > + smi2021_dbg("killing %d urbs...\n", num_bufs); > > + > > + for (i = 0; i < num_bufs; i++) > > + usb_kill_urb(dev->isoc_ctl.urb[i]); > > + > > + smi2021_dbg("all urbs killed\n"); > > + > > +} > > + > > +/* > > + * Releases urb and transfer buffers > > + * Obviously, associated urb must be killed before releasing it > > + */ > > +void smi2021_free_isoc(struct smi2021_dev *dev) > > +{ > > + struct urb *urb; > > + int i, num_bufs = dev->isoc_ctl.num_bufs; > > + > > + smi2021_dbg("freeing %d urb buffers...\n", num_bufs); > > + > > + for (i = 0; i < num_bufs; i++) { > > + urb = dev->isoc_ctl.urb[i]; > > + if (urb) { > > + if (dev->isoc_ctl.transfer_buffer[i]) { > > +#ifndef CONFIG_DMA_NONCOHERENT > > + usb_free_coherent(dev->udev, > > + urb->transfer_buffer_length, > > + dev->isoc_ctl.transfer_buffer[i], > > + urb->transfer_dma); > > +#else > > + kfree(dev->isoc_ctl.transfer_buffer[i]); > > +#endif > > + } > > + usb_free_urb(urb); > > + dev->isoc_ctl.urb[i] = NULL; > > + } > > + dev->isoc_ctl.transfer_buffer[i] = NULL; > > + } > > + > > + kfree(dev->isoc_ctl.urb); > > + kfree(dev->isoc_ctl.transfer_buffer); > > + > > + dev->isoc_ctl.urb = NULL; > > + dev->isoc_ctl.transfer_buffer = NULL; > > + dev->isoc_ctl.num_bufs = 0; > > + > > + smi2021_dbg("all urb buffers freed\n"); > > +} > > + > > +/* > > + * Helper for canceling and freeing urbs > > + * This function can not be called in atomic context > > + */ > > +void smi2021_uninit_isoc(struct smi2021_dev *dev) > > +{ > > + smi2021_cancel_isoc(dev); > > + smi2021_free_isoc(dev); > > +} > > + > > + > > +int smi2021_alloc_isoc(struct smi2021_dev *dev) > > +{ > > + struct urb *urb; > > + int i, j, k, sb_size, max_packets, num_bufs; > > + > > + if (dev->isoc_ctl.num_bufs) > > + smi2021_uninit_isoc(dev); > > + > > + num_bufs = SMI2021_ISOC_BUFS; > > + max_packets = SMI2021_ISOC_PACKETS; > > + sb_size = max_packets * SMI2021_MAX_PKT_SIZE; > > + > > + dev->isoc_ctl.buf = NULL; > > + dev->isoc_ctl.max_pkt_size = SMI2021_MAX_PKT_SIZE; > > + dev->isoc_ctl.urb = kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL); > > + if (!dev->isoc_ctl.urb) { > > + smi2021_err("out of memory for urb array\n"); > > + return -ENOMEM; > > + } > > + > > + dev->isoc_ctl.transfer_buffer = kzalloc(sizeof(void *) * num_bufs, > > + GFP_KERNEL); > > + if (!dev->isoc_ctl.transfer_buffer) { > > + smi2021_err("out of memory for usb transfer\n"); > > + kfree(dev->isoc_ctl.urb); > > + return -ENOMEM; > > + } > > + > > + for (i = 0; i < num_bufs; i++) { > > + urb = usb_alloc_urb(max_packets, GFP_KERNEL); > > + if (!urb) { > > + smi2021_err("connot allocate urb[%d]\n", i); > > + goto free_i_bufs; > > + } > > + dev->isoc_ctl.urb[i] = urb; > > +#ifndef CONFIG_DMA_NONCOHERENT > > + dev->isoc_ctl.transfer_buffer[i] = usb_alloc_coherent( > > + dev->udev, sb_size, GFP_KERNEL, > > + &urb->transfer_dma); > > +#else > > + dev->isoc_ctl.transfer_buffer[i] = kmalloc(sb_size, > > + GFP_KERNEL); > > +#endif > > + if (!dev->isoc_ctl.transfer_buffer[i]) { > > + smi2021_err("cannot alloc %d bytes for tx[%d] buffer", > > + sb_size, i); > > + goto free_i_bufs; > > + } > > + /* Do not leak kernel data */ > > + memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size); > > + > > + urb->dev = dev->udev; > > + urb->pipe = usb_rcvisocpipe(dev->udev, SMI2021_ISOC_EP); > > + urb->transfer_buffer = dev->isoc_ctl.transfer_buffer[i]; > > + urb->transfer_buffer_length = sb_size; > > + urb->complete = smi2021_isoc_isr; > > + urb->context = dev; > > + urb->interval = 1; > > + urb->start_frame = 0; > > + urb->number_of_packets = max_packets; > > +#ifndef CONFIG_DMA_NONCOHERENT > > + urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP; > > +#else > > + urb->transfer_flags = URB_ISO_ASAP; > > +#endif > > + k = 0; > > + for (j = 0; j < max_packets; j++) { > > + urb->iso_frame_desc[j].offset = k; > > + urb->iso_frame_desc[j].length = > > + dev->isoc_ctl.max_pkt_size; > > + k += dev->isoc_ctl.max_pkt_size; > > + } > > + } > > + smi2021_dbg("urbs allocated\n"); > > + dev->isoc_ctl.num_bufs = num_bufs; > > + return 0; > > + > > +free_i_bufs: > > + dev->isoc_ctl.num_bufs = i+1; > > + smi2021_free_isoc(dev); > > + return -ENOMEM; > > +} > > -- > > 1.8.1.1 > > > > -- > Ezequiel García, Free Electrons > Embedded Linux, Kernel and Android Engineering > http://free-electrons.com -- To unsubscribe from this list: send the line "unsubscribe linux-media" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html
