[linux-2.6-block.git] / drivers / ieee1394 / 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/mm.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);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* IEEE 1394 for Linux
	3	*
	4	* kernel ISO transmission/reception
	5	*
	6	* Copyright (C) 2002 Maas Digital LLC
	7	*
	8	* This code is licensed under the GPL. See the file COPYING in the root
	9	* directory of the kernel sources for details.
	10	*/
	11
de4394f1	12	#include <linux/pci.h>
b9e5eb06	13	#include <linux/sched.h>
27ac792c	14	#include <linux/mm.h>
de4394f1 SR	15	#include <linux/slab.h>
	16
	17	#include "hosts.h"
1da177e4 LT	18	#include "iso.h"
1da177e4 LT	19
afd6546d SR	20	/**
	21	* hpsb_iso_stop - stop DMA
	22	*/
1da177e4 LT	23	void hpsb_iso_stop(struct hpsb_iso *iso)
	24	{
	25	if (!(iso->flags & HPSB_ISO_DRIVER_STARTED))
	26	return;
	27
	28	iso->host->driver->isoctl(iso, iso->type == HPSB_ISO_XMIT ?
	29	XMIT_STOP : RECV_STOP, 0);
	30	iso->flags &= ~HPSB_ISO_DRIVER_STARTED;
	31	}
	32
afd6546d SR	33	/**
	34	* hpsb_iso_shutdown - deallocate buffer and DMA context
	35	*/
1da177e4 LT	36	void hpsb_iso_shutdown(struct hpsb_iso *iso)
	37	{
	38	if (iso->flags & HPSB_ISO_DRIVER_INIT) {
	39	hpsb_iso_stop(iso);
	40	iso->host->driver->isoctl(iso, iso->type == HPSB_ISO_XMIT ?
	41	XMIT_SHUTDOWN : RECV_SHUTDOWN, 0);
	42	iso->flags &= ~HPSB_ISO_DRIVER_INIT;
	43	}
	44
	45	dma_region_free(&iso->data_buf);
	46	kfree(iso);
	47	}
	48
066ef9c2 JMH	49	static struct hpsb_iso hpsb_iso_common_init(struct hpsb_host host,
066ef9c2 JMH	50	enum hpsb_iso_type type,
1da177e4 LT	51	unsigned int data_buf_size,
1da177e4 LT	52	unsigned int buf_packets,
066ef9c2	53	int channel, int dma_mode,
1da177e4	54	int irq_interval,
066ef9c2 JMH	55	void (*callback) (struct hpsb_iso
066ef9c2 JMH	56	*))
1da177e4 LT	57	{
	58	struct hpsb_iso *iso;
	59	int dma_direction;
	60
	61	/* make sure driver supports the ISO API */
	62	if (!host->driver->isoctl) {
066ef9c2 JMH	63	printk(KERN_INFO
066ef9c2 JMH	64	"ieee1394: host driver '%s' does not support the rawiso API\n",
1da177e4 LT	65	host->driver->name);
	66	return NULL;
	67	}
	68
	69	/* sanitize parameters */
	70
	71	if (buf_packets < 2)
	72	buf_packets = 2;
	73
066ef9c2 JMH	74	if ((dma_mode < HPSB_ISO_DMA_DEFAULT)
	75	\|\| (dma_mode > HPSB_ISO_DMA_PACKET_PER_BUFFER))
	76	dma_mode = HPSB_ISO_DMA_DEFAULT;
1da177e4	77
1934b8b6	78	if ((irq_interval < 0) \|\| (irq_interval > buf_packets / 4))
066ef9c2 JMH	79	irq_interval = buf_packets / 4;
066ef9c2 JMH	80	if (irq_interval == 0) /* really interrupt for each packet */
1da177e4	81	irq_interval = 1;
1da177e4 LT	82
	83	if (channel < -1 \|\| channel >= 64)
	84	return NULL;
	85
	86	/* channel = -1 is OK for multi-channel recv but not for xmit */
	87	if (type == HPSB_ISO_XMIT && channel < 0)
	88	return NULL;
	89
	90	/* allocate and write the struct hpsb_iso */
	91
066ef9c2 JMH	92	iso =
	93	kmalloc(sizeof(*iso) +
	94	buf_packets * sizeof(struct hpsb_iso_packet_info),
	95	GFP_KERNEL);
1da177e4 LT	96	if (!iso)
	97	return NULL;
	98
	99	iso->infos = (struct hpsb_iso_packet_info *)(iso + 1);
	100
	101	iso->type = type;
	102	iso->host = host;
	103	iso->hostdata = NULL;
	104	iso->callback = callback;
	105	init_waitqueue_head(&iso->waitq);
	106	iso->channel = channel;
	107	iso->irq_interval = irq_interval;
	108	iso->dma_mode = dma_mode;
	109	dma_region_init(&iso->data_buf);
	110	iso->buf_size = PAGE_ALIGN(data_buf_size);
	111	iso->buf_packets = buf_packets;
	112	iso->pkt_dma = 0;
	113	iso->first_packet = 0;
	114	spin_lock_init(&iso->lock);
	115
	116	if (iso->type == HPSB_ISO_XMIT) {
	117	iso->n_ready_packets = iso->buf_packets;
	118	dma_direction = PCI_DMA_TODEVICE;
	119	} else {
	120	iso->n_ready_packets = 0;
	121	dma_direction = PCI_DMA_FROMDEVICE;
	122	}
	123
	124	atomic_set(&iso->overflows, 0);
1934b8b6	125	iso->bytes_discarded = 0;
1da177e4 LT	126	iso->flags = 0;
	127	iso->prebuffer = 0;
	128
	129	/* allocate the packet buffer */
066ef9c2 JMH	130	if (dma_region_alloc
066ef9c2 JMH	131	(&iso->data_buf, iso->buf_size, host->pdev, dma_direction))
1da177e4 LT	132	goto err;
	133
	134	return iso;
	135
066ef9c2	136	err:
1da177e4 LT	137	hpsb_iso_shutdown(iso);
	138	return NULL;
	139	}
	140
afd6546d SR	141	/**
	142	* hpsb_iso_n_ready - returns number of packets ready to send or receive
	143	*/
066ef9c2	144	int hpsb_iso_n_ready(struct hpsb_iso *iso)
1da177e4 LT	145	{
	146	unsigned long flags;
	147	int val;
	148
	149	spin_lock_irqsave(&iso->lock, flags);
	150	val = iso->n_ready_packets;
	151	spin_unlock_irqrestore(&iso->lock, flags);
	152
	153	return val;
	154	}
	155
afd6546d SR	156	/**
	157	* hpsb_iso_xmit_init - allocate the buffer and DMA context
	158	*/
066ef9c2	159	struct hpsb_iso hpsb_iso_xmit_init(struct hpsb_host host,
1da177e4 LT	160	unsigned int data_buf_size,
	161	unsigned int buf_packets,
	162	int channel,
	163	int speed,
	164	int irq_interval,
066ef9c2	165	void (callback) (struct hpsb_iso ))
1da177e4 LT	166	{
	167	struct hpsb_iso *iso = hpsb_iso_common_init(host, HPSB_ISO_XMIT,
	168	data_buf_size, buf_packets,
066ef9c2 JMH	169	channel,
	170	HPSB_ISO_DMA_DEFAULT,
	171	irq_interval, callback);
1da177e4 LT	172	if (!iso)
	173	return NULL;
	174
	175	iso->speed = speed;
	176
	177	/* tell the driver to start working */
	178	if (host->driver->isoctl(iso, XMIT_INIT, 0))
	179	goto err;
	180
	181	iso->flags \|= HPSB_ISO_DRIVER_INIT;
	182	return iso;
	183
066ef9c2	184	err:
1da177e4 LT	185	hpsb_iso_shutdown(iso);
	186	return NULL;
	187	}
	188
afd6546d SR	189	/**
	190	* hpsb_iso_recv_init - allocate the buffer and DMA context
	191	*
	192	* Note, if channel = -1, multi-channel receive is enabled.
	193	*/
066ef9c2	194	struct hpsb_iso hpsb_iso_recv_init(struct hpsb_host host,
1da177e4 LT	195	unsigned int data_buf_size,
	196	unsigned int buf_packets,
	197	int channel,
	198	int dma_mode,
	199	int irq_interval,
066ef9c2	200	void (callback) (struct hpsb_iso ))
1da177e4 LT	201	{
	202	struct hpsb_iso *iso = hpsb_iso_common_init(host, HPSB_ISO_RECV,
	203	data_buf_size, buf_packets,
066ef9c2 JMH	204	channel, dma_mode,
066ef9c2 JMH	205	irq_interval, callback);
1da177e4 LT	206	if (!iso)
	207	return NULL;
	208
	209	/* tell the driver to start working */
	210	if (host->driver->isoctl(iso, RECV_INIT, 0))
	211	goto err;
	212
	213	iso->flags \|= HPSB_ISO_DRIVER_INIT;
	214	return iso;
	215
066ef9c2	216	err:
1da177e4 LT	217	hpsb_iso_shutdown(iso);
	218	return NULL;
	219	}
	220
afd6546d SR	221	/**
	222	* hpsb_iso_recv_listen_channel
	223	*
	224	* multi-channel only
	225	*/
1da177e4 LT	226	int hpsb_iso_recv_listen_channel(struct hpsb_iso *iso, unsigned char channel)
	227	{
	228	if (iso->type != HPSB_ISO_RECV \|\| iso->channel != -1 \|\| channel >= 64)
	229	return -EINVAL;
	230	return iso->host->driver->isoctl(iso, RECV_LISTEN_CHANNEL, channel);
	231	}
	232
afd6546d SR	233	/**
	234	* hpsb_iso_recv_unlisten_channel
	235	*
	236	* multi-channel only
	237	*/
1da177e4 LT	238	int hpsb_iso_recv_unlisten_channel(struct hpsb_iso *iso, unsigned char channel)
1da177e4 LT	239	{
066ef9c2 JMH	240	if (iso->type != HPSB_ISO_RECV \|\| iso->channel != -1 \|\| channel >= 64)
	241	return -EINVAL;
	242	return iso->host->driver->isoctl(iso, RECV_UNLISTEN_CHANNEL, channel);
1da177e4 LT	243	}
1da177e4 LT	244
afd6546d SR	245	/**
	246	* hpsb_iso_recv_set_channel_mask
	247	*
	248	* multi-channel only
	249	*/
1da177e4 LT	250	int hpsb_iso_recv_set_channel_mask(struct hpsb_iso *iso, u64 mask)
	251	{
	252	if (iso->type != HPSB_ISO_RECV \|\| iso->channel != -1)
	253	return -EINVAL;
066ef9c2 JMH	254	return iso->host->driver->isoctl(iso, RECV_SET_CHANNEL_MASK,
066ef9c2 JMH	255	(unsigned long)&mask);
1da177e4 LT	256	}
1da177e4 LT	257
afd6546d SR	258	/**
	259	* hpsb_iso_recv_flush - check for arrival of new packets
	260	*
	261	* check for arrival of new packets immediately (even if irq_interval
	262	* has not yet been reached)
	263	*/
1da177e4 LT	264	int hpsb_iso_recv_flush(struct hpsb_iso *iso)
	265	{
	266	if (iso->type != HPSB_ISO_RECV)
	267	return -EINVAL;
	268	return iso->host->driver->isoctl(iso, RECV_FLUSH, 0);
	269	}
	270
	271	static int do_iso_xmit_start(struct hpsb_iso *iso, int cycle)
	272	{
	273	int retval = iso->host->driver->isoctl(iso, XMIT_START, cycle);
	274	if (retval)
	275	return retval;
	276
	277	iso->flags \|= HPSB_ISO_DRIVER_STARTED;
	278	return retval;
	279	}
	280
afd6546d SR	281	/**
	282	* hpsb_iso_xmit_start - start DMA
	283	*/
1da177e4 LT	284	int hpsb_iso_xmit_start(struct hpsb_iso *iso, int cycle, int prebuffer)
	285	{
	286	if (iso->type != HPSB_ISO_XMIT)
	287	return -1;
	288
	289	if (iso->flags & HPSB_ISO_DRIVER_STARTED)
	290	return 0;
	291
	292	if (cycle < -1)
	293	cycle = -1;
	294	else if (cycle >= 8000)
	295	cycle %= 8000;
	296
	297	iso->xmit_cycle = cycle;
	298
	299	if (prebuffer < 0)
1934b8b6	300	prebuffer = iso->buf_packets - 1;
1da177e4 LT	301	else if (prebuffer == 0)
	302	prebuffer = 1;
	303
1934b8b6 BC	304	if (prebuffer >= iso->buf_packets)
1934b8b6 BC	305	prebuffer = iso->buf_packets - 1;
1da177e4 LT	306
	307	iso->prebuffer = prebuffer;
	308
	309	/* remember the starting cycle; DMA will commence from xmit_queue_packets()
	310	once enough packets have been buffered */
	311	iso->start_cycle = cycle;
	312
	313	return 0;
	314	}
	315
afd6546d SR	316	/**
	317	* hpsb_iso_recv_start - start DMA
	318	*/
1da177e4 LT	319	int hpsb_iso_recv_start(struct hpsb_iso *iso, int cycle, int tag_mask, int sync)
	320	{
	321	int retval = 0;
	322	int isoctl_args[3];
	323
	324	if (iso->type != HPSB_ISO_RECV)
	325	return -1;
	326
	327	if (iso->flags & HPSB_ISO_DRIVER_STARTED)
	328	return 0;
	329
	330	if (cycle < -1)
	331	cycle = -1;
	332	else if (cycle >= 8000)
	333	cycle %= 8000;
	334
	335	isoctl_args[0] = cycle;
	336
	337	if (tag_mask < 0)
	338	/* match all tags */
	339	tag_mask = 0xF;
	340	isoctl_args[1] = tag_mask;
	341
	342	isoctl_args[2] = sync;
	343
066ef9c2 JMH	344	retval =
	345	iso->host->driver->isoctl(iso, RECV_START,
	346	(unsigned long)&isoctl_args[0]);
1da177e4 LT	347	if (retval)
	348	return retval;
	349
	350	iso->flags \|= HPSB_ISO_DRIVER_STARTED;
	351	return retval;
	352	}
	353
	354	/* check to make sure the user has not supplied bogus values of offset/len
afd6546d	355	* that would cause the kernel to access memory outside the buffer */
1da177e4 LT	356	static int hpsb_iso_check_offset_len(struct hpsb_iso *iso,
1da177e4 LT	357	unsigned int offset, unsigned short len,
066ef9c2 JMH	358	unsigned int *out_offset,
066ef9c2 JMH	359	unsigned short *out_len)
1da177e4 LT	360	{
	361	if (offset >= iso->buf_size)
	362	return -EFAULT;
	363
	364	/* make sure the packet does not go beyond the end of the buffer */
	365	if (offset + len > iso->buf_size)
	366	return -EFAULT;
	367
	368	/* check for wrap-around */
	369	if (offset + len < offset)
	370	return -EFAULT;
	371
	372	/* now we can trust 'offset' and 'length' */
	373	*out_offset = offset;
	374	*out_len = len;
	375
	376	return 0;
	377	}
	378
afd6546d SR	379	/**
	380	* hpsb_iso_xmit_queue_packet - queue a packet for transmission.
	381	*
	382	* @offset is relative to the beginning of the DMA buffer, where the packet's
	383	* data payload should already have been placed.
	384	*/
066ef9c2 JMH	385	int hpsb_iso_xmit_queue_packet(struct hpsb_iso *iso, u32 offset, u16 len,
066ef9c2 JMH	386	u8 tag, u8 sy)
1da177e4 LT	387	{
	388	struct hpsb_iso_packet_info *info;
	389	unsigned long flags;
	390	int rv;
	391
	392	if (iso->type != HPSB_ISO_XMIT)
	393	return -EINVAL;
	394
	395	/* is there space in the buffer? */
	396	if (iso->n_ready_packets <= 0) {
	397	return -EBUSY;
	398	}
	399
	400	info = &iso->infos[iso->first_packet];
	401
	402	/* check for bogus offset/length */
066ef9c2 JMH	403	if (hpsb_iso_check_offset_len
066ef9c2 JMH	404	(iso, offset, len, &info->offset, &info->len))
1da177e4 LT	405	return -EFAULT;
	406
	407	info->tag = tag;
	408	info->sy = sy;
	409
	410	spin_lock_irqsave(&iso->lock, flags);
	411
066ef9c2	412	rv = iso->host->driver->isoctl(iso, XMIT_QUEUE, (unsigned long)info);
1da177e4 LT	413	if (rv)
	414	goto out;
	415
	416	/* increment cursors */
066ef9c2 JMH	417	iso->first_packet = (iso->first_packet + 1) % iso->buf_packets;
066ef9c2 JMH	418	iso->xmit_cycle = (iso->xmit_cycle + 1) % 8000;
1da177e4 LT	419	iso->n_ready_packets--;
	420
	421	if (iso->prebuffer != 0) {
	422	iso->prebuffer--;
	423	if (iso->prebuffer <= 0) {
	424	iso->prebuffer = 0;
	425	rv = do_iso_xmit_start(iso, iso->start_cycle);
	426	}
	427	}
	428
066ef9c2	429	out:
1da177e4 LT	430	spin_unlock_irqrestore(&iso->lock, flags);
	431	return rv;
	432	}
	433
afd6546d SR	434	/**
	435	* hpsb_iso_xmit_sync - wait until all queued packets have been transmitted
	436	*/
1da177e4 LT	437	int hpsb_iso_xmit_sync(struct hpsb_iso *iso)
	438	{
	439	if (iso->type != HPSB_ISO_XMIT)
	440	return -EINVAL;
	441
066ef9c2 JMH	442	return wait_event_interruptible(iso->waitq,
	443	hpsb_iso_n_ready(iso) ==
	444	iso->buf_packets);
1da177e4 LT	445	}
1da177e4 LT	446
afd6546d SR	447	/**
	448	* hpsb_iso_packet_sent
	449	*
	450	* Available to low-level drivers.
	451	*
	452	* Call after a packet has been transmitted to the bus (interrupt context is
	453	* OK). @cycle is the _exact_ cycle the packet was sent on. @error should be
	454	* non-zero if some sort of error occurred when sending the packet.
	455	*/
1da177e4 LT	456	void hpsb_iso_packet_sent(struct hpsb_iso *iso, int cycle, int error)
	457	{
	458	unsigned long flags;
	459	spin_lock_irqsave(&iso->lock, flags);
	460
	461	/* predict the cycle of the next packet to be queued */
	462
	463	/* jump ahead by the number of packets that are already buffered */
	464	cycle += iso->buf_packets - iso->n_ready_packets;
	465	cycle %= 8000;
	466
	467	iso->xmit_cycle = cycle;
	468	iso->n_ready_packets++;
	469	iso->pkt_dma = (iso->pkt_dma + 1) % iso->buf_packets;
	470
	471	if (iso->n_ready_packets == iso->buf_packets \|\| error != 0) {
	472	/* the buffer has run empty! */
	473	atomic_inc(&iso->overflows);
	474	}
	475
	476	spin_unlock_irqrestore(&iso->lock, flags);
	477	}
	478
afd6546d SR	479	/**
	480	* hpsb_iso_packet_received
	481	*
	482	* Available to low-level drivers.
	483	*
	484	* Call after a packet has been received (interrupt context is OK).
	485	*/
1da177e4	486	void hpsb_iso_packet_received(struct hpsb_iso *iso, u32 offset, u16 len,
066ef9c2 JMH	487	u16 total_len, u16 cycle, u8 channel, u8 tag,
066ef9c2 JMH	488	u8 sy)
1da177e4 LT	489	{
	490	unsigned long flags;
	491	spin_lock_irqsave(&iso->lock, flags);
	492
	493	if (iso->n_ready_packets == iso->buf_packets) {
	494	/* overflow! */
	495	atomic_inc(&iso->overflows);
1934b8b6 BC	496	/* Record size of this discarded packet */
1934b8b6 BC	497	iso->bytes_discarded += total_len;
1da177e4 LT	498	} else {
	499	struct hpsb_iso_packet_info *info = &iso->infos[iso->pkt_dma];
	500	info->offset = offset;
	501	info->len = len;
1934b8b6	502	info->total_len = total_len;
1da177e4 LT	503	info->cycle = cycle;
	504	info->channel = channel;
	505	info->tag = tag;
	506	info->sy = sy;
	507
066ef9c2	508	iso->pkt_dma = (iso->pkt_dma + 1) % iso->buf_packets;
1da177e4 LT	509	iso->n_ready_packets++;
	510	}
	511
	512	spin_unlock_irqrestore(&iso->lock, flags);
	513	}
	514
afd6546d SR	515	/**
	516	* hpsb_iso_recv_release_packets - release packets, reuse buffer
	517	*
	518	* @n_packets have been read out of the buffer, re-use the buffer space
	519	*/
1da177e4 LT	520	int hpsb_iso_recv_release_packets(struct hpsb_iso *iso, unsigned int n_packets)
	521	{
	522	unsigned long flags;
	523	unsigned int i;
	524	int rv = 0;
	525
	526	if (iso->type != HPSB_ISO_RECV)
	527	return -1;
	528
	529	spin_lock_irqsave(&iso->lock, flags);
	530	for (i = 0; i < n_packets; i++) {
	531	rv = iso->host->driver->isoctl(iso, RECV_RELEASE,
066ef9c2 JMH	532	(unsigned long)&iso->infos[iso->
066ef9c2 JMH	533	first_packet]);
1da177e4 LT	534	if (rv)
	535	break;
	536
066ef9c2	537	iso->first_packet = (iso->first_packet + 1) % iso->buf_packets;
1da177e4	538	iso->n_ready_packets--;
1934b8b6 BC	539
1934b8b6 BC	540	/* release memory from packets discarded when queue was full */
066ef9c2	541	if (iso->n_ready_packets == 0) { /* Release only after all prior packets handled */
1934b8b6 BC	542	if (iso->bytes_discarded != 0) {
	543	struct hpsb_iso_packet_info inf;
	544	inf.total_len = iso->bytes_discarded;
	545	iso->host->driver->isoctl(iso, RECV_RELEASE,
066ef9c2	546	(unsigned long)&inf);
1934b8b6 BC	547	iso->bytes_discarded = 0;
	548	}
	549	}
1da177e4 LT	550	}
	551	spin_unlock_irqrestore(&iso->lock, flags);
	552	return rv;
	553	}
	554
afd6546d SR	555	/**
	556	* hpsb_iso_wake
	557	*
	558	* Available to low-level drivers.
	559	*
	560	* Call to wake waiting processes after buffer space has opened up.
	561	*/
1da177e4 LT	562	void hpsb_iso_wake(struct hpsb_iso *iso)
	563	{
	564	wake_up_interruptible(&iso->waitq);
	565
	566	if (iso->callback)
	567	iso->callback(iso);
	568	}