]>
Commit | Line | Data |
---|---|---|
31ef9134 CL |
1 | /* |
2 | * Connection Management Procedures (IEC 61883-1) 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/module.h> | |
12 | #include <linux/sched.h> | |
13 | #include "lib.h" | |
14 | #include "iso-resources.h" | |
15 | #include "cmp.h" | |
16 | ||
a7fa0d04 TS |
17 | /* MPR common fields */ |
18 | #define MPR_SPEED_MASK 0xc0000000 | |
19 | #define MPR_SPEED_SHIFT 30 | |
20 | #define MPR_XSPEED_MASK 0x00000060 | |
21 | #define MPR_XSPEED_SHIFT 5 | |
22 | #define MPR_PLUGS_MASK 0x0000001f | |
23 | ||
24 | /* PCR common fields */ | |
25 | #define PCR_ONLINE 0x80000000 | |
26 | #define PCR_BCAST_CONN 0x40000000 | |
27 | #define PCR_P2P_CONN_MASK 0x3f000000 | |
28 | #define PCR_P2P_CONN_SHIFT 24 | |
29 | #define PCR_CHANNEL_MASK 0x003f0000 | |
30 | #define PCR_CHANNEL_SHIFT 16 | |
31ef9134 | 31 | |
44aff698 TS |
32 | /* oPCR specific fields */ |
33 | #define OPCR_XSPEED_MASK 0x00C00000 | |
34 | #define OPCR_XSPEED_SHIFT 22 | |
35 | #define OPCR_SPEED_MASK 0x0000C000 | |
36 | #define OPCR_SPEED_SHIFT 14 | |
37 | #define OPCR_OVERHEAD_ID_MASK 0x00003C00 | |
38 | #define OPCR_OVERHEAD_ID_SHIFT 10 | |
39 | ||
31ef9134 CL |
40 | enum bus_reset_handling { |
41 | ABORT_ON_BUS_RESET, | |
42 | SUCCEED_ON_BUS_RESET, | |
43 | }; | |
44 | ||
b9075fa9 | 45 | static __printf(2, 3) |
31ef9134 CL |
46 | void cmp_error(struct cmp_connection *c, const char *fmt, ...) |
47 | { | |
48 | va_list va; | |
49 | ||
50 | va_start(va, fmt); | |
51 | dev_err(&c->resources.unit->device, "%cPCR%u: %pV", | |
44aff698 TS |
52 | (c->direction == CMP_INPUT) ? 'i' : 'o', |
53 | c->pcr_index, &(struct va_format){ fmt, &va }); | |
31ef9134 CL |
54 | va_end(va); |
55 | } | |
56 | ||
44aff698 TS |
57 | static u64 mpr_address(struct cmp_connection *c) |
58 | { | |
59 | if (c->direction == CMP_INPUT) | |
60 | return CSR_REGISTER_BASE + CSR_IMPR; | |
61 | else | |
62 | return CSR_REGISTER_BASE + CSR_OMPR; | |
63 | } | |
64 | ||
65 | static u64 pcr_address(struct cmp_connection *c) | |
66 | { | |
67 | if (c->direction == CMP_INPUT) | |
68 | return CSR_REGISTER_BASE + CSR_IPCR(c->pcr_index); | |
69 | else | |
70 | return CSR_REGISTER_BASE + CSR_OPCR(c->pcr_index); | |
71 | } | |
72 | ||
31ef9134 CL |
73 | static int pcr_modify(struct cmp_connection *c, |
74 | __be32 (*modify)(struct cmp_connection *c, __be32 old), | |
75 | int (*check)(struct cmp_connection *c, __be32 pcr), | |
76 | enum bus_reset_handling bus_reset_handling) | |
77 | { | |
f30e6d3e | 78 | __be32 old_arg, buffer[2]; |
31ef9134 CL |
79 | int err; |
80 | ||
81 | buffer[0] = c->last_pcr_value; | |
82 | for (;;) { | |
83 | old_arg = buffer[0]; | |
84 | buffer[1] = modify(c, buffer[0]); | |
85 | ||
1b70485f CL |
86 | err = snd_fw_transaction( |
87 | c->resources.unit, TCODE_LOCK_COMPARE_SWAP, | |
44aff698 | 88 | pcr_address(c), buffer, 8, |
1b70485f CL |
89 | FW_FIXED_GENERATION | c->resources.generation); |
90 | ||
91 | if (err < 0) { | |
92 | if (err == -EAGAIN && | |
93 | bus_reset_handling == SUCCEED_ON_BUS_RESET) | |
94 | err = 0; | |
95 | return err; | |
96 | } | |
97 | ||
98 | if (buffer[0] == old_arg) /* success? */ | |
99 | break; | |
100 | ||
101 | if (check) { | |
102 | err = check(c, buffer[0]); | |
103 | if (err < 0) | |
104 | return err; | |
105 | } | |
31ef9134 CL |
106 | } |
107 | c->last_pcr_value = buffer[1]; | |
108 | ||
109 | return 0; | |
31ef9134 CL |
110 | } |
111 | ||
112 | ||
113 | /** | |
114 | * cmp_connection_init - initializes a connection manager | |
115 | * @c: the connection manager to initialize | |
116 | * @unit: a unit of the target device | |
5f217f90 | 117 | * @direction: input or output |
a7fa0d04 | 118 | * @pcr_index: the index of the iPCR/oPCR on the target device |
31ef9134 CL |
119 | */ |
120 | int cmp_connection_init(struct cmp_connection *c, | |
121 | struct fw_unit *unit, | |
c68a1c65 | 122 | enum cmp_direction direction, |
a7fa0d04 | 123 | unsigned int pcr_index) |
31ef9134 | 124 | { |
a7fa0d04 TS |
125 | __be32 mpr_be; |
126 | u32 mpr; | |
31ef9134 CL |
127 | int err; |
128 | ||
44aff698 | 129 | c->direction = direction; |
31ef9134 | 130 | err = snd_fw_transaction(unit, TCODE_READ_QUADLET_REQUEST, |
44aff698 | 131 | mpr_address(c), &mpr_be, 4, 0); |
31ef9134 CL |
132 | if (err < 0) |
133 | return err; | |
a7fa0d04 | 134 | mpr = be32_to_cpu(mpr_be); |
31ef9134 | 135 | |
a7fa0d04 | 136 | if (pcr_index >= (mpr & MPR_PLUGS_MASK)) |
31ef9134 CL |
137 | return -EINVAL; |
138 | ||
5b2599a0 CL |
139 | err = fw_iso_resources_init(&c->resources, unit); |
140 | if (err < 0) | |
141 | return err; | |
142 | ||
31ef9134 CL |
143 | c->connected = false; |
144 | mutex_init(&c->mutex); | |
31ef9134 | 145 | c->last_pcr_value = cpu_to_be32(0x80000000); |
a7fa0d04 TS |
146 | c->pcr_index = pcr_index; |
147 | c->max_speed = (mpr & MPR_SPEED_MASK) >> MPR_SPEED_SHIFT; | |
31ef9134 | 148 | if (c->max_speed == SCODE_BETA) |
a7fa0d04 | 149 | c->max_speed += (mpr & MPR_XSPEED_MASK) >> MPR_XSPEED_SHIFT; |
31ef9134 CL |
150 | |
151 | return 0; | |
152 | } | |
153 | EXPORT_SYMBOL(cmp_connection_init); | |
154 | ||
b04479fb TS |
155 | /** |
156 | * cmp_connection_check_used - check connection is already esablished or not | |
157 | * @c: the connection manager to be checked | |
5f217f90 | 158 | * @used: the pointer to store the result of checking the connection |
b04479fb TS |
159 | */ |
160 | int cmp_connection_check_used(struct cmp_connection *c, bool *used) | |
161 | { | |
162 | __be32 pcr; | |
163 | int err; | |
164 | ||
165 | err = snd_fw_transaction( | |
166 | c->resources.unit, TCODE_READ_QUADLET_REQUEST, | |
167 | pcr_address(c), &pcr, 4, 0); | |
168 | if (err >= 0) | |
51212eea TS |
169 | *used = !!(pcr & cpu_to_be32(PCR_BCAST_CONN | |
170 | PCR_P2P_CONN_MASK)); | |
171 | ||
b04479fb TS |
172 | return err; |
173 | } | |
174 | EXPORT_SYMBOL(cmp_connection_check_used); | |
175 | ||
31ef9134 CL |
176 | /** |
177 | * cmp_connection_destroy - free connection manager resources | |
178 | * @c: the connection manager | |
179 | */ | |
180 | void cmp_connection_destroy(struct cmp_connection *c) | |
181 | { | |
182 | WARN_ON(c->connected); | |
183 | mutex_destroy(&c->mutex); | |
184 | fw_iso_resources_destroy(&c->resources); | |
185 | } | |
186 | EXPORT_SYMBOL(cmp_connection_destroy); | |
187 | ||
188 | ||
189 | static __be32 ipcr_set_modify(struct cmp_connection *c, __be32 ipcr) | |
190 | { | |
a7fa0d04 TS |
191 | ipcr &= ~cpu_to_be32(PCR_BCAST_CONN | |
192 | PCR_P2P_CONN_MASK | | |
193 | PCR_CHANNEL_MASK); | |
194 | ipcr |= cpu_to_be32(1 << PCR_P2P_CONN_SHIFT); | |
195 | ipcr |= cpu_to_be32(c->resources.channel << PCR_CHANNEL_SHIFT); | |
31ef9134 CL |
196 | |
197 | return ipcr; | |
198 | } | |
199 | ||
44aff698 TS |
200 | static int get_overhead_id(struct cmp_connection *c) |
201 | { | |
202 | int id; | |
203 | ||
204 | /* | |
205 | * apply "oPCR overhead ID encoding" | |
206 | * the encoding table can convert up to 512. | |
207 | * here the value over 512 is converted as the same way as 512. | |
208 | */ | |
209 | for (id = 1; id < 16; id++) { | |
210 | if (c->resources.bandwidth_overhead < (id << 5)) | |
211 | break; | |
212 | } | |
213 | if (id == 16) | |
214 | id = 0; | |
215 | ||
216 | return id; | |
217 | } | |
218 | ||
219 | static __be32 opcr_set_modify(struct cmp_connection *c, __be32 opcr) | |
220 | { | |
221 | unsigned int spd, xspd; | |
222 | ||
223 | /* generate speed and extended speed field value */ | |
224 | if (c->speed > SCODE_400) { | |
225 | spd = SCODE_800; | |
226 | xspd = c->speed - SCODE_800; | |
227 | } else { | |
228 | spd = c->speed; | |
229 | xspd = 0; | |
230 | } | |
231 | ||
232 | opcr &= ~cpu_to_be32(PCR_BCAST_CONN | | |
233 | PCR_P2P_CONN_MASK | | |
234 | OPCR_XSPEED_MASK | | |
235 | PCR_CHANNEL_MASK | | |
236 | OPCR_SPEED_MASK | | |
237 | OPCR_OVERHEAD_ID_MASK); | |
238 | opcr |= cpu_to_be32(1 << PCR_P2P_CONN_SHIFT); | |
239 | opcr |= cpu_to_be32(xspd << OPCR_XSPEED_SHIFT); | |
240 | opcr |= cpu_to_be32(c->resources.channel << PCR_CHANNEL_SHIFT); | |
241 | opcr |= cpu_to_be32(spd << OPCR_SPEED_SHIFT); | |
242 | opcr |= cpu_to_be32(get_overhead_id(c) << OPCR_OVERHEAD_ID_SHIFT); | |
243 | ||
244 | return opcr; | |
245 | } | |
246 | ||
a7fa0d04 | 247 | static int pcr_set_check(struct cmp_connection *c, __be32 pcr) |
31ef9134 | 248 | { |
a7fa0d04 TS |
249 | if (pcr & cpu_to_be32(PCR_BCAST_CONN | |
250 | PCR_P2P_CONN_MASK)) { | |
31ef9134 CL |
251 | cmp_error(c, "plug is already in use\n"); |
252 | return -EBUSY; | |
253 | } | |
a7fa0d04 | 254 | if (!(pcr & cpu_to_be32(PCR_ONLINE))) { |
31ef9134 CL |
255 | cmp_error(c, "plug is not on-line\n"); |
256 | return -ECONNREFUSED; | |
257 | } | |
258 | ||
259 | return 0; | |
260 | } | |
261 | ||
262 | /** | |
263 | * cmp_connection_establish - establish a connection to the target | |
264 | * @c: the connection manager | |
265 | * @max_payload_bytes: the amount of data (including CIP headers) per packet | |
266 | * | |
267 | * This function establishes a point-to-point connection from the local | |
268 | * computer to the target by allocating isochronous resources (channel and | |
a7fa0d04 TS |
269 | * bandwidth) and setting the target's input/output plug control register. |
270 | * When this function succeeds, the caller is responsible for starting | |
271 | * transmitting packets. | |
31ef9134 CL |
272 | */ |
273 | int cmp_connection_establish(struct cmp_connection *c, | |
274 | unsigned int max_payload_bytes) | |
275 | { | |
276 | int err; | |
277 | ||
278 | if (WARN_ON(c->connected)) | |
279 | return -EISCONN; | |
280 | ||
281 | c->speed = min(c->max_speed, | |
282 | fw_parent_device(c->resources.unit)->max_speed); | |
283 | ||
284 | mutex_lock(&c->mutex); | |
285 | ||
286 | retry_after_bus_reset: | |
287 | err = fw_iso_resources_allocate(&c->resources, | |
288 | max_payload_bytes, c->speed); | |
289 | if (err < 0) | |
290 | goto err_mutex; | |
291 | ||
44aff698 TS |
292 | if (c->direction == CMP_OUTPUT) |
293 | err = pcr_modify(c, opcr_set_modify, pcr_set_check, | |
294 | ABORT_ON_BUS_RESET); | |
295 | else | |
296 | err = pcr_modify(c, ipcr_set_modify, pcr_set_check, | |
297 | ABORT_ON_BUS_RESET); | |
298 | ||
31ef9134 CL |
299 | if (err == -EAGAIN) { |
300 | fw_iso_resources_free(&c->resources); | |
301 | goto retry_after_bus_reset; | |
302 | } | |
303 | if (err < 0) | |
304 | goto err_resources; | |
305 | ||
306 | c->connected = true; | |
307 | ||
308 | mutex_unlock(&c->mutex); | |
309 | ||
310 | return 0; | |
311 | ||
312 | err_resources: | |
313 | fw_iso_resources_free(&c->resources); | |
314 | err_mutex: | |
315 | mutex_unlock(&c->mutex); | |
316 | ||
317 | return err; | |
318 | } | |
319 | EXPORT_SYMBOL(cmp_connection_establish); | |
320 | ||
321 | /** | |
322 | * cmp_connection_update - update the connection after a bus reset | |
323 | * @c: the connection manager | |
324 | * | |
a7fa0d04 TS |
325 | * This function must be called from the driver's .update handler to |
326 | * reestablish any connection that might have been active. | |
31ef9134 CL |
327 | * |
328 | * Returns zero on success, or a negative error code. On an error, the | |
329 | * connection is broken and the caller must stop transmitting iso packets. | |
330 | */ | |
331 | int cmp_connection_update(struct cmp_connection *c) | |
332 | { | |
333 | int err; | |
334 | ||
335 | mutex_lock(&c->mutex); | |
336 | ||
337 | if (!c->connected) { | |
338 | mutex_unlock(&c->mutex); | |
339 | return 0; | |
340 | } | |
341 | ||
342 | err = fw_iso_resources_update(&c->resources); | |
343 | if (err < 0) | |
344 | goto err_unconnect; | |
345 | ||
44aff698 TS |
346 | if (c->direction == CMP_OUTPUT) |
347 | err = pcr_modify(c, opcr_set_modify, pcr_set_check, | |
348 | SUCCEED_ON_BUS_RESET); | |
349 | else | |
350 | err = pcr_modify(c, ipcr_set_modify, pcr_set_check, | |
351 | SUCCEED_ON_BUS_RESET); | |
352 | ||
31ef9134 CL |
353 | if (err < 0) |
354 | goto err_resources; | |
355 | ||
356 | mutex_unlock(&c->mutex); | |
357 | ||
358 | return 0; | |
359 | ||
360 | err_resources: | |
361 | fw_iso_resources_free(&c->resources); | |
362 | err_unconnect: | |
363 | c->connected = false; | |
364 | mutex_unlock(&c->mutex); | |
365 | ||
366 | return err; | |
367 | } | |
368 | EXPORT_SYMBOL(cmp_connection_update); | |
369 | ||
a7fa0d04 | 370 | static __be32 pcr_break_modify(struct cmp_connection *c, __be32 pcr) |
31ef9134 | 371 | { |
a7fa0d04 | 372 | return pcr & ~cpu_to_be32(PCR_BCAST_CONN | PCR_P2P_CONN_MASK); |
31ef9134 CL |
373 | } |
374 | ||
375 | /** | |
376 | * cmp_connection_break - break the connection to the target | |
377 | * @c: the connection manager | |
378 | * | |
a7fa0d04 TS |
379 | * This function deactives the connection in the target's input/output plug |
380 | * control register, and frees the isochronous resources of the connection. | |
381 | * Before calling this function, the caller should cease transmitting packets. | |
31ef9134 CL |
382 | */ |
383 | void cmp_connection_break(struct cmp_connection *c) | |
384 | { | |
385 | int err; | |
386 | ||
387 | mutex_lock(&c->mutex); | |
388 | ||
389 | if (!c->connected) { | |
390 | mutex_unlock(&c->mutex); | |
391 | return; | |
392 | } | |
393 | ||
a7fa0d04 | 394 | err = pcr_modify(c, pcr_break_modify, NULL, SUCCEED_ON_BUS_RESET); |
31ef9134 CL |
395 | if (err < 0) |
396 | cmp_error(c, "plug is still connected\n"); | |
397 | ||
398 | fw_iso_resources_free(&c->resources); | |
399 | ||
400 | c->connected = false; | |
401 | ||
402 | mutex_unlock(&c->mutex); | |
403 | } | |
404 | EXPORT_SYMBOL(cmp_connection_break); |