Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab...
[pandora-kernel.git] / sound / firewire / iso-resources.c
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 }