sound/firewire/oxfw/oxfw-scs1x.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * oxfw-scs1x.c - a part of driver for OXFW970/971 based devices
   4  *
   5  * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
   6  * Copyright (c) 2015 Takashi Sakamoto <o-takashi@sakamocchi.jp>
   7  */
   8
   9 #include "oxfw.h"
  10
  11 #define HSS1394_ADDRESS                 0xc007dedadadaULL
  12 #define HSS1394_MAX_PACKET_SIZE         64
  13 #define HSS1394_TAG_USER_DATA           0x00
  14 #define HSS1394_TAG_CHANGE_ADDRESS      0xf1
  15
  16 struct fw_scs1x {
  17         struct fw_address_handler hss_handler;
  18         u8 input_escape_count;
  19         struct snd_rawmidi_substream *input;
  20
  21         /* For MIDI playback. */
  22         struct snd_rawmidi_substream *output;
  23         bool output_idle;
  24         u8 output_status;
  25         u8 output_bytes;
  26         bool output_escaped;
  27         bool output_escape_high_nibble;
  28         struct work_struct work;
  29         wait_queue_head_t idle_wait;
  30         u8 buffer[HSS1394_MAX_PACKET_SIZE];
  31         bool transaction_running;
  32         struct fw_transaction transaction;
  33         unsigned int transaction_bytes;
  34         bool error;
  35         struct fw_device *fw_dev;
  36 };
  37
  38 static const u8 sysex_escape_prefix[] = {
  39         0xf0,                   /* SysEx begin */
  40         0x00, 0x01, 0x60,       /* Stanton DJ */
  41         0x48, 0x53, 0x53,       /* "HSS" */
  42 };
  43
  44 static void midi_input_escaped_byte(struct snd_rawmidi_substream *stream,
  45                                     u8 byte)
  46 {
  47         u8 nibbles[2];
  48
  49         nibbles[0] = byte >> 4;
  50         nibbles[1] = byte & 0x0f;
  51         snd_rawmidi_receive(stream, nibbles, 2);
  52 }
  53
  54 static void midi_input_byte(struct fw_scs1x *scs,
  55                             struct snd_rawmidi_substream *stream, u8 byte)
  56 {
  57         const u8 eox = 0xf7;
  58
  59         if (scs->input_escape_count > 0) {
  60                 midi_input_escaped_byte(stream, byte);
  61                 scs->input_escape_count--;
  62                 if (scs->input_escape_count == 0)
  63                         snd_rawmidi_receive(stream, &eox, sizeof(eox));
  64         } else if (byte == 0xf9) {
  65                 snd_rawmidi_receive(stream, sysex_escape_prefix,
  66                                     ARRAY_SIZE(sysex_escape_prefix));
  67                 midi_input_escaped_byte(stream, 0x00);
  68                 midi_input_escaped_byte(stream, 0xf9);
  69                 scs->input_escape_count = 3;
  70         } else {
  71                 snd_rawmidi_receive(stream, &byte, 1);
  72         }
  73 }
  74
  75 static void midi_input_packet(struct fw_scs1x *scs,
  76                               struct snd_rawmidi_substream *stream,
  77                               const u8 *data, unsigned int bytes)
  78 {
  79         unsigned int i;
  80         const u8 eox = 0xf7;
  81
  82         if (data[0] == HSS1394_TAG_USER_DATA) {
  83                 for (i = 1; i < bytes; ++i)
  84                         midi_input_byte(scs, stream, data[i]);
  85         } else {
  86                 snd_rawmidi_receive(stream, sysex_escape_prefix,
  87                                     ARRAY_SIZE(sysex_escape_prefix));
  88                 for (i = 0; i < bytes; ++i)
  89                         midi_input_escaped_byte(stream, data[i]);
  90                 snd_rawmidi_receive(stream, &eox, sizeof(eox));
  91         }
  92 }
  93
  94 static void handle_hss(struct fw_card *card, struct fw_request *request,
  95                        int tcode, int destination, int source, int generation,
  96                        unsigned long long offset, void *data, size_t length,
  97                        void *callback_data)
  98 {
  99         struct fw_scs1x *scs = callback_data;
 100         struct snd_rawmidi_substream *stream;
 101         int rcode;
 102
 103         if (offset != scs->hss_handler.offset) {
 104                 rcode = RCODE_ADDRESS_ERROR;
 105                 goto end;
 106         }
 107         if (tcode != TCODE_WRITE_QUADLET_REQUEST &&
 108             tcode != TCODE_WRITE_BLOCK_REQUEST) {
 109                 rcode = RCODE_TYPE_ERROR;
 110                 goto end;
 111         }
 112
 113         if (length >= 1) {
 114                 stream = READ_ONCE(scs->input);
 115                 if (stream)
 116                         midi_input_packet(scs, stream, data, length);
 117         }
 118
 119         rcode = RCODE_COMPLETE;
 120 end:
 121         fw_send_response(card, request, rcode);
 122 }
 123
 124 static void scs_write_callback(struct fw_card *card, int rcode,
 125                                void *data, size_t length, void *callback_data)
 126 {
 127         struct fw_scs1x *scs = callback_data;
 128
 129         if (!rcode_is_permanent_error(rcode)) {
 130                 /* Don't retry for this data. */
 131                 if (rcode == RCODE_COMPLETE)
 132                         scs->transaction_bytes = 0;
 133         } else {
 134                 scs->error = true;
 135         }
 136
 137         scs->transaction_running = false;
 138         schedule_work(&scs->work);
 139 }
 140
 141 static bool is_valid_running_status(u8 status)
 142 {
 143         return status >= 0x80 && status <= 0xef;
 144 }
 145
 146 static bool is_one_byte_cmd(u8 status)
 147 {
 148         return status == 0xf6 ||
 149                status >= 0xf8;
 150 }
 151
 152 static bool is_two_bytes_cmd(u8 status)
 153 {
 154         return (status >= 0xc0 && status <= 0xdf) ||
 155                status == 0xf1 ||
 156                status == 0xf3;
 157 }
 158
 159 static bool is_three_bytes_cmd(u8 status)
 160 {
 161         return (status >= 0x80 && status <= 0xbf) ||
 162                (status >= 0xe0 && status <= 0xef) ||
 163                status == 0xf2;
 164 }
 165
 166 static bool is_invalid_cmd(u8 status)
 167 {
 168         return status == 0xf4 ||
 169                status == 0xf5 ||
 170                status == 0xf9 ||
 171                status == 0xfd;
 172 }
 173
 174 static void scs_output_work(struct work_struct *work)
 175 {
 176         struct fw_scs1x *scs = container_of(work, struct fw_scs1x, work);
 177         struct snd_rawmidi_substream *stream;
 178         unsigned int i;
 179         u8 byte;
 180         int generation;
 181
 182         if (scs->transaction_running)
 183                 return;
 184
 185         stream = READ_ONCE(scs->output);
 186         if (!stream || scs->error) {
 187                 scs->output_idle = true;
 188                 wake_up(&scs->idle_wait);
 189                 return;
 190         }
 191
 192         if (scs->transaction_bytes > 0)
 193                 goto retry;
 194
 195         i = scs->output_bytes;
 196         for (;;) {
 197                 if (snd_rawmidi_transmit(stream, &byte, 1) != 1) {
 198                         scs->output_bytes = i;
 199                         scs->output_idle = true;
 200                         wake_up(&scs->idle_wait);
 201                         return;
 202                 }
 203                 /*
 204                  * Convert from real MIDI to what I think the device expects (no
 205                  * running status, one command per packet, unescaped SysExs).
 206                  */
 207                 if (scs->output_escaped && byte < 0x80) {
 208                         if (scs->output_escape_high_nibble) {
 209                                 if (i < HSS1394_MAX_PACKET_SIZE) {
 210                                         scs->buffer[i] = byte << 4;
 211                                         scs->output_escape_high_nibble = false;
 212                                 }
 213                         } else {
 214                                 scs->buffer[i++] |= byte & 0x0f;
 215                                 scs->output_escape_high_nibble = true;
 216                         }
 217                 } else if (byte < 0x80) {
 218                         if (i == 1) {
 219                                 if (!is_valid_running_status(
 220                                                         scs->output_status))
 221                                         continue;
 222                                 scs->buffer[0] = HSS1394_TAG_USER_DATA;
 223                                 scs->buffer[i++] = scs->output_status;
 224                         }
 225                         scs->buffer[i++] = byte;
 226                         if ((i == 3 && is_two_bytes_cmd(scs->output_status)) ||
 227                             (i == 4 && is_three_bytes_cmd(scs->output_status)))
 228                                 break;
 229                         if (i == 1 + ARRAY_SIZE(sysex_escape_prefix) &&
 230                             !memcmp(scs->buffer + 1, sysex_escape_prefix,
 231                                     ARRAY_SIZE(sysex_escape_prefix))) {
 232                                 scs->output_escaped = true;
 233                                 scs->output_escape_high_nibble = true;
 234                                 i = 0;
 235                         }
 236                         if (i >= HSS1394_MAX_PACKET_SIZE)
 237                                 i = 1;
 238                 } else if (byte == 0xf7) {
 239                         if (scs->output_escaped) {
 240                                 if (i >= 1 && scs->output_escape_high_nibble &&
 241                                     scs->buffer[0] !=
 242                                                 HSS1394_TAG_CHANGE_ADDRESS)
 243                                         break;
 244                         } else {
 245                                 if (i > 1 && scs->output_status == 0xf0) {
 246                                         scs->buffer[i++] = 0xf7;
 247                                         break;
 248                                 }
 249                         }
 250                         i = 1;
 251                         scs->output_escaped = false;
 252                 } else if (!is_invalid_cmd(byte) && byte < 0xf8) {
 253                         i = 1;
 254                         scs->buffer[0] = HSS1394_TAG_USER_DATA;
 255                         scs->buffer[i++] = byte;
 256                         scs->output_status = byte;
 257                         scs->output_escaped = false;
 258                         if (is_one_byte_cmd(byte))
 259                                 break;
 260                 }
 261         }
 262         scs->output_bytes = 1;
 263         scs->output_escaped = false;
 264
 265         scs->transaction_bytes = i;
 266 retry:
 267         scs->transaction_running = true;
 268         generation = scs->fw_dev->generation;
 269         smp_rmb(); /* node_id vs. generation */
 270         fw_send_request(scs->fw_dev->card, &scs->transaction,
 271                         TCODE_WRITE_BLOCK_REQUEST, scs->fw_dev->node_id,
 272                         generation, scs->fw_dev->max_speed, HSS1394_ADDRESS,
 273                         scs->buffer, scs->transaction_bytes,
 274                         scs_write_callback, scs);
 275 }
 276
 277 static int midi_capture_open(struct snd_rawmidi_substream *stream)
 278 {
 279         return 0;
 280 }
 281
 282 static int midi_capture_close(struct snd_rawmidi_substream *stream)
 283 {
 284         return 0;
 285 }
 286
 287 static void midi_capture_trigger(struct snd_rawmidi_substream *stream, int up)
 288 {
 289         struct fw_scs1x *scs = stream->rmidi->private_data;
 290
 291         if (up) {
 292                 scs->input_escape_count = 0;
 293                 WRITE_ONCE(scs->input, stream);
 294         } else {
 295                 WRITE_ONCE(scs->input, NULL);
 296         }
 297 }
 298
 299 static int midi_playback_open(struct snd_rawmidi_substream *stream)
 300 {
 301         return 0;
 302 }
 303
 304 static int midi_playback_close(struct snd_rawmidi_substream *stream)
 305 {
 306         return 0;
 307 }
 308
 309 static void midi_playback_trigger(struct snd_rawmidi_substream *stream, int up)
 310 {
 311         struct fw_scs1x *scs = stream->rmidi->private_data;
 312
 313         if (up) {
 314                 scs->output_status = 0;
 315                 scs->output_bytes = 1;
 316                 scs->output_escaped = false;
 317                 scs->output_idle = false;
 318                 scs->transaction_bytes = 0;
 319                 scs->error = false;
 320
 321                 WRITE_ONCE(scs->output, stream);
 322                 schedule_work(&scs->work);
 323         } else {
 324                 WRITE_ONCE(scs->output, NULL);
 325         }
 326 }
 327 static void midi_playback_drain(struct snd_rawmidi_substream *stream)
 328 {
 329         struct fw_scs1x *scs = stream->rmidi->private_data;
 330
 331         wait_event(scs->idle_wait, scs->output_idle);
 332 }
 333
 334 static int register_address(struct snd_oxfw *oxfw)
 335 {
 336         struct fw_scs1x *scs = oxfw->spec;
 337         __be64 data;
 338
 339         data = cpu_to_be64(((u64)HSS1394_TAG_CHANGE_ADDRESS << 56) |
 340                             scs->hss_handler.offset);
 341         return snd_fw_transaction(oxfw->unit, TCODE_WRITE_BLOCK_REQUEST,
 342                                   HSS1394_ADDRESS, &data, sizeof(data), 0);
 343 }
 344
 345 static void remove_scs1x(struct snd_rawmidi *rmidi)
 346 {
 347         struct fw_scs1x *scs = rmidi->private_data;
 348
 349         fw_core_remove_address_handler(&scs->hss_handler);
 350 }
 351
 352 void snd_oxfw_scs1x_update(struct snd_oxfw *oxfw)
 353 {
 354         register_address(oxfw);
 355 }
 356
 357 int snd_oxfw_scs1x_add(struct snd_oxfw *oxfw)
 358 {
 359         static const struct snd_rawmidi_ops midi_capture_ops = {
 360                 .open    = midi_capture_open,
 361                 .close   = midi_capture_close,
 362                 .trigger = midi_capture_trigger,
 363         };
 364         static const struct snd_rawmidi_ops midi_playback_ops = {
 365                 .open    = midi_playback_open,
 366                 .close   = midi_playback_close,
 367                 .trigger = midi_playback_trigger,
 368                 .drain   = midi_playback_drain,
 369         };
 370         struct snd_rawmidi *rmidi;
 371         struct fw_scs1x *scs;
 372         int err;
 373
 374         scs = devm_kzalloc(&oxfw->card->card_dev, sizeof(struct fw_scs1x),
 375                            GFP_KERNEL);
 376         if (!scs)
 377                 return -ENOMEM;
 378         scs->fw_dev = fw_parent_device(oxfw->unit);
 379         oxfw->spec = scs;
 380
 381         /* Allocate own handler for imcoming asynchronous transaction. */
 382         scs->hss_handler.length = HSS1394_MAX_PACKET_SIZE;
 383         scs->hss_handler.address_callback = handle_hss;
 384         scs->hss_handler.callback_data = scs;
 385         err = fw_core_add_address_handler(&scs->hss_handler,
 386                                           &fw_high_memory_region);
 387         if (err < 0)
 388                 return err;
 389
 390         err = register_address(oxfw);
 391         if (err < 0)
 392                 goto err_allocated;
 393
 394         /* Use unique name for backward compatibility to scs1x module. */
 395         err = snd_rawmidi_new(oxfw->card, "SCS.1x", 0, 1, 1, &rmidi);
 396         if (err < 0)
 397                 goto err_allocated;
 398         rmidi->private_data = scs;
 399         rmidi->private_free = remove_scs1x;
 400
 401         snprintf(rmidi->name, sizeof(rmidi->name),
 402                  "%s MIDI", oxfw->card->shortname);
 403
 404         rmidi->info_flags = SNDRV_RAWMIDI_INFO_INPUT |
 405                             SNDRV_RAWMIDI_INFO_OUTPUT |
 406                             SNDRV_RAWMIDI_INFO_DUPLEX;
 407         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
 408                             &midi_capture_ops);
 409         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
 410                             &midi_playback_ops);
 411
 412         INIT_WORK(&scs->work, scs_output_work);
 413         init_waitqueue_head(&scs->idle_wait);
 414         scs->output_idle = true;
 415
 416         return 0;
 417 err_allocated:
 418         fw_core_remove_address_handler(&scs->hss_handler);
 419         return err;
 420 }