blob: 1c0b504a42f3068e852fa1b7423ee5c37bfb0abd [file] [log] [blame]
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001/*
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +01002 * Isochronous I/O functionality:
3 * - Isochronous DMA context management
4 * - Isochronous bus resource management (channels, bandwidth), client side
Kristian Høgsberg3038e352006-12-19 19:58:27 -05005 *
Kristian Høgsberg3038e352006-12-19 19:58:27 -05006 * 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
Kristian Høgsberg3038e352006-12-19 19:58:27 -050023#include <linux/dma-mapping.h>
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +010024#include <linux/errno.h>
Stefan Richter77c9a5d2009-06-05 16:26:18 +020025#include <linux/firewire.h>
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +010026#include <linux/firewire-constants.h>
27#include <linux/kernel.h>
Kristian Høgsberg3038e352006-12-19 19:58:27 -050028#include <linux/mm.h>
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +010029#include <linux/spinlock.h>
30#include <linux/vmalloc.h>
Kristian Høgsberg3038e352006-12-19 19:58:27 -050031
Stefan Richtere8ca9702009-06-04 21:09:38 +020032#include <asm/byteorder.h>
33
Stefan Richter77c9a5d2009-06-05 16:26:18 +020034#include "core.h"
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +010035
36/*
37 * Isochronous DMA context management
38 */
Kristian Høgsberg3038e352006-12-19 19:58:27 -050039
Stefan Richter53dca512008-12-14 21:47:04 +010040int fw_iso_buffer_init(struct fw_iso_buffer *buffer, struct fw_card *card,
41 int page_count, enum dma_data_direction direction)
Kristian Høgsberg3038e352006-12-19 19:58:27 -050042{
Stefan Richter2dbd7d72008-12-14 21:45:45 +010043 int i, j;
Kristian Høgsberg9aad8122007-02-16 17:34:38 -050044 dma_addr_t address;
Kristian Høgsberg3038e352006-12-19 19:58:27 -050045
Kristian Høgsberg9aad8122007-02-16 17:34:38 -050046 buffer->page_count = page_count;
47 buffer->direction = direction;
Kristian Høgsberg3038e352006-12-19 19:58:27 -050048
Kristian Høgsberg9aad8122007-02-16 17:34:38 -050049 buffer->pages = kmalloc(page_count * sizeof(buffer->pages[0]),
50 GFP_KERNEL);
51 if (buffer->pages == NULL)
52 goto out;
Kristian Høgsberg3038e352006-12-19 19:58:27 -050053
Kristian Høgsberg9aad8122007-02-16 17:34:38 -050054 for (i = 0; i < buffer->page_count; i++) {
Kristian Høgsberg68be3fa2007-02-16 17:34:48 -050055 buffer->pages[i] = alloc_page(GFP_KERNEL | GFP_DMA32 | __GFP_ZERO);
Kristian Høgsberg9aad8122007-02-16 17:34:38 -050056 if (buffer->pages[i] == NULL)
57 goto out_pages;
Stefan Richter373b2ed2007-03-04 14:45:18 +010058
Kristian Høgsberg9aad8122007-02-16 17:34:38 -050059 address = dma_map_page(card->device, buffer->pages[i],
60 0, PAGE_SIZE, direction);
FUJITA Tomonori8d8bb392008-07-25 19:44:49 -070061 if (dma_mapping_error(card->device, address)) {
Kristian Høgsberg9aad8122007-02-16 17:34:38 -050062 __free_page(buffer->pages[i]);
63 goto out_pages;
64 }
65 set_page_private(buffer->pages[i], address);
Kristian Høgsberg3038e352006-12-19 19:58:27 -050066 }
67
68 return 0;
Kristian Høgsberg82eff9d2007-02-06 14:49:40 -050069
Kristian Høgsberg9aad8122007-02-16 17:34:38 -050070 out_pages:
71 for (j = 0; j < i; j++) {
72 address = page_private(buffer->pages[j]);
73 dma_unmap_page(card->device, address,
Stefan Richter29ad14c2009-06-15 00:38:50 +020074 PAGE_SIZE, direction);
Kristian Høgsberg9aad8122007-02-16 17:34:38 -050075 __free_page(buffer->pages[j]);
76 }
77 kfree(buffer->pages);
78 out:
79 buffer->pages = NULL;
Stefan Richtere1eff7a2009-02-03 17:55:19 +010080
Stefan Richter2dbd7d72008-12-14 21:45:45 +010081 return -ENOMEM;
Kristian Høgsberg3038e352006-12-19 19:58:27 -050082}
Jay Fenlasonc76acec2009-05-18 13:08:06 -040083EXPORT_SYMBOL(fw_iso_buffer_init);
Kristian Høgsberg3038e352006-12-19 19:58:27 -050084
Kristian Høgsberg9aad8122007-02-16 17:34:38 -050085int fw_iso_buffer_map(struct fw_iso_buffer *buffer, struct vm_area_struct *vma)
86{
87 unsigned long uaddr;
Stefan Richtere1eff7a2009-02-03 17:55:19 +010088 int i, err;
Kristian Høgsberg9aad8122007-02-16 17:34:38 -050089
90 uaddr = vma->vm_start;
91 for (i = 0; i < buffer->page_count; i++) {
Stefan Richtere1eff7a2009-02-03 17:55:19 +010092 err = vm_insert_page(vma, uaddr, buffer->pages[i]);
93 if (err)
94 return err;
95
Kristian Høgsberg9aad8122007-02-16 17:34:38 -050096 uaddr += PAGE_SIZE;
97 }
98
99 return 0;
100}
101
102void fw_iso_buffer_destroy(struct fw_iso_buffer *buffer,
103 struct fw_card *card)
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500104{
105 int i;
Kristian Høgsberg9aad8122007-02-16 17:34:38 -0500106 dma_addr_t address;
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500107
Kristian Høgsberg9aad8122007-02-16 17:34:38 -0500108 for (i = 0; i < buffer->page_count; i++) {
109 address = page_private(buffer->pages[i]);
110 dma_unmap_page(card->device, address,
Stefan Richter29ad14c2009-06-15 00:38:50 +0200111 PAGE_SIZE, buffer->direction);
Kristian Høgsberg9aad8122007-02-16 17:34:38 -0500112 __free_page(buffer->pages[i]);
113 }
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500114
Kristian Høgsberg9aad8122007-02-16 17:34:38 -0500115 kfree(buffer->pages);
116 buffer->pages = NULL;
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500117}
Jay Fenlasonc76acec2009-05-18 13:08:06 -0400118EXPORT_SYMBOL(fw_iso_buffer_destroy);
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500119
Stefan Richter53dca512008-12-14 21:47:04 +0100120struct fw_iso_context *fw_iso_context_create(struct fw_card *card,
121 int type, int channel, int speed, size_t header_size,
122 fw_iso_callback_t callback, void *callback_data)
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500123{
124 struct fw_iso_context *ctx;
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500125
Stefan Richter4817ed22008-12-21 16:39:46 +0100126 ctx = card->driver->allocate_iso_context(card,
127 type, channel, header_size);
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500128 if (IS_ERR(ctx))
129 return ctx;
130
131 ctx->card = card;
132 ctx->type = type;
Kristian Høgsberg21efb3c2007-02-16 17:34:50 -0500133 ctx->channel = channel;
134 ctx->speed = speed;
Kristian Høgsberg295e3fe2007-02-16 17:34:40 -0500135 ctx->header_size = header_size;
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500136 ctx->callback = callback;
137 ctx->callback_data = callback_data;
138
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500139 return ctx;
140}
Jay Fenlasonc76acec2009-05-18 13:08:06 -0400141EXPORT_SYMBOL(fw_iso_context_create);
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500142
143void fw_iso_context_destroy(struct fw_iso_context *ctx)
144{
145 struct fw_card *card = ctx->card;
146
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500147 card->driver->free_iso_context(ctx);
148}
Jay Fenlasonc76acec2009-05-18 13:08:06 -0400149EXPORT_SYMBOL(fw_iso_context_destroy);
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500150
Stefan Richter53dca512008-12-14 21:47:04 +0100151int fw_iso_context_start(struct fw_iso_context *ctx,
152 int cycle, int sync, int tags)
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500153{
Kristian Høgsbergeb0306e2007-03-14 17:34:54 -0400154 return ctx->card->driver->start_iso(ctx, cycle, sync, tags);
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500155}
Jay Fenlasonc76acec2009-05-18 13:08:06 -0400156EXPORT_SYMBOL(fw_iso_context_start);
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500157
Stefan Richter53dca512008-12-14 21:47:04 +0100158int fw_iso_context_queue(struct fw_iso_context *ctx,
159 struct fw_iso_packet *packet,
160 struct fw_iso_buffer *buffer,
161 unsigned long payload)
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500162{
163 struct fw_card *card = ctx->card;
164
Kristian Høgsberg9aad8122007-02-16 17:34:38 -0500165 return card->driver->queue_iso(ctx, packet, buffer, payload);
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500166}
Jay Fenlasonc76acec2009-05-18 13:08:06 -0400167EXPORT_SYMBOL(fw_iso_context_queue);
Kristian Høgsbergb8295662007-02-16 17:34:42 -0500168
Stefan Richter53dca512008-12-14 21:47:04 +0100169int fw_iso_context_stop(struct fw_iso_context *ctx)
Kristian Høgsbergb8295662007-02-16 17:34:42 -0500170{
171 return ctx->card->driver->stop_iso(ctx);
172}
Jay Fenlasonc76acec2009-05-18 13:08:06 -0400173EXPORT_SYMBOL(fw_iso_context_stop);
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100174
175/*
176 * Isochronous bus resource management (channels, bandwidth), client side
177 */
178
179static int manage_bandwidth(struct fw_card *card, int irm_id, int generation,
Stefan Richter6fdc0372009-06-20 13:23:59 +0200180 int bandwidth, bool allocate, __be32 data[2])
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100181{
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100182 int try, new, old = allocate ? BANDWIDTH_AVAILABLE_INITIAL : 0;
183
184 /*
185 * On a 1394a IRM with low contention, try < 1 is enough.
186 * On a 1394-1995 IRM, we need at least try < 2.
187 * Let's just do try < 5.
188 */
189 for (try = 0; try < 5; try++) {
190 new = allocate ? old - bandwidth : old + bandwidth;
191 if (new < 0 || new > BANDWIDTH_AVAILABLE_INITIAL)
192 break;
193
194 data[0] = cpu_to_be32(old);
195 data[1] = cpu_to_be32(new);
196 switch (fw_run_transaction(card, TCODE_LOCK_COMPARE_SWAP,
197 irm_id, generation, SCODE_100,
198 CSR_REGISTER_BASE + CSR_BANDWIDTH_AVAILABLE,
Stefan Richter1821bc12009-09-05 13:23:49 +0200199 data, 8)) {
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100200 case RCODE_GENERATION:
201 /* A generation change frees all bandwidth. */
202 return allocate ? -EAGAIN : bandwidth;
203
204 case RCODE_COMPLETE:
205 if (be32_to_cpup(data) == old)
206 return bandwidth;
207
208 old = be32_to_cpup(data);
209 /* Fall through. */
210 }
211 }
212
213 return -EIO;
214}
215
216static int manage_channel(struct fw_card *card, int irm_id, int generation,
Stefan Richter6fdc0372009-06-20 13:23:59 +0200217 u32 channels_mask, u64 offset, bool allocate, __be32 data[2])
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100218{
Stefan Richter6fdc0372009-06-20 13:23:59 +0200219 __be32 c, all, old;
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100220 int i, retry = 5;
221
Stefan Richter5d9cb7d272009-01-08 23:07:40 +0100222 old = all = allocate ? cpu_to_be32(~0) : 0;
223
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100224 for (i = 0; i < 32; i++) {
Stefan Richter5d9cb7d272009-01-08 23:07:40 +0100225 if (!(channels_mask & 1 << i))
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100226 continue;
227
Stefan Richter5d9cb7d272009-01-08 23:07:40 +0100228 c = cpu_to_be32(1 << (31 - i));
229 if ((old & c) != (all & c))
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100230 continue;
231
232 data[0] = old;
233 data[1] = old ^ c;
234 switch (fw_run_transaction(card, TCODE_LOCK_COMPARE_SWAP,
235 irm_id, generation, SCODE_100,
Stefan Richter1821bc12009-09-05 13:23:49 +0200236 offset, data, 8)) {
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100237 case RCODE_GENERATION:
238 /* A generation change frees all channels. */
239 return allocate ? -EAGAIN : i;
240
241 case RCODE_COMPLETE:
242 if (data[0] == old)
243 return i;
244
245 old = data[0];
246
247 /* Is the IRM 1394a-2000 compliant? */
Stefan Richter5d9cb7d272009-01-08 23:07:40 +0100248 if ((data[0] & c) == (data[1] & c))
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100249 continue;
250
251 /* 1394-1995 IRM, fall through to retry. */
252 default:
253 if (retry--)
254 i--;
255 }
256 }
257
258 return -EIO;
259}
260
261static void deallocate_channel(struct fw_card *card, int irm_id,
Stefan Richter6fdc0372009-06-20 13:23:59 +0200262 int generation, int channel, __be32 buffer[2])
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100263{
Stefan Richter5d9cb7d272009-01-08 23:07:40 +0100264 u32 mask;
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100265 u64 offset;
266
Stefan Richter5d9cb7d272009-01-08 23:07:40 +0100267 mask = channel < 32 ? 1 << channel : 1 << (channel - 32);
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100268 offset = channel < 32 ? CSR_REGISTER_BASE + CSR_CHANNELS_AVAILABLE_HI :
269 CSR_REGISTER_BASE + CSR_CHANNELS_AVAILABLE_LO;
270
Stefan Richter6fdc0372009-06-20 13:23:59 +0200271 manage_channel(card, irm_id, generation, mask, offset, false, buffer);
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100272}
273
274/**
275 * fw_iso_resource_manage - Allocate or deallocate a channel and/or bandwidth
276 *
277 * In parameters: card, generation, channels_mask, bandwidth, allocate
278 * Out parameters: channel, bandwidth
279 * This function blocks (sleeps) during communication with the IRM.
Stefan Richter5d9cb7d272009-01-08 23:07:40 +0100280 *
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100281 * Allocates or deallocates at most one channel out of channels_mask.
Stefan Richter5d9cb7d272009-01-08 23:07:40 +0100282 * channels_mask is a bitfield with MSB for channel 63 and LSB for channel 0.
283 * (Note, the IRM's CHANNELS_AVAILABLE is a big-endian bitfield with MSB for
284 * channel 0 and LSB for channel 63.)
285 * Allocates or deallocates as many bandwidth allocation units as specified.
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100286 *
287 * Returns channel < 0 if no channel was allocated or deallocated.
288 * Returns bandwidth = 0 if no bandwidth was allocated or deallocated.
289 *
290 * If generation is stale, deallocations succeed but allocations fail with
291 * channel = -EAGAIN.
292 *
Stefan Richter5d9cb7d272009-01-08 23:07:40 +0100293 * If channel allocation fails, no bandwidth will be allocated either.
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100294 * If bandwidth allocation fails, no channel will be allocated either.
Stefan Richter5d9cb7d272009-01-08 23:07:40 +0100295 * But deallocations of channel and bandwidth are tried independently
296 * of each other's success.
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100297 */
298void fw_iso_resource_manage(struct fw_card *card, int generation,
299 u64 channels_mask, int *channel, int *bandwidth,
Stefan Richter6fdc0372009-06-20 13:23:59 +0200300 bool allocate, __be32 buffer[2])
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100301{
Stefan Richter5d9cb7d272009-01-08 23:07:40 +0100302 u32 channels_hi = channels_mask; /* channels 31...0 */
303 u32 channels_lo = channels_mask >> 32; /* channels 63...32 */
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100304 int irm_id, ret, c = -EINVAL;
305
306 spin_lock_irq(&card->lock);
307 irm_id = card->irm_node->node_id;
308 spin_unlock_irq(&card->lock);
309
310 if (channels_hi)
311 c = manage_channel(card, irm_id, generation, channels_hi,
Stefan Richter6fdc0372009-06-20 13:23:59 +0200312 CSR_REGISTER_BASE + CSR_CHANNELS_AVAILABLE_HI,
313 allocate, buffer);
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100314 if (channels_lo && c < 0) {
315 c = manage_channel(card, irm_id, generation, channels_lo,
Stefan Richter6fdc0372009-06-20 13:23:59 +0200316 CSR_REGISTER_BASE + CSR_CHANNELS_AVAILABLE_LO,
317 allocate, buffer);
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100318 if (c >= 0)
319 c += 32;
320 }
321 *channel = c;
322
Stefan Richter5d9cb7d272009-01-08 23:07:40 +0100323 if (allocate && channels_mask != 0 && c < 0)
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100324 *bandwidth = 0;
325
326 if (*bandwidth == 0)
327 return;
328
Stefan Richter6fdc0372009-06-20 13:23:59 +0200329 ret = manage_bandwidth(card, irm_id, generation, *bandwidth,
330 allocate, buffer);
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100331 if (ret < 0)
332 *bandwidth = 0;
333
Stefan Richter5d9cb7d272009-01-08 23:07:40 +0100334 if (allocate && ret < 0 && c >= 0) {
Stefan Richter6fdc0372009-06-20 13:23:59 +0200335 deallocate_channel(card, irm_id, generation, c, buffer);
Jay Fenlason, Stefan Richterb1bda4c2009-01-04 16:23:29 +0100336 *channel = ret;
337 }
338}