tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

ALSA: usb-audio: Whitespace cleanups for sound/usb/midi.*

Signed-off-by: Adam Goode <agoode@google.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>

authored by

Adam Goode and committed by
Takashi Iwai a509574e f7881e5e

+211 -166
+209 -164
sound/usb/midi.c
··· 102 102 void (*input)(struct snd_usb_midi_in_endpoint*, uint8_t*, int); 103 103 void (*output)(struct snd_usb_midi_out_endpoint *ep, struct urb *urb); 104 104 void (*output_packet)(struct urb*, uint8_t, uint8_t, uint8_t, uint8_t); 105 - void (*init_out_endpoint)(struct snd_usb_midi_out_endpoint*); 106 - void (*finish_out_endpoint)(struct snd_usb_midi_out_endpoint*); 105 + void (*init_out_endpoint)(struct snd_usb_midi_out_endpoint *); 106 + void (*finish_out_endpoint)(struct snd_usb_midi_out_endpoint *); 107 107 }; 108 108 109 109 struct snd_usb_midi { ··· 112 112 struct usb_interface *iface; 113 113 const struct snd_usb_audio_quirk *quirk; 114 114 struct snd_rawmidi *rmidi; 115 - struct usb_protocol_ops* usb_protocol_ops; 115 + struct usb_protocol_ops *usb_protocol_ops; 116 116 struct list_head list; 117 117 struct timer_list error_timer; 118 118 spinlock_t disc_lock; ··· 134 134 }; 135 135 136 136 struct snd_usb_midi_out_endpoint { 137 - struct snd_usb_midi* umidi; 137 + struct snd_usb_midi *umidi; 138 138 struct out_urb_context { 139 139 struct urb *urb; 140 140 struct snd_usb_midi_out_endpoint *ep; ··· 147 147 spinlock_t buffer_lock; 148 148 149 149 struct usbmidi_out_port { 150 - struct snd_usb_midi_out_endpoint* ep; 150 + struct snd_usb_midi_out_endpoint *ep; 151 151 struct snd_rawmidi_substream *substream; 152 152 int active; 153 153 uint8_t cable; /* cable number << 4 */ ··· 167 167 }; 168 168 169 169 struct snd_usb_midi_in_endpoint { 170 - struct snd_usb_midi* umidi; 171 - struct urb* urbs[INPUT_URBS]; 170 + struct snd_usb_midi *umidi; 171 + struct urb *urbs[INPUT_URBS]; 172 172 struct usbmidi_in_port { 173 173 struct snd_rawmidi_substream *substream; 174 174 u8 running_status_length; ··· 178 178 int current_port; 179 179 }; 180 180 181 - static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint* ep); 181 + static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint *ep); 182 182 183 183 static const uint8_t snd_usbmidi_cin_length[] = { 184 184 0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1 ··· 187 187 /* 188 188 * Submits the URB, with error handling. 189 189 */ 190 - static int snd_usbmidi_submit_urb(struct urb* urb, gfp_t flags) 190 + static int snd_usbmidi_submit_urb(struct urb *urb, gfp_t flags) 191 191 { 192 192 int err = usb_submit_urb(urb, flags); 193 193 if (err < 0 && err != -ENODEV) ··· 221 221 /* 222 222 * Receives a chunk of MIDI data. 223 223 */ 224 - static void snd_usbmidi_input_data(struct snd_usb_midi_in_endpoint* ep, int portidx, 225 - uint8_t* data, int length) 224 + static void snd_usbmidi_input_data(struct snd_usb_midi_in_endpoint *ep, 225 + int portidx, uint8_t *data, int length) 226 226 { 227 - struct usbmidi_in_port* port = &ep->ports[portidx]; 227 + struct usbmidi_in_port *port = &ep->ports[portidx]; 228 228 229 229 if (!port->substream) { 230 230 dev_dbg(&ep->umidi->dev->dev, "unexpected port %d!\n", portidx); ··· 250 250 /* 251 251 * Processes the data read from the device. 252 252 */ 253 - static void snd_usbmidi_in_urb_complete(struct urb* urb) 253 + static void snd_usbmidi_in_urb_complete(struct urb *urb) 254 254 { 255 - struct snd_usb_midi_in_endpoint* ep = urb->context; 255 + struct snd_usb_midi_in_endpoint *ep = urb->context; 256 256 257 257 if (urb->status == 0) { 258 258 dump_urb("received", urb->transfer_buffer, urb->actual_length); ··· 274 274 snd_usbmidi_submit_urb(urb, GFP_ATOMIC); 275 275 } 276 276 277 - static void snd_usbmidi_out_urb_complete(struct urb* urb) 277 + static void snd_usbmidi_out_urb_complete(struct urb *urb) 278 278 { 279 279 struct out_urb_context *context = urb->context; 280 - struct snd_usb_midi_out_endpoint* ep = context->ep; 280 + struct snd_usb_midi_out_endpoint *ep = context->ep; 281 281 unsigned int urb_index; 282 282 283 283 spin_lock(&ep->buffer_lock); ··· 304 304 * This is called when some data should be transferred to the device 305 305 * (from one or more substreams). 306 306 */ 307 - static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint* ep) 307 + static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint *ep) 308 308 { 309 309 unsigned int urb_index; 310 - struct urb* urb; 310 + struct urb *urb; 311 311 unsigned long flags; 312 312 313 313 spin_lock_irqsave(&ep->buffer_lock, flags); ··· 343 343 344 344 static void snd_usbmidi_out_tasklet(unsigned long data) 345 345 { 346 - struct snd_usb_midi_out_endpoint* ep = (struct snd_usb_midi_out_endpoint *) data; 346 + struct snd_usb_midi_out_endpoint *ep = 347 + (struct snd_usb_midi_out_endpoint *) data; 347 348 348 349 snd_usbmidi_do_output(ep); 349 350 } ··· 376 375 } 377 376 378 377 /* helper function to send static data that may not DMA-able */ 379 - static int send_bulk_static_data(struct snd_usb_midi_out_endpoint* ep, 378 + static int send_bulk_static_data(struct snd_usb_midi_out_endpoint *ep, 380 379 const void *data, int len) 381 380 { 382 381 int err = 0; ··· 397 396 * fourth byte in each packet, and uses length instead of CIN. 398 397 */ 399 398 400 - static void snd_usbmidi_standard_input(struct snd_usb_midi_in_endpoint* ep, 401 - uint8_t* buffer, int buffer_length) 399 + static void snd_usbmidi_standard_input(struct snd_usb_midi_in_endpoint *ep, 400 + uint8_t *buffer, int buffer_length) 402 401 { 403 402 int i; 404 403 ··· 406 405 if (buffer[i] != 0) { 407 406 int cable = buffer[i] >> 4; 408 407 int length = snd_usbmidi_cin_length[buffer[i] & 0x0f]; 409 - snd_usbmidi_input_data(ep, cable, &buffer[i + 1], length); 408 + snd_usbmidi_input_data(ep, cable, &buffer[i + 1], 409 + length); 410 410 } 411 411 } 412 412 413 - static void snd_usbmidi_midiman_input(struct snd_usb_midi_in_endpoint* ep, 414 - uint8_t* buffer, int buffer_length) 413 + static void snd_usbmidi_midiman_input(struct snd_usb_midi_in_endpoint *ep, 414 + uint8_t *buffer, int buffer_length) 415 415 { 416 416 int i; 417 417 ··· 429 427 * the data bytes but not the status byte and that is marked with CIN 4. 430 428 */ 431 429 static void snd_usbmidi_maudio_broken_running_status_input( 432 - struct snd_usb_midi_in_endpoint* ep, 433 - uint8_t* buffer, int buffer_length) 430 + struct snd_usb_midi_in_endpoint *ep, 431 + uint8_t *buffer, int buffer_length) 434 432 { 435 433 int i; 436 434 ··· 460 458 * doesn't use this format.) 461 459 */ 462 460 port->running_status_length = 0; 463 - snd_usbmidi_input_data(ep, cable, &buffer[i + 1], length); 461 + snd_usbmidi_input_data(ep, cable, &buffer[i + 1], 462 + length); 464 463 } 465 464 } 466 465 ··· 482 479 /* 483 480 * Adds one USB MIDI packet to the output buffer. 484 481 */ 485 - static void snd_usbmidi_output_standard_packet(struct urb* urb, uint8_t p0, 486 - uint8_t p1, uint8_t p2, uint8_t p3) 482 + static void snd_usbmidi_output_standard_packet(struct urb *urb, uint8_t p0, 483 + uint8_t p1, uint8_t p2, 484 + uint8_t p3) 487 485 { 488 486 489 - uint8_t* buf = (uint8_t*)urb->transfer_buffer + urb->transfer_buffer_length; 487 + uint8_t *buf = 488 + (uint8_t *)urb->transfer_buffer + urb->transfer_buffer_length; 490 489 buf[0] = p0; 491 490 buf[1] = p1; 492 491 buf[2] = p2; ··· 499 494 /* 500 495 * Adds one Midiman packet to the output buffer. 501 496 */ 502 - static void snd_usbmidi_output_midiman_packet(struct urb* urb, uint8_t p0, 503 - uint8_t p1, uint8_t p2, uint8_t p3) 497 + static void snd_usbmidi_output_midiman_packet(struct urb *urb, uint8_t p0, 498 + uint8_t p1, uint8_t p2, 499 + uint8_t p3) 504 500 { 505 501 506 - uint8_t* buf = (uint8_t*)urb->transfer_buffer + urb->transfer_buffer_length; 502 + uint8_t *buf = 503 + (uint8_t *)urb->transfer_buffer + urb->transfer_buffer_length; 507 504 buf[0] = p1; 508 505 buf[1] = p2; 509 506 buf[2] = p3; ··· 516 509 /* 517 510 * Converts MIDI commands to USB MIDI packets. 518 511 */ 519 - static void snd_usbmidi_transmit_byte(struct usbmidi_out_port* port, 520 - uint8_t b, struct urb* urb) 512 + static void snd_usbmidi_transmit_byte(struct usbmidi_out_port *port, 513 + uint8_t b, struct urb *urb) 521 514 { 522 515 uint8_t p0 = port->cable; 523 516 void (*output_packet)(struct urb*, uint8_t, uint8_t, uint8_t, uint8_t) = ··· 554 547 output_packet(urb, p0 | 0x05, 0xf7, 0, 0); 555 548 break; 556 549 case STATE_SYSEX_1: 557 - output_packet(urb, p0 | 0x06, port->data[0], 0xf7, 0); 550 + output_packet(urb, p0 | 0x06, port->data[0], 551 + 0xf7, 0); 558 552 break; 559 553 case STATE_SYSEX_2: 560 - output_packet(urb, p0 | 0x07, port->data[0], port->data[1], 0xf7); 554 + output_packet(urb, p0 | 0x07, port->data[0], 555 + port->data[1], 0xf7); 561 556 break; 562 557 } 563 558 port->state = STATE_UNKNOWN; ··· 605 596 port->state = STATE_SYSEX_2; 606 597 break; 607 598 case STATE_SYSEX_2: 608 - output_packet(urb, p0 | 0x04, port->data[0], port->data[1], b); 599 + output_packet(urb, p0 | 0x04, port->data[0], 600 + port->data[1], b); 609 601 port->state = STATE_SYSEX_0; 610 602 break; 611 603 } 612 604 } 613 605 } 614 606 615 - static void snd_usbmidi_standard_output(struct snd_usb_midi_out_endpoint* ep, 607 + static void snd_usbmidi_standard_output(struct snd_usb_midi_out_endpoint *ep, 616 608 struct urb *urb) 617 609 { 618 610 int p; 619 611 620 612 /* FIXME: lower-numbered ports can starve higher-numbered ports */ 621 613 for (p = 0; p < 0x10; ++p) { 622 - struct usbmidi_out_port* port = &ep->ports[p]; 614 + struct usbmidi_out_port *port = &ep->ports[p]; 623 615 if (!port->active) 624 616 continue; 625 617 while (urb->transfer_buffer_length + 3 < ep->max_transfer) { ··· 763 753 * at the third byte. 764 754 */ 765 755 766 - static void snd_usbmidi_novation_input(struct snd_usb_midi_in_endpoint* ep, 767 - uint8_t* buffer, int buffer_length) 756 + static void snd_usbmidi_novation_input(struct snd_usb_midi_in_endpoint *ep, 757 + uint8_t *buffer, int buffer_length) 768 758 { 769 759 if (buffer_length < 2 || !buffer[0] || buffer_length < buffer[0] + 1) 770 760 return; 771 761 snd_usbmidi_input_data(ep, 0, &buffer[2], buffer[0] - 1); 772 762 } 773 763 774 - static void snd_usbmidi_novation_output(struct snd_usb_midi_out_endpoint* ep, 764 + static void snd_usbmidi_novation_output(struct snd_usb_midi_out_endpoint *ep, 775 765 struct urb *urb) 776 766 { 777 - uint8_t* transfer_buffer; 767 + uint8_t *transfer_buffer; 778 768 int count; 779 769 780 770 if (!ep->ports[0].active) ··· 801 791 * "raw" protocol: just move raw MIDI bytes from/to the endpoint 802 792 */ 803 793 804 - static void snd_usbmidi_raw_input(struct snd_usb_midi_in_endpoint* ep, 805 - uint8_t* buffer, int buffer_length) 794 + static void snd_usbmidi_raw_input(struct snd_usb_midi_in_endpoint *ep, 795 + uint8_t *buffer, int buffer_length) 806 796 { 807 797 snd_usbmidi_input_data(ep, 0, buffer, buffer_length); 808 798 } 809 799 810 - static void snd_usbmidi_raw_output(struct snd_usb_midi_out_endpoint* ep, 800 + static void snd_usbmidi_raw_output(struct snd_usb_midi_out_endpoint *ep, 811 801 struct urb *urb) 812 802 { 813 803 int count; ··· 833 823 * FTDI protocol: raw MIDI bytes, but input packets have two modem status bytes. 834 824 */ 835 825 836 - static void snd_usbmidi_ftdi_input(struct snd_usb_midi_in_endpoint* ep, 837 - uint8_t* buffer, int buffer_length) 826 + static void snd_usbmidi_ftdi_input(struct snd_usb_midi_in_endpoint *ep, 827 + uint8_t *buffer, int buffer_length) 838 828 { 839 829 if (buffer_length > 2) 840 830 snd_usbmidi_input_data(ep, 0, buffer + 2, buffer_length - 2); ··· 893 883 * Emagic USB MIDI protocol: raw MIDI with "F5 xx" port switching. 894 884 */ 895 885 896 - static void snd_usbmidi_emagic_init_out(struct snd_usb_midi_out_endpoint* ep) 886 + static void snd_usbmidi_emagic_init_out(struct snd_usb_midi_out_endpoint *ep) 897 887 { 898 888 static const u8 init_data[] = { 899 889 /* initialization magic: "get version" */ ··· 910 900 send_bulk_static_data(ep, init_data, sizeof(init_data)); 911 901 } 912 902 913 - static void snd_usbmidi_emagic_finish_out(struct snd_usb_midi_out_endpoint* ep) 903 + static void snd_usbmidi_emagic_finish_out(struct snd_usb_midi_out_endpoint *ep) 914 904 { 915 905 static const u8 finish_data[] = { 916 906 /* switch to patch mode with last preset */ ··· 926 916 send_bulk_static_data(ep, finish_data, sizeof(finish_data)); 927 917 } 928 918 929 - static void snd_usbmidi_emagic_input(struct snd_usb_midi_in_endpoint* ep, 930 - uint8_t* buffer, int buffer_length) 919 + static void snd_usbmidi_emagic_input(struct snd_usb_midi_in_endpoint *ep, 920 + uint8_t *buffer, int buffer_length) 931 921 { 932 922 int i; 933 923 ··· 970 960 } 971 961 } 972 962 973 - static void snd_usbmidi_emagic_output(struct snd_usb_midi_out_endpoint* ep, 963 + static void snd_usbmidi_emagic_output(struct snd_usb_midi_out_endpoint *ep, 974 964 struct urb *urb) 975 965 { 976 966 int port0 = ep->current_port; 977 - uint8_t* buf = urb->transfer_buffer; 967 + uint8_t *buf = urb->transfer_buffer; 978 968 int buf_free = ep->max_transfer; 979 969 int length, i; 980 970 981 971 for (i = 0; i < 0x10; ++i) { 982 972 /* round-robin, starting at the last current port */ 983 973 int portnum = (port0 + i) & 15; 984 - struct usbmidi_out_port* port = &ep->ports[portnum]; 974 + struct usbmidi_out_port *port = &ep->ports[portnum]; 985 975 986 976 if (!port->active) 987 977 continue; ··· 1025 1015 }; 1026 1016 1027 1017 1028 - static void update_roland_altsetting(struct snd_usb_midi* umidi) 1018 + static void update_roland_altsetting(struct snd_usb_midi *umidi) 1029 1019 { 1030 1020 struct usb_interface *intf; 1031 1021 struct usb_host_interface *hostif; ··· 1047 1037 static int substream_open(struct snd_rawmidi_substream *substream, int dir, 1048 1038 int open) 1049 1039 { 1050 - struct snd_usb_midi* umidi = substream->rmidi->private_data; 1040 + struct snd_usb_midi *umidi = substream->rmidi->private_data; 1051 1041 struct snd_kcontrol *ctl; 1052 1042 1053 1043 down_read(&umidi->disc_rwsem); ··· 1061 1051 if (!umidi->opened[0] && !umidi->opened[1]) { 1062 1052 if (umidi->roland_load_ctl) { 1063 1053 ctl = umidi->roland_load_ctl; 1064 - ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE; 1054 + ctl->vd[0].access |= 1055 + SNDRV_CTL_ELEM_ACCESS_INACTIVE; 1065 1056 snd_ctl_notify(umidi->card, 1066 1057 SNDRV_CTL_EVENT_MASK_INFO, &ctl->id); 1067 1058 update_roland_altsetting(umidi); ··· 1078 1067 if (!umidi->opened[0] && !umidi->opened[1]) { 1079 1068 if (umidi->roland_load_ctl) { 1080 1069 ctl = umidi->roland_load_ctl; 1081 - ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE; 1070 + ctl->vd[0].access &= 1071 + ~SNDRV_CTL_ELEM_ACCESS_INACTIVE; 1082 1072 snd_ctl_notify(umidi->card, 1083 1073 SNDRV_CTL_EVENT_MASK_INFO, &ctl->id); 1084 1074 } ··· 1092 1080 1093 1081 static int snd_usbmidi_output_open(struct snd_rawmidi_substream *substream) 1094 1082 { 1095 - struct snd_usb_midi* umidi = substream->rmidi->private_data; 1096 - struct usbmidi_out_port* port = NULL; 1083 + struct snd_usb_midi *umidi = substream->rmidi->private_data; 1084 + struct usbmidi_out_port *port = NULL; 1097 1085 int i, j; 1098 1086 1099 1087 for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) ··· 1118 1106 return substream_open(substream, 0, 0); 1119 1107 } 1120 1108 1121 - static void snd_usbmidi_output_trigger(struct snd_rawmidi_substream *substream, int up) 1109 + static void snd_usbmidi_output_trigger(struct snd_rawmidi_substream *substream, 1110 + int up) 1122 1111 { 1123 - struct usbmidi_out_port* port = (struct usbmidi_out_port*)substream->runtime->private_data; 1112 + struct usbmidi_out_port *port = 1113 + (struct usbmidi_out_port *)substream->runtime->private_data; 1124 1114 1125 1115 port->active = up; 1126 1116 if (up) { ··· 1139 1125 1140 1126 static void snd_usbmidi_output_drain(struct snd_rawmidi_substream *substream) 1141 1127 { 1142 - struct usbmidi_out_port* port = substream->runtime->private_data; 1128 + struct usbmidi_out_port *port = substream->runtime->private_data; 1143 1129 struct snd_usb_midi_out_endpoint *ep = port->ep; 1144 1130 unsigned int drain_urbs; 1145 1131 DEFINE_WAIT(wait); ··· 1178 1164 return substream_open(substream, 1, 0); 1179 1165 } 1180 1166 1181 - static void snd_usbmidi_input_trigger(struct snd_rawmidi_substream *substream, int up) 1167 + static void snd_usbmidi_input_trigger(struct snd_rawmidi_substream *substream, 1168 + int up) 1182 1169 { 1183 - struct snd_usb_midi* umidi = substream->rmidi->private_data; 1170 + struct snd_usb_midi *umidi = substream->rmidi->private_data; 1184 1171 1185 1172 if (up) 1186 1173 set_bit(substream->number, &umidi->input_triggered); ··· 1214 1199 * Frees an input endpoint. 1215 1200 * May be called when ep hasn't been initialized completely. 1216 1201 */ 1217 - static void snd_usbmidi_in_endpoint_delete(struct snd_usb_midi_in_endpoint* ep) 1202 + static void snd_usbmidi_in_endpoint_delete(struct snd_usb_midi_in_endpoint *ep) 1218 1203 { 1219 1204 unsigned int i; 1220 1205 ··· 1228 1213 /* 1229 1214 * Creates an input endpoint. 1230 1215 */ 1231 - static int snd_usbmidi_in_endpoint_create(struct snd_usb_midi* umidi, 1232 - struct snd_usb_midi_endpoint_info* ep_info, 1233 - struct snd_usb_midi_endpoint* rep) 1216 + static int snd_usbmidi_in_endpoint_create(struct snd_usb_midi *umidi, 1217 + struct snd_usb_midi_endpoint_info *ep_info, 1218 + struct snd_usb_midi_endpoint *rep) 1234 1219 { 1235 - struct snd_usb_midi_in_endpoint* ep; 1236 - void* buffer; 1220 + struct snd_usb_midi_in_endpoint *ep; 1221 + void *buffer; 1237 1222 unsigned int pipe; 1238 1223 int length; 1239 1224 unsigned int i; ··· 1304 1289 /* 1305 1290 * Creates an output endpoint, and initializes output ports. 1306 1291 */ 1307 - static int snd_usbmidi_out_endpoint_create(struct snd_usb_midi* umidi, 1308 - struct snd_usb_midi_endpoint_info* ep_info, 1309 - struct snd_usb_midi_endpoint* rep) 1292 + static int snd_usbmidi_out_endpoint_create(struct snd_usb_midi *umidi, 1293 + struct snd_usb_midi_endpoint_info *ep_info, 1294 + struct snd_usb_midi_endpoint *rep) 1310 1295 { 1311 - struct snd_usb_midi_out_endpoint* ep; 1296 + struct snd_usb_midi_out_endpoint *ep; 1312 1297 unsigned int i; 1313 1298 unsigned int pipe; 1314 - void* buffer; 1299 + void *buffer; 1315 1300 1316 1301 rep->out = NULL; 1317 1302 ep = kzalloc(sizeof(*ep), GFP_KERNEL); ··· 1396 1381 /* 1397 1382 * Frees everything. 1398 1383 */ 1399 - static void snd_usbmidi_free(struct snd_usb_midi* umidi) 1384 + static void snd_usbmidi_free(struct snd_usb_midi *umidi) 1400 1385 { 1401 1386 int i; 1402 1387 1403 1388 for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { 1404 - struct snd_usb_midi_endpoint* ep = &umidi->endpoints[i]; 1389 + struct snd_usb_midi_endpoint *ep = &umidi->endpoints[i]; 1405 1390 if (ep->out) 1406 1391 snd_usbmidi_out_endpoint_delete(ep->out); 1407 1392 if (ep->in) ··· 1414 1399 /* 1415 1400 * Unlinks all URBs (must be done before the usb_device is deleted). 1416 1401 */ 1417 - void snd_usbmidi_disconnect(struct list_head* p) 1402 + void snd_usbmidi_disconnect(struct list_head *p) 1418 1403 { 1419 - struct snd_usb_midi* umidi; 1404 + struct snd_usb_midi *umidi; 1420 1405 unsigned int i, j; 1421 1406 1422 1407 umidi = list_entry(p, struct snd_usb_midi, list); ··· 1432 1417 up_write(&umidi->disc_rwsem); 1433 1418 1434 1419 for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { 1435 - struct snd_usb_midi_endpoint* ep = &umidi->endpoints[i]; 1420 + struct snd_usb_midi_endpoint *ep = &umidi->endpoints[i]; 1436 1421 if (ep->out) 1437 1422 tasklet_kill(&ep->out->tasklet); 1438 1423 if (ep->out) { ··· 1463 1448 1464 1449 static void snd_usbmidi_rawmidi_free(struct snd_rawmidi *rmidi) 1465 1450 { 1466 - struct snd_usb_midi* umidi = rmidi->private_data; 1451 + struct snd_usb_midi *umidi = rmidi->private_data; 1467 1452 snd_usbmidi_free(umidi); 1468 1453 } 1469 1454 1470 - static struct snd_rawmidi_substream *snd_usbmidi_find_substream(struct snd_usb_midi* umidi, 1471 - int stream, int number) 1455 + static struct snd_rawmidi_substream *snd_usbmidi_find_substream(struct snd_usb_midi *umidi, 1456 + int stream, 1457 + int number) 1472 1458 { 1473 1459 struct snd_rawmidi_substream *substream; 1474 1460 1475 - list_for_each_entry(substream, &umidi->rmidi->streams[stream].substreams, list) { 1461 + list_for_each_entry(substream, &umidi->rmidi->streams[stream].substreams, 1462 + list) { 1476 1463 if (substream->number == number) 1477 1464 return substream; 1478 1465 } ··· 1650 1633 SNDRV_SEQ_PORT_TYPE_SYNTHESIZER), 1651 1634 }; 1652 1635 1653 - static struct port_info *find_port_info(struct snd_usb_midi* umidi, int number) 1636 + static struct port_info *find_port_info(struct snd_usb_midi *umidi, int number) 1654 1637 { 1655 1638 int i; 1656 1639 ··· 1676 1659 } 1677 1660 } 1678 1661 1679 - static void snd_usbmidi_init_substream(struct snd_usb_midi* umidi, 1662 + static void snd_usbmidi_init_substream(struct snd_usb_midi *umidi, 1680 1663 int stream, int number, 1681 - struct snd_rawmidi_substream ** rsubstream) 1664 + struct snd_rawmidi_substream **rsubstream) 1682 1665 { 1683 1666 struct port_info *port_info; 1684 1667 const char *name_format; 1685 1668 1686 - struct snd_rawmidi_substream *substream = snd_usbmidi_find_substream(umidi, stream, number); 1669 + struct snd_rawmidi_substream *substream = 1670 + snd_usbmidi_find_substream(umidi, stream, number); 1687 1671 if (!substream) { 1688 - dev_err(&umidi->dev->dev, "substream %d:%d not found\n", stream, number); 1672 + dev_err(&umidi->dev->dev, "substream %d:%d not found\n", stream, 1673 + number); 1689 1674 return; 1690 1675 } 1691 1676 ··· 1703 1684 /* 1704 1685 * Creates the endpoints and their ports. 1705 1686 */ 1706 - static int snd_usbmidi_create_endpoints(struct snd_usb_midi* umidi, 1707 - struct snd_usb_midi_endpoint_info* endpoints) 1687 + static int snd_usbmidi_create_endpoints(struct snd_usb_midi *umidi, 1688 + struct snd_usb_midi_endpoint_info *endpoints) 1708 1689 { 1709 1690 int i, j, err; 1710 1691 int out_ports = 0, in_ports = 0; 1711 1692 1712 1693 for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { 1713 1694 if (endpoints[i].out_cables) { 1714 - err = snd_usbmidi_out_endpoint_create(umidi, &endpoints[i], 1695 + err = snd_usbmidi_out_endpoint_create(umidi, 1696 + &endpoints[i], 1715 1697 &umidi->endpoints[i]); 1716 1698 if (err < 0) 1717 1699 return err; 1718 1700 } 1719 1701 if (endpoints[i].in_cables) { 1720 - err = snd_usbmidi_in_endpoint_create(umidi, &endpoints[i], 1702 + err = snd_usbmidi_in_endpoint_create(umidi, 1703 + &endpoints[i], 1721 1704 &umidi->endpoints[i]); 1722 1705 if (err < 0) 1723 1706 return err; ··· 1727 1706 1728 1707 for (j = 0; j < 0x10; ++j) { 1729 1708 if (endpoints[i].out_cables & (1 << j)) { 1730 - snd_usbmidi_init_substream(umidi, SNDRV_RAWMIDI_STREAM_OUTPUT, out_ports, 1709 + snd_usbmidi_init_substream(umidi, 1710 + SNDRV_RAWMIDI_STREAM_OUTPUT, 1711 + out_ports, 1731 1712 &umidi->endpoints[i].out->ports[j].substream); 1732 1713 ++out_ports; 1733 1714 } 1734 1715 if (endpoints[i].in_cables & (1 << j)) { 1735 - snd_usbmidi_init_substream(umidi, SNDRV_RAWMIDI_STREAM_INPUT, in_ports, 1716 + snd_usbmidi_init_substream(umidi, 1717 + SNDRV_RAWMIDI_STREAM_INPUT, 1718 + in_ports, 1736 1719 &umidi->endpoints[i].in->ports[j].substream); 1737 1720 ++in_ports; 1738 1721 } ··· 1750 1725 /* 1751 1726 * Returns MIDIStreaming device capabilities. 1752 1727 */ 1753 - static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi, 1754 - struct snd_usb_midi_endpoint_info* endpoints) 1728 + static int snd_usbmidi_get_ms_info(struct snd_usb_midi *umidi, 1729 + struct snd_usb_midi_endpoint_info *endpoints) 1755 1730 { 1756 - struct usb_interface* intf; 1731 + struct usb_interface *intf; 1757 1732 struct usb_host_interface *hostif; 1758 - struct usb_interface_descriptor* intfd; 1759 - struct usb_ms_header_descriptor* ms_header; 1733 + struct usb_interface_descriptor *intfd; 1734 + struct usb_ms_header_descriptor *ms_header; 1760 1735 struct usb_host_endpoint *hostep; 1761 - struct usb_endpoint_descriptor* ep; 1762 - struct usb_ms_endpoint_descriptor* ms_ep; 1736 + struct usb_endpoint_descriptor *ep; 1737 + struct usb_ms_endpoint_descriptor *ms_ep; 1763 1738 int i, epidx; 1764 1739 1765 1740 intf = umidi->iface; ··· 1767 1742 return -ENXIO; 1768 1743 hostif = &intf->altsetting[0]; 1769 1744 intfd = get_iface_desc(hostif); 1770 - ms_header = (struct usb_ms_header_descriptor*)hostif->extra; 1745 + ms_header = (struct usb_ms_header_descriptor *)hostif->extra; 1771 1746 if (hostif->extralen >= 7 && 1772 1747 ms_header->bLength >= 7 && 1773 1748 ms_header->bDescriptorType == USB_DT_CS_INTERFACE && ··· 1784 1759 ep = get_ep_desc(hostep); 1785 1760 if (!usb_endpoint_xfer_bulk(ep) && !usb_endpoint_xfer_int(ep)) 1786 1761 continue; 1787 - ms_ep = (struct usb_ms_endpoint_descriptor*)hostep->extra; 1762 + ms_ep = (struct usb_ms_endpoint_descriptor *)hostep->extra; 1788 1763 if (hostep->extralen < 4 || 1789 1764 ms_ep->bLength < 4 || 1790 1765 ms_ep->bDescriptorType != USB_DT_CS_ENDPOINT || ··· 1808 1783 * ESI MIDI Mate that try to use them anyway. 1809 1784 */ 1810 1785 endpoints[epidx].out_interval = 1; 1811 - endpoints[epidx].out_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1; 1786 + endpoints[epidx].out_cables = 1787 + (1 << ms_ep->bNumEmbMIDIJack) - 1; 1812 1788 dev_dbg(&umidi->dev->dev, "EP %02X: %d jack(s)\n", 1813 - ep->bEndpointAddress, ms_ep->bNumEmbMIDIJack); 1789 + ep->bEndpointAddress, ms_ep->bNumEmbMIDIJack); 1814 1790 } else { 1815 1791 if (endpoints[epidx].in_ep) { 1816 1792 if (++epidx >= MIDI_MAX_ENDPOINTS) { ··· 1825 1799 endpoints[epidx].in_interval = ep->bInterval; 1826 1800 else if (snd_usb_get_speed(umidi->dev) == USB_SPEED_LOW) 1827 1801 endpoints[epidx].in_interval = 1; 1828 - endpoints[epidx].in_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1; 1802 + endpoints[epidx].in_cables = 1803 + (1 << ms_ep->bNumEmbMIDIJack) - 1; 1829 1804 dev_dbg(&umidi->dev->dev, "EP %02X: %d jack(s)\n", 1830 - ep->bEndpointAddress, ms_ep->bNumEmbMIDIJack); 1805 + ep->bEndpointAddress, ms_ep->bNumEmbMIDIJack); 1831 1806 } 1832 1807 } 1833 1808 return 0; ··· 1852 1825 static int roland_load_put(struct snd_kcontrol *kcontrol, 1853 1826 struct snd_ctl_elem_value *value) 1854 1827 { 1855 - struct snd_usb_midi* umidi = kcontrol->private_data; 1828 + struct snd_usb_midi *umidi = kcontrol->private_data; 1856 1829 int changed; 1857 1830 1858 1831 if (value->value.enumerated.item[0] > 1) ··· 1878 1851 * On Roland devices, use the second alternate setting to be able to use 1879 1852 * the interrupt input endpoint. 1880 1853 */ 1881 - static void snd_usbmidi_switch_roland_altsetting(struct snd_usb_midi* umidi) 1854 + static void snd_usbmidi_switch_roland_altsetting(struct snd_usb_midi *umidi) 1882 1855 { 1883 - struct usb_interface* intf; 1856 + struct usb_interface *intf; 1884 1857 struct usb_host_interface *hostif; 1885 - struct usb_interface_descriptor* intfd; 1858 + struct usb_interface_descriptor *intfd; 1886 1859 1887 1860 intf = umidi->iface; 1888 1861 if (!intf || intf->num_altsetting != 2) ··· 1891 1864 hostif = &intf->altsetting[1]; 1892 1865 intfd = get_iface_desc(hostif); 1893 1866 if (intfd->bNumEndpoints != 2 || 1894 - (get_endpoint(hostif, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK || 1895 - (get_endpoint(hostif, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_INT) 1867 + (get_endpoint(hostif, 0)->bmAttributes & 1868 + USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK || 1869 + (get_endpoint(hostif, 1)->bmAttributes & 1870 + USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_INT) 1896 1871 return; 1897 1872 1898 1873 dev_dbg(&umidi->dev->dev, "switching to altsetting %d with int ep\n", ··· 1910 1881 /* 1911 1882 * Try to find any usable endpoints in the interface. 1912 1883 */ 1913 - static int snd_usbmidi_detect_endpoints(struct snd_usb_midi* umidi, 1914 - struct snd_usb_midi_endpoint_info* endpoint, 1884 + static int snd_usbmidi_detect_endpoints(struct snd_usb_midi *umidi, 1885 + struct snd_usb_midi_endpoint_info *endpoint, 1915 1886 int max_endpoints) 1916 1887 { 1917 - struct usb_interface* intf; 1888 + struct usb_interface *intf; 1918 1889 struct usb_host_interface *hostif; 1919 - struct usb_interface_descriptor* intfd; 1920 - struct usb_endpoint_descriptor* epd; 1890 + struct usb_interface_descriptor *intfd; 1891 + struct usb_endpoint_descriptor *epd; 1921 1892 int i, out_eps = 0, in_eps = 0; 1922 1893 1923 1894 if (USB_ID_VENDOR(umidi->usb_id) == 0x0582) ··· 1958 1929 /* 1959 1930 * Detects the endpoints for one-port-per-endpoint protocols. 1960 1931 */ 1961 - static int snd_usbmidi_detect_per_port_endpoints(struct snd_usb_midi* umidi, 1962 - struct snd_usb_midi_endpoint_info* endpoints) 1932 + static int snd_usbmidi_detect_per_port_endpoints(struct snd_usb_midi *umidi, 1933 + struct snd_usb_midi_endpoint_info *endpoints) 1963 1934 { 1964 1935 int err, i; 1965 1936 ··· 1976 1947 /* 1977 1948 * Detects the endpoints and ports of Yamaha devices. 1978 1949 */ 1979 - static int snd_usbmidi_detect_yamaha(struct snd_usb_midi* umidi, 1980 - struct snd_usb_midi_endpoint_info* endpoint) 1950 + static int snd_usbmidi_detect_yamaha(struct snd_usb_midi *umidi, 1951 + struct snd_usb_midi_endpoint_info *endpoint) 1981 1952 { 1982 - struct usb_interface* intf; 1953 + struct usb_interface *intf; 1983 1954 struct usb_host_interface *hostif; 1984 - struct usb_interface_descriptor* intfd; 1985 - uint8_t* cs_desc; 1955 + struct usb_interface_descriptor *intfd; 1956 + uint8_t *cs_desc; 1986 1957 1987 1958 intf = umidi->iface; 1988 1959 if (!intf) ··· 2001 1972 cs_desc += cs_desc[0]) { 2002 1973 if (cs_desc[1] == USB_DT_CS_INTERFACE) { 2003 1974 if (cs_desc[2] == UAC_MIDI_IN_JACK) 2004 - endpoint->in_cables = (endpoint->in_cables << 1) | 1; 1975 + endpoint->in_cables = 1976 + (endpoint->in_cables << 1) | 1; 2005 1977 else if (cs_desc[2] == UAC_MIDI_OUT_JACK) 2006 - endpoint->out_cables = (endpoint->out_cables << 1) | 1; 1978 + endpoint->out_cables = 1979 + (endpoint->out_cables << 1) | 1; 2007 1980 } 2008 1981 } 2009 1982 if (!endpoint->in_cables && !endpoint->out_cables) ··· 2017 1986 /* 2018 1987 * Detects the endpoints and ports of Roland devices. 2019 1988 */ 2020 - static int snd_usbmidi_detect_roland(struct snd_usb_midi* umidi, 2021 - struct snd_usb_midi_endpoint_info* endpoint) 1989 + static int snd_usbmidi_detect_roland(struct snd_usb_midi *umidi, 1990 + struct snd_usb_midi_endpoint_info *endpoint) 2022 1991 { 2023 - struct usb_interface* intf; 1992 + struct usb_interface *intf; 2024 1993 struct usb_host_interface *hostif; 2025 - u8* cs_desc; 1994 + u8 *cs_desc; 2026 1995 2027 1996 intf = umidi->iface; 2028 1997 if (!intf) ··· 2055 2024 /* 2056 2025 * Creates the endpoints and their ports for Midiman devices. 2057 2026 */ 2058 - static int snd_usbmidi_create_endpoints_midiman(struct snd_usb_midi* umidi, 2059 - struct snd_usb_midi_endpoint_info* endpoint) 2027 + static int snd_usbmidi_create_endpoints_midiman(struct snd_usb_midi *umidi, 2028 + struct snd_usb_midi_endpoint_info *endpoint) 2060 2029 { 2061 2030 struct snd_usb_midi_endpoint_info ep_info; 2062 - struct usb_interface* intf; 2031 + struct usb_interface *intf; 2063 2032 struct usb_host_interface *hostif; 2064 - struct usb_interface_descriptor* intfd; 2065 - struct usb_endpoint_descriptor* epd; 2033 + struct usb_interface_descriptor *intfd; 2034 + struct usb_endpoint_descriptor *epd; 2066 2035 int cable, err; 2067 2036 2068 2037 intf = umidi->iface; ··· 2099 2068 epd = get_endpoint(hostif, 4); 2100 2069 if (!usb_endpoint_dir_out(epd) || 2101 2070 !usb_endpoint_xfer_bulk(epd)) { 2102 - dev_dbg(&umidi->dev->dev, "endpoint[4] isn't bulk output\n"); 2071 + dev_dbg(&umidi->dev->dev, 2072 + "endpoint[4] isn't bulk output\n"); 2103 2073 return -ENXIO; 2104 2074 } 2105 2075 } 2106 2076 2107 - ep_info.out_ep = get_endpoint(hostif, 2)->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; 2077 + ep_info.out_ep = get_endpoint(hostif, 2)->bEndpointAddress & 2078 + USB_ENDPOINT_NUMBER_MASK; 2108 2079 ep_info.out_interval = 0; 2109 2080 ep_info.out_cables = endpoint->out_cables & 0x5555; 2110 - err = snd_usbmidi_out_endpoint_create(umidi, &ep_info, &umidi->endpoints[0]); 2081 + err = snd_usbmidi_out_endpoint_create(umidi, &ep_info, 2082 + &umidi->endpoints[0]); 2111 2083 if (err < 0) 2112 2084 return err; 2113 2085 2114 - ep_info.in_ep = get_endpoint(hostif, 0)->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; 2086 + ep_info.in_ep = get_endpoint(hostif, 0)->bEndpointAddress & 2087 + USB_ENDPOINT_NUMBER_MASK; 2115 2088 ep_info.in_interval = get_endpoint(hostif, 0)->bInterval; 2116 2089 ep_info.in_cables = endpoint->in_cables; 2117 - err = snd_usbmidi_in_endpoint_create(umidi, &ep_info, &umidi->endpoints[0]); 2090 + err = snd_usbmidi_in_endpoint_create(umidi, &ep_info, 2091 + &umidi->endpoints[0]); 2118 2092 if (err < 0) 2119 2093 return err; 2120 2094 2121 2095 if (endpoint->out_cables > 0x0001) { 2122 - ep_info.out_ep = get_endpoint(hostif, 4)->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; 2096 + ep_info.out_ep = get_endpoint(hostif, 4)->bEndpointAddress & 2097 + USB_ENDPOINT_NUMBER_MASK; 2123 2098 ep_info.out_cables = endpoint->out_cables & 0xaaaa; 2124 - err = snd_usbmidi_out_endpoint_create(umidi, &ep_info, &umidi->endpoints[1]); 2099 + err = snd_usbmidi_out_endpoint_create(umidi, &ep_info, 2100 + &umidi->endpoints[1]); 2125 2101 if (err < 0) 2126 2102 return err; 2127 2103 } 2128 2104 2129 2105 for (cable = 0; cable < 0x10; ++cable) { 2130 2106 if (endpoint->out_cables & (1 << cable)) 2131 - snd_usbmidi_init_substream(umidi, SNDRV_RAWMIDI_STREAM_OUTPUT, cable, 2107 + snd_usbmidi_init_substream(umidi, 2108 + SNDRV_RAWMIDI_STREAM_OUTPUT, 2109 + cable, 2132 2110 &umidi->endpoints[cable & 1].out->ports[cable].substream); 2133 2111 if (endpoint->in_cables & (1 << cable)) 2134 - snd_usbmidi_init_substream(umidi, SNDRV_RAWMIDI_STREAM_INPUT, cable, 2112 + snd_usbmidi_init_substream(umidi, 2113 + SNDRV_RAWMIDI_STREAM_INPUT, 2114 + cable, 2135 2115 &umidi->endpoints[0].in->ports[cable].substream); 2136 2116 } 2137 2117 return 0; ··· 2152 2110 .get_port_info = snd_usbmidi_get_port_info, 2153 2111 }; 2154 2112 2155 - static int snd_usbmidi_create_rawmidi(struct snd_usb_midi* umidi, 2113 + static int snd_usbmidi_create_rawmidi(struct snd_usb_midi *umidi, 2156 2114 int out_ports, int in_ports) 2157 2115 { 2158 2116 struct snd_rawmidi *rmidi; ··· 2170 2128 rmidi->ops = &snd_usbmidi_ops; 2171 2129 rmidi->private_data = umidi; 2172 2130 rmidi->private_free = snd_usbmidi_rawmidi_free; 2173 - snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_usbmidi_output_ops); 2174 - snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_usbmidi_input_ops); 2131 + snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, 2132 + &snd_usbmidi_output_ops); 2133 + snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, 2134 + &snd_usbmidi_input_ops); 2175 2135 2176 2136 umidi->rmidi = rmidi; 2177 2137 return 0; ··· 2182 2138 /* 2183 2139 * Temporarily stop input. 2184 2140 */ 2185 - void snd_usbmidi_input_stop(struct list_head* p) 2141 + void snd_usbmidi_input_stop(struct list_head *p) 2186 2142 { 2187 - struct snd_usb_midi* umidi; 2143 + struct snd_usb_midi *umidi; 2188 2144 unsigned int i, j; 2189 2145 2190 2146 umidi = list_entry(p, struct snd_usb_midi, list); 2191 2147 if (!umidi->input_running) 2192 2148 return; 2193 2149 for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { 2194 - struct snd_usb_midi_endpoint* ep = &umidi->endpoints[i]; 2150 + struct snd_usb_midi_endpoint *ep = &umidi->endpoints[i]; 2195 2151 if (ep->in) 2196 2152 for (j = 0; j < INPUT_URBS; ++j) 2197 2153 usb_kill_urb(ep->in->urbs[j]); ··· 2200 2156 } 2201 2157 EXPORT_SYMBOL(snd_usbmidi_input_stop); 2202 2158 2203 - static void snd_usbmidi_input_start_ep(struct snd_usb_midi_in_endpoint* ep) 2159 + static void snd_usbmidi_input_start_ep(struct snd_usb_midi_in_endpoint *ep) 2204 2160 { 2205 2161 unsigned int i; 2206 2162 2207 2163 if (!ep) 2208 2164 return; 2209 2165 for (i = 0; i < INPUT_URBS; ++i) { 2210 - struct urb* urb = ep->urbs[i]; 2166 + struct urb *urb = ep->urbs[i]; 2211 2167 urb->dev = ep->umidi->dev; 2212 2168 snd_usbmidi_submit_urb(urb, GFP_KERNEL); 2213 2169 } ··· 2216 2172 /* 2217 2173 * Resume input after a call to snd_usbmidi_input_stop(). 2218 2174 */ 2219 - void snd_usbmidi_input_start(struct list_head* p) 2175 + void snd_usbmidi_input_start(struct list_head *p) 2220 2176 { 2221 - struct snd_usb_midi* umidi; 2177 + struct snd_usb_midi *umidi; 2222 2178 int i; 2223 2179 2224 2180 umidi = list_entry(p, struct snd_usb_midi, list); ··· 2262 2218 * Creates and registers everything needed for a MIDI streaming interface. 2263 2219 */ 2264 2220 int snd_usbmidi_create(struct snd_card *card, 2265 - struct usb_interface* iface, 2221 + struct usb_interface *iface, 2266 2222 struct list_head *midi_list, 2267 - const struct snd_usb_audio_quirk* quirk) 2223 + const struct snd_usb_audio_quirk *quirk) 2268 2224 { 2269 - struct snd_usb_midi* umidi; 2225 + struct snd_usb_midi *umidi; 2270 2226 struct snd_usb_midi_endpoint_info endpoints[MIDI_MAX_ENDPOINTS]; 2271 2227 int out_ports, in_ports; 2272 2228 int i, err; ··· 2364 2320 err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints); 2365 2321 break; 2366 2322 default: 2367 - dev_err(&umidi->dev->dev, "invalid quirk type %d\n", quirk->type); 2323 + dev_err(&umidi->dev->dev, "invalid quirk type %d\n", 2324 + quirk->type); 2368 2325 err = -ENXIO; 2369 2326 break; 2370 2327 }
+2 -2
sound/usb/midi.h
··· 43 43 struct usb_interface *iface, 44 44 struct list_head *midi_list, 45 45 const struct snd_usb_audio_quirk *quirk); 46 - void snd_usbmidi_input_stop(struct list_head* p); 47 - void snd_usbmidi_input_start(struct list_head* p); 46 + void snd_usbmidi_input_stop(struct list_head *p); 47 + void snd_usbmidi_input_start(struct list_head *p); 48 48 void snd_usbmidi_disconnect(struct list_head *p); 49 49 void snd_usbmidi_suspend(struct list_head *p); 50 50 void snd_usbmidi_resume(struct list_head *p);