Subversion Repositories test_project

/*

 * 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);

}