1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Driver for Midiman Portman2x4 parallel port midi interface 4 * 5 * Copyright (c) by Levent Guendogdu <levon@feature-it.com> 6 * 7 * ChangeLog 8 * Jan 24 2007 Matthias Koenig <mkoenig@suse.de> 9 * - cleanup and rewrite 10 * Sep 30 2004 Tobias Gehrig <tobias@gehrig.tk> 11 * - source code cleanup 12 * Sep 03 2004 Tobias Gehrig <tobias@gehrig.tk> 13 * - fixed compilation problem with alsa 1.0.6a (removed MODULE_CLASSES, 14 * MODULE_PARM_SYNTAX and changed MODULE_DEVICES to 15 * MODULE_SUPPORTED_DEVICE) 16 * Mar 24 2004 Tobias Gehrig <tobias@gehrig.tk> 17 * - added 2.6 kernel support 18 * Mar 18 2004 Tobias Gehrig <tobias@gehrig.tk> 19 * - added parport_unregister_driver to the startup routine if the driver fails to detect a portman 20 * - added support for all 4 output ports in portman_putmidi 21 * Mar 17 2004 Tobias Gehrig <tobias@gehrig.tk> 22 * - added checks for opened input device in interrupt handler 23 * Feb 20 2004 Tobias Gehrig <tobias@gehrig.tk> 24 * - ported from alsa 0.5 to 1.0 25 */ 26 27 #include <linux/init.h> 28 #include <linux/platform_device.h> 29 #include <linux/parport.h> 30 #include <linux/spinlock.h> 31 #include <linux/delay.h> 32 #include <linux/slab.h> 33 #include <linux/module.h> 34 #include <sound/core.h> 35 #include <sound/initval.h> 36 #include <sound/rawmidi.h> 37 #include <sound/control.h> 38 39 #define CARD_NAME "Portman 2x4" 40 #define DRIVER_NAME "portman" 41 #define PLATFORM_DRIVER "snd_portman2x4" 42 43 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; 44 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; 45 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; 46 47 static struct platform_device *platform_devices[SNDRV_CARDS]; 48 static int device_count; 49 50 module_param_array(index, int, NULL, 0444); 51 MODULE_PARM_DESC(index, "Index value for " CARD_NAME " soundcard."); 52 module_param_array(id, charp, NULL, 0444); 53 MODULE_PARM_DESC(id, "ID string for " CARD_NAME " soundcard."); 54 module_param_array(enable, bool, NULL, 0444); 55 MODULE_PARM_DESC(enable, "Enable " CARD_NAME " soundcard."); 56 57 MODULE_AUTHOR("Levent Guendogdu, Tobias Gehrig, Matthias Koenig"); 58 MODULE_DESCRIPTION("Midiman Portman2x4"); 59 MODULE_LICENSE("GPL"); 60 MODULE_SUPPORTED_DEVICE("{{Midiman,Portman2x4}}"); 61 62 /********************************************************************* 63 * Chip specific 64 *********************************************************************/ 65 #define PORTMAN_NUM_INPUT_PORTS 2 66 #define PORTMAN_NUM_OUTPUT_PORTS 4 67 68 struct portman { 69 spinlock_t reg_lock; 70 struct snd_card *card; 71 struct snd_rawmidi *rmidi; 72 struct pardevice *pardev; 73 int open_count; 74 int mode[PORTMAN_NUM_INPUT_PORTS]; 75 struct snd_rawmidi_substream *midi_input[PORTMAN_NUM_INPUT_PORTS]; 76 }; 77 78 static int portman_free(struct portman *pm) 79 { 80 kfree(pm); 81 return 0; 82 } 83 84 static int portman_create(struct snd_card *card, 85 struct pardevice *pardev, 86 struct portman **rchip) 87 { 88 struct portman *pm; 89 90 *rchip = NULL; 91 92 pm = kzalloc(sizeof(struct portman), GFP_KERNEL); 93 if (pm == NULL) 94 return -ENOMEM; 95 96 /* Init chip specific data */ 97 spin_lock_init(&pm->reg_lock); 98 pm->card = card; 99 pm->pardev = pardev; 100 101 *rchip = pm; 102 103 return 0; 104 } 105 106 /********************************************************************* 107 * HW related constants 108 *********************************************************************/ 109 110 /* Standard PC parallel port status register equates. */ 111 #define PP_STAT_BSY 0x80 /* Busy status. Inverted. */ 112 #define PP_STAT_ACK 0x40 /* Acknowledge. Non-Inverted. */ 113 #define PP_STAT_POUT 0x20 /* Paper Out. Non-Inverted. */ 114 #define PP_STAT_SEL 0x10 /* Select. Non-Inverted. */ 115 #define PP_STAT_ERR 0x08 /* Error. Non-Inverted. */ 116 117 /* Standard PC parallel port command register equates. */ 118 #define PP_CMD_IEN 0x10 /* IRQ Enable. Non-Inverted. */ 119 #define PP_CMD_SELI 0x08 /* Select Input. Inverted. */ 120 #define PP_CMD_INIT 0x04 /* Init Printer. Non-Inverted. */ 121 #define PP_CMD_FEED 0x02 /* Auto Feed. Inverted. */ 122 #define PP_CMD_STB 0x01 /* Strobe. Inverted. */ 123 124 /* Parallel Port Command Register as implemented by PCP2x4. */ 125 #define INT_EN PP_CMD_IEN /* Interrupt enable. */ 126 #define STROBE PP_CMD_STB /* Command strobe. */ 127 128 /* The parallel port command register field (b1..b3) selects the 129 * various "registers" within the PC/P 2x4. These are the internal 130 * address of these "registers" that must be written to the parallel 131 * port command register. 132 */ 133 #define RXDATA0 (0 << 1) /* PCP RxData channel 0. */ 134 #define RXDATA1 (1 << 1) /* PCP RxData channel 1. */ 135 #define GEN_CTL (2 << 1) /* PCP General Control Register. */ 136 #define SYNC_CTL (3 << 1) /* PCP Sync Control Register. */ 137 #define TXDATA0 (4 << 1) /* PCP TxData channel 0. */ 138 #define TXDATA1 (5 << 1) /* PCP TxData channel 1. */ 139 #define TXDATA2 (6 << 1) /* PCP TxData channel 2. */ 140 #define TXDATA3 (7 << 1) /* PCP TxData channel 3. */ 141 142 /* Parallel Port Status Register as implemented by PCP2x4. */ 143 #define ESTB PP_STAT_POUT /* Echoed strobe. */ 144 #define INT_REQ PP_STAT_ACK /* Input data int request. */ 145 #define BUSY PP_STAT_ERR /* Interface Busy. */ 146 147 /* Parallel Port Status Register BUSY and SELECT lines are multiplexed 148 * between several functions. Depending on which 2x4 "register" is 149 * currently selected (b1..b3), the BUSY and SELECT lines are 150 * assigned as follows: 151 * 152 * SELECT LINE: A3 A2 A1 153 * -------- 154 */ 155 #define RXAVAIL PP_STAT_SEL /* Rx Available, channel 0. 0 0 0 */ 156 // RXAVAIL1 PP_STAT_SEL /* Rx Available, channel 1. 0 0 1 */ 157 #define SYNC_STAT PP_STAT_SEL /* Reserved - Sync Status. 0 1 0 */ 158 // /* Reserved. 0 1 1 */ 159 #define TXEMPTY PP_STAT_SEL /* Tx Empty, channel 0. 1 0 0 */ 160 // TXEMPTY1 PP_STAT_SEL /* Tx Empty, channel 1. 1 0 1 */ 161 // TXEMPTY2 PP_STAT_SEL /* Tx Empty, channel 2. 1 1 0 */ 162 // TXEMPTY3 PP_STAT_SEL /* Tx Empty, channel 3. 1 1 1 */ 163 164 /* BUSY LINE: A3 A2 A1 165 * -------- 166 */ 167 #define RXDATA PP_STAT_BSY /* Rx Input Data, channel 0. 0 0 0 */ 168 // RXDATA1 PP_STAT_BSY /* Rx Input Data, channel 1. 0 0 1 */ 169 #define SYNC_DATA PP_STAT_BSY /* Reserved - Sync Data. 0 1 0 */ 170 /* Reserved. 0 1 1 */ 171 #define DATA_ECHO PP_STAT_BSY /* Parallel Port Data Echo. 1 0 0 */ 172 #define A0_ECHO PP_STAT_BSY /* Address 0 Echo. 1 0 1 */ 173 #define A1_ECHO PP_STAT_BSY /* Address 1 Echo. 1 1 0 */ 174 #define A2_ECHO PP_STAT_BSY /* Address 2 Echo. 1 1 1 */ 175 176 #define PORTMAN2X4_MODE_INPUT_TRIGGERED 0x01 177 178 /********************************************************************* 179 * Hardware specific functions 180 *********************************************************************/ 181 static inline void portman_write_command(struct portman *pm, u8 value) 182 { 183 parport_write_control(pm->pardev->port, value); 184 } 185 186 static inline u8 portman_read_command(struct portman *pm) 187 { 188 return parport_read_control(pm->pardev->port); 189 } 190 191 static inline u8 portman_read_status(struct portman *pm) 192 { 193 return parport_read_status(pm->pardev->port); 194 } 195 196 static inline u8 portman_read_data(struct portman *pm) 197 { 198 return parport_read_data(pm->pardev->port); 199 } 200 201 static inline void portman_write_data(struct portman *pm, u8 value) 202 { 203 parport_write_data(pm->pardev->port, value); 204 } 205 206 static void portman_write_midi(struct portman *pm, 207 int port, u8 mididata) 208 { 209 int command = ((port + 4) << 1); 210 211 /* Get entering data byte and port number in BL and BH respectively. 212 * Set up Tx Channel address field for use with PP Cmd Register. 213 * Store address field in BH register. 214 * Inputs: AH = Output port number (0..3). 215 * AL = Data byte. 216 * command = TXDATA0 | INT_EN; 217 * Align port num with address field (b1...b3), 218 * set address for TXDatax, Strobe=0 219 */ 220 command |= INT_EN; 221 222 /* Disable interrupts so that the process is not interrupted, then 223 * write the address associated with the current Tx channel to the 224 * PP Command Reg. Do not set the Strobe signal yet. 225 */ 226 227 do { 228 portman_write_command(pm, command); 229 230 /* While the address lines settle, write parallel output data to 231 * PP Data Reg. This has no effect until Strobe signal is asserted. 232 */ 233 234 portman_write_data(pm, mididata); 235 236 /* If PCP channel's TxEmpty is set (TxEmpty is read through the PP 237 * Status Register), then go write data. Else go back and wait. 238 */ 239 } while ((portman_read_status(pm) & TXEMPTY) != TXEMPTY); 240 241 /* TxEmpty is set. Maintain PC/P destination address and assert 242 * Strobe through the PP Command Reg. This will Strobe data into 243 * the PC/P transmitter and set the PC/P BUSY signal. 244 */ 245 246 portman_write_command(pm, command | STROBE); 247 248 /* Wait for strobe line to settle and echo back through hardware. 249 * Once it has echoed back, assume that the address and data lines 250 * have settled! 251 */ 252 253 while ((portman_read_status(pm) & ESTB) == 0) 254 cpu_relax(); 255 256 /* Release strobe and immediately re-allow interrupts. */ 257 portman_write_command(pm, command); 258 259 while ((portman_read_status(pm) & ESTB) == ESTB) 260 cpu_relax(); 261 262 /* PC/P BUSY is now set. We must wait until BUSY resets itself. 263 * We'll reenable ints while we're waiting. 264 */ 265 266 while ((portman_read_status(pm) & BUSY) == BUSY) 267 cpu_relax(); 268 269 /* Data sent. */ 270 } 271 272 273 /* 274 * Read MIDI byte from port 275 * Attempt to read input byte from specified hardware input port (0..). 276 * Return -1 if no data 277 */ 278 static int portman_read_midi(struct portman *pm, int port) 279 { 280 unsigned char midi_data = 0; 281 unsigned char cmdout; /* Saved address+IE bit. */ 282 283 /* Make sure clocking edge is down before starting... */ 284 portman_write_data(pm, 0); /* Make sure edge is down. */ 285 286 /* Set destination address to PCP. */ 287 cmdout = (port << 1) | INT_EN; /* Address + IE + No Strobe. */ 288 portman_write_command(pm, cmdout); 289 290 while ((portman_read_status(pm) & ESTB) == ESTB) 291 cpu_relax(); /* Wait for strobe echo. */ 292 293 /* After the address lines settle, check multiplexed RxAvail signal. 294 * If data is available, read it. 295 */ 296 if ((portman_read_status(pm) & RXAVAIL) == 0) 297 return -1; /* No data. */ 298 299 /* Set the Strobe signal to enable the Rx clocking circuitry. */ 300 portman_write_command(pm, cmdout | STROBE); /* Write address+IE+Strobe. */ 301 302 while ((portman_read_status(pm) & ESTB) == 0) 303 cpu_relax(); /* Wait for strobe echo. */ 304 305 /* The first data bit (msb) is already sitting on the input line. */ 306 midi_data = (portman_read_status(pm) & 128); 307 portman_write_data(pm, 1); /* Cause rising edge, which shifts data. */ 308 309 /* Data bit 6. */ 310 portman_write_data(pm, 0); /* Cause falling edge while data settles. */ 311 midi_data |= (portman_read_status(pm) >> 1) & 64; 312 portman_write_data(pm, 1); /* Cause rising edge, which shifts data. */ 313 314 /* Data bit 5. */ 315 portman_write_data(pm, 0); /* Cause falling edge while data settles. */ 316 midi_data |= (portman_read_status(pm) >> 2) & 32; 317 portman_write_data(pm, 1); /* Cause rising edge, which shifts data. */ 318 319 /* Data bit 4. */ 320 portman_write_data(pm, 0); /* Cause falling edge while data settles. */ 321 midi_data |= (portman_read_status(pm) >> 3) & 16; 322 portman_write_data(pm, 1); /* Cause rising edge, which shifts data. */ 323 324 /* Data bit 3. */ 325 portman_write_data(pm, 0); /* Cause falling edge while data settles. */ 326 midi_data |= (portman_read_status(pm) >> 4) & 8; 327 portman_write_data(pm, 1); /* Cause rising edge, which shifts data. */ 328 329 /* Data bit 2. */ 330 portman_write_data(pm, 0); /* Cause falling edge while data settles. */ 331 midi_data |= (portman_read_status(pm) >> 5) & 4; 332 portman_write_data(pm, 1); /* Cause rising edge, which shifts data. */ 333 334 /* Data bit 1. */ 335 portman_write_data(pm, 0); /* Cause falling edge while data settles. */ 336 midi_data |= (portman_read_status(pm) >> 6) & 2; 337 portman_write_data(pm, 1); /* Cause rising edge, which shifts data. */ 338 339 /* Data bit 0. */ 340 portman_write_data(pm, 0); /* Cause falling edge while data settles. */ 341 midi_data |= (portman_read_status(pm) >> 7) & 1; 342 portman_write_data(pm, 1); /* Cause rising edge, which shifts data. */ 343 portman_write_data(pm, 0); /* Return data clock low. */ 344 345 346 /* De-assert Strobe and return data. */ 347 portman_write_command(pm, cmdout); /* Output saved address+IE. */ 348 349 /* Wait for strobe echo. */ 350 while ((portman_read_status(pm) & ESTB) == ESTB) 351 cpu_relax(); 352 353 return (midi_data & 255); /* Shift back and return value. */ 354 } 355 356 /* 357 * Checks if any input data on the given channel is available 358 * Checks RxAvail 359 */ 360 static int portman_data_avail(struct portman *pm, int channel) 361 { 362 int command = INT_EN; 363 switch (channel) { 364 case 0: 365 command |= RXDATA0; 366 break; 367 case 1: 368 command |= RXDATA1; 369 break; 370 } 371 /* Write hardware (assumme STROBE=0) */ 372 portman_write_command(pm, command); 373 /* Check multiplexed RxAvail signal */ 374 if ((portman_read_status(pm) & RXAVAIL) == RXAVAIL) 375 return 1; /* Data available */ 376 377 /* No Data available */ 378 return 0; 379 } 380 381 382 /* 383 * Flushes any input 384 */ 385 static void portman_flush_input(struct portman *pm, unsigned char port) 386 { 387 /* Local variable for counting things */ 388 unsigned int i = 0; 389 unsigned char command = 0; 390 391 switch (port) { 392 case 0: 393 command = RXDATA0; 394 break; 395 case 1: 396 command = RXDATA1; 397 break; 398 default: 399 snd_printk(KERN_WARNING 400 "portman_flush_input() Won't flush port %i\n", 401 port); 402 return; 403 } 404 405 /* Set address for specified channel in port and allow to settle. */ 406 portman_write_command(pm, command); 407 408 /* Assert the Strobe and wait for echo back. */ 409 portman_write_command(pm, command | STROBE); 410 411 /* Wait for ESTB */ 412 while ((portman_read_status(pm) & ESTB) == 0) 413 cpu_relax(); 414 415 /* Output clock cycles to the Rx circuitry. */ 416 portman_write_data(pm, 0); 417 418 /* Flush 250 bits... */ 419 for (i = 0; i < 250; i++) { 420 portman_write_data(pm, 1); 421 portman_write_data(pm, 0); 422 } 423 424 /* Deassert the Strobe signal of the port and wait for it to settle. */ 425 portman_write_command(pm, command | INT_EN); 426 427 /* Wait for settling */ 428 while ((portman_read_status(pm) & ESTB) == ESTB) 429 cpu_relax(); 430 } 431 432 static int portman_probe(struct parport *p) 433 { 434 /* Initialize the parallel port data register. Will set Rx clocks 435 * low in case we happen to be addressing the Rx ports at this time. 436 */ 437 /* 1 */ 438 parport_write_data(p, 0); 439 440 /* Initialize the parallel port command register, thus initializing 441 * hardware handshake lines to midi box: 442 * 443 * Strobe = 0 444 * Interrupt Enable = 0 445 */ 446 /* 2 */ 447 parport_write_control(p, 0); 448 449 /* Check if Portman PC/P 2x4 is out there. */ 450 /* 3 */ 451 parport_write_control(p, RXDATA0); /* Write Strobe=0 to command reg. */ 452 453 /* Check for ESTB to be clear */ 454 /* 4 */ 455 if ((parport_read_status(p) & ESTB) == ESTB) 456 return 1; /* CODE 1 - Strobe Failure. */ 457 458 /* Set for RXDATA0 where no damage will be done. */ 459 /* 5 */ 460 parport_write_control(p, RXDATA0 + STROBE); /* Write Strobe=1 to command reg. */ 461 462 /* 6 */ 463 if ((parport_read_status(p) & ESTB) != ESTB) 464 return 1; /* CODE 1 - Strobe Failure. */ 465 466 /* 7 */ 467 parport_write_control(p, 0); /* Reset Strobe=0. */ 468 469 /* Check if Tx circuitry is functioning properly. If initialized 470 * unit TxEmpty is false, send out char and see if if goes true. 471 */ 472 /* 8 */ 473 parport_write_control(p, TXDATA0); /* Tx channel 0, strobe off. */ 474 475 /* If PCP channel's TxEmpty is set (TxEmpty is read through the PP 476 * Status Register), then go write data. Else go back and wait. 477 */ 478 /* 9 */ 479 if ((parport_read_status(p) & TXEMPTY) == 0) 480 return 2; 481 482 /* Return OK status. */ 483 return 0; 484 } 485 486 static int portman_device_init(struct portman *pm) 487 { 488 portman_flush_input(pm, 0); 489 portman_flush_input(pm, 1); 490 491 return 0; 492 } 493 494 /********************************************************************* 495 * Rawmidi 496 *********************************************************************/ 497 static int snd_portman_midi_open(struct snd_rawmidi_substream *substream) 498 { 499 return 0; 500 } 501 502 static int snd_portman_midi_close(struct snd_rawmidi_substream *substream) 503 { 504 return 0; 505 } 506 507 static void snd_portman_midi_input_trigger(struct snd_rawmidi_substream *substream, 508 int up) 509 { 510 struct portman *pm = substream->rmidi->private_data; 511 unsigned long flags; 512 513 spin_lock_irqsave(&pm->reg_lock, flags); 514 if (up) 515 pm->mode[substream->number] |= PORTMAN2X4_MODE_INPUT_TRIGGERED; 516 else 517 pm->mode[substream->number] &= ~PORTMAN2X4_MODE_INPUT_TRIGGERED; 518 spin_unlock_irqrestore(&pm->reg_lock, flags); 519 } 520 521 static void snd_portman_midi_output_trigger(struct snd_rawmidi_substream *substream, 522 int up) 523 { 524 struct portman *pm = substream->rmidi->private_data; 525 unsigned long flags; 526 unsigned char byte; 527 528 spin_lock_irqsave(&pm->reg_lock, flags); 529 if (up) { 530 while ((snd_rawmidi_transmit(substream, &byte, 1) == 1)) 531 portman_write_midi(pm, substream->number, byte); 532 } 533 spin_unlock_irqrestore(&pm->reg_lock, flags); 534 } 535 536 static const struct snd_rawmidi_ops snd_portman_midi_output = { 537 .open = snd_portman_midi_open, 538 .close = snd_portman_midi_close, 539 .trigger = snd_portman_midi_output_trigger, 540 }; 541 542 static const struct snd_rawmidi_ops snd_portman_midi_input = { 543 .open = snd_portman_midi_open, 544 .close = snd_portman_midi_close, 545 .trigger = snd_portman_midi_input_trigger, 546 }; 547 548 /* Create and initialize the rawmidi component */ 549 static int snd_portman_rawmidi_create(struct snd_card *card) 550 { 551 struct portman *pm = card->private_data; 552 struct snd_rawmidi *rmidi; 553 struct snd_rawmidi_substream *substream; 554 int err; 555 556 err = snd_rawmidi_new(card, CARD_NAME, 0, 557 PORTMAN_NUM_OUTPUT_PORTS, 558 PORTMAN_NUM_INPUT_PORTS, 559 &rmidi); 560 if (err < 0) 561 return err; 562 563 rmidi->private_data = pm; 564 strcpy(rmidi->name, CARD_NAME); 565 rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT | 566 SNDRV_RAWMIDI_INFO_INPUT | 567 SNDRV_RAWMIDI_INFO_DUPLEX; 568 569 pm->rmidi = rmidi; 570 571 /* register rawmidi ops */ 572 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, 573 &snd_portman_midi_output); 574 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, 575 &snd_portman_midi_input); 576 577 /* name substreams */ 578 /* output */ 579 list_for_each_entry(substream, 580 &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams, 581 list) { 582 sprintf(substream->name, 583 "Portman2x4 %d", substream->number+1); 584 } 585 /* input */ 586 list_for_each_entry(substream, 587 &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams, 588 list) { 589 pm->midi_input[substream->number] = substream; 590 sprintf(substream->name, 591 "Portman2x4 %d", substream->number+1); 592 } 593 594 return err; 595 } 596 597 /********************************************************************* 598 * parport stuff 599 *********************************************************************/ 600 static void snd_portman_interrupt(void *userdata) 601 { 602 unsigned char midivalue = 0; 603 struct portman *pm = ((struct snd_card*)userdata)->private_data; 604 605 spin_lock(&pm->reg_lock); 606 607 /* While any input data is waiting */ 608 while ((portman_read_status(pm) & INT_REQ) == INT_REQ) { 609 /* If data available on channel 0, 610 read it and stuff it into the queue. */ 611 if (portman_data_avail(pm, 0)) { 612 /* Read Midi */ 613 midivalue = portman_read_midi(pm, 0); 614 /* put midi into queue... */ 615 if (pm->mode[0] & PORTMAN2X4_MODE_INPUT_TRIGGERED) 616 snd_rawmidi_receive(pm->midi_input[0], 617 &midivalue, 1); 618 619 } 620 /* If data available on channel 1, 621 read it and stuff it into the queue. */ 622 if (portman_data_avail(pm, 1)) { 623 /* Read Midi */ 624 midivalue = portman_read_midi(pm, 1); 625 /* put midi into queue... */ 626 if (pm->mode[1] & PORTMAN2X4_MODE_INPUT_TRIGGERED) 627 snd_rawmidi_receive(pm->midi_input[1], 628 &midivalue, 1); 629 } 630 631 } 632 633 spin_unlock(&pm->reg_lock); 634 } 635 636 static void snd_portman_attach(struct parport *p) 637 { 638 struct platform_device *device; 639 640 device = platform_device_alloc(PLATFORM_DRIVER, device_count); 641 if (!device) 642 return; 643 644 /* Temporary assignment to forward the parport */ 645 platform_set_drvdata(device, p); 646 647 if (platform_device_add(device) < 0) { 648 platform_device_put(device); 649 return; 650 } 651 652 /* Since we dont get the return value of probe 653 * We need to check if device probing succeeded or not */ 654 if (!platform_get_drvdata(device)) { 655 platform_device_unregister(device); 656 return; 657 } 658 659 /* register device in global table */ 660 platform_devices[device_count] = device; 661 device_count++; 662 } 663 664 static void snd_portman_detach(struct parport *p) 665 { 666 /* nothing to do here */ 667 } 668 669 static int snd_portman_dev_probe(struct pardevice *pardev) 670 { 671 if (strcmp(pardev->name, DRIVER_NAME)) 672 return -ENODEV; 673 674 return 0; 675 } 676 677 static struct parport_driver portman_parport_driver = { 678 .name = "portman2x4", 679 .probe = snd_portman_dev_probe, 680 .match_port = snd_portman_attach, 681 .detach = snd_portman_detach, 682 .devmodel = true, 683 }; 684 685 /********************************************************************* 686 * platform stuff 687 *********************************************************************/ 688 static void snd_portman_card_private_free(struct snd_card *card) 689 { 690 struct portman *pm = card->private_data; 691 struct pardevice *pardev = pm->pardev; 692 693 if (pardev) { 694 parport_release(pardev); 695 parport_unregister_device(pardev); 696 } 697 698 portman_free(pm); 699 } 700 701 static int snd_portman_probe(struct platform_device *pdev) 702 { 703 struct pardevice *pardev; 704 struct parport *p; 705 int dev = pdev->id; 706 struct snd_card *card = NULL; 707 struct portman *pm = NULL; 708 int err; 709 struct pardev_cb portman_cb = { 710 .preempt = NULL, 711 .wakeup = NULL, 712 .irq_func = snd_portman_interrupt, /* ISR */ 713 .flags = PARPORT_DEV_EXCL, /* flags */ 714 }; 715 716 p = platform_get_drvdata(pdev); 717 platform_set_drvdata(pdev, NULL); 718 719 if (dev >= SNDRV_CARDS) 720 return -ENODEV; 721 if (!enable[dev]) 722 return -ENOENT; 723 724 err = snd_card_new(&pdev->dev, index[dev], id[dev], THIS_MODULE, 725 0, &card); 726 if (err < 0) { 727 snd_printd("Cannot create card\n"); 728 return err; 729 } 730 strcpy(card->driver, DRIVER_NAME); 731 strcpy(card->shortname, CARD_NAME); 732 sprintf(card->longname, "%s at 0x%lx, irq %i", 733 card->shortname, p->base, p->irq); 734 735 portman_cb.private = card; /* private */ 736 pardev = parport_register_dev_model(p, /* port */ 737 DRIVER_NAME, /* name */ 738 &portman_cb, /* callbacks */ 739 pdev->id); /* device number */ 740 if (pardev == NULL) { 741 snd_printd("Cannot register pardevice\n"); 742 err = -EIO; 743 goto __err; 744 } 745 746 /* claim parport */ 747 if (parport_claim(pardev)) { 748 snd_printd("Cannot claim parport 0x%lx\n", pardev->port->base); 749 err = -EIO; 750 goto free_pardev; 751 } 752 753 if ((err = portman_create(card, pardev, &pm)) < 0) { 754 snd_printd("Cannot create main component\n"); 755 goto release_pardev; 756 } 757 card->private_data = pm; 758 card->private_free = snd_portman_card_private_free; 759 760 err = portman_probe(p); 761 if (err) { 762 err = -EIO; 763 goto __err; 764 } 765 766 if ((err = snd_portman_rawmidi_create(card)) < 0) { 767 snd_printd("Creating Rawmidi component failed\n"); 768 goto __err; 769 } 770 771 /* init device */ 772 if ((err = portman_device_init(pm)) < 0) 773 goto __err; 774 775 platform_set_drvdata(pdev, card); 776 777 /* At this point card will be usable */ 778 if ((err = snd_card_register(card)) < 0) { 779 snd_printd("Cannot register card\n"); 780 goto __err; 781 } 782 783 snd_printk(KERN_INFO "Portman 2x4 on 0x%lx\n", p->base); 784 return 0; 785 786 release_pardev: 787 parport_release(pardev); 788 free_pardev: 789 parport_unregister_device(pardev); 790 __err: 791 snd_card_free(card); 792 return err; 793 } 794 795 static int snd_portman_remove(struct platform_device *pdev) 796 { 797 struct snd_card *card = platform_get_drvdata(pdev); 798 799 if (card) 800 snd_card_free(card); 801 802 return 0; 803 } 804 805 806 static struct platform_driver snd_portman_driver = { 807 .probe = snd_portman_probe, 808 .remove = snd_portman_remove, 809 .driver = { 810 .name = PLATFORM_DRIVER, 811 } 812 }; 813 814 /********************************************************************* 815 * module init stuff 816 *********************************************************************/ 817 static void snd_portman_unregister_all(void) 818 { 819 int i; 820 821 for (i = 0; i < SNDRV_CARDS; ++i) { 822 if (platform_devices[i]) { 823 platform_device_unregister(platform_devices[i]); 824 platform_devices[i] = NULL; 825 } 826 } 827 platform_driver_unregister(&snd_portman_driver); 828 parport_unregister_driver(&portman_parport_driver); 829 } 830 831 static int __init snd_portman_module_init(void) 832 { 833 int err; 834 835 if ((err = platform_driver_register(&snd_portman_driver)) < 0) 836 return err; 837 838 if (parport_register_driver(&portman_parport_driver) != 0) { 839 platform_driver_unregister(&snd_portman_driver); 840 return -EIO; 841 } 842 843 if (device_count == 0) { 844 snd_portman_unregister_all(); 845 return -ENODEV; 846 } 847 848 return 0; 849 } 850 851 static void __exit snd_portman_module_exit(void) 852 { 853 snd_portman_unregister_all(); 854 } 855 856 module_init(snd_portman_module_init); 857 module_exit(snd_portman_module_exit); 858