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 | |
a7fa0d04 | 117 | * @pcr_index: the index of the iPCR/oPCR on the target device |
31ef9134 CL |
118 | */ |
119 | int cmp_connection_init(struct cmp_connection *c, | |
120 | struct fw_unit *unit, | |
c68a1c65 | 121 | enum cmp_direction direction, |
a7fa0d04 | 122 | unsigned int pcr_index) |
31ef9134 | 123 | { |
a7fa0d04 TS |
124 | __be32 mpr_be; |
125 | u32 mpr; | |
31ef9134 CL |
126 | int err; |
127 | ||
44aff698 | 128 | c->direction = direction; |
31ef9134 | 129 | err = snd_fw_transaction(unit, TCODE_READ_QUADLET_REQUEST, |
44aff698 | 130 | mpr_address(c), &mpr_be, 4, 0); |
31ef9134 CL |
131 | if (err < 0) |
132 | return err; | |
a7fa0d04 | 133 | mpr = be32_to_cpu(mpr_be); |
31ef9134 | 134 | |
a7fa0d04 | 135 | if (pcr_index >= (mpr & MPR_PLUGS_MASK)) |
31ef9134 CL |
136 | return -EINVAL; |
137 | ||
5b2599a0 CL |
138 | err = fw_iso_resources_init(&c->resources, unit); |
139 | if (err < 0) | |
140 | return err; | |
141 | ||
31ef9134 CL |
142 | c->connected = false; |
143 | mutex_init(&c->mutex); | |
31ef9134 | 144 | c->last_pcr_value = cpu_to_be32(0x80000000); |
a7fa0d04 TS |
145 | c->pcr_index = pcr_index; |
146 | c->max_speed = (mpr & MPR_SPEED_MASK) >> MPR_SPEED_SHIFT; | |
31ef9134 | 147 | if (c->max_speed == SCODE_BETA) |
a7fa0d04 | 148 | c->max_speed += (mpr & MPR_XSPEED_MASK) >> MPR_XSPEED_SHIFT; |
31ef9134 CL |
149 | |
150 | return 0; | |
151 | } | |
152 | EXPORT_SYMBOL(cmp_connection_init); | |
153 | ||
b04479fb TS |
154 | /** |
155 | * cmp_connection_check_used - check connection is already esablished or not | |
156 | * @c: the connection manager to be checked | |
157 | */ | |
158 | int cmp_connection_check_used(struct cmp_connection *c, bool *used) | |
159 | { | |
160 | __be32 pcr; | |
161 | int err; | |
162 | ||
163 | err = snd_fw_transaction( | |
164 | c->resources.unit, TCODE_READ_QUADLET_REQUEST, | |
165 | pcr_address(c), &pcr, 4, 0); | |
166 | if (err >= 0) | |
51212eea TS |
167 | *used = !!(pcr & cpu_to_be32(PCR_BCAST_CONN | |
168 | PCR_P2P_CONN_MASK)); | |
169 | ||
b04479fb TS |
170 | return err; |
171 | } | |
172 | EXPORT_SYMBOL(cmp_connection_check_used); | |
173 | ||
31ef9134 CL |
174 | /** |
175 | * cmp_connection_destroy - free connection manager resources | |
176 | * @c: the connection manager | |
177 | */ | |
178 | void cmp_connection_destroy(struct cmp_connection *c) | |
179 | { | |
180 | WARN_ON(c->connected); | |
181 | mutex_destroy(&c->mutex); | |
182 | fw_iso_resources_destroy(&c->resources); | |
183 | } | |
184 | EXPORT_SYMBOL(cmp_connection_destroy); | |
185 | ||
186 | ||
187 | static __be32 ipcr_set_modify(struct cmp_connection *c, __be32 ipcr) | |
188 | { | |
a7fa0d04 TS |
189 | ipcr &= ~cpu_to_be32(PCR_BCAST_CONN | |
190 | PCR_P2P_CONN_MASK | | |
191 | PCR_CHANNEL_MASK); | |
192 | ipcr |= cpu_to_be32(1 << PCR_P2P_CONN_SHIFT); | |
193 | ipcr |= cpu_to_be32(c->resources.channel << PCR_CHANNEL_SHIFT); | |
31ef9134 CL |
194 | |
195 | return ipcr; | |
196 | } | |
197 | ||
44aff698 TS |
198 | static int get_overhead_id(struct cmp_connection *c) |
199 | { | |
200 | int id; | |
201 | ||
202 | /* | |
203 | * apply "oPCR overhead ID encoding" | |
204 | * the encoding table can convert up to 512. | |
205 | * here the value over 512 is converted as the same way as 512. | |
206 | */ | |
207 | for (id = 1; id < 16; id++) { | |
208 | if (c->resources.bandwidth_overhead < (id << 5)) | |
209 | break; | |
210 | } | |
211 | if (id == 16) | |
212 | id = 0; | |
213 | ||
214 | return id; | |
215 | } | |
216 | ||
217 | static __be32 opcr_set_modify(struct cmp_connection *c, __be32 opcr) | |
218 | { | |
219 | unsigned int spd, xspd; | |
220 | ||
221 | /* generate speed and extended speed field value */ | |
222 | if (c->speed > SCODE_400) { | |
223 | spd = SCODE_800; | |
224 | xspd = c->speed - SCODE_800; | |
225 | } else { | |
226 | spd = c->speed; | |
227 | xspd = 0; | |
228 | } | |
229 | ||
230 | opcr &= ~cpu_to_be32(PCR_BCAST_CONN | | |
231 | PCR_P2P_CONN_MASK | | |
232 | OPCR_XSPEED_MASK | | |
233 | PCR_CHANNEL_MASK | | |
234 | OPCR_SPEED_MASK | | |
235 | OPCR_OVERHEAD_ID_MASK); | |
236 | opcr |= cpu_to_be32(1 << PCR_P2P_CONN_SHIFT); | |
237 | opcr |= cpu_to_be32(xspd << OPCR_XSPEED_SHIFT); | |
238 | opcr |= cpu_to_be32(c->resources.channel << PCR_CHANNEL_SHIFT); | |
239 | opcr |= cpu_to_be32(spd << OPCR_SPEED_SHIFT); | |
240 | opcr |= cpu_to_be32(get_overhead_id(c) << OPCR_OVERHEAD_ID_SHIFT); | |
241 | ||
242 | return opcr; | |
243 | } | |
244 | ||
a7fa0d04 | 245 | static int pcr_set_check(struct cmp_connection *c, __be32 pcr) |
31ef9134 | 246 | { |
a7fa0d04 TS |
247 | if (pcr & cpu_to_be32(PCR_BCAST_CONN | |
248 | PCR_P2P_CONN_MASK)) { | |
31ef9134 CL |
249 | cmp_error(c, "plug is already in use\n"); |
250 | return -EBUSY; | |
251 | } | |
a7fa0d04 | 252 | if (!(pcr & cpu_to_be32(PCR_ONLINE))) { |
31ef9134 CL |
253 | cmp_error(c, "plug is not on-line\n"); |
254 | return -ECONNREFUSED; | |
255 | } | |
256 | ||
257 | return 0; | |
258 | } | |
259 | ||
260 | /** | |
261 | * cmp_connection_establish - establish a connection to the target | |
262 | * @c: the connection manager | |
263 | * @max_payload_bytes: the amount of data (including CIP headers) per packet | |
264 | * | |
265 | * This function establishes a point-to-point connection from the local | |
266 | * computer to the target by allocating isochronous resources (channel and | |
a7fa0d04 TS |
267 | * bandwidth) and setting the target's input/output plug control register. |
268 | * When this function succeeds, the caller is responsible for starting | |
269 | * transmitting packets. | |
31ef9134 CL |
270 | */ |
271 | int cmp_connection_establish(struct cmp_connection *c, | |
272 | unsigned int max_payload_bytes) | |
273 | { | |
274 | int err; | |
275 | ||
276 | if (WARN_ON(c->connected)) | |
277 | return -EISCONN; | |
278 | ||
279 | c->speed = min(c->max_speed, | |
280 | fw_parent_device(c->resources.unit)->max_speed); | |
281 | ||
282 | mutex_lock(&c->mutex); | |
283 | ||
284 | retry_after_bus_reset: | |
285 | err = fw_iso_resources_allocate(&c->resources, | |
286 | max_payload_bytes, c->speed); | |
287 | if (err < 0) | |
288 | goto err_mutex; | |
289 | ||
44aff698 TS |
290 | if (c->direction == CMP_OUTPUT) |
291 | err = pcr_modify(c, opcr_set_modify, pcr_set_check, | |
292 | ABORT_ON_BUS_RESET); | |
293 | else | |
294 | err = pcr_modify(c, ipcr_set_modify, pcr_set_check, | |
295 | ABORT_ON_BUS_RESET); | |
296 | ||
31ef9134 CL |
297 | if (err == -EAGAIN) { |
298 | fw_iso_resources_free(&c->resources); | |
299 | goto retry_after_bus_reset; | |
300 | } | |
301 | if (err < 0) | |
302 | goto err_resources; | |
303 | ||
304 | c->connected = true; | |
305 | ||
306 | mutex_unlock(&c->mutex); | |
307 | ||
308 | return 0; | |
309 | ||
310 | err_resources: | |
311 | fw_iso_resources_free(&c->resources); | |
312 | err_mutex: | |
313 | mutex_unlock(&c->mutex); | |
314 | ||
315 | return err; | |
316 | } | |
317 | EXPORT_SYMBOL(cmp_connection_establish); | |
318 | ||
319 | /** | |
320 | * cmp_connection_update - update the connection after a bus reset | |
321 | * @c: the connection manager | |
322 | * | |
a7fa0d04 TS |
323 | * This function must be called from the driver's .update handler to |
324 | * reestablish any connection that might have been active. | |
31ef9134 CL |
325 | * |
326 | * Returns zero on success, or a negative error code. On an error, the | |
327 | * connection is broken and the caller must stop transmitting iso packets. | |
328 | */ | |
329 | int cmp_connection_update(struct cmp_connection *c) | |
330 | { | |
331 | int err; | |
332 | ||
333 | mutex_lock(&c->mutex); | |
334 | ||
335 | if (!c->connected) { | |
336 | mutex_unlock(&c->mutex); | |
337 | return 0; | |
338 | } | |
339 | ||
340 | err = fw_iso_resources_update(&c->resources); | |
341 | if (err < 0) | |
342 | goto err_unconnect; | |
343 | ||
44aff698 TS |
344 | if (c->direction == CMP_OUTPUT) |
345 | err = pcr_modify(c, opcr_set_modify, pcr_set_check, | |
346 | SUCCEED_ON_BUS_RESET); | |
347 | else | |
348 | err = pcr_modify(c, ipcr_set_modify, pcr_set_check, | |
349 | SUCCEED_ON_BUS_RESET); | |
350 | ||
31ef9134 CL |
351 | if (err < 0) |
352 | goto err_resources; | |
353 | ||
354 | mutex_unlock(&c->mutex); | |
355 | ||
356 | return 0; | |
357 | ||
358 | err_resources: | |
359 | fw_iso_resources_free(&c->resources); | |
360 | err_unconnect: | |
361 | c->connected = false; | |
362 | mutex_unlock(&c->mutex); | |
363 | ||
364 | return err; | |
365 | } | |
366 | EXPORT_SYMBOL(cmp_connection_update); | |
367 | ||
a7fa0d04 | 368 | static __be32 pcr_break_modify(struct cmp_connection *c, __be32 pcr) |
31ef9134 | 369 | { |
a7fa0d04 | 370 | return pcr & ~cpu_to_be32(PCR_BCAST_CONN | PCR_P2P_CONN_MASK); |
31ef9134 CL |
371 | } |
372 | ||
373 | /** | |
374 | * cmp_connection_break - break the connection to the target | |
375 | * @c: the connection manager | |
376 | * | |
a7fa0d04 TS |
377 | * This function deactives the connection in the target's input/output plug |
378 | * control register, and frees the isochronous resources of the connection. | |
379 | * Before calling this function, the caller should cease transmitting packets. | |
31ef9134 CL |
380 | */ |
381 | void cmp_connection_break(struct cmp_connection *c) | |
382 | { | |
383 | int err; | |
384 | ||
385 | mutex_lock(&c->mutex); | |
386 | ||
387 | if (!c->connected) { | |
388 | mutex_unlock(&c->mutex); | |
389 | return; | |
390 | } | |
391 | ||
a7fa0d04 | 392 | err = pcr_modify(c, pcr_break_modify, NULL, SUCCEED_ON_BUS_RESET); |
31ef9134 CL |
393 | if (err < 0) |
394 | cmp_error(c, "plug is still connected\n"); | |
395 | ||
396 | fw_iso_resources_free(&c->resources); | |
397 | ||
398 | c->connected = false; | |
399 | ||
400 | mutex_unlock(&c->mutex); | |
401 | } | |
402 | EXPORT_SYMBOL(cmp_connection_break); |