1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * fireworks_transaction.c - a part of driver for Fireworks based devices
4 *
5 * Copyright (c) 2013-2014 Takashi Sakamoto
6 */
7
8 /*
9 * Fireworks have its own transaction. The transaction can be delivered by AV/C
10 * Vendor Specific command frame or usual asynchronous transaction. At least,
11 * Windows driver and firmware version 5.5 or later don't use AV/C command.
12 *
13 * Transaction substance:
14 * At first, 6 data exist. Following to the data, parameters for each command
15 * exist. All of the parameters are 32 bit aligned to big endian.
16 * data[0]: Length of transaction substance
17 * data[1]: Transaction version
18 * data[2]: Sequence number. This is incremented by the device
19 * data[3]: Transaction category
20 * data[4]: Transaction command
21 * data[5]: Return value in response.
22 * data[6-]: Parameters
23 *
24 * Transaction address:
25 * command: 0xecc000000000
26 * response: 0xecc080000000 (default)
27 *
28 * I note that the address for response can be changed by command. But this
29 * module uses the default address.
30 */
31 #include "./fireworks.h"
32
33 #define MEMORY_SPACE_EFW_COMMAND 0xecc000000000ULL
34 #define MEMORY_SPACE_EFW_RESPONSE 0xecc080000000ULL
35
36 #define ERROR_RETRIES 3
37 #define ERROR_DELAY_MS 5
38 #define EFC_TIMEOUT_MS 125
39
40 static DEFINE_SPINLOCK(instances_lock);
41 static struct snd_efw *instances[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
42
43 static DEFINE_SPINLOCK(transaction_queues_lock);
44 static LIST_HEAD(transaction_queues);
45
46 enum transaction_queue_state {
47 STATE_PENDING,
48 STATE_BUS_RESET,
49 STATE_COMPLETE
50 };
51
52 struct transaction_queue {
53 struct list_head list;
54 struct fw_unit *unit;
55 void *buf;
56 unsigned int size;
57 u32 seqnum;
58 enum transaction_queue_state state;
59 wait_queue_head_t wait;
60 };
61
62 int snd_efw_transaction_cmd(struct fw_unit *unit,
63 const void *cmd, unsigned int size)
64 {
65 return snd_fw_transaction(unit, TCODE_WRITE_BLOCK_REQUEST,
66 MEMORY_SPACE_EFW_COMMAND,
67 (void *)cmd, size, 0);
68 }
69
70 int snd_efw_transaction_run(struct fw_unit *unit,
71 const void *cmd, unsigned int cmd_size,
72 void *resp, unsigned int resp_size)
73 {
74 struct transaction_queue t;
75 unsigned int tries;
76 int ret;
77
78 t.unit = unit;
79 t.buf = resp;
80 t.size = resp_size;
81 t.seqnum = be32_to_cpu(((struct snd_efw_transaction *)cmd)->seqnum) + 1;
82 t.state = STATE_PENDING;
83 init_waitqueue_head(&t.wait);
84
85 spin_lock_irq(&transaction_queues_lock);
86 list_add_tail(&t.list, &transaction_queues);
87 spin_unlock_irq(&transaction_queues_lock);
88
89 tries = 0;
90 do {
91 ret = snd_efw_transaction_cmd(t.unit, (void *)cmd, cmd_size);
92 if (ret < 0)
93 break;
94
95 wait_event_timeout(t.wait, t.state != STATE_PENDING,
96 msecs_to_jiffies(EFC_TIMEOUT_MS));
97
98 if (t.state == STATE_COMPLETE) {
99 ret = t.size;
100 break;
101 } else if (t.state == STATE_BUS_RESET) {
102 msleep(ERROR_DELAY_MS);
103 } else if (++tries >= ERROR_RETRIES) {
104 dev_err(&t.unit->device, "EFW transaction timed out\n");
105 ret = -EIO;
106 break;
107 }
108 } while (1);
109
110 spin_lock_irq(&transaction_queues_lock);
111 list_del(&t.list);
112 spin_unlock_irq(&transaction_queues_lock);
113
114 return ret;
115 }
116
117 static void
118 copy_resp_to_buf(struct snd_efw *efw, void *data, size_t length, int *rcode)
119 {
120 size_t capacity, till_end;
121 struct snd_efw_transaction *t;
122
123 t = (struct snd_efw_transaction *)data;
124 length = min_t(size_t, be32_to_cpu(t->length) * sizeof(u32), length);
125
126 spin_lock(&efw->lock);
127
128 if (efw->push_ptr < efw->pull_ptr)
129 capacity = (unsigned int)(efw->pull_ptr - efw->push_ptr);
130 else
131 capacity = snd_efw_resp_buf_size -
132 (unsigned int)(efw->push_ptr - efw->pull_ptr);
133
134 /* confirm enough space for this response */
135 if (capacity < length) {
136 *rcode = RCODE_CONFLICT_ERROR;
137 goto end;
138 }
139
140 /* copy to ring buffer */
141 while (length > 0) {
142 till_end = snd_efw_resp_buf_size -
143 (unsigned int)(efw->push_ptr - efw->resp_buf);
144 till_end = min_t(unsigned int, length, till_end);
145
146 memcpy(efw->push_ptr, data, till_end);
147
148 efw->push_ptr += till_end;
149 if (efw->push_ptr >= efw->resp_buf + snd_efw_resp_buf_size)
150 efw->push_ptr -= snd_efw_resp_buf_size;
151
152 length -= till_end;
153 data += till_end;
154 }
155
156 /* for hwdep */
157 wake_up(&efw->hwdep_wait);
158
159 *rcode = RCODE_COMPLETE;
160 end:
161 spin_unlock_irq(&efw->lock);
162 }
163
164 static void
165 handle_resp_for_user(struct fw_card *card, int generation, int source,
166 void *data, size_t length, int *rcode)
167 {
168 struct fw_device *device;
169 struct snd_efw *efw;
170 unsigned int i;
171
172 spin_lock_irq(&instances_lock);
173
174 for (i = 0; i < SNDRV_CARDS; i++) {
175 efw = instances[i];
176 if (efw == NULL)
177 continue;
178 device = fw_parent_device(efw->unit);
179 if ((device->card != card) ||
180 (device->generation != generation))
181 continue;
182 smp_rmb(); /* node id vs. generation */
183 if (device->node_id != source)
184 continue;
185
186 break;
187 }
188 if (i == SNDRV_CARDS)
189 goto end;
190
191 copy_resp_to_buf(efw, data, length, rcode);
192 end:
193 spin_unlock(&instances_lock);
194 }
195
196 static void
197 handle_resp_for_kernel(struct fw_card *card, int generation, int source,
198 void *data, size_t length, int *rcode, u32 seqnum)
199 {
200 struct fw_device *device;
201 struct transaction_queue *t;
202 unsigned long flags;
203
204 spin_lock_irqsave(&transaction_queues_lock, flags);
205 list_for_each_entry(t, &transaction_queues, list) {
206 device = fw_parent_device(t->unit);
207 if ((device->card != card) ||
208 (device->generation != generation))
209 continue;
210 smp_rmb(); /* node_id vs. generation */
211 if (device->node_id != source)
212 continue;
213
214 if ((t->state == STATE_PENDING) && (t->seqnum == seqnum)) {
215 t->state = STATE_COMPLETE;
216 t->size = min_t(unsigned int, length, t->size);
217 memcpy(t->buf, data, t->size);
218 wake_up(&t->wait);
219 *rcode = RCODE_COMPLETE;
220 }
221 }
222 spin_unlock_irqrestore(&transaction_queues_lock, flags);
223 }
224
225 static void
226 efw_response(struct fw_card *card, struct fw_request *request,
227 int tcode, int destination, int source,
228 int generation, unsigned long long offset,
229 void *data, size_t length, void *callback_data)
230 {
231 int rcode, dummy;
232 u32 seqnum;
233
234 rcode = RCODE_TYPE_ERROR;
235 if (length < sizeof(struct snd_efw_transaction)) {
236 rcode = RCODE_DATA_ERROR;
237 goto end;
238 } else if (offset != MEMORY_SPACE_EFW_RESPONSE) {
239 rcode = RCODE_ADDRESS_ERROR;
240 goto end;
241 }
242
243 seqnum = be32_to_cpu(((struct snd_efw_transaction *)data)->seqnum);
244 if (seqnum > SND_EFW_TRANSACTION_USER_SEQNUM_MAX + 1) {
245 handle_resp_for_kernel(card, generation, source,
246 data, length, &rcode, seqnum);
247 if (snd_efw_resp_buf_debug)
248 handle_resp_for_user(card, generation, source,
249 data, length, &dummy);
250 } else {
251 handle_resp_for_user(card, generation, source,
252 data, length, &rcode);
253 }
254 end:
255 fw_send_response(card, request, rcode);
256 }
257
258 void snd_efw_transaction_add_instance(struct snd_efw *efw)
259 {
260 unsigned int i;
261
262 spin_lock_irq(&instances_lock);
263
264 for (i = 0; i < SNDRV_CARDS; i++) {
265 if (instances[i] != NULL)
266 continue;
267 instances[i] = efw;
268 break;
269 }
270
271 spin_unlock_irq(&instances_lock);
272 }
273
274 void snd_efw_transaction_remove_instance(struct snd_efw *efw)
275 {
276 unsigned int i;
277
278 spin_lock_irq(&instances_lock);
279
280 for (i = 0; i < SNDRV_CARDS; i++) {
281 if (instances[i] != efw)
282 continue;
283 instances[i] = NULL;
284 }
285
286 spin_unlock_irq(&instances_lock);
287 }
288
289 void snd_efw_transaction_bus_reset(struct fw_unit *unit)
290 {
291 struct transaction_queue *t;
292
293 spin_lock_irq(&transaction_queues_lock);
294 list_for_each_entry(t, &transaction_queues, list) {
295 if ((t->unit == unit) &&
296 (t->state == STATE_PENDING)) {
297 t->state = STATE_BUS_RESET;
298 wake_up(&t->wait);
299 }
300 }
301 spin_unlock_irq(&transaction_queues_lock);
302 }
303
304 static struct fw_address_handler resp_register_handler = {
305 .length = SND_EFW_RESPONSE_MAXIMUM_BYTES,
306 .address_callback = efw_response
307 };
308
309 int snd_efw_transaction_register(void)
310 {
311 static const struct fw_address_region resp_register_region = {
312 .start = MEMORY_SPACE_EFW_RESPONSE,
313 .end = MEMORY_SPACE_EFW_RESPONSE +
314 SND_EFW_RESPONSE_MAXIMUM_BYTES
315 };
316 return fw_core_add_address_handler(&resp_register_handler,
317 &resp_register_region);
318 }
319
320 void snd_efw_transaction_unregister(void)
321 {
322 WARN_ON(!list_empty(&transaction_queues));
323 fw_core_remove_address_handler(&resp_register_handler);
324 }
325
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.