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