Logo Search packages:      
Sourcecode: linux version File versions  Download package

iso.c

/*
 * IEEE 1394 for Linux
 *
 * kernel ISO transmission/reception
 *
 * Copyright (C) 2002 Maas Digital LLC
 *
 * This code is licensed under the GPL.  See the file COPYING in the root
 * directory of the kernel sources for details.
 */

#include <linux/pci.h>
#include <linux/sched.h>
#include <linux/slab.h>

#include "hosts.h"
#include "iso.h"

/**
 * hpsb_iso_stop - stop DMA
 */
void hpsb_iso_stop(struct hpsb_iso *iso)
{
      if (!(iso->flags & HPSB_ISO_DRIVER_STARTED))
            return;

      iso->host->driver->isoctl(iso, iso->type == HPSB_ISO_XMIT ?
                          XMIT_STOP : RECV_STOP, 0);
      iso->flags &= ~HPSB_ISO_DRIVER_STARTED;
}

/**
 * hpsb_iso_shutdown - deallocate buffer and DMA context
 */
void hpsb_iso_shutdown(struct hpsb_iso *iso)
{
      if (iso->flags & HPSB_ISO_DRIVER_INIT) {
            hpsb_iso_stop(iso);
            iso->host->driver->isoctl(iso, iso->type == HPSB_ISO_XMIT ?
                                XMIT_SHUTDOWN : RECV_SHUTDOWN, 0);
            iso->flags &= ~HPSB_ISO_DRIVER_INIT;
      }

      dma_region_free(&iso->data_buf);
      kfree(iso);
}

static struct hpsb_iso *hpsb_iso_common_init(struct hpsb_host *host,
                                   enum hpsb_iso_type type,
                                   unsigned int data_buf_size,
                                   unsigned int buf_packets,
                                   int channel, int dma_mode,
                                   int irq_interval,
                                   void (*callback) (struct hpsb_iso
                                                 *))
{
      struct hpsb_iso *iso;
      int dma_direction;

      /* make sure driver supports the ISO API */
      if (!host->driver->isoctl) {
            printk(KERN_INFO
                   "ieee1394: host driver '%s' does not support the rawiso API\n",
                   host->driver->name);
            return NULL;
      }

      /* sanitize parameters */

      if (buf_packets < 2)
            buf_packets = 2;

      if ((dma_mode < HPSB_ISO_DMA_DEFAULT)
          || (dma_mode > HPSB_ISO_DMA_PACKET_PER_BUFFER))
            dma_mode = HPSB_ISO_DMA_DEFAULT;

      if ((irq_interval < 0) || (irq_interval > buf_packets / 4))
            irq_interval = buf_packets / 4;
      if (irq_interval == 0)  /* really interrupt for each packet */
            irq_interval = 1;

      if (channel < -1 || channel >= 64)
            return NULL;

      /* channel = -1 is OK for multi-channel recv but not for xmit */
      if (type == HPSB_ISO_XMIT && channel < 0)
            return NULL;

      /* allocate and write the struct hpsb_iso */

      iso =
          kmalloc(sizeof(*iso) +
                buf_packets * sizeof(struct hpsb_iso_packet_info),
                GFP_KERNEL);
      if (!iso)
            return NULL;

      iso->infos = (struct hpsb_iso_packet_info *)(iso + 1);

      iso->type = type;
      iso->host = host;
      iso->hostdata = NULL;
      iso->callback = callback;
      init_waitqueue_head(&iso->waitq);
      iso->channel = channel;
      iso->irq_interval = irq_interval;
      iso->dma_mode = dma_mode;
      dma_region_init(&iso->data_buf);
      iso->buf_size = PAGE_ALIGN(data_buf_size);
      iso->buf_packets = buf_packets;
      iso->pkt_dma = 0;
      iso->first_packet = 0;
      spin_lock_init(&iso->lock);

      if (iso->type == HPSB_ISO_XMIT) {
            iso->n_ready_packets = iso->buf_packets;
            dma_direction = PCI_DMA_TODEVICE;
      } else {
            iso->n_ready_packets = 0;
            dma_direction = PCI_DMA_FROMDEVICE;
      }

      atomic_set(&iso->overflows, 0);
      iso->bytes_discarded = 0;
      iso->flags = 0;
      iso->prebuffer = 0;

      /* allocate the packet buffer */
      if (dma_region_alloc
          (&iso->data_buf, iso->buf_size, host->pdev, dma_direction))
            goto err;

      return iso;

      err:
      hpsb_iso_shutdown(iso);
      return NULL;
}

/**
 * hpsb_iso_n_ready - returns number of packets ready to send or receive
 */
int hpsb_iso_n_ready(struct hpsb_iso *iso)
{
      unsigned long flags;
      int val;

      spin_lock_irqsave(&iso->lock, flags);
      val = iso->n_ready_packets;
      spin_unlock_irqrestore(&iso->lock, flags);

      return val;
}

/**
 * hpsb_iso_xmit_init - allocate the buffer and DMA context
 */
struct hpsb_iso *hpsb_iso_xmit_init(struct hpsb_host *host,
                            unsigned int data_buf_size,
                            unsigned int buf_packets,
                            int channel,
                            int speed,
                            int irq_interval,
                            void (*callback) (struct hpsb_iso *))
{
      struct hpsb_iso *iso = hpsb_iso_common_init(host, HPSB_ISO_XMIT,
                                        data_buf_size, buf_packets,
                                        channel,
                                        HPSB_ISO_DMA_DEFAULT,
                                        irq_interval, callback);
      if (!iso)
            return NULL;

      iso->speed = speed;

      /* tell the driver to start working */
      if (host->driver->isoctl(iso, XMIT_INIT, 0))
            goto err;

      iso->flags |= HPSB_ISO_DRIVER_INIT;
      return iso;

      err:
      hpsb_iso_shutdown(iso);
      return NULL;
}

/**
 * hpsb_iso_recv_init - allocate the buffer and DMA context
 *
 * Note, if channel = -1, multi-channel receive is enabled.
 */
struct hpsb_iso *hpsb_iso_recv_init(struct hpsb_host *host,
                            unsigned int data_buf_size,
                            unsigned int buf_packets,
                            int channel,
                            int dma_mode,
                            int irq_interval,
                            void (*callback) (struct hpsb_iso *))
{
      struct hpsb_iso *iso = hpsb_iso_common_init(host, HPSB_ISO_RECV,
                                        data_buf_size, buf_packets,
                                        channel, dma_mode,
                                        irq_interval, callback);
      if (!iso)
            return NULL;

      /* tell the driver to start working */
      if (host->driver->isoctl(iso, RECV_INIT, 0))
            goto err;

      iso->flags |= HPSB_ISO_DRIVER_INIT;
      return iso;

      err:
      hpsb_iso_shutdown(iso);
      return NULL;
}

/**
 * hpsb_iso_recv_listen_channel
 *
 * multi-channel only
 */
int hpsb_iso_recv_listen_channel(struct hpsb_iso *iso, unsigned char channel)
{
      if (iso->type != HPSB_ISO_RECV || iso->channel != -1 || channel >= 64)
            return -EINVAL;
      return iso->host->driver->isoctl(iso, RECV_LISTEN_CHANNEL, channel);
}

/**
 * hpsb_iso_recv_unlisten_channel
 *
 * multi-channel only
 */
int hpsb_iso_recv_unlisten_channel(struct hpsb_iso *iso, unsigned char channel)
{
      if (iso->type != HPSB_ISO_RECV || iso->channel != -1 || channel >= 64)
            return -EINVAL;
      return iso->host->driver->isoctl(iso, RECV_UNLISTEN_CHANNEL, channel);
}

/**
 * hpsb_iso_recv_set_channel_mask
 *
 * multi-channel only
 */
int hpsb_iso_recv_set_channel_mask(struct hpsb_iso *iso, u64 mask)
{
      if (iso->type != HPSB_ISO_RECV || iso->channel != -1)
            return -EINVAL;
      return iso->host->driver->isoctl(iso, RECV_SET_CHANNEL_MASK,
                               (unsigned long)&mask);
}

/**
 * hpsb_iso_recv_flush - check for arrival of new packets
 *
 * check for arrival of new packets immediately (even if irq_interval
 * has not yet been reached)
 */
int hpsb_iso_recv_flush(struct hpsb_iso *iso)
{
      if (iso->type != HPSB_ISO_RECV)
            return -EINVAL;
      return iso->host->driver->isoctl(iso, RECV_FLUSH, 0);
}

static int do_iso_xmit_start(struct hpsb_iso *iso, int cycle)
{
      int retval = iso->host->driver->isoctl(iso, XMIT_START, cycle);
      if (retval)
            return retval;

      iso->flags |= HPSB_ISO_DRIVER_STARTED;
      return retval;
}

/**
 * hpsb_iso_xmit_start - start DMA
 */
int hpsb_iso_xmit_start(struct hpsb_iso *iso, int cycle, int prebuffer)
{
      if (iso->type != HPSB_ISO_XMIT)
            return -1;

      if (iso->flags & HPSB_ISO_DRIVER_STARTED)
            return 0;

      if (cycle < -1)
            cycle = -1;
      else if (cycle >= 8000)
            cycle %= 8000;

      iso->xmit_cycle = cycle;

      if (prebuffer < 0)
            prebuffer = iso->buf_packets - 1;
      else if (prebuffer == 0)
            prebuffer = 1;

      if (prebuffer >= iso->buf_packets)
            prebuffer = iso->buf_packets - 1;

      iso->prebuffer = prebuffer;

      /* remember the starting cycle; DMA will commence from xmit_queue_packets()
         once enough packets have been buffered */
      iso->start_cycle = cycle;

      return 0;
}

/**
 * hpsb_iso_recv_start - start DMA
 */
int hpsb_iso_recv_start(struct hpsb_iso *iso, int cycle, int tag_mask, int sync)
{
      int retval = 0;
      int isoctl_args[3];

      if (iso->type != HPSB_ISO_RECV)
            return -1;

      if (iso->flags & HPSB_ISO_DRIVER_STARTED)
            return 0;

      if (cycle < -1)
            cycle = -1;
      else if (cycle >= 8000)
            cycle %= 8000;

      isoctl_args[0] = cycle;

      if (tag_mask < 0)
            /* match all tags */
            tag_mask = 0xF;
      isoctl_args[1] = tag_mask;

      isoctl_args[2] = sync;

      retval =
          iso->host->driver->isoctl(iso, RECV_START,
                              (unsigned long)&isoctl_args[0]);
      if (retval)
            return retval;

      iso->flags |= HPSB_ISO_DRIVER_STARTED;
      return retval;
}

/* check to make sure the user has not supplied bogus values of offset/len
 * that would cause the kernel to access memory outside the buffer */
static int hpsb_iso_check_offset_len(struct hpsb_iso *iso,
                             unsigned int offset, unsigned short len,
                             unsigned int *out_offset,
                             unsigned short *out_len)
{
      if (offset >= iso->buf_size)
            return -EFAULT;

      /* make sure the packet does not go beyond the end of the buffer */
      if (offset + len > iso->buf_size)
            return -EFAULT;

      /* check for wrap-around */
      if (offset + len < offset)
            return -EFAULT;

      /* now we can trust 'offset' and 'length' */
      *out_offset = offset;
      *out_len = len;

      return 0;
}

/**
 * hpsb_iso_xmit_queue_packet - queue a packet for transmission.
 *
 * @offset is relative to the beginning of the DMA buffer, where the packet's
 * data payload should already have been placed.
 */
int hpsb_iso_xmit_queue_packet(struct hpsb_iso *iso, u32 offset, u16 len,
                         u8 tag, u8 sy)
{
      struct hpsb_iso_packet_info *info;
      unsigned long flags;
      int rv;

      if (iso->type != HPSB_ISO_XMIT)
            return -EINVAL;

      /* is there space in the buffer? */
      if (iso->n_ready_packets <= 0) {
            return -EBUSY;
      }

      info = &iso->infos[iso->first_packet];

      /* check for bogus offset/length */
      if (hpsb_iso_check_offset_len
          (iso, offset, len, &info->offset, &info->len))
            return -EFAULT;

      info->tag = tag;
      info->sy = sy;

      spin_lock_irqsave(&iso->lock, flags);

      rv = iso->host->driver->isoctl(iso, XMIT_QUEUE, (unsigned long)info);
      if (rv)
            goto out;

      /* increment cursors */
      iso->first_packet = (iso->first_packet + 1) % iso->buf_packets;
      iso->xmit_cycle = (iso->xmit_cycle + 1) % 8000;
      iso->n_ready_packets--;

      if (iso->prebuffer != 0) {
            iso->prebuffer--;
            if (iso->prebuffer <= 0) {
                  iso->prebuffer = 0;
                  rv = do_iso_xmit_start(iso, iso->start_cycle);
            }
      }

      out:
      spin_unlock_irqrestore(&iso->lock, flags);
      return rv;
}

/**
 * hpsb_iso_xmit_sync - wait until all queued packets have been transmitted
 */
int hpsb_iso_xmit_sync(struct hpsb_iso *iso)
{
      if (iso->type != HPSB_ISO_XMIT)
            return -EINVAL;

      return wait_event_interruptible(iso->waitq,
                              hpsb_iso_n_ready(iso) ==
                              iso->buf_packets);
}

/**
 * hpsb_iso_packet_sent
 *
 * Available to low-level drivers.
 *
 * Call after a packet has been transmitted to the bus (interrupt context is
 * OK).  @cycle is the _exact_ cycle the packet was sent on.  @error should be
 * non-zero if some sort of error occurred when sending the packet.
 */
void hpsb_iso_packet_sent(struct hpsb_iso *iso, int cycle, int error)
{
      unsigned long flags;
      spin_lock_irqsave(&iso->lock, flags);

      /* predict the cycle of the next packet to be queued */

      /* jump ahead by the number of packets that are already buffered */
      cycle += iso->buf_packets - iso->n_ready_packets;
      cycle %= 8000;

      iso->xmit_cycle = cycle;
      iso->n_ready_packets++;
      iso->pkt_dma = (iso->pkt_dma + 1) % iso->buf_packets;

      if (iso->n_ready_packets == iso->buf_packets || error != 0) {
            /* the buffer has run empty! */
            atomic_inc(&iso->overflows);
      }

      spin_unlock_irqrestore(&iso->lock, flags);
}

/**
 * hpsb_iso_packet_received
 *
 * Available to low-level drivers.
 *
 * Call after a packet has been received (interrupt context is OK).
 */
void hpsb_iso_packet_received(struct hpsb_iso *iso, u32 offset, u16 len,
                        u16 total_len, u16 cycle, u8 channel, u8 tag,
                        u8 sy)
{
      unsigned long flags;
      spin_lock_irqsave(&iso->lock, flags);

      if (iso->n_ready_packets == iso->buf_packets) {
            /* overflow! */
            atomic_inc(&iso->overflows);
            /* Record size of this discarded packet */
            iso->bytes_discarded += total_len;
      } else {
            struct hpsb_iso_packet_info *info = &iso->infos[iso->pkt_dma];
            info->offset = offset;
            info->len = len;
            info->total_len = total_len;
            info->cycle = cycle;
            info->channel = channel;
            info->tag = tag;
            info->sy = sy;

            iso->pkt_dma = (iso->pkt_dma + 1) % iso->buf_packets;
            iso->n_ready_packets++;
      }

      spin_unlock_irqrestore(&iso->lock, flags);
}

/**
 * hpsb_iso_recv_release_packets - release packets, reuse buffer
 *
 * @n_packets have been read out of the buffer, re-use the buffer space
 */
int hpsb_iso_recv_release_packets(struct hpsb_iso *iso, unsigned int n_packets)
{
      unsigned long flags;
      unsigned int i;
      int rv = 0;

      if (iso->type != HPSB_ISO_RECV)
            return -1;

      spin_lock_irqsave(&iso->lock, flags);
      for (i = 0; i < n_packets; i++) {
            rv = iso->host->driver->isoctl(iso, RECV_RELEASE,
                                     (unsigned long)&iso->infos[iso->
                                                        first_packet]);
            if (rv)
                  break;

            iso->first_packet = (iso->first_packet + 1) % iso->buf_packets;
            iso->n_ready_packets--;

            /* release memory from packets discarded when queue was full  */
            if (iso->n_ready_packets == 0) {    /* Release only after all prior packets handled */
                  if (iso->bytes_discarded != 0) {
                        struct hpsb_iso_packet_info inf;
                        inf.total_len = iso->bytes_discarded;
                        iso->host->driver->isoctl(iso, RECV_RELEASE,
                                            (unsigned long)&inf);
                        iso->bytes_discarded = 0;
                  }
            }
      }
      spin_unlock_irqrestore(&iso->lock, flags);
      return rv;
}

/**
 * hpsb_iso_wake
 *
 * Available to low-level drivers.
 *
 * Call to wake waiting processes after buffer space has opened up.
 */
void hpsb_iso_wake(struct hpsb_iso *iso)
{
      wake_up_interruptible(&iso->waitq);

      if (iso->callback)
            iso->callback(iso);
}

Generated by  Doxygen 1.6.0   Back to index