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 | ||
585d7cba TS |
70 | static void async_midi_port_callback(struct fw_card *card, int rcode, |
71 | void *data, size_t length, | |
72 | void *callback_data) | |
73 | { | |
74 | struct snd_fw_async_midi_port *port = callback_data; | |
75 | struct snd_rawmidi_substream *substream = ACCESS_ONCE(port->substream); | |
76 | ||
77 | if (rcode == RCODE_COMPLETE && substream != NULL) | |
78 | snd_rawmidi_transmit_ack(substream, port->consume_bytes); | |
79 | } | |
80 | ||
81 | static void midi_port_work(struct work_struct *work) | |
82 | { | |
83 | struct snd_fw_async_midi_port *port = | |
84 | container_of(work, struct snd_fw_async_midi_port, work); | |
85 | struct snd_rawmidi_substream *substream = ACCESS_ONCE(port->substream); | |
86 | int generation; | |
87 | int type; | |
88 | ||
89 | /* Nothing to do. */ | |
90 | if (substream == NULL || snd_rawmidi_transmit_empty(substream)) | |
91 | return; | |
92 | ||
93 | /* | |
94 | * Fill the buffer. The callee must use snd_rawmidi_transmit_peek(). | |
95 | * Later, snd_rawmidi_transmit_ack() is called. | |
96 | */ | |
97 | memset(port->buf, 0, port->len); | |
98 | port->consume_bytes = port->fill(substream, port->buf); | |
99 | if (port->consume_bytes <= 0) { | |
100 | /* Do it in next chance, immediately. */ | |
101 | if (port->consume_bytes == 0) | |
102 | schedule_work(&port->work); | |
103 | return; | |
104 | } | |
105 | ||
106 | /* Calculate type of transaction. */ | |
107 | if (port->len == 4) | |
108 | type = TCODE_WRITE_QUADLET_REQUEST; | |
109 | else | |
110 | type = TCODE_WRITE_BLOCK_REQUEST; | |
111 | ||
112 | /* Start this transaction. */ | |
113 | /* | |
114 | * In Linux FireWire core, when generation is updated with memory | |
115 | * barrier, node id has already been updated. In this module, After | |
116 | * this smp_rmb(), load/store instructions to memory are completed. | |
117 | * Thus, both of generation and node id are available with recent | |
118 | * values. This is a light-serialization solution to handle bus reset | |
119 | * events on IEEE 1394 bus. | |
120 | */ | |
121 | generation = port->parent->generation; | |
122 | smp_rmb(); | |
123 | ||
124 | fw_send_request(port->parent->card, &port->transaction, type, | |
125 | port->parent->node_id, generation, | |
126 | port->parent->max_speed, port->addr, | |
127 | port->buf, port->len, async_midi_port_callback, | |
128 | port); | |
129 | } | |
130 | ||
131 | /** | |
132 | * snd_fw_async_midi_port_init - initialize asynchronous MIDI port structure | |
133 | * @port: the asynchronous MIDI port to initialize | |
134 | * @unit: the target of the asynchronous transaction | |
135 | * @addr: the address to which transactions are transferred | |
136 | * @len: the length of transaction | |
137 | * @fill: the callback function to fill given buffer, and returns the | |
138 | * number of consumed bytes for MIDI message. | |
139 | * | |
140 | */ | |
141 | int snd_fw_async_midi_port_init(struct snd_fw_async_midi_port *port, | |
142 | struct fw_unit *unit, u64 addr, unsigned int len, | |
143 | snd_fw_async_midi_port_fill fill) | |
144 | { | |
145 | port->len = DIV_ROUND_UP(len, 4) * 4; | |
146 | port->buf = kzalloc(port->len, GFP_KERNEL); | |
147 | if (port->buf == NULL) | |
148 | return -ENOMEM; | |
149 | ||
150 | port->parent = fw_parent_device(unit); | |
151 | port->addr = addr; | |
152 | port->fill = fill; | |
153 | ||
154 | INIT_WORK(&port->work, midi_port_work); | |
155 | ||
156 | return 0; | |
157 | } | |
158 | EXPORT_SYMBOL(snd_fw_async_midi_port_init); | |
159 | ||
160 | /** | |
161 | * snd_fw_async_midi_port_destroy - free asynchronous MIDI port structure | |
162 | * @port: the asynchronous MIDI port structure | |
163 | */ | |
164 | void snd_fw_async_midi_port_destroy(struct snd_fw_async_midi_port *port) | |
165 | { | |
166 | snd_fw_async_midi_port_finish(port); | |
167 | cancel_work_sync(&port->work); | |
168 | kfree(port->buf); | |
169 | } | |
170 | EXPORT_SYMBOL(snd_fw_async_midi_port_destroy); | |
171 | ||
31ef9134 CL |
172 | MODULE_DESCRIPTION("FireWire audio helper functions"); |
173 | MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>"); | |
174 | MODULE_LICENSE("GPL v2"); |