2 * isochronous resources helper functions
4 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
5 * Licensed under the terms of the GNU General Public License, version 2.
8 #include <linux/device.h>
9 #include <linux/firewire.h>
10 #include <linux/firewire-constants.h>
11 #include <linux/export.h>
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"
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
23 * If the device does not support all channel numbers, change @r->channels_mask
24 * after calling this function.
26 int fw_iso_resources_init(struct fw_iso_resources
*r
, struct fw_unit
*unit
)
28 r
->channels_mask
= ~0uLL;
30 mutex_init(&r
->mutex
);
35 EXPORT_SYMBOL(fw_iso_resources_init
);
38 * fw_iso_resources_destroy - destroy a resource manager
39 * @r: the resource manager that is no longer needed
41 void fw_iso_resources_destroy(struct fw_iso_resources
*r
)
43 WARN_ON(r
->allocated
);
44 mutex_destroy(&r
->mutex
);
46 EXPORT_SYMBOL(fw_iso_resources_destroy
);
48 static unsigned int packet_bandwidth(unsigned int max_payload_bytes
, int speed
)
50 unsigned int bytes
, s400_bytes
;
52 /* iso packets have three header quadlets and quadlet-aligned payload */
53 bytes
= 3 * 4 + ALIGN(max_payload_bytes
, 4);
55 /* convert to bandwidth units (quadlets at S1600 = bytes at S400) */
56 if (speed
<= SCODE_400
)
57 s400_bytes
= bytes
* (1 << (SCODE_400
- speed
));
59 s400_bytes
= DIV_ROUND_UP(bytes
, 1 << (speed
- SCODE_400
));
64 static int current_bandwidth_overhead(struct fw_card
*card
)
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.
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
76 return card
->gap_count
< 63 ? card
->gap_count
* 97 / 10 + 89 : 512;
79 static int wait_isoch_resource_delay_after_bus_reset(struct fw_card
*card
)
82 s64 delay
= (card
->reset_jiffies
+ HZ
) - get_jiffies_64();
85 if (schedule_timeout_interruptible(delay
) > 0)
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
96 * This function allocates one isochronous channel and enough bandwidth for the
97 * specified packet size.
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.
105 int fw_iso_resources_allocate(struct fw_iso_resources
*r
,
106 unsigned int max_payload_bytes
, int speed
)
108 struct fw_card
*card
= fw_parent_device(r
->unit
)->card
;
109 int bandwidth
, channel
, err
;
111 if (WARN_ON(r
->allocated
))
114 r
->bandwidth
= packet_bandwidth(max_payload_bytes
, speed
);
116 retry_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
);
122 err
= wait_isoch_resource_delay_after_bus_reset(card
);
126 mutex_lock(&r
->mutex
);
128 bandwidth
= r
->bandwidth
+ r
->bandwidth_overhead
;
129 fw_iso_resource_manage(card
, r
->generation
, r
->channels_mask
,
130 &channel
, &bandwidth
, true);
131 if (channel
== -EAGAIN
) {
132 mutex_unlock(&r
->mutex
);
133 goto retry_after_bus_reset
;
136 r
->channel
= channel
;
139 if (channel
== -EBUSY
)
140 dev_err(&r
->unit
->device
,
141 "isochronous resources exhausted\n");
143 dev_err(&r
->unit
->device
,
144 "isochronous resource allocation failed\n");
147 mutex_unlock(&r
->mutex
);
151 EXPORT_SYMBOL(fw_iso_resources_allocate
);
154 * fw_iso_resources_update - update resource allocations after a bus reset
155 * @r: the resource manager
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.
161 * Returns a negative error code on failure. If this happens, the caller must
164 int fw_iso_resources_update(struct fw_iso_resources
*r
)
166 struct fw_card
*card
= fw_parent_device(r
->unit
)->card
;
167 int bandwidth
, channel
;
169 mutex_lock(&r
->mutex
);
172 mutex_unlock(&r
->mutex
);
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
);
181 bandwidth
= r
->bandwidth
+ r
->bandwidth_overhead
;
183 fw_iso_resource_manage(card
, r
->generation
, 1uLL << r
->channel
,
184 &channel
, &bandwidth
, true);
186 * When another bus reset happens, pretend that the allocation
187 * succeeded; we will try again for the new generation later.
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");
195 dev_err(&r
->unit
->device
,
196 "isochronous resource allocation failed\n");
199 mutex_unlock(&r
->mutex
);
203 EXPORT_SYMBOL(fw_iso_resources_update
);
206 * fw_iso_resources_free - frees allocated resources
207 * @r: the resource manager
209 * This function deallocates the channel and bandwidth, if allocated.
211 void fw_iso_resources_free(struct fw_iso_resources
*r
)
213 struct fw_card
*card
= fw_parent_device(r
->unit
)->card
;
214 int bandwidth
, channel
;
216 mutex_lock(&r
->mutex
);
219 bandwidth
= r
->bandwidth
+ r
->bandwidth_overhead
;
220 fw_iso_resource_manage(card
, r
->generation
, 1uLL << r
->channel
,
221 &channel
, &bandwidth
, false);
223 dev_err(&r
->unit
->device
,
224 "isochronous resource deallocation failed\n");
226 r
->allocated
= false;
229 mutex_unlock(&r
->mutex
);
231 EXPORT_SYMBOL(fw_iso_resources_free
);