Commit | Line | Data |
---|---|---|
31ef9134 CL |
1 | /* |
2 | * miscellaneous 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/delay.h> | |
9 | #include <linux/device.h> | |
10 | #include <linux/firewire.h> | |
11 | #include <linux/module.h> | |
585d7cba | 12 | #include <linux/slab.h> |
31ef9134 CL |
13 | #include "lib.h" |
14 | ||
1b70485f | 15 | #define ERROR_RETRY_DELAY_MS 20 |
31ef9134 | 16 | |
31ef9134 CL |
17 | /** |
18 | * snd_fw_transaction - send a request and wait for its completion | |
19 | * @unit: the driver's unit on the target device | |
20 | * @tcode: the transaction code | |
21 | * @offset: the address in the target's address space | |
22 | * @buffer: input/output data | |
23 | * @length: length of @buffer | |
1b70485f CL |
24 | * @flags: use %FW_FIXED_GENERATION and add the generation value to attempt the |
25 | * request only in that generation; use %FW_QUIET to suppress error | |
26 | * messages | |
31ef9134 CL |
27 | * |
28 | * Submits an asynchronous request to the target device, and waits for the | |
29 | * response. The node ID and the current generation are derived from @unit. | |
30 | * On a bus reset or an error, the transaction is retried a few times. | |
31 | * Returns zero on success, or a negative error code. | |
32 | */ | |
33 | int snd_fw_transaction(struct fw_unit *unit, int tcode, | |
1b70485f CL |
34 | u64 offset, void *buffer, size_t length, |
35 | unsigned int flags) | |
31ef9134 CL |
36 | { |
37 | struct fw_device *device = fw_parent_device(unit); | |
38 | int generation, rcode, tries = 0; | |
39 | ||
1b70485f | 40 | generation = flags & FW_GENERATION_MASK; |
31ef9134 | 41 | for (;;) { |
1b70485f CL |
42 | if (!(flags & FW_FIXED_GENERATION)) { |
43 | generation = device->generation; | |
44 | smp_rmb(); /* node_id vs. generation */ | |
45 | } | |
31ef9134 CL |
46 | rcode = fw_run_transaction(device->card, tcode, |
47 | device->node_id, generation, | |
48 | device->max_speed, offset, | |
49 | buffer, length); | |
50 | ||
51 | if (rcode == RCODE_COMPLETE) | |
52 | return 0; | |
53 | ||
1b70485f CL |
54 | if (rcode == RCODE_GENERATION && (flags & FW_FIXED_GENERATION)) |
55 | return -EAGAIN; | |
56 | ||
31ef9134 | 57 | if (rcode_is_permanent_error(rcode) || ++tries >= 3) { |
1b70485f CL |
58 | if (!(flags & FW_QUIET)) |
59 | dev_err(&unit->device, | |
60 | "transaction failed: %s\n", | |
61 | fw_rcode_string(rcode)); | |
31ef9134 CL |
62 | return -EIO; |
63 | } | |
64 | ||
65 | msleep(ERROR_RETRY_DELAY_MS); | |
66 | } | |
67 | } | |
68 | EXPORT_SYMBOL(snd_fw_transaction); | |
69 | ||
923f92eb TS |
70 | #define PROBE_DELAY_MS (2 * MSEC_PER_SEC) |
71 | ||
72 | /** | |
73 | * snd_fw_schedule_registration - schedule work for sound card registration | |
74 | * @unit: an instance for unit on IEEE 1394 bus | |
75 | * @dwork: delayed work with callback function | |
76 | * | |
77 | * This function is not designed for general purposes. When new unit is | |
78 | * connected to IEEE 1394 bus, the bus is under bus-reset state because of | |
79 | * topological change. In this state, units tend to fail both of asynchronous | |
80 | * and isochronous communication. To avoid this problem, this function is used | |
81 | * to postpone sound card registration after the state. The callers must | |
82 | * set up instance of delayed work in advance. | |
83 | */ | |
84 | void snd_fw_schedule_registration(struct fw_unit *unit, | |
85 | struct delayed_work *dwork) | |
86 | { | |
87 | u64 now, delay; | |
88 | ||
89 | now = get_jiffies_64(); | |
90 | delay = fw_parent_device(unit)->card->reset_jiffies | |
91 | + msecs_to_jiffies(PROBE_DELAY_MS); | |
92 | ||
93 | if (time_after64(delay, now)) | |
94 | delay -= now; | |
95 | else | |
96 | delay = 0; | |
97 | ||
98 | mod_delayed_work(system_wq, dwork, delay); | |
99 | } | |
100 | EXPORT_SYMBOL(snd_fw_schedule_registration); | |
101 | ||
585d7cba TS |
102 | static void async_midi_port_callback(struct fw_card *card, int rcode, |
103 | void *data, size_t length, | |
104 | void *callback_data) | |
105 | { | |
106 | struct snd_fw_async_midi_port *port = callback_data; | |
107 | struct snd_rawmidi_substream *substream = ACCESS_ONCE(port->substream); | |
108 | ||
56b1c72a TS |
109 | /* This port is closed. */ |
110 | if (substream == NULL) | |
111 | return; | |
112 | ||
113 | if (rcode == RCODE_COMPLETE) | |
585d7cba | 114 | snd_rawmidi_transmit_ack(substream, port->consume_bytes); |
ea848b7b TS |
115 | else if (!rcode_is_permanent_error(rcode)) |
116 | /* To start next transaction immediately for recovery. */ | |
8b0e1953 | 117 | port->next_ktime = 0; |
bde3e288 TS |
118 | else |
119 | /* Don't continue processing. */ | |
120 | port->error = true; | |
d3ef9cb9 TS |
121 | |
122 | port->idling = true; | |
e8a40d9b TS |
123 | |
124 | if (!snd_rawmidi_transmit_empty(substream)) | |
125 | schedule_work(&port->work); | |
585d7cba TS |
126 | } |
127 | ||
128 | static void midi_port_work(struct work_struct *work) | |
129 | { | |
130 | struct snd_fw_async_midi_port *port = | |
131 | container_of(work, struct snd_fw_async_midi_port, work); | |
132 | struct snd_rawmidi_substream *substream = ACCESS_ONCE(port->substream); | |
133 | int generation; | |
134 | int type; | |
135 | ||
bde3e288 TS |
136 | /* Under transacting or error state. */ |
137 | if (!port->idling || port->error) | |
d3ef9cb9 TS |
138 | return; |
139 | ||
585d7cba TS |
140 | /* Nothing to do. */ |
141 | if (substream == NULL || snd_rawmidi_transmit_empty(substream)) | |
142 | return; | |
143 | ||
ea848b7b TS |
144 | /* Do it in next chance. */ |
145 | if (ktime_after(port->next_ktime, ktime_get())) { | |
146 | schedule_work(&port->work); | |
147 | return; | |
148 | } | |
149 | ||
585d7cba TS |
150 | /* |
151 | * Fill the buffer. The callee must use snd_rawmidi_transmit_peek(). | |
152 | * Later, snd_rawmidi_transmit_ack() is called. | |
153 | */ | |
154 | memset(port->buf, 0, port->len); | |
155 | port->consume_bytes = port->fill(substream, port->buf); | |
156 | if (port->consume_bytes <= 0) { | |
157 | /* Do it in next chance, immediately. */ | |
ea848b7b | 158 | if (port->consume_bytes == 0) { |
8b0e1953 | 159 | port->next_ktime = 0; |
585d7cba | 160 | schedule_work(&port->work); |
bde3e288 TS |
161 | } else { |
162 | /* Fatal error. */ | |
163 | port->error = true; | |
ea848b7b | 164 | } |
585d7cba TS |
165 | return; |
166 | } | |
167 | ||
168 | /* Calculate type of transaction. */ | |
169 | if (port->len == 4) | |
170 | type = TCODE_WRITE_QUADLET_REQUEST; | |
171 | else | |
172 | type = TCODE_WRITE_BLOCK_REQUEST; | |
173 | ||
ea848b7b TS |
174 | /* Set interval to next transaction. */ |
175 | port->next_ktime = ktime_add_ns(ktime_get(), | |
176 | port->consume_bytes * 8 * NSEC_PER_SEC / 31250); | |
177 | ||
585d7cba | 178 | /* Start this transaction. */ |
d3ef9cb9 TS |
179 | port->idling = false; |
180 | ||
585d7cba TS |
181 | /* |
182 | * In Linux FireWire core, when generation is updated with memory | |
183 | * barrier, node id has already been updated. In this module, After | |
184 | * this smp_rmb(), load/store instructions to memory are completed. | |
185 | * Thus, both of generation and node id are available with recent | |
186 | * values. This is a light-serialization solution to handle bus reset | |
187 | * events on IEEE 1394 bus. | |
188 | */ | |
189 | generation = port->parent->generation; | |
190 | smp_rmb(); | |
191 | ||
192 | fw_send_request(port->parent->card, &port->transaction, type, | |
193 | port->parent->node_id, generation, | |
194 | port->parent->max_speed, port->addr, | |
195 | port->buf, port->len, async_midi_port_callback, | |
196 | port); | |
197 | } | |
198 | ||
199 | /** | |
200 | * snd_fw_async_midi_port_init - initialize asynchronous MIDI port structure | |
201 | * @port: the asynchronous MIDI port to initialize | |
202 | * @unit: the target of the asynchronous transaction | |
203 | * @addr: the address to which transactions are transferred | |
204 | * @len: the length of transaction | |
205 | * @fill: the callback function to fill given buffer, and returns the | |
206 | * number of consumed bytes for MIDI message. | |
207 | * | |
208 | */ | |
209 | int snd_fw_async_midi_port_init(struct snd_fw_async_midi_port *port, | |
210 | struct fw_unit *unit, u64 addr, unsigned int len, | |
211 | snd_fw_async_midi_port_fill fill) | |
212 | { | |
213 | port->len = DIV_ROUND_UP(len, 4) * 4; | |
214 | port->buf = kzalloc(port->len, GFP_KERNEL); | |
215 | if (port->buf == NULL) | |
216 | return -ENOMEM; | |
217 | ||
218 | port->parent = fw_parent_device(unit); | |
219 | port->addr = addr; | |
220 | port->fill = fill; | |
d3ef9cb9 | 221 | port->idling = true; |
8b0e1953 | 222 | port->next_ktime = 0; |
bde3e288 | 223 | port->error = false; |
585d7cba TS |
224 | |
225 | INIT_WORK(&port->work, midi_port_work); | |
226 | ||
227 | return 0; | |
228 | } | |
229 | EXPORT_SYMBOL(snd_fw_async_midi_port_init); | |
230 | ||
231 | /** | |
232 | * snd_fw_async_midi_port_destroy - free asynchronous MIDI port structure | |
233 | * @port: the asynchronous MIDI port structure | |
234 | */ | |
235 | void snd_fw_async_midi_port_destroy(struct snd_fw_async_midi_port *port) | |
236 | { | |
237 | snd_fw_async_midi_port_finish(port); | |
238 | cancel_work_sync(&port->work); | |
239 | kfree(port->buf); | |
240 | } | |
241 | EXPORT_SYMBOL(snd_fw_async_midi_port_destroy); | |
242 | ||
31ef9134 CL |
243 | MODULE_DESCRIPTION("FireWire audio helper functions"); |
244 | MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>"); | |
245 | MODULE_LICENSE("GPL v2"); |