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