forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
236 lines
6.5 KiB
236 lines
6.5 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* isochronous resources helper functions |
|
* |
|
* Copyright (c) Clemens Ladisch <[email protected]> |
|
*/ |
|
|
|
#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 = 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); |
|
} |
|
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; |
|
int bandwidth, channel; |
|
|
|
/* Not initialized. */ |
|
if (r->unit == NULL) |
|
return; |
|
card = fw_parent_device(r->unit)->card; |
|
|
|
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);
|
|
|