1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Helpers for UMP <-> MIDI 1.0 byte stream conversion 4 */ 5 6 #include <linux/module.h> 7 #include <linux/export.h> 8 #include <sound/core.h> 9 #include <sound/asound.h> 10 #include <sound/ump.h> 11 #include "ump_convert.h" 12 13 /* 14 * Upgrade / downgrade value bits 15 */ 16 static u8 downscale_32_to_7bit(u32 src) 17 { 18 return src >> 25; 19 } 20 21 static u16 downscale_32_to_14bit(u32 src) 22 { 23 return src >> 18; 24 } 25 26 static u8 downscale_16_to_7bit(u16 src) 27 { 28 return src >> 9; 29 } 30 31 static u16 upscale_7_to_16bit(u8 src) 32 { 33 u16 val, repeat; 34 35 val = (u16)src << 9; 36 if (src <= 0x40) 37 return val; 38 repeat = src & 0x3f; 39 return val | (repeat << 3) | (repeat >> 3); 40 } 41 42 static u32 upscale_7_to_32bit(u8 src) 43 { 44 u32 val, repeat; 45 46 val = src << 25; 47 if (src <= 0x40) 48 return val; 49 repeat = src & 0x3f; 50 return val | (repeat << 19) | (repeat << 13) | 51 (repeat << 7) | (repeat << 1) | (repeat >> 5); 52 } 53 54 static u32 upscale_14_to_32bit(u16 src) 55 { 56 u32 val, repeat; 57 58 val = src << 18; 59 if (src <= 0x2000) 60 return val; 61 repeat = src & 0x1fff; 62 return val | (repeat << 5) | (repeat >> 8); 63 } 64 65 /* 66 * UMP -> MIDI 1 byte stream conversion 67 */ 68 /* convert a UMP System message to MIDI 1.0 byte stream */ 69 static int cvt_ump_system_to_legacy(u32 data, unsigned char *buf) 70 { 71 buf[0] = ump_message_status_channel(data); 72 switch (ump_message_status_code(data)) { 73 case UMP_SYSTEM_STATUS_MIDI_TIME_CODE: 74 case UMP_SYSTEM_STATUS_SONG_SELECT: 75 buf[1] = (data >> 8) & 0x7f; 76 return 1; 77 case UMP_SYSTEM_STATUS_SONG_POSITION: 78 buf[1] = (data >> 8) & 0x7f; 79 buf[2] = data & 0x7f; 80 return 3; 81 default: 82 return 1; 83 } 84 } 85 86 /* convert a UMP MIDI 1.0 Channel Voice message to MIDI 1.0 byte stream */ 87 static int cvt_ump_midi1_to_legacy(u32 data, unsigned char *buf) 88 { 89 buf[0] = ump_message_status_channel(data); 90 buf[1] = (data >> 8) & 0xff; 91 switch (ump_message_status_code(data)) { 92 case UMP_MSG_STATUS_PROGRAM: 93 case UMP_MSG_STATUS_CHANNEL_PRESSURE: 94 return 2; 95 default: 96 buf[2] = data & 0xff; 97 return 3; 98 } 99 } 100 101 /* convert a UMP MIDI 2.0 Channel Voice message to MIDI 1.0 byte stream */ 102 static int cvt_ump_midi2_to_legacy(const union snd_ump_midi2_msg *midi2, 103 unsigned char *buf) 104 { 105 unsigned char status = midi2->note.status; 106 unsigned char channel = midi2->note.channel; 107 u16 v; 108 109 buf[0] = (status << 4) | channel; 110 switch (status) { 111 case UMP_MSG_STATUS_NOTE_OFF: 112 case UMP_MSG_STATUS_NOTE_ON: 113 buf[1] = midi2->note.note; 114 buf[2] = downscale_16_to_7bit(midi2->note.velocity); 115 if (status == UMP_MSG_STATUS_NOTE_ON && !buf[2]) 116 buf[2] = 1; 117 return 3; 118 case UMP_MSG_STATUS_POLY_PRESSURE: 119 buf[1] = midi2->paf.note; 120 buf[2] = downscale_32_to_7bit(midi2->paf.data); 121 return 3; 122 case UMP_MSG_STATUS_CC: 123 buf[1] = midi2->cc.index; 124 buf[2] = downscale_32_to_7bit(midi2->cc.data); 125 return 3; 126 case UMP_MSG_STATUS_CHANNEL_PRESSURE: 127 buf[1] = downscale_32_to_7bit(midi2->caf.data); 128 return 2; 129 case UMP_MSG_STATUS_PROGRAM: 130 if (midi2->pg.bank_valid) { 131 buf[0] = channel | (UMP_MSG_STATUS_CC << 4); 132 buf[1] = UMP_CC_BANK_SELECT; 133 buf[2] = midi2->pg.bank_msb; 134 buf[3] = channel | (UMP_MSG_STATUS_CC << 4); 135 buf[4] = UMP_CC_BANK_SELECT_LSB; 136 buf[5] = midi2->pg.bank_lsb; 137 buf[6] = channel | (UMP_MSG_STATUS_PROGRAM << 4); 138 buf[7] = midi2->pg.program; 139 return 8; 140 } 141 buf[1] = midi2->pg.program; 142 return 2; 143 case UMP_MSG_STATUS_PITCH_BEND: 144 v = downscale_32_to_14bit(midi2->pb.data); 145 buf[1] = v & 0x7f; 146 buf[2] = v >> 7; 147 return 3; 148 case UMP_MSG_STATUS_RPN: 149 case UMP_MSG_STATUS_NRPN: 150 buf[0] = channel | (UMP_MSG_STATUS_CC << 4); 151 buf[1] = status == UMP_MSG_STATUS_RPN ? UMP_CC_RPN_MSB : UMP_CC_NRPN_MSB; 152 buf[2] = midi2->rpn.bank; 153 buf[3] = buf[0]; 154 buf[4] = status == UMP_MSG_STATUS_RPN ? UMP_CC_RPN_LSB : UMP_CC_NRPN_LSB; 155 buf[5] = midi2->rpn.index; 156 buf[6] = buf[0]; 157 buf[7] = UMP_CC_DATA; 158 v = downscale_32_to_14bit(midi2->rpn.data); 159 buf[8] = v >> 7; 160 buf[9] = buf[0]; 161 buf[10] = UMP_CC_DATA_LSB; 162 buf[11] = v & 0x7f; 163 return 12; 164 default: 165 return 0; 166 } 167 } 168 169 /* convert a UMP 7-bit SysEx message to MIDI 1.0 byte stream */ 170 static int cvt_ump_sysex7_to_legacy(const u32 *data, unsigned char *buf) 171 { 172 unsigned char status; 173 unsigned char bytes; 174 int size, offset; 175 176 status = ump_sysex_message_status(*data); 177 if (status > UMP_SYSEX_STATUS_END) 178 return 0; // unsupported, skip 179 bytes = ump_sysex_message_length(*data); 180 if (bytes > 6) 181 return 0; // skip 182 183 size = 0; 184 if (status == UMP_SYSEX_STATUS_SINGLE || 185 status == UMP_SYSEX_STATUS_START) { 186 buf[0] = UMP_MIDI1_MSG_SYSEX_START; 187 size = 1; 188 } 189 190 offset = 8; 191 for (; bytes; bytes--, size++) { 192 buf[size] = (*data >> offset) & 0x7f; 193 if (!offset) { 194 offset = 24; 195 data++; 196 } else { 197 offset -= 8; 198 } 199 } 200 201 if (status == UMP_SYSEX_STATUS_SINGLE || 202 status == UMP_SYSEX_STATUS_END) 203 buf[size++] = UMP_MIDI1_MSG_SYSEX_END; 204 205 return size; 206 } 207 208 /* convert from a UMP packet @data to MIDI 1.0 bytes at @buf; 209 * the target group is stored at @group_ret, 210 * returns the number of bytes of MIDI 1.0 stream 211 */ 212 int snd_ump_convert_from_ump(struct snd_ump_endpoint *ump, 213 const u32 *data, 214 unsigned char *buf, 215 unsigned char *group_ret) 216 { 217 *group_ret = ump_message_group(*data); 218 219 switch (ump_message_type(*data)) { 220 case UMP_MSG_TYPE_SYSTEM: 221 return cvt_ump_system_to_legacy(*data, buf); 222 case UMP_MSG_TYPE_MIDI1_CHANNEL_VOICE: 223 return cvt_ump_midi1_to_legacy(*data, buf); 224 case UMP_MSG_TYPE_MIDI2_CHANNEL_VOICE: 225 return cvt_ump_midi2_to_legacy((const union snd_ump_midi2_msg *)data, 226 buf); 227 case UMP_MSG_TYPE_DATA: 228 return cvt_ump_sysex7_to_legacy(data, buf); 229 } 230 231 return 0; 232 } 233 234 /* 235 * MIDI 1 byte stream -> UMP conversion 236 */ 237 /* convert MIDI 1.0 SysEx to a UMP packet */ 238 static int cvt_legacy_sysex_to_ump(struct ump_cvt_to_ump *cvt, 239 unsigned char group, u32 *data, bool finish) 240 { 241 unsigned char status; 242 bool start = cvt->in_sysex == 1; 243 int i, offset; 244 245 if (start && finish) 246 status = UMP_SYSEX_STATUS_SINGLE; 247 else if (start) 248 status = UMP_SYSEX_STATUS_START; 249 else if (finish) 250 status = UMP_SYSEX_STATUS_END; 251 else 252 status = UMP_SYSEX_STATUS_CONTINUE; 253 *data = ump_compose(UMP_MSG_TYPE_DATA, group, status, cvt->len); 254 offset = 8; 255 for (i = 0; i < cvt->len; i++) { 256 *data |= cvt->buf[i] << offset; 257 if (!offset) { 258 offset = 24; 259 data++; 260 } else 261 offset -= 8; 262 } 263 cvt->len = 0; 264 if (finish) 265 cvt->in_sysex = 0; 266 else 267 cvt->in_sysex++; 268 return 8; 269 } 270 271 /* convert to a UMP System message */ 272 static int cvt_legacy_system_to_ump(struct ump_cvt_to_ump *cvt, 273 unsigned char group, u32 *data) 274 { 275 data[0] = ump_compose(UMP_MSG_TYPE_SYSTEM, group, 0, cvt->buf[0]); 276 if (cvt->cmd_bytes > 1) 277 data[0] |= cvt->buf[1] << 8; 278 if (cvt->cmd_bytes > 2) 279 data[0] |= cvt->buf[2]; 280 return 4; 281 } 282 283 static void fill_rpn(struct ump_cvt_to_ump_bank *cc, 284 union snd_ump_midi2_msg *midi2) 285 { 286 if (cc->rpn_set) { 287 midi2->rpn.status = UMP_MSG_STATUS_RPN; 288 midi2->rpn.bank = cc->cc_rpn_msb; 289 midi2->rpn.index = cc->cc_rpn_lsb; 290 cc->rpn_set = 0; 291 cc->cc_rpn_msb = cc->cc_rpn_lsb = 0; 292 } else { 293 midi2->rpn.status = UMP_MSG_STATUS_NRPN; 294 midi2->rpn.bank = cc->cc_nrpn_msb; 295 midi2->rpn.index = cc->cc_nrpn_lsb; 296 cc->nrpn_set = 0; 297 cc->cc_nrpn_msb = cc->cc_nrpn_lsb = 0; 298 } 299 midi2->rpn.data = upscale_14_to_32bit((cc->cc_data_msb << 7) | 300 cc->cc_data_lsb); 301 cc->cc_data_msb = cc->cc_data_lsb = 0; 302 } 303 304 /* convert to a MIDI 1.0 Channel Voice message */ 305 static int cvt_legacy_cmd_to_ump(struct snd_ump_endpoint *ump, 306 struct ump_cvt_to_ump *cvt, 307 unsigned char group, u32 *data, 308 unsigned char bytes) 309 { 310 const unsigned char *buf = cvt->buf; 311 struct ump_cvt_to_ump_bank *cc; 312 union snd_ump_midi2_msg *midi2 = (union snd_ump_midi2_msg *)data; 313 unsigned char status, channel; 314 315 BUILD_BUG_ON(sizeof(union snd_ump_midi1_msg) != 4); 316 BUILD_BUG_ON(sizeof(union snd_ump_midi2_msg) != 8); 317 318 /* for MIDI 1.0 UMP, it's easy, just pack it into UMP */ 319 if (ump->info.protocol & SNDRV_UMP_EP_INFO_PROTO_MIDI1) { 320 data[0] = ump_compose(UMP_MSG_TYPE_MIDI1_CHANNEL_VOICE, 321 group, 0, buf[0]); 322 data[0] |= buf[1] << 8; 323 if (bytes > 2) 324 data[0] |= buf[2]; 325 return 4; 326 } 327 328 status = *buf >> 4; 329 channel = *buf & 0x0f; 330 cc = &cvt->bank[channel]; 331 332 /* special handling: treat note-on with 0 velocity as note-off */ 333 if (status == UMP_MSG_STATUS_NOTE_ON && !buf[2]) 334 status = UMP_MSG_STATUS_NOTE_OFF; 335 336 /* initialize the packet */ 337 data[0] = ump_compose(UMP_MSG_TYPE_MIDI2_CHANNEL_VOICE, 338 group, status, channel); 339 data[1] = 0; 340 341 switch (status) { 342 case UMP_MSG_STATUS_NOTE_ON: 343 case UMP_MSG_STATUS_NOTE_OFF: 344 midi2->note.note = buf[1]; 345 midi2->note.velocity = upscale_7_to_16bit(buf[2]); 346 break; 347 case UMP_MSG_STATUS_POLY_PRESSURE: 348 midi2->paf.note = buf[1]; 349 midi2->paf.data = upscale_7_to_32bit(buf[2]); 350 break; 351 case UMP_MSG_STATUS_CC: 352 switch (buf[1]) { 353 case UMP_CC_RPN_MSB: 354 cc->rpn_set = 1; 355 cc->cc_rpn_msb = buf[2]; 356 return 0; // skip 357 case UMP_CC_RPN_LSB: 358 cc->rpn_set = 1; 359 cc->cc_rpn_lsb = buf[2]; 360 return 0; // skip 361 case UMP_CC_NRPN_MSB: 362 cc->nrpn_set = 1; 363 cc->cc_nrpn_msb = buf[2]; 364 return 0; // skip 365 case UMP_CC_NRPN_LSB: 366 cc->nrpn_set = 1; 367 cc->cc_nrpn_lsb = buf[2]; 368 return 0; // skip 369 case UMP_CC_DATA: 370 cc->cc_data_msb = buf[2]; 371 return 0; // skip 372 case UMP_CC_BANK_SELECT: 373 cc->bank_set = 1; 374 cc->cc_bank_msb = buf[2]; 375 return 0; // skip 376 case UMP_CC_BANK_SELECT_LSB: 377 cc->bank_set = 1; 378 cc->cc_bank_lsb = buf[2]; 379 return 0; // skip 380 case UMP_CC_DATA_LSB: 381 cc->cc_data_lsb = buf[2]; 382 if (cc->rpn_set || cc->nrpn_set) 383 fill_rpn(cc, midi2); 384 else 385 return 0; // skip 386 break; 387 default: 388 midi2->cc.index = buf[1]; 389 midi2->cc.data = upscale_7_to_32bit(buf[2]); 390 break; 391 } 392 break; 393 case UMP_MSG_STATUS_PROGRAM: 394 midi2->pg.program = buf[1]; 395 if (cc->bank_set) { 396 midi2->pg.bank_valid = 1; 397 midi2->pg.bank_msb = cc->cc_bank_msb; 398 midi2->pg.bank_lsb = cc->cc_bank_lsb; 399 cc->bank_set = 0; 400 cc->cc_bank_msb = cc->cc_bank_lsb = 0; 401 } 402 break; 403 case UMP_MSG_STATUS_CHANNEL_PRESSURE: 404 midi2->caf.data = upscale_7_to_32bit(buf[1]); 405 break; 406 case UMP_MSG_STATUS_PITCH_BEND: 407 midi2->pb.data = upscale_14_to_32bit(buf[1] | (buf[2] << 7)); 408 break; 409 default: 410 return 0; 411 } 412 413 return 8; 414 } 415 416 static int do_convert_to_ump(struct snd_ump_endpoint *ump, 417 unsigned char group, unsigned char c, u32 *data) 418 { 419 /* bytes for 0x80-0xf0 */ 420 static unsigned char cmd_bytes[8] = { 421 3, 3, 3, 3, 2, 2, 3, 0 422 }; 423 /* bytes for 0xf0-0xff */ 424 static unsigned char system_bytes[16] = { 425 0, 2, 3, 2, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1 426 }; 427 struct ump_cvt_to_ump *cvt = &ump->out_cvts[group]; 428 unsigned char bytes; 429 430 if (c == UMP_MIDI1_MSG_SYSEX_START) { 431 cvt->in_sysex = 1; 432 cvt->len = 0; 433 return 0; 434 } 435 if (c == UMP_MIDI1_MSG_SYSEX_END) { 436 if (!cvt->in_sysex) 437 return 0; /* skip */ 438 return cvt_legacy_sysex_to_ump(cvt, group, data, true); 439 } 440 441 if ((c & 0xf0) == UMP_MIDI1_MSG_REALTIME) { 442 bytes = system_bytes[c & 0x0f]; 443 if (!bytes) 444 return 0; /* skip */ 445 if (bytes == 1) { 446 data[0] = ump_compose(UMP_MSG_TYPE_SYSTEM, group, 0, c); 447 return 4; 448 } 449 cvt->buf[0] = c; 450 cvt->len = 1; 451 cvt->cmd_bytes = bytes; 452 cvt->in_sysex = 0; /* abort SysEx */ 453 return 0; 454 } 455 456 if (c & 0x80) { 457 bytes = cmd_bytes[(c >> 4) & 7]; 458 cvt->buf[0] = c; 459 cvt->len = 1; 460 cvt->cmd_bytes = bytes; 461 cvt->in_sysex = 0; /* abort SysEx */ 462 return 0; 463 } 464 465 if (cvt->in_sysex) { 466 cvt->buf[cvt->len++] = c; 467 if (cvt->len == 6) 468 return cvt_legacy_sysex_to_ump(cvt, group, data, false); 469 return 0; 470 } 471 472 if (!cvt->len) 473 return 0; 474 475 cvt->buf[cvt->len++] = c; 476 if (cvt->len < cvt->cmd_bytes) 477 return 0; 478 cvt->len = 1; 479 if ((cvt->buf[0] & 0xf0) == UMP_MIDI1_MSG_REALTIME) 480 return cvt_legacy_system_to_ump(cvt, group, data); 481 return cvt_legacy_cmd_to_ump(ump, cvt, group, data, cvt->cmd_bytes); 482 } 483 484 /* feed a MIDI 1.0 byte @c and convert to a UMP packet; 485 * the target group is @group, 486 * the result is stored in out_cvts[group].ump[] and out_cvts[group].ump_bytes 487 */ 488 void snd_ump_convert_to_ump(struct snd_ump_endpoint *ump, 489 unsigned char group, unsigned char c) 490 { 491 struct ump_cvt_to_ump *cvt = &ump->out_cvts[group]; 492 493 cvt->ump_bytes = do_convert_to_ump(ump, group, c, cvt->ump); 494 } 495 496 /* reset the converter context, called at each open */ 497 void snd_ump_reset_convert_to_ump(struct snd_ump_endpoint *ump, 498 unsigned char group) 499 { 500 memset(&ump->out_cvts[group], 0, sizeof(*ump->out_cvts)); 501 } 502 503 /* initialize converters */ 504 int snd_ump_convert_init(struct snd_ump_endpoint *ump) 505 { 506 ump->out_cvts = kcalloc(16, sizeof(*ump->out_cvts), GFP_KERNEL); 507 if (!ump->out_cvts) 508 return -ENOMEM; 509 return 0; 510 } 511 512 /* release resources */ 513 void snd_ump_convert_free(struct snd_ump_endpoint *ump) 514 { 515 kfree(ump->out_cvts); 516 ump->out_cvts = NULL; 517 } 518