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 <sound/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 2; 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 /** 209 * snd_ump_convert_from_ump - convert from UMP to legacy MIDI 210 * @data: UMP packet 211 * @buf: buffer to store legacy MIDI data 212 * @group_ret: pointer to store the target group 213 * 214 * Convert from a UMP packet @data to MIDI 1.0 bytes at @buf. 215 * The target group is stored at @group_ret. 216 * 217 * The function returns the number of bytes of MIDI 1.0 stream. 218 */ 219 int snd_ump_convert_from_ump(const u32 *data, 220 unsigned char *buf, 221 unsigned char *group_ret) 222 { 223 *group_ret = ump_message_group(*data); 224 225 switch (ump_message_type(*data)) { 226 case UMP_MSG_TYPE_SYSTEM: 227 return cvt_ump_system_to_legacy(*data, buf); 228 case UMP_MSG_TYPE_MIDI1_CHANNEL_VOICE: 229 return cvt_ump_midi1_to_legacy(*data, buf); 230 case UMP_MSG_TYPE_MIDI2_CHANNEL_VOICE: 231 return cvt_ump_midi2_to_legacy((const union snd_ump_midi2_msg *)data, 232 buf); 233 case UMP_MSG_TYPE_DATA: 234 return cvt_ump_sysex7_to_legacy(data, buf); 235 } 236 237 return 0; 238 } 239 EXPORT_SYMBOL_GPL(snd_ump_convert_from_ump); 240 241 /* 242 * MIDI 1 byte stream -> UMP conversion 243 */ 244 /* convert MIDI 1.0 SysEx to a UMP packet */ 245 static int cvt_legacy_sysex_to_ump(struct ump_cvt_to_ump *cvt, 246 unsigned char group, u32 *data, bool finish) 247 { 248 unsigned char status; 249 bool start = cvt->in_sysex == 1; 250 int i, offset; 251 252 if (start && finish) 253 status = UMP_SYSEX_STATUS_SINGLE; 254 else if (start) 255 status = UMP_SYSEX_STATUS_START; 256 else if (finish) 257 status = UMP_SYSEX_STATUS_END; 258 else 259 status = UMP_SYSEX_STATUS_CONTINUE; 260 *data = ump_compose(UMP_MSG_TYPE_DATA, group, status, cvt->len); 261 data[1] = 0; 262 offset = 8; 263 for (i = 0; i < cvt->len; i++) { 264 *data |= cvt->buf[i] << offset; 265 if (!offset) { 266 offset = 24; 267 data++; 268 } else 269 offset -= 8; 270 } 271 cvt->len = 0; 272 if (finish) 273 cvt->in_sysex = 0; 274 else 275 cvt->in_sysex++; 276 return 8; 277 } 278 279 /* convert to a UMP System message */ 280 static int cvt_legacy_system_to_ump(struct ump_cvt_to_ump *cvt, 281 unsigned char group, u32 *data) 282 { 283 data[0] = ump_compose(UMP_MSG_TYPE_SYSTEM, group, 0, cvt->buf[0]); 284 if (cvt->cmd_bytes > 1) 285 data[0] |= cvt->buf[1] << 8; 286 if (cvt->cmd_bytes > 2) 287 data[0] |= cvt->buf[2]; 288 return 4; 289 } 290 291 static void reset_rpn(struct ump_cvt_to_ump_bank *cc) 292 { 293 cc->rpn_set = 0; 294 cc->nrpn_set = 0; 295 cc->cc_rpn_msb = cc->cc_rpn_lsb = 0; 296 cc->cc_data_msb = cc->cc_data_lsb = 0; 297 cc->cc_data_msb_set = cc->cc_data_lsb_set = 0; 298 } 299 300 static int fill_rpn(struct ump_cvt_to_ump_bank *cc, 301 union snd_ump_midi2_msg *midi2, 302 bool flush) 303 { 304 if (!(cc->cc_data_lsb_set || cc->cc_data_msb_set)) 305 return 0; // skip 306 /* when not flushing, wait for complete data set */ 307 if (!flush && (!cc->cc_data_lsb_set || !cc->cc_data_msb_set)) 308 return 0; // skip 309 310 if (cc->rpn_set) { 311 midi2->rpn.status = UMP_MSG_STATUS_RPN; 312 midi2->rpn.bank = cc->cc_rpn_msb; 313 midi2->rpn.index = cc->cc_rpn_lsb; 314 } else if (cc->nrpn_set) { 315 midi2->rpn.status = UMP_MSG_STATUS_NRPN; 316 midi2->rpn.bank = cc->cc_nrpn_msb; 317 midi2->rpn.index = cc->cc_nrpn_lsb; 318 } else { 319 return 0; // skip 320 } 321 322 midi2->rpn.data = upscale_14_to_32bit((cc->cc_data_msb << 7) | 323 cc->cc_data_lsb); 324 325 reset_rpn(cc); 326 return 1; 327 } 328 329 /* convert to a MIDI 1.0 Channel Voice message */ 330 static int cvt_legacy_cmd_to_ump(struct ump_cvt_to_ump *cvt, 331 unsigned char group, 332 unsigned int protocol, 333 u32 *data, unsigned char bytes) 334 { 335 const unsigned char *buf = cvt->buf; 336 struct ump_cvt_to_ump_bank *cc; 337 union snd_ump_midi2_msg *midi2 = (union snd_ump_midi2_msg *)data; 338 unsigned char status, channel; 339 int ret; 340 341 BUILD_BUG_ON(sizeof(union snd_ump_midi1_msg) != 4); 342 BUILD_BUG_ON(sizeof(union snd_ump_midi2_msg) != 8); 343 344 /* for MIDI 1.0 UMP, it's easy, just pack it into UMP */ 345 if (protocol & SNDRV_UMP_EP_INFO_PROTO_MIDI1) { 346 data[0] = ump_compose(UMP_MSG_TYPE_MIDI1_CHANNEL_VOICE, 347 group, 0, buf[0]); 348 data[0] |= buf[1] << 8; 349 if (bytes > 2) 350 data[0] |= buf[2]; 351 return 4; 352 } 353 354 status = *buf >> 4; 355 channel = *buf & 0x0f; 356 cc = &cvt->bank[channel]; 357 358 /* special handling: treat note-on with 0 velocity as note-off */ 359 if (status == UMP_MSG_STATUS_NOTE_ON && !buf[2]) 360 status = UMP_MSG_STATUS_NOTE_OFF; 361 362 /* initialize the packet */ 363 data[0] = ump_compose(UMP_MSG_TYPE_MIDI2_CHANNEL_VOICE, 364 group, status, channel); 365 data[1] = 0; 366 367 switch (status) { 368 case UMP_MSG_STATUS_NOTE_ON: 369 case UMP_MSG_STATUS_NOTE_OFF: 370 midi2->note.note = buf[1]; 371 midi2->note.velocity = upscale_7_to_16bit(buf[2]); 372 break; 373 case UMP_MSG_STATUS_POLY_PRESSURE: 374 midi2->paf.note = buf[1]; 375 midi2->paf.data = upscale_7_to_32bit(buf[2]); 376 break; 377 case UMP_MSG_STATUS_CC: 378 switch (buf[1]) { 379 case UMP_CC_RPN_MSB: 380 ret = fill_rpn(cc, midi2, true); 381 cc->rpn_set = 1; 382 cc->cc_rpn_msb = buf[2]; 383 if (cc->cc_rpn_msb == 0x7f && cc->cc_rpn_lsb == 0x7f) 384 reset_rpn(cc); 385 return ret; 386 case UMP_CC_RPN_LSB: 387 ret = fill_rpn(cc, midi2, true); 388 cc->rpn_set = 1; 389 cc->cc_rpn_lsb = buf[2]; 390 if (cc->cc_rpn_msb == 0x7f && cc->cc_rpn_lsb == 0x7f) 391 reset_rpn(cc); 392 return ret; 393 case UMP_CC_NRPN_MSB: 394 ret = fill_rpn(cc, midi2, true); 395 cc->nrpn_set = 1; 396 cc->cc_nrpn_msb = buf[2]; 397 return ret; 398 case UMP_CC_NRPN_LSB: 399 ret = fill_rpn(cc, midi2, true); 400 cc->nrpn_set = 1; 401 cc->cc_nrpn_lsb = buf[2]; 402 return ret; 403 case UMP_CC_DATA: 404 cc->cc_data_msb_set = 1; 405 cc->cc_data_msb = buf[2]; 406 return fill_rpn(cc, midi2, false); 407 case UMP_CC_BANK_SELECT: 408 cc->bank_set = 1; 409 cc->cc_bank_msb = buf[2]; 410 return 0; // skip 411 case UMP_CC_BANK_SELECT_LSB: 412 cc->bank_set = 1; 413 cc->cc_bank_lsb = buf[2]; 414 return 0; // skip 415 case UMP_CC_DATA_LSB: 416 cc->cc_data_lsb_set = 1; 417 cc->cc_data_lsb = buf[2]; 418 return fill_rpn(cc, midi2, false); 419 default: 420 midi2->cc.index = buf[1]; 421 midi2->cc.data = upscale_7_to_32bit(buf[2]); 422 break; 423 } 424 break; 425 case UMP_MSG_STATUS_PROGRAM: 426 midi2->pg.program = buf[1]; 427 if (cc->bank_set) { 428 midi2->pg.bank_valid = 1; 429 midi2->pg.bank_msb = cc->cc_bank_msb; 430 midi2->pg.bank_lsb = cc->cc_bank_lsb; 431 cc->bank_set = 0; 432 } 433 break; 434 case UMP_MSG_STATUS_CHANNEL_PRESSURE: 435 midi2->caf.data = upscale_7_to_32bit(buf[1]); 436 break; 437 case UMP_MSG_STATUS_PITCH_BEND: 438 midi2->pb.data = upscale_14_to_32bit(buf[1] | (buf[2] << 7)); 439 break; 440 default: 441 return 0; 442 } 443 444 return 8; 445 } 446 447 static int do_convert_to_ump(struct ump_cvt_to_ump *cvt, unsigned char group, 448 unsigned int protocol, unsigned char c, u32 *data) 449 { 450 /* bytes for 0x80-0xf0 */ 451 static unsigned char cmd_bytes[8] = { 452 3, 3, 3, 3, 2, 2, 3, 0 453 }; 454 /* bytes for 0xf0-0xff */ 455 static unsigned char system_bytes[16] = { 456 0, 2, 3, 2, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1 457 }; 458 unsigned char bytes; 459 460 if (c == UMP_MIDI1_MSG_SYSEX_START) { 461 cvt->in_sysex = 1; 462 cvt->len = 0; 463 return 0; 464 } 465 if (c == UMP_MIDI1_MSG_SYSEX_END) { 466 if (!cvt->in_sysex) 467 return 0; /* skip */ 468 return cvt_legacy_sysex_to_ump(cvt, group, data, true); 469 } 470 471 if ((c & 0xf0) == UMP_MIDI1_MSG_REALTIME) { 472 bytes = system_bytes[c & 0x0f]; 473 if (!bytes) 474 return 0; /* skip */ 475 if (bytes == 1) { 476 data[0] = ump_compose(UMP_MSG_TYPE_SYSTEM, group, 0, c); 477 return 4; 478 } 479 cvt->buf[0] = c; 480 cvt->len = 1; 481 cvt->cmd_bytes = bytes; 482 cvt->in_sysex = 0; /* abort SysEx */ 483 return 0; 484 } 485 486 if (c & 0x80) { 487 bytes = cmd_bytes[(c >> 4) & 7]; 488 cvt->buf[0] = c; 489 cvt->len = 1; 490 cvt->cmd_bytes = bytes; 491 cvt->in_sysex = 0; /* abort SysEx */ 492 return 0; 493 } 494 495 if (cvt->in_sysex) { 496 cvt->buf[cvt->len++] = c; 497 if (cvt->len == 6) 498 return cvt_legacy_sysex_to_ump(cvt, group, data, false); 499 return 0; 500 } 501 502 if (!cvt->len) 503 return 0; 504 505 cvt->buf[cvt->len++] = c; 506 if (cvt->len < cvt->cmd_bytes) 507 return 0; 508 cvt->len = 1; 509 if ((cvt->buf[0] & 0xf0) == UMP_MIDI1_MSG_REALTIME) 510 return cvt_legacy_system_to_ump(cvt, group, data); 511 return cvt_legacy_cmd_to_ump(cvt, group, protocol, data, cvt->cmd_bytes); 512 } 513 514 /** 515 * snd_ump_convert_to_ump - convert legacy MIDI byte to UMP packet 516 * @cvt: converter context 517 * @group: target UMP group 518 * @protocol: target UMP protocol 519 * @c: MIDI 1.0 byte data 520 * 521 * Feed a MIDI 1.0 byte @c and convert to a UMP packet if completed. 522 * The result is stored in the buffer in @cvt. 523 */ 524 void snd_ump_convert_to_ump(struct ump_cvt_to_ump *cvt, unsigned char group, 525 unsigned int protocol, unsigned char c) 526 { 527 cvt->ump_bytes = do_convert_to_ump(cvt, group, protocol, c, cvt->ump); 528 } 529 EXPORT_SYMBOL_GPL(snd_ump_convert_to_ump); 530