~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/firewire/fireface/ff-transaction.c

Version: ~ [ linux-5.12-rc1 ] ~ [ linux-5.11.2 ] ~ [ linux-5.10.19 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.101 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.177 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.222 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.258 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.258 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-only
  2 /*
  3  * ff-transaction.c - a part of driver for RME Fireface series
  4  *
  5  * Copyright (c) 2015-2017 Takashi Sakamoto
  6  */
  7 
  8 #include "ff.h"
  9 
 10 static void finish_transmit_midi_msg(struct snd_ff *ff, unsigned int port,
 11                                      int rcode)
 12 {
 13         struct snd_rawmidi_substream *substream =
 14                                 READ_ONCE(ff->rx_midi_substreams[port]);
 15 
 16         if (rcode_is_permanent_error(rcode)) {
 17                 ff->rx_midi_error[port] = true;
 18                 return;
 19         }
 20 
 21         if (rcode != RCODE_COMPLETE) {
 22                 /* Transfer the message again, immediately. */
 23                 ff->next_ktime[port] = 0;
 24                 schedule_work(&ff->rx_midi_work[port]);
 25                 return;
 26         }
 27 
 28         snd_rawmidi_transmit_ack(substream, ff->rx_bytes[port]);
 29         ff->rx_bytes[port] = 0;
 30 
 31         if (!snd_rawmidi_transmit_empty(substream))
 32                 schedule_work(&ff->rx_midi_work[port]);
 33 }
 34 
 35 static void finish_transmit_midi0_msg(struct fw_card *card, int rcode,
 36                                       void *data, size_t length,
 37                                       void *callback_data)
 38 {
 39         struct snd_ff *ff =
 40                 container_of(callback_data, struct snd_ff, transactions[0]);
 41         finish_transmit_midi_msg(ff, 0, rcode);
 42 }
 43 
 44 static void finish_transmit_midi1_msg(struct fw_card *card, int rcode,
 45                                       void *data, size_t length,
 46                                       void *callback_data)
 47 {
 48         struct snd_ff *ff =
 49                 container_of(callback_data, struct snd_ff, transactions[1]);
 50         finish_transmit_midi_msg(ff, 1, rcode);
 51 }
 52 
 53 static void transmit_midi_msg(struct snd_ff *ff, unsigned int port)
 54 {
 55         struct snd_rawmidi_substream *substream =
 56                         READ_ONCE(ff->rx_midi_substreams[port]);
 57         int quad_count;
 58 
 59         struct fw_device *fw_dev = fw_parent_device(ff->unit);
 60         unsigned long long addr;
 61         int generation;
 62         fw_transaction_callback_t callback;
 63         int tcode;
 64 
 65         if (substream == NULL || snd_rawmidi_transmit_empty(substream))
 66                 return;
 67 
 68         if (ff->rx_bytes[port] > 0 || ff->rx_midi_error[port])
 69                 return;
 70 
 71         /* Do it in next chance. */
 72         if (ktime_after(ff->next_ktime[port], ktime_get())) {
 73                 schedule_work(&ff->rx_midi_work[port]);
 74                 return;
 75         }
 76 
 77         quad_count = ff->spec->protocol->fill_midi_msg(ff, substream, port);
 78         if (quad_count <= 0)
 79                 return;
 80 
 81         if (port == 0) {
 82                 addr = ff->spec->midi_rx_addrs[0];
 83                 callback = finish_transmit_midi0_msg;
 84         } else {
 85                 addr = ff->spec->midi_rx_addrs[1];
 86                 callback = finish_transmit_midi1_msg;
 87         }
 88 
 89         /* Set interval to next transaction. */
 90         ff->next_ktime[port] = ktime_add_ns(ktime_get(),
 91                                 ff->rx_bytes[port] * 8 * NSEC_PER_SEC / 31250);
 92 
 93         if (quad_count == 1)
 94                 tcode = TCODE_WRITE_QUADLET_REQUEST;
 95         else
 96                 tcode = TCODE_WRITE_BLOCK_REQUEST;
 97 
 98         /*
 99          * In Linux FireWire core, when generation is updated with memory
100          * barrier, node id has already been updated. In this module, After
101          * this smp_rmb(), load/store instructions to memory are completed.
102          * Thus, both of generation and node id are available with recent
103          * values. This is a light-serialization solution to handle bus reset
104          * events on IEEE 1394 bus.
105          */
106         generation = fw_dev->generation;
107         smp_rmb();
108         fw_send_request(fw_dev->card, &ff->transactions[port], tcode,
109                         fw_dev->node_id, generation, fw_dev->max_speed,
110                         addr, &ff->msg_buf[port], quad_count * 4,
111                         callback, &ff->transactions[port]);
112 }
113 
114 static void transmit_midi0_msg(struct work_struct *work)
115 {
116         struct snd_ff *ff = container_of(work, struct snd_ff, rx_midi_work[0]);
117 
118         transmit_midi_msg(ff, 0);
119 }
120 
121 static void transmit_midi1_msg(struct work_struct *work)
122 {
123         struct snd_ff *ff = container_of(work, struct snd_ff, rx_midi_work[1]);
124 
125         transmit_midi_msg(ff, 1);
126 }
127 
128 static void handle_midi_msg(struct fw_card *card, struct fw_request *request,
129                             int tcode, int destination, int source,
130                             int generation, unsigned long long offset,
131                             void *data, size_t length, void *callback_data)
132 {
133         struct snd_ff *ff = callback_data;
134         __le32 *buf = data;
135 
136         fw_send_response(card, request, RCODE_COMPLETE);
137 
138         offset -= ff->async_handler.offset;
139         ff->spec->protocol->handle_midi_msg(ff, (unsigned int)offset, buf,
140                                             length);
141 }
142 
143 static int allocate_own_address(struct snd_ff *ff, int i)
144 {
145         struct fw_address_region midi_msg_region;
146         int err;
147 
148         ff->async_handler.length = ff->spec->midi_addr_range;
149         ff->async_handler.address_callback = handle_midi_msg;
150         ff->async_handler.callback_data = ff;
151 
152         midi_msg_region.start = 0x000100000000ull * i;
153         midi_msg_region.end = midi_msg_region.start + ff->async_handler.length;
154 
155         err = fw_core_add_address_handler(&ff->async_handler, &midi_msg_region);
156         if (err >= 0) {
157                 /* Controllers are allowed to register this region. */
158                 if (ff->async_handler.offset & 0x0000ffffffff) {
159                         fw_core_remove_address_handler(&ff->async_handler);
160                         err = -EAGAIN;
161                 }
162         }
163 
164         return err;
165 }
166 
167 // Controllers are allowed to register higher 4 bytes of destination address to
168 // receive asynchronous transactions for MIDI messages, while the way to
169 // register lower 4 bytes of address is different depending on protocols. For
170 // details, please refer to comments in protocol implementations.
171 //
172 // This driver expects userspace applications to configure registers for the
173 // lower address because in most cases such registers has the other settings.
174 int snd_ff_transaction_reregister(struct snd_ff *ff)
175 {
176         struct fw_card *fw_card = fw_parent_device(ff->unit)->card;
177         u32 addr;
178         __le32 reg;
179 
180         /*
181          * Controllers are allowed to register its node ID and upper 2 byte of
182          * local address to listen asynchronous transactions.
183          */
184         addr = (fw_card->node_id << 16) | (ff->async_handler.offset >> 32);
185         reg = cpu_to_le32(addr);
186         return snd_fw_transaction(ff->unit, TCODE_WRITE_QUADLET_REQUEST,
187                                   ff->spec->midi_high_addr,
188                                   &reg, sizeof(reg), 0);
189 }
190 
191 int snd_ff_transaction_register(struct snd_ff *ff)
192 {
193         int i, err;
194 
195         /*
196          * Allocate in Memory Space of IEC 13213, but lower 4 byte in LSB should
197          * be zero due to device specification.
198          */
199         for (i = 0; i < 0xffff; i++) {
200                 err = allocate_own_address(ff, i);
201                 if (err != -EBUSY && err != -EAGAIN)
202                         break;
203         }
204         if (err < 0)
205                 return err;
206 
207         err = snd_ff_transaction_reregister(ff);
208         if (err < 0)
209                 return err;
210 
211         INIT_WORK(&ff->rx_midi_work[0], transmit_midi0_msg);
212         INIT_WORK(&ff->rx_midi_work[1], transmit_midi1_msg);
213 
214         return 0;
215 }
216 
217 void snd_ff_transaction_unregister(struct snd_ff *ff)
218 {
219         __le32 reg;
220 
221         if (ff->async_handler.callback_data == NULL)
222                 return;
223         ff->async_handler.callback_data = NULL;
224 
225         /* Release higher 4 bytes of address. */
226         reg = cpu_to_le32(0x00000000);
227         snd_fw_transaction(ff->unit, TCODE_WRITE_QUADLET_REQUEST,
228                            ff->spec->midi_high_addr,
229                            &reg, sizeof(reg), 0);
230 
231         fw_core_remove_address_handler(&ff->async_handler);
232 }
233 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp