diff options
author | Stefan Richter <stefanr@s5r6.in-berlin.de> | 2009-06-05 10:26:18 -0400 |
---|---|---|
committer | Stefan Richter <stefanr@s5r6.in-berlin.de> | 2009-06-05 10:26:18 -0400 |
commit | e71d31da062095d8b0b02a26fb5e8879e8d3d0de (patch) | |
tree | 6d45660ec489d9d58bad51a02d8d8877b534e81b /drivers/firewire/fw-iso.c | |
parent | 77c9a5daa9c4d9b37812c9c69c7bcbb3f9399c3c (diff) |
firewire: rename source files
The source files of firewire-core, firewire-ohci, firewire-sbp2, i.e.
"drivers/firewire/fw-*.c"
are renamed to
"drivers/firewire/core-*.c",
"drivers/firewire/ohci.c",
"drivers/firewire/sbp2.c".
The old fw- prefix was redundant to the directory name. The new core-
prefix distinguishes the files according to which driver they belong to.
This change comes a little late, but still before further firewire
drivers are added as anticipated RSN.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Diffstat (limited to 'drivers/firewire/fw-iso.c')
-rw-r--r-- | drivers/firewire/fw-iso.c | 329 |
1 files changed, 0 insertions, 329 deletions
diff --git a/drivers/firewire/fw-iso.c b/drivers/firewire/fw-iso.c deleted file mode 100644 index 28076c892d7e..000000000000 --- a/drivers/firewire/fw-iso.c +++ /dev/null | |||
@@ -1,329 +0,0 @@ | |||
1 | /* | ||
2 | * Isochronous I/O functionality: | ||
3 | * - Isochronous DMA context management | ||
4 | * - Isochronous bus resource management (channels, bandwidth), client side | ||
5 | * | ||
6 | * Copyright (C) 2006 Kristian Hoegsberg <krh@bitplanet.net> | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License as published by | ||
10 | * the Free Software Foundation; either version 2 of the License, or | ||
11 | * (at your option) any later version. | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, | ||
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
16 | * GNU General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with this program; if not, write to the Free Software Foundation, | ||
20 | * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | ||
21 | */ | ||
22 | |||
23 | #include <linux/dma-mapping.h> | ||
24 | #include <linux/errno.h> | ||
25 | #include <linux/firewire.h> | ||
26 | #include <linux/firewire-constants.h> | ||
27 | #include <linux/kernel.h> | ||
28 | #include <linux/mm.h> | ||
29 | #include <linux/spinlock.h> | ||
30 | #include <linux/vmalloc.h> | ||
31 | |||
32 | #include <asm/byteorder.h> | ||
33 | |||
34 | #include "core.h" | ||
35 | |||
36 | /* | ||
37 | * Isochronous DMA context management | ||
38 | */ | ||
39 | |||
40 | int fw_iso_buffer_init(struct fw_iso_buffer *buffer, struct fw_card *card, | ||
41 | int page_count, enum dma_data_direction direction) | ||
42 | { | ||
43 | int i, j; | ||
44 | dma_addr_t address; | ||
45 | |||
46 | buffer->page_count = page_count; | ||
47 | buffer->direction = direction; | ||
48 | |||
49 | buffer->pages = kmalloc(page_count * sizeof(buffer->pages[0]), | ||
50 | GFP_KERNEL); | ||
51 | if (buffer->pages == NULL) | ||
52 | goto out; | ||
53 | |||
54 | for (i = 0; i < buffer->page_count; i++) { | ||
55 | buffer->pages[i] = alloc_page(GFP_KERNEL | GFP_DMA32 | __GFP_ZERO); | ||
56 | if (buffer->pages[i] == NULL) | ||
57 | goto out_pages; | ||
58 | |||
59 | address = dma_map_page(card->device, buffer->pages[i], | ||
60 | 0, PAGE_SIZE, direction); | ||
61 | if (dma_mapping_error(card->device, address)) { | ||
62 | __free_page(buffer->pages[i]); | ||
63 | goto out_pages; | ||
64 | } | ||
65 | set_page_private(buffer->pages[i], address); | ||
66 | } | ||
67 | |||
68 | return 0; | ||
69 | |||
70 | out_pages: | ||
71 | for (j = 0; j < i; j++) { | ||
72 | address = page_private(buffer->pages[j]); | ||
73 | dma_unmap_page(card->device, address, | ||
74 | PAGE_SIZE, DMA_TO_DEVICE); | ||
75 | __free_page(buffer->pages[j]); | ||
76 | } | ||
77 | kfree(buffer->pages); | ||
78 | out: | ||
79 | buffer->pages = NULL; | ||
80 | |||
81 | return -ENOMEM; | ||
82 | } | ||
83 | |||
84 | int fw_iso_buffer_map(struct fw_iso_buffer *buffer, struct vm_area_struct *vma) | ||
85 | { | ||
86 | unsigned long uaddr; | ||
87 | int i, err; | ||
88 | |||
89 | uaddr = vma->vm_start; | ||
90 | for (i = 0; i < buffer->page_count; i++) { | ||
91 | err = vm_insert_page(vma, uaddr, buffer->pages[i]); | ||
92 | if (err) | ||
93 | return err; | ||
94 | |||
95 | uaddr += PAGE_SIZE; | ||
96 | } | ||
97 | |||
98 | return 0; | ||
99 | } | ||
100 | |||
101 | void fw_iso_buffer_destroy(struct fw_iso_buffer *buffer, | ||
102 | struct fw_card *card) | ||
103 | { | ||
104 | int i; | ||
105 | dma_addr_t address; | ||
106 | |||
107 | for (i = 0; i < buffer->page_count; i++) { | ||
108 | address = page_private(buffer->pages[i]); | ||
109 | dma_unmap_page(card->device, address, | ||
110 | PAGE_SIZE, DMA_TO_DEVICE); | ||
111 | __free_page(buffer->pages[i]); | ||
112 | } | ||
113 | |||
114 | kfree(buffer->pages); | ||
115 | buffer->pages = NULL; | ||
116 | } | ||
117 | |||
118 | struct fw_iso_context *fw_iso_context_create(struct fw_card *card, | ||
119 | int type, int channel, int speed, size_t header_size, | ||
120 | fw_iso_callback_t callback, void *callback_data) | ||
121 | { | ||
122 | struct fw_iso_context *ctx; | ||
123 | |||
124 | ctx = card->driver->allocate_iso_context(card, | ||
125 | type, channel, header_size); | ||
126 | if (IS_ERR(ctx)) | ||
127 | return ctx; | ||
128 | |||
129 | ctx->card = card; | ||
130 | ctx->type = type; | ||
131 | ctx->channel = channel; | ||
132 | ctx->speed = speed; | ||
133 | ctx->header_size = header_size; | ||
134 | ctx->callback = callback; | ||
135 | ctx->callback_data = callback_data; | ||
136 | |||
137 | return ctx; | ||
138 | } | ||
139 | |||
140 | void fw_iso_context_destroy(struct fw_iso_context *ctx) | ||
141 | { | ||
142 | struct fw_card *card = ctx->card; | ||
143 | |||
144 | card->driver->free_iso_context(ctx); | ||
145 | } | ||
146 | |||
147 | int fw_iso_context_start(struct fw_iso_context *ctx, | ||
148 | int cycle, int sync, int tags) | ||
149 | { | ||
150 | return ctx->card->driver->start_iso(ctx, cycle, sync, tags); | ||
151 | } | ||
152 | |||
153 | int fw_iso_context_queue(struct fw_iso_context *ctx, | ||
154 | struct fw_iso_packet *packet, | ||
155 | struct fw_iso_buffer *buffer, | ||
156 | unsigned long payload) | ||
157 | { | ||
158 | struct fw_card *card = ctx->card; | ||
159 | |||
160 | return card->driver->queue_iso(ctx, packet, buffer, payload); | ||
161 | } | ||
162 | |||
163 | int fw_iso_context_stop(struct fw_iso_context *ctx) | ||
164 | { | ||
165 | return ctx->card->driver->stop_iso(ctx); | ||
166 | } | ||
167 | |||
168 | /* | ||
169 | * Isochronous bus resource management (channels, bandwidth), client side | ||
170 | */ | ||
171 | |||
172 | static int manage_bandwidth(struct fw_card *card, int irm_id, int generation, | ||
173 | int bandwidth, bool allocate) | ||
174 | { | ||
175 | __be32 data[2]; | ||
176 | int try, new, old = allocate ? BANDWIDTH_AVAILABLE_INITIAL : 0; | ||
177 | |||
178 | /* | ||
179 | * On a 1394a IRM with low contention, try < 1 is enough. | ||
180 | * On a 1394-1995 IRM, we need at least try < 2. | ||
181 | * Let's just do try < 5. | ||
182 | */ | ||
183 | for (try = 0; try < 5; try++) { | ||
184 | new = allocate ? old - bandwidth : old + bandwidth; | ||
185 | if (new < 0 || new > BANDWIDTH_AVAILABLE_INITIAL) | ||
186 | break; | ||
187 | |||
188 | data[0] = cpu_to_be32(old); | ||
189 | data[1] = cpu_to_be32(new); | ||
190 | switch (fw_run_transaction(card, TCODE_LOCK_COMPARE_SWAP, | ||
191 | irm_id, generation, SCODE_100, | ||
192 | CSR_REGISTER_BASE + CSR_BANDWIDTH_AVAILABLE, | ||
193 | data, sizeof(data))) { | ||
194 | case RCODE_GENERATION: | ||
195 | /* A generation change frees all bandwidth. */ | ||
196 | return allocate ? -EAGAIN : bandwidth; | ||
197 | |||
198 | case RCODE_COMPLETE: | ||
199 | if (be32_to_cpup(data) == old) | ||
200 | return bandwidth; | ||
201 | |||
202 | old = be32_to_cpup(data); | ||
203 | /* Fall through. */ | ||
204 | } | ||
205 | } | ||
206 | |||
207 | return -EIO; | ||
208 | } | ||
209 | |||
210 | static int manage_channel(struct fw_card *card, int irm_id, int generation, | ||
211 | u32 channels_mask, u64 offset, bool allocate) | ||
212 | { | ||
213 | __be32 data[2], c, all, old; | ||
214 | int i, retry = 5; | ||
215 | |||
216 | old = all = allocate ? cpu_to_be32(~0) : 0; | ||
217 | |||
218 | for (i = 0; i < 32; i++) { | ||
219 | if (!(channels_mask & 1 << i)) | ||
220 | continue; | ||
221 | |||
222 | c = cpu_to_be32(1 << (31 - i)); | ||
223 | if ((old & c) != (all & c)) | ||
224 | continue; | ||
225 | |||
226 | data[0] = old; | ||
227 | data[1] = old ^ c; | ||
228 | switch (fw_run_transaction(card, TCODE_LOCK_COMPARE_SWAP, | ||
229 | irm_id, generation, SCODE_100, | ||
230 | offset, data, sizeof(data))) { | ||
231 | case RCODE_GENERATION: | ||
232 | /* A generation change frees all channels. */ | ||
233 | return allocate ? -EAGAIN : i; | ||
234 | |||
235 | case RCODE_COMPLETE: | ||
236 | if (data[0] == old) | ||
237 | return i; | ||
238 | |||
239 | old = data[0]; | ||
240 | |||
241 | /* Is the IRM 1394a-2000 compliant? */ | ||
242 | if ((data[0] & c) == (data[1] & c)) | ||
243 | continue; | ||
244 | |||
245 | /* 1394-1995 IRM, fall through to retry. */ | ||
246 | default: | ||
247 | if (retry--) | ||
248 | i--; | ||
249 | } | ||
250 | } | ||
251 | |||
252 | return -EIO; | ||
253 | } | ||
254 | |||
255 | static void deallocate_channel(struct fw_card *card, int irm_id, | ||
256 | int generation, int channel) | ||
257 | { | ||
258 | u32 mask; | ||
259 | u64 offset; | ||
260 | |||
261 | mask = channel < 32 ? 1 << channel : 1 << (channel - 32); | ||
262 | offset = channel < 32 ? CSR_REGISTER_BASE + CSR_CHANNELS_AVAILABLE_HI : | ||
263 | CSR_REGISTER_BASE + CSR_CHANNELS_AVAILABLE_LO; | ||
264 | |||
265 | manage_channel(card, irm_id, generation, mask, offset, false); | ||
266 | } | ||
267 | |||
268 | /** | ||
269 | * fw_iso_resource_manage - Allocate or deallocate a channel and/or bandwidth | ||
270 | * | ||
271 | * In parameters: card, generation, channels_mask, bandwidth, allocate | ||
272 | * Out parameters: channel, bandwidth | ||
273 | * This function blocks (sleeps) during communication with the IRM. | ||
274 | * | ||
275 | * Allocates or deallocates at most one channel out of channels_mask. | ||
276 | * channels_mask is a bitfield with MSB for channel 63 and LSB for channel 0. | ||
277 | * (Note, the IRM's CHANNELS_AVAILABLE is a big-endian bitfield with MSB for | ||
278 | * channel 0 and LSB for channel 63.) | ||
279 | * Allocates or deallocates as many bandwidth allocation units as specified. | ||
280 | * | ||
281 | * Returns channel < 0 if no channel was allocated or deallocated. | ||
282 | * Returns bandwidth = 0 if no bandwidth was allocated or deallocated. | ||
283 | * | ||
284 | * If generation is stale, deallocations succeed but allocations fail with | ||
285 | * channel = -EAGAIN. | ||
286 | * | ||
287 | * If channel allocation fails, no bandwidth will be allocated either. | ||
288 | * If bandwidth allocation fails, no channel will be allocated either. | ||
289 | * But deallocations of channel and bandwidth are tried independently | ||
290 | * of each other's success. | ||
291 | */ | ||
292 | void fw_iso_resource_manage(struct fw_card *card, int generation, | ||
293 | u64 channels_mask, int *channel, int *bandwidth, | ||
294 | bool allocate) | ||
295 | { | ||
296 | u32 channels_hi = channels_mask; /* channels 31...0 */ | ||
297 | u32 channels_lo = channels_mask >> 32; /* channels 63...32 */ | ||
298 | int irm_id, ret, c = -EINVAL; | ||
299 | |||
300 | spin_lock_irq(&card->lock); | ||
301 | irm_id = card->irm_node->node_id; | ||
302 | spin_unlock_irq(&card->lock); | ||
303 | |||
304 | if (channels_hi) | ||
305 | c = manage_channel(card, irm_id, generation, channels_hi, | ||
306 | CSR_REGISTER_BASE + CSR_CHANNELS_AVAILABLE_HI, allocate); | ||
307 | if (channels_lo && c < 0) { | ||
308 | c = manage_channel(card, irm_id, generation, channels_lo, | ||
309 | CSR_REGISTER_BASE + CSR_CHANNELS_AVAILABLE_LO, allocate); | ||
310 | if (c >= 0) | ||
311 | c += 32; | ||
312 | } | ||
313 | *channel = c; | ||
314 | |||
315 | if (allocate && channels_mask != 0 && c < 0) | ||
316 | *bandwidth = 0; | ||
317 | |||
318 | if (*bandwidth == 0) | ||
319 | return; | ||
320 | |||
321 | ret = manage_bandwidth(card, irm_id, generation, *bandwidth, allocate); | ||
322 | if (ret < 0) | ||
323 | *bandwidth = 0; | ||
324 | |||
325 | if (allocate && ret < 0 && c >= 0) { | ||
326 | deallocate_channel(card, irm_id, generation, c); | ||
327 | *channel = ret; | ||
328 | } | ||
329 | } | ||