[linux-2.6-block.git] / sound / firewire / iso-resources.c

/*
 * isochronous resources helper functions
 *
 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
 * Licensed under the terms of the GNU General Public License, version 2.
 */

#include <linux/device.h>
#include <linux/firewire.h>
#include <linux/firewire-constants.h>
#include <linux/export.h>
#include <linux/jiffies.h>
#include <linux/mutex.h>
#include <linux/sched.h>
#include <linux/spinlock.h>
#include "iso-resources.h"

/**
 * fw_iso_resources_init - initializes a &struct fw_iso_resources
 * @r: the resource manager to initialize
 * @unit: the device unit for which the resources will be needed
 *
 * If the device does not support all channel numbers, change @r->channels_mask
 * after calling this function.
 */
int fw_iso_resources_init(struct fw_iso_resources *r, struct fw_unit *unit)
{
	r->channels_mask = ~0uLL;
	r->unit = fw_unit_get(unit);
	mutex_init(&r->mutex);
	r->allocated = false;

	return 0;
}
EXPORT_SYMBOL(fw_iso_resources_init);

/**
 * fw_iso_resources_destroy - destroy a resource manager
 * @r: the resource manager that is no longer needed
 */
void fw_iso_resources_destroy(struct fw_iso_resources *r)
{
	WARN_ON(r->allocated);
	mutex_destroy(&r->mutex);
	fw_unit_put(r->unit);
}
EXPORT_SYMBOL(fw_iso_resources_destroy);

static unsigned int packet_bandwidth(unsigned int max_payload_bytes, int speed)
{
	unsigned int bytes, s400_bytes;

	/* iso packets have three header quadlets and quadlet-aligned payload */
	bytes = 3 * 4 + ALIGN(max_payload_bytes, 4);

	/* convert to bandwidth units (quadlets at S1600 = bytes at S400) */
	if (speed <= SCODE_400)
		s400_bytes = bytes * (1 << (SCODE_400 - speed));
	else
		s400_bytes = DIV_ROUND_UP(bytes, 1 << (speed - SCODE_400));

	return s400_bytes;
}

static int current_bandwidth_overhead(struct fw_card *card)
{
	/*
	 * Under the usual pessimistic assumption (cable length 4.5 m), the
	 * isochronous overhead for N cables is 1.797 µs + N * 0.494 µs, or
	 * 88.3 + N * 24.3 in bandwidth units.
	 *
	 * The calculation below tries to deduce N from the current gap count.
	 * If the gap count has been optimized by measuring the actual packet
	 * transmission time, this derived overhead should be near the actual
	 * overhead as well.
	 */
	return card->gap_count < 63 ? card->gap_count * 97 / 10 + 89 : 512;
}

static int wait_isoch_resource_delay_after_bus_reset(struct fw_card *card)
{
	for (;;) {
		s64 delay = (card->reset_jiffies + HZ) - get_jiffies_64();
		if (delay <= 0)
			return 0;
		if (schedule_timeout_interruptible(delay) > 0)
			return -ERESTARTSYS;
	}
}

/**
 * fw_iso_resources_allocate - allocate isochronous channel and bandwidth
 * @r: the resource manager
 * @max_payload_bytes: the amount of data (including CIP headers) per packet
 * @speed: the speed (e.g., SCODE_400) at which the packets will be sent
 *
 * This function allocates one isochronous channel and enough bandwidth for the
 * specified packet size.
 *
 * Returns the channel number that the caller must use for streaming, or
 * a negative error code.  Due to potentionally long delays, this function is
 * interruptible and can return -ERESTARTSYS.  On success, the caller is
 * responsible for calling fw_iso_resources_update() on bus resets, and
 * fw_iso_resources_free() when the resources are not longer needed.
 */
int fw_iso_resources_allocate(struct fw_iso_resources *r,
			      unsigned int max_payload_bytes, int speed)
{
	struct fw_card *card = fw_parent_device(r->unit)->card;
	int bandwidth, channel, err;

	if (WARN_ON(r->allocated))
		return -EBADFD;

	r->bandwidth = packet_bandwidth(max_payload_bytes, speed);

retry_after_bus_reset:
	spin_lock_irq(&card->lock);
	r->generation = card->generation;
	r->bandwidth_overhead = current_bandwidth_overhead(card);
	spin_unlock_irq(&card->lock);

	err = wait_isoch_resource_delay_after_bus_reset(card);
	if (err < 0)
		return err;

	mutex_lock(&r->mutex);

	bandwidth = r->bandwidth + r->bandwidth_overhead;
	fw_iso_resource_manage(card, r->generation, r->channels_mask,
			       &channel, &bandwidth, true);
	if (channel == -EAGAIN) {
		mutex_unlock(&r->mutex);
		goto retry_after_bus_reset;
	}
	if (channel >= 0) {
		r->channel = channel;
		r->allocated = true;
	} else {
		if (channel == -EBUSY)
			dev_err(&r->unit->device,
				"isochronous resources exhausted\n");
		else
			dev_err(&r->unit->device,
				"isochronous resource allocation failed\n");
	}

	mutex_unlock(&r->mutex);

	return channel;
}
EXPORT_SYMBOL(fw_iso_resources_allocate);

/**
 * fw_iso_resources_update - update resource allocations after a bus reset
 * @r: the resource manager
 *
 * This function must be called from the driver's .update handler to reallocate
 * any resources that were allocated before the bus reset.  It is safe to call
 * this function if no resources are currently allocated.
 *
 * Returns a negative error code on failure.  If this happens, the caller must
 * stop streaming.
 */
int fw_iso_resources_update(struct fw_iso_resources *r)
{
	struct fw_card *card = fw_parent_device(r->unit)->card;
	int bandwidth, channel;

	mutex_lock(&r->mutex);

	if (!r->allocated) {
		mutex_unlock(&r->mutex);
		return 0;
	}

	spin_lock_irq(&card->lock);
	r->generation = card->generation;
	r->bandwidth_overhead = current_bandwidth_overhead(card);
	spin_unlock_irq(&card->lock);

	bandwidth = r->bandwidth + r->bandwidth_overhead;

	fw_iso_resource_manage(card, r->generation, 1uLL << r->channel,
			       &channel, &bandwidth, true);
	/*
	 * When another bus reset happens, pretend that the allocation
	 * succeeded; we will try again for the new generation later.
	 */
	if (channel < 0 && channel != -EAGAIN) {
		r->allocated = false;
		if (channel == -EBUSY)
			dev_err(&r->unit->device,
				"isochronous resources exhausted\n");
		else
			dev_err(&r->unit->device,
				"isochronous resource allocation failed\n");
	}

	mutex_unlock(&r->mutex);

	return channel;
}
EXPORT_SYMBOL(fw_iso_resources_update);

/**
 * fw_iso_resources_free - frees allocated resources
 * @r: the resource manager
 *
 * This function deallocates the channel and bandwidth, if allocated.
 */
void fw_iso_resources_free(struct fw_iso_resources *r)
{
	struct fw_card *card = fw_parent_device(r->unit)->card;
	int bandwidth, channel;

	mutex_lock(&r->mutex);

	if (r->allocated) {
		bandwidth = r->bandwidth + r->bandwidth_overhead;
		fw_iso_resource_manage(card, r->generation, 1uLL << r->channel,
				       &channel, &bandwidth, false);
		if (channel < 0)
			dev_err(&r->unit->device,
				"isochronous resource deallocation failed\n");

		r->allocated = false;
	}

	mutex_unlock(&r->mutex);
}
EXPORT_SYMBOL(fw_iso_resources_free);
Commit	Line	Data
31ef9134 CL	1	/*
	2	* isochronous resources helper functions
	3	*
	4	* Copyright (c) Clemens Ladisch <clemens@ladisch.de>
	5	* Licensed under the terms of the GNU General Public License, version 2.
	6	*/
	7
	8	#include <linux/device.h>
	9	#include <linux/firewire.h>
	10	#include <linux/firewire-constants.h>
d81a6d71	11	#include <linux/export.h>
31ef9134 CL	12	#include <linux/jiffies.h>
	13	#include <linux/mutex.h>
	14	#include <linux/sched.h>
	15	#include <linux/spinlock.h>
	16	#include "iso-resources.h"
	17
	18	/**
	19	* fw_iso_resources_init - initializes a &struct fw_iso_resources
	20	* @r: the resource manager to initialize
	21	* @unit: the device unit for which the resources will be needed
	22	*
	23	* If the device does not support all channel numbers, change @r->channels_mask
	24	* after calling this function.
	25	*/
5b2599a0	26	int fw_iso_resources_init(struct fw_iso_resources r, struct fw_unit unit)
31ef9134 CL	27	{
	28	r->channels_mask = ~0uLL;
	29	r->unit = fw_unit_get(unit);
	30	mutex_init(&r->mutex);
	31	r->allocated = false;
5b2599a0 CL	32
5b2599a0 CL	33	return 0;
31ef9134	34	}
3a691b28	35	EXPORT_SYMBOL(fw_iso_resources_init);
31ef9134 CL	36
	37	/**
	38	* fw_iso_resources_destroy - destroy a resource manager
	39	* @r: the resource manager that is no longer needed
	40	*/
	41	void fw_iso_resources_destroy(struct fw_iso_resources *r)
	42	{
	43	WARN_ON(r->allocated);
	44	mutex_destroy(&r->mutex);
	45	fw_unit_put(r->unit);
	46	}
3a691b28	47	EXPORT_SYMBOL(fw_iso_resources_destroy);
31ef9134 CL	48
	49	static unsigned int packet_bandwidth(unsigned int max_payload_bytes, int speed)
	50	{
	51	unsigned int bytes, s400_bytes;
	52
	53	/* iso packets have three header quadlets and quadlet-aligned payload */
	54	bytes = 3 * 4 + ALIGN(max_payload_bytes, 4);
	55
	56	/* convert to bandwidth units (quadlets at S1600 = bytes at S400) */
	57	if (speed <= SCODE_400)
	58	s400_bytes = bytes * (1 << (SCODE_400 - speed));
	59	else
	60	s400_bytes = DIV_ROUND_UP(bytes, 1 << (speed - SCODE_400));
	61
	62	return s400_bytes;
	63	}
	64
	65	static int current_bandwidth_overhead(struct fw_card *card)
	66	{
	67	/*
	68	* Under the usual pessimistic assumption (cable length 4.5 m), the
	69	* isochronous overhead for N cables is 1.797 µs + N * 0.494 µs, or
	70	* 88.3 + N * 24.3 in bandwidth units.
	71	*
	72	* The calculation below tries to deduce N from the current gap count.
	73	* If the gap count has been optimized by measuring the actual packet
	74	* transmission time, this derived overhead should be near the actual
	75	* overhead as well.
	76	*/
	77	return card->gap_count < 63 ? card->gap_count * 97 / 10 + 89 : 512;
	78	}
	79
	80	static int wait_isoch_resource_delay_after_bus_reset(struct fw_card *card)
	81	{
	82	for (;;) {
	83	s64 delay = (card->reset_jiffies + HZ) - get_jiffies_64();
	84	if (delay <= 0)
	85	return 0;
	86	if (schedule_timeout_interruptible(delay) > 0)
	87	return -ERESTARTSYS;
	88	}
	89	}
	90
	91	/**
	92	* fw_iso_resources_allocate - allocate isochronous channel and bandwidth
	93	* @r: the resource manager
	94	* @max_payload_bytes: the amount of data (including CIP headers) per packet
	95	* @speed: the speed (e.g., SCODE_400) at which the packets will be sent
	96	*
	97	* This function allocates one isochronous channel and enough bandwidth for the
	98	* specified packet size.
	99	*
	100	* Returns the channel number that the caller must use for streaming, or
	101	* a negative error code. Due to potentionally long delays, this function is
	102	* interruptible and can return -ERESTARTSYS. On success, the caller is
	103	* responsible for calling fw_iso_resources_update() on bus resets, and
	104	* fw_iso_resources_free() when the resources are not longer needed.
	105	*/
	106	int fw_iso_resources_allocate(struct fw_iso_resources *r,
	107	unsigned int max_payload_bytes, int speed)
	108	{
	109	struct fw_card *card = fw_parent_device(r->unit)->card;
	110	int bandwidth, channel, err;
	111
112	if (WARN_ON(r->allocated))
113	return -EBADFD;
114
115	r->bandwidth = packet_bandwidth(max_payload_bytes, speed);
116
117	retry_after_bus_reset:
118	spin_lock_irq(&card->lock);
119	r->generation = card->generation;
120	r->bandwidth_overhead = current_bandwidth_overhead(card);
121	spin_unlock_irq(&card->lock);
122
123	err = wait_isoch_resource_delay_after_bus_reset(card);
124	if (err < 0)
125	return err;
126
127	mutex_lock(&r->mutex);
128
129	bandwidth = r->bandwidth + r->bandwidth_overhead;
130	fw_iso_resource_manage(card, r->generation, r->channels_mask,
f30e6d3e	131	&channel, &bandwidth, true);
31ef9134 CL	132	if (channel == -EAGAIN) {
	133	mutex_unlock(&r->mutex);
	134	goto retry_after_bus_reset;
	135	}
	136	if (channel >= 0) {
	137	r->channel = channel;
	138	r->allocated = true;
	139	} else {
	140	if (channel == -EBUSY)
	141	dev_err(&r->unit->device,
	142	"isochronous resources exhausted\n");
	143	else
	144	dev_err(&r->unit->device,
	145	"isochronous resource allocation failed\n");
	146	}
	147
	148	mutex_unlock(&r->mutex);
	149
	150	return channel;
	151	}
3a691b28	152	EXPORT_SYMBOL(fw_iso_resources_allocate);
31ef9134 CL	153
	154	/**
	155	* fw_iso_resources_update - update resource allocations after a bus reset
	156	* @r: the resource manager
	157	*
	158	* This function must be called from the driver's .update handler to reallocate
	159	* any resources that were allocated before the bus reset. It is safe to call
	160	* this function if no resources are currently allocated.
	161	*
	162	* Returns a negative error code on failure. If this happens, the caller must
	163	* stop streaming.
	164	*/
	165	int fw_iso_resources_update(struct fw_iso_resources *r)
	166	{
	167	struct fw_card *card = fw_parent_device(r->unit)->card;
	168	int bandwidth, channel;
	169
	170	mutex_lock(&r->mutex);
	171
	172	if (!r->allocated) {
	173	mutex_unlock(&r->mutex);
	174	return 0;
	175	}
	176
	177	spin_lock_irq(&card->lock);
	178	r->generation = card->generation;
	179	r->bandwidth_overhead = current_bandwidth_overhead(card);
	180	spin_unlock_irq(&card->lock);
	181
	182	bandwidth = r->bandwidth + r->bandwidth_overhead;
	183
	184	fw_iso_resource_manage(card, r->generation, 1uLL << r->channel,
f30e6d3e	185	&channel, &bandwidth, true);
31ef9134 CL	186	/*
	187	* When another bus reset happens, pretend that the allocation
	188	* succeeded; we will try again for the new generation later.
	189	*/
	190	if (channel < 0 && channel != -EAGAIN) {
	191	r->allocated = false;
	192	if (channel == -EBUSY)
	193	dev_err(&r->unit->device,
	194	"isochronous resources exhausted\n");
	195	else
	196	dev_err(&r->unit->device,
	197	"isochronous resource allocation failed\n");
	198	}
	199
	200	mutex_unlock(&r->mutex);
	201
	202	return channel;
	203	}
3a691b28	204	EXPORT_SYMBOL(fw_iso_resources_update);
31ef9134 CL	205
	206	/**
	207	* fw_iso_resources_free - frees allocated resources
	208	* @r: the resource manager
	209	*
	210	* This function deallocates the channel and bandwidth, if allocated.
	211	*/
	212	void fw_iso_resources_free(struct fw_iso_resources *r)
	213	{
	214	struct fw_card *card = fw_parent_device(r->unit)->card;
	215	int bandwidth, channel;
	216
	217	mutex_lock(&r->mutex);
	218
	219	if (r->allocated) {
	220	bandwidth = r->bandwidth + r->bandwidth_overhead;
	221	fw_iso_resource_manage(card, r->generation, 1uLL << r->channel,
f30e6d3e	222	&channel, &bandwidth, false);
31ef9134 CL	223	if (channel < 0)
	224	dev_err(&r->unit->device,
	225	"isochronous resource deallocation failed\n");
	226
	227	r->allocated = false;
	228	}
	229
	230	mutex_unlock(&r->mutex);
	231	}
3a691b28	232	EXPORT_SYMBOL(fw_iso_resources_free);