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