1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Function Control Protocol (IEC 61883-1) helper functions |
4 | * |
5 | * Copyright (c) Clemens Ladisch <clemens@ladisch.de> |
6 | */ |
7 | |
8 | #include <linux/device.h> |
9 | #include <linux/firewire.h> |
10 | #include <linux/firewire-constants.h> |
11 | #include <linux/list.h> |
12 | #include <linux/module.h> |
13 | #include <linux/slab.h> |
14 | #include <linux/sched.h> |
15 | #include <linux/spinlock.h> |
16 | #include <linux/wait.h> |
17 | #include <linux/delay.h> |
18 | #include "fcp.h" |
19 | #include "lib.h" |
20 | #include "amdtp-stream.h" |
21 | |
22 | #define CTS_AVC 0x00 |
23 | |
24 | #define ERROR_RETRIES 3 |
25 | #define ERROR_DELAY_MS 5 |
26 | #define FCP_TIMEOUT_MS 125 |
27 | |
28 | int avc_general_set_sig_fmt(struct fw_unit *unit, unsigned int rate, |
29 | enum avc_general_plug_dir dir, |
30 | unsigned short pid) |
31 | { |
32 | unsigned int sfc; |
33 | u8 *buf; |
34 | bool flag; |
35 | int err; |
36 | |
37 | flag = false; |
38 | for (sfc = 0; sfc < CIP_SFC_COUNT; sfc++) { |
39 | if (amdtp_rate_table[sfc] == rate) { |
40 | flag = true; |
41 | break; |
42 | } |
43 | } |
44 | if (!flag) |
45 | return -EINVAL; |
46 | |
47 | buf = kzalloc(size: 8, GFP_KERNEL); |
48 | if (buf == NULL) |
49 | return -ENOMEM; |
50 | |
51 | buf[0] = 0x00; /* AV/C CONTROL */ |
52 | buf[1] = 0xff; /* UNIT */ |
53 | if (dir == AVC_GENERAL_PLUG_DIR_IN) |
54 | buf[2] = 0x19; /* INPUT PLUG SIGNAL FORMAT */ |
55 | else |
56 | buf[2] = 0x18; /* OUTPUT PLUG SIGNAL FORMAT */ |
57 | buf[3] = 0xff & pid; /* plug id */ |
58 | buf[4] = 0x90; /* EOH_1, Form_1, FMT. AM824 */ |
59 | buf[5] = 0x07 & sfc; /* FDF-hi. AM824, frequency */ |
60 | buf[6] = 0xff; /* FDF-mid. AM824, SYT hi (not used)*/ |
61 | buf[7] = 0xff; /* FDF-low. AM824, SYT lo (not used) */ |
62 | |
63 | /* do transaction and check buf[1-5] are the same against command */ |
64 | err = fcp_avc_transaction(unit, command: buf, command_size: 8, response: buf, response_size: 8, |
65 | BIT(1) | BIT(2) | BIT(3) | BIT(4) | BIT(5)); |
66 | if (err < 0) |
67 | ; |
68 | else if (err < 8) |
69 | err = -EIO; |
70 | else if (buf[0] == 0x08) /* NOT IMPLEMENTED */ |
71 | err = -ENOSYS; |
72 | else if (buf[0] == 0x0a) /* REJECTED */ |
73 | err = -EINVAL; |
74 | if (err < 0) |
75 | goto end; |
76 | |
77 | err = 0; |
78 | end: |
79 | kfree(objp: buf); |
80 | return err; |
81 | } |
82 | EXPORT_SYMBOL(avc_general_set_sig_fmt); |
83 | |
84 | int avc_general_get_sig_fmt(struct fw_unit *unit, unsigned int *rate, |
85 | enum avc_general_plug_dir dir, |
86 | unsigned short pid) |
87 | { |
88 | unsigned int sfc; |
89 | u8 *buf; |
90 | int err; |
91 | |
92 | buf = kzalloc(size: 8, GFP_KERNEL); |
93 | if (buf == NULL) |
94 | return -ENOMEM; |
95 | |
96 | buf[0] = 0x01; /* AV/C STATUS */ |
97 | buf[1] = 0xff; /* Unit */ |
98 | if (dir == AVC_GENERAL_PLUG_DIR_IN) |
99 | buf[2] = 0x19; /* INPUT PLUG SIGNAL FORMAT */ |
100 | else |
101 | buf[2] = 0x18; /* OUTPUT PLUG SIGNAL FORMAT */ |
102 | buf[3] = 0xff & pid; /* plug id */ |
103 | buf[4] = 0x90; /* EOH_1, Form_1, FMT. AM824 */ |
104 | buf[5] = 0xff; /* FDF-hi. AM824, frequency */ |
105 | buf[6] = 0xff; /* FDF-mid. AM824, SYT hi (not used) */ |
106 | buf[7] = 0xff; /* FDF-low. AM824, SYT lo (not used) */ |
107 | |
108 | /* do transaction and check buf[1-4] are the same against command */ |
109 | err = fcp_avc_transaction(unit, command: buf, command_size: 8, response: buf, response_size: 8, |
110 | BIT(1) | BIT(2) | BIT(3) | BIT(4)); |
111 | if (err < 0) |
112 | ; |
113 | else if (err < 8) |
114 | err = -EIO; |
115 | else if (buf[0] == 0x08) /* NOT IMPLEMENTED */ |
116 | err = -ENOSYS; |
117 | else if (buf[0] == 0x0a) /* REJECTED */ |
118 | err = -EINVAL; |
119 | else if (buf[0] == 0x0b) /* IN TRANSITION */ |
120 | err = -EAGAIN; |
121 | if (err < 0) |
122 | goto end; |
123 | |
124 | /* check sfc field and pick up rate */ |
125 | sfc = 0x07 & buf[5]; |
126 | if (sfc >= CIP_SFC_COUNT) { |
127 | err = -EAGAIN; /* also in transition */ |
128 | goto end; |
129 | } |
130 | |
131 | *rate = amdtp_rate_table[sfc]; |
132 | err = 0; |
133 | end: |
134 | kfree(objp: buf); |
135 | return err; |
136 | } |
137 | EXPORT_SYMBOL(avc_general_get_sig_fmt); |
138 | |
139 | int avc_general_get_plug_info(struct fw_unit *unit, unsigned int subunit_type, |
140 | unsigned int subunit_id, unsigned int subfunction, |
141 | u8 info[AVC_PLUG_INFO_BUF_BYTES]) |
142 | { |
143 | u8 *buf; |
144 | int err; |
145 | |
146 | /* extended subunit in spec.4.2 is not supported */ |
147 | if ((subunit_type == 0x1E) || (subunit_id == 5)) |
148 | return -EINVAL; |
149 | |
150 | buf = kzalloc(size: 8, GFP_KERNEL); |
151 | if (buf == NULL) |
152 | return -ENOMEM; |
153 | |
154 | buf[0] = 0x01; /* AV/C STATUS */ |
155 | /* UNIT or Subunit, Functionblock */ |
156 | buf[1] = ((subunit_type & 0x1f) << 3) | (subunit_id & 0x7); |
157 | buf[2] = 0x02; /* PLUG INFO */ |
158 | buf[3] = 0xff & subfunction; |
159 | |
160 | err = fcp_avc_transaction(unit, command: buf, command_size: 8, response: buf, response_size: 8, BIT(1) | BIT(2)); |
161 | if (err < 0) |
162 | ; |
163 | else if (err < 8) |
164 | err = -EIO; |
165 | else if (buf[0] == 0x08) /* NOT IMPLEMENTED */ |
166 | err = -ENOSYS; |
167 | else if (buf[0] == 0x0a) /* REJECTED */ |
168 | err = -EINVAL; |
169 | else if (buf[0] == 0x0b) /* IN TRANSITION */ |
170 | err = -EAGAIN; |
171 | if (err < 0) |
172 | goto end; |
173 | |
174 | info[0] = buf[4]; |
175 | info[1] = buf[5]; |
176 | info[2] = buf[6]; |
177 | info[3] = buf[7]; |
178 | |
179 | err = 0; |
180 | end: |
181 | kfree(objp: buf); |
182 | return err; |
183 | } |
184 | EXPORT_SYMBOL(avc_general_get_plug_info); |
185 | |
186 | static DEFINE_SPINLOCK(transactions_lock); |
187 | static LIST_HEAD(transactions); |
188 | |
189 | enum fcp_state { |
190 | STATE_PENDING, |
191 | STATE_BUS_RESET, |
192 | STATE_COMPLETE, |
193 | STATE_DEFERRED, |
194 | }; |
195 | |
196 | struct fcp_transaction { |
197 | struct list_head list; |
198 | struct fw_unit *unit; |
199 | void *response_buffer; |
200 | unsigned int response_size; |
201 | unsigned int response_match_bytes; |
202 | enum fcp_state state; |
203 | wait_queue_head_t wait; |
204 | bool deferrable; |
205 | }; |
206 | |
207 | /** |
208 | * fcp_avc_transaction - send an AV/C command and wait for its response |
209 | * @unit: a unit on the target device |
210 | * @command: a buffer containing the command frame; must be DMA-able |
211 | * @command_size: the size of @command |
212 | * @response: a buffer for the response frame |
213 | * @response_size: the maximum size of @response |
214 | * @response_match_bytes: a bitmap specifying the bytes used to detect the |
215 | * correct response frame |
216 | * |
217 | * This function sends a FCP command frame to the target and waits for the |
218 | * corresponding response frame to be returned. |
219 | * |
220 | * Because it is possible for multiple FCP transactions to be active at the |
221 | * same time, the correct response frame is detected by the value of certain |
222 | * bytes. These bytes must be set in @response before calling this function, |
223 | * and the corresponding bits must be set in @response_match_bytes. |
224 | * |
225 | * @command and @response can point to the same buffer. |
226 | * |
227 | * Returns the actual size of the response frame, or a negative error code. |
228 | */ |
229 | int fcp_avc_transaction(struct fw_unit *unit, |
230 | const void *command, unsigned int command_size, |
231 | void *response, unsigned int response_size, |
232 | unsigned int response_match_bytes) |
233 | { |
234 | struct fcp_transaction t; |
235 | int tcode, ret, tries = 0; |
236 | |
237 | t.unit = unit; |
238 | t.response_buffer = response; |
239 | t.response_size = response_size; |
240 | t.response_match_bytes = response_match_bytes; |
241 | t.state = STATE_PENDING; |
242 | init_waitqueue_head(&t.wait); |
243 | t.deferrable = (*(const u8 *)command == 0x00 || *(const u8 *)command == 0x03); |
244 | |
245 | spin_lock_irq(lock: &transactions_lock); |
246 | list_add_tail(new: &t.list, head: &transactions); |
247 | spin_unlock_irq(lock: &transactions_lock); |
248 | |
249 | for (;;) { |
250 | tcode = command_size == 4 ? TCODE_WRITE_QUADLET_REQUEST |
251 | : TCODE_WRITE_BLOCK_REQUEST; |
252 | ret = snd_fw_transaction(unit: t.unit, tcode, |
253 | CSR_REGISTER_BASE + CSR_FCP_COMMAND, |
254 | buffer: (void *)command, length: command_size, flags: 0); |
255 | if (ret < 0) |
256 | break; |
257 | deferred: |
258 | wait_event_timeout(t.wait, t.state != STATE_PENDING, |
259 | msecs_to_jiffies(FCP_TIMEOUT_MS)); |
260 | |
261 | if (t.state == STATE_DEFERRED) { |
262 | /* |
263 | * 'AV/C General Specification' define no time limit |
264 | * on command completion once an INTERIM response has |
265 | * been sent. but we promise to finish this function |
266 | * for a caller. Here we use FCP_TIMEOUT_MS for next |
267 | * interval. This is not in the specification. |
268 | */ |
269 | t.state = STATE_PENDING; |
270 | goto deferred; |
271 | } else if (t.state == STATE_COMPLETE) { |
272 | ret = t.response_size; |
273 | break; |
274 | } else if (t.state == STATE_BUS_RESET) { |
275 | msleep(ERROR_DELAY_MS); |
276 | } else if (++tries >= ERROR_RETRIES) { |
277 | dev_err(&t.unit->device, "FCP command timed out\n" ); |
278 | ret = -EIO; |
279 | break; |
280 | } |
281 | } |
282 | |
283 | spin_lock_irq(lock: &transactions_lock); |
284 | list_del(entry: &t.list); |
285 | spin_unlock_irq(lock: &transactions_lock); |
286 | |
287 | return ret; |
288 | } |
289 | EXPORT_SYMBOL(fcp_avc_transaction); |
290 | |
291 | /** |
292 | * fcp_bus_reset - inform the target handler about a bus reset |
293 | * @unit: the unit that might be used by fcp_avc_transaction() |
294 | * |
295 | * This function must be called from the driver's .update handler to inform |
296 | * the FCP transaction handler that a bus reset has happened. Any pending FCP |
297 | * transactions are retried. |
298 | */ |
299 | void fcp_bus_reset(struct fw_unit *unit) |
300 | { |
301 | struct fcp_transaction *t; |
302 | |
303 | spin_lock_irq(lock: &transactions_lock); |
304 | list_for_each_entry(t, &transactions, list) { |
305 | if (t->unit == unit && |
306 | (t->state == STATE_PENDING || |
307 | t->state == STATE_DEFERRED)) { |
308 | t->state = STATE_BUS_RESET; |
309 | wake_up(&t->wait); |
310 | } |
311 | } |
312 | spin_unlock_irq(lock: &transactions_lock); |
313 | } |
314 | EXPORT_SYMBOL(fcp_bus_reset); |
315 | |
316 | /* checks whether the response matches the masked bytes in response_buffer */ |
317 | static bool is_matching_response(struct fcp_transaction *transaction, |
318 | const void *response, size_t length) |
319 | { |
320 | const u8 *p1, *p2; |
321 | unsigned int mask, i; |
322 | |
323 | p1 = response; |
324 | p2 = transaction->response_buffer; |
325 | mask = transaction->response_match_bytes; |
326 | |
327 | for (i = 0; ; ++i) { |
328 | if ((mask & 1) && p1[i] != p2[i]) |
329 | return false; |
330 | mask >>= 1; |
331 | if (!mask) |
332 | return true; |
333 | if (--length == 0) |
334 | return false; |
335 | } |
336 | } |
337 | |
338 | static void fcp_response(struct fw_card *card, struct fw_request *request, |
339 | int tcode, int destination, int source, |
340 | int generation, unsigned long long offset, |
341 | void *data, size_t length, void *callback_data) |
342 | { |
343 | struct fcp_transaction *t; |
344 | unsigned long flags; |
345 | |
346 | if (length < 1 || (*(const u8 *)data & 0xf0) != CTS_AVC) |
347 | return; |
348 | |
349 | spin_lock_irqsave(&transactions_lock, flags); |
350 | list_for_each_entry(t, &transactions, list) { |
351 | struct fw_device *device = fw_parent_device(t->unit); |
352 | if (device->card != card || |
353 | device->generation != generation) |
354 | continue; |
355 | smp_rmb(); /* node_id vs. generation */ |
356 | if (device->node_id != source) |
357 | continue; |
358 | |
359 | if (t->state == STATE_PENDING && |
360 | is_matching_response(transaction: t, response: data, length)) { |
361 | if (t->deferrable && *(const u8 *)data == 0x0f) { |
362 | t->state = STATE_DEFERRED; |
363 | } else { |
364 | t->state = STATE_COMPLETE; |
365 | t->response_size = min_t(unsigned int, length, |
366 | t->response_size); |
367 | memcpy(t->response_buffer, data, |
368 | t->response_size); |
369 | } |
370 | wake_up(&t->wait); |
371 | } |
372 | } |
373 | spin_unlock_irqrestore(lock: &transactions_lock, flags); |
374 | } |
375 | |
376 | static struct fw_address_handler response_register_handler = { |
377 | .length = 0x200, |
378 | .address_callback = fcp_response, |
379 | }; |
380 | |
381 | static int __init fcp_module_init(void) |
382 | { |
383 | static const struct fw_address_region response_register_region = { |
384 | .start = CSR_REGISTER_BASE + CSR_FCP_RESPONSE, |
385 | .end = CSR_REGISTER_BASE + CSR_FCP_END, |
386 | }; |
387 | |
388 | fw_core_add_address_handler(handler: &response_register_handler, |
389 | region: &response_register_region); |
390 | |
391 | return 0; |
392 | } |
393 | |
394 | static void __exit fcp_module_exit(void) |
395 | { |
396 | WARN_ON(!list_empty(&transactions)); |
397 | fw_core_remove_address_handler(handler: &response_register_handler); |
398 | } |
399 | |
400 | module_init(fcp_module_init); |
401 | module_exit(fcp_module_exit); |
402 | |