2362 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Driver for the Korg 1212 IO PCI card4 *5 * Copyright (c) 2001 Haroldo Gamal <gamal@alternex.com.br>6 */7 8#include <linux/delay.h>9#include <linux/init.h>10#include <linux/interrupt.h>11#include <linux/pci.h>12#include <linux/slab.h>13#include <linux/wait.h>14#include <linux/module.h>15#include <linux/mutex.h>16#include <linux/firmware.h>17#include <linux/io.h>18 19#include <sound/core.h>20#include <sound/info.h>21#include <sound/control.h>22#include <sound/pcm.h>23#include <sound/pcm_params.h>24#include <sound/initval.h>25 26// ----------------------------------------------------------------------------27// Debug Stuff28// ----------------------------------------------------------------------------29#define K1212_DEBUG_LEVEL 030#if K1212_DEBUG_LEVEL > 031#define K1212_DEBUG_PRINTK(fmt, args...) pr_debug(fmt, ##args)32#else33#define K1212_DEBUG_PRINTK(fmt, ...) do { } while (0)34#endif35#if K1212_DEBUG_LEVEL > 136#define K1212_DEBUG_PRINTK_VERBOSE(fmt, args...) pr_debug(fmt, ##args)37#else38#define K1212_DEBUG_PRINTK_VERBOSE(fmt, ...)39#endif40 41// ----------------------------------------------------------------------------42// Record/Play Buffer Allocation Method. If K1212_LARGEALLOC is defined all 43// buffers are alocated as a large piece inside KorgSharedBuffer.44// ----------------------------------------------------------------------------45//#define K1212_LARGEALLOC 146 47// ----------------------------------------------------------------------------48// Valid states of the Korg 1212 I/O card.49// ----------------------------------------------------------------------------50enum CardState {51 K1212_STATE_NONEXISTENT, // there is no card here52 K1212_STATE_UNINITIALIZED, // the card is awaiting DSP download53 K1212_STATE_DSP_IN_PROCESS, // the card is currently downloading its DSP code54 K1212_STATE_DSP_COMPLETE, // the card has finished the DSP download55 K1212_STATE_READY, // the card can be opened by an application. Any application56 // requests prior to this state should fail. Only an open57 // request can be made at this state.58 K1212_STATE_OPEN, // an application has opened the card59 K1212_STATE_SETUP, // the card has been setup for play60 K1212_STATE_PLAYING, // the card is playing61 K1212_STATE_MONITOR, // the card is in the monitor mode62 K1212_STATE_CALIBRATING, // the card is currently calibrating63 K1212_STATE_ERRORSTOP, // the card has stopped itself because of an error and we64 // are in the process of cleaning things up.65 K1212_STATE_MAX_STATE // state values of this and beyond are invalid66};67 68// ----------------------------------------------------------------------------69// The following enumeration defines the constants written to the card's70// host-to-card doorbell to initiate a command.71// ----------------------------------------------------------------------------72enum korg1212_dbcnst {73 K1212_DB_RequestForData = 0, // sent by the card to request a buffer fill.74 K1212_DB_TriggerPlay = 1, // starts playback/record on the card.75 K1212_DB_SelectPlayMode = 2, // select monitor, playback setup, or stop.76 K1212_DB_ConfigureBufferMemory = 3, // tells card where the host audio buffers are.77 K1212_DB_RequestAdatTimecode = 4, // asks the card for the latest ADAT timecode value.78 K1212_DB_SetClockSourceRate = 5, // sets the clock source and rate for the card.79 K1212_DB_ConfigureMiscMemory = 6, // tells card where other buffers are.80 K1212_DB_TriggerFromAdat = 7, // tells card to trigger from Adat at a specific81 // timecode value.82 K1212_DB_DMAERROR = 0x80, // DMA Error - the PCI bus is congestioned.83 K1212_DB_CARDSTOPPED = 0x81, // Card has stopped by user request.84 K1212_DB_RebootCard = 0xA0, // instructs the card to reboot.85 K1212_DB_BootFromDSPPage4 = 0xA4, // instructs the card to boot from the DSP microcode86 // on page 4 (local page to card).87 K1212_DB_DSPDownloadDone = 0xAE, // sent by the card to indicate the download has88 // completed.89 K1212_DB_StartDSPDownload = 0xAF // tells the card to download its DSP firmware.90};91 92 93// ----------------------------------------------------------------------------94// The following enumeration defines return codes 95// to the Korg 1212 I/O driver.96// ----------------------------------------------------------------------------97enum snd_korg1212rc {98 K1212_CMDRET_Success = 0, // command was successfully placed99 K1212_CMDRET_DIOCFailure, // the DeviceIoControl call failed100 K1212_CMDRET_PMFailure, // the protected mode call failed101 K1212_CMDRET_FailUnspecified, // unspecified failure102 K1212_CMDRET_FailBadState, // the specified command can not be given in103 // the card's current state. (or the wave device's104 // state)105 K1212_CMDRET_CardUninitialized, // the card is uninitialized and cannot be used106 K1212_CMDRET_BadIndex, // an out of range card index was specified107 K1212_CMDRET_BadHandle, // an invalid card handle was specified108 K1212_CMDRET_NoFillRoutine, // a play request has been made before a fill routine set109 K1212_CMDRET_FillRoutineInUse, // can't set a new fill routine while one is in use110 K1212_CMDRET_NoAckFromCard, // the card never acknowledged a command111 K1212_CMDRET_BadParams, // bad parameters were provided by the caller112 113 K1212_CMDRET_BadDevice, // the specified wave device was out of range114 K1212_CMDRET_BadFormat // the specified wave format is unsupported115};116 117// ----------------------------------------------------------------------------118// The following enumeration defines the constants used to select the play119// mode for the card in the SelectPlayMode command.120// ----------------------------------------------------------------------------121enum PlayModeSelector {122 K1212_MODE_SetupPlay = 0x00000001, // provides card with pre-play information123 K1212_MODE_MonitorOn = 0x00000002, // tells card to turn on monitor mode124 K1212_MODE_MonitorOff = 0x00000004, // tells card to turn off monitor mode125 K1212_MODE_StopPlay = 0x00000008 // stops playback on the card126};127 128// ----------------------------------------------------------------------------129// The following enumeration defines the constants used to select the monitor130// mode for the card in the SetMonitorMode command.131// ----------------------------------------------------------------------------132enum MonitorModeSelector {133 K1212_MONMODE_Off = 0, // tells card to turn off monitor mode134 K1212_MONMODE_On // tells card to turn on monitor mode135};136 137#define MAILBOX0_OFFSET 0x40 // location of mailbox 0 relative to base address138#define MAILBOX1_OFFSET 0x44 // location of mailbox 1 relative to base address139#define MAILBOX2_OFFSET 0x48 // location of mailbox 2 relative to base address140#define MAILBOX3_OFFSET 0x4c // location of mailbox 3 relative to base address141#define OUT_DOORBELL_OFFSET 0x60 // location of PCI to local doorbell142#define IN_DOORBELL_OFFSET 0x64 // location of local to PCI doorbell143#define STATUS_REG_OFFSET 0x68 // location of interrupt control/status register144#define PCI_CONTROL_OFFSET 0x6c // location of the EEPROM, PCI, User I/O, init control145 // register146#define SENS_CONTROL_OFFSET 0x6e // location of the input sensitivity setting register.147 // this is the upper word of the PCI control reg.148#define DEV_VEND_ID_OFFSET 0x70 // location of the device and vendor ID register149 150#define MAX_COMMAND_RETRIES 5 // maximum number of times the driver will attempt151 // to send a command before giving up.152#define COMMAND_ACK_MASK 0x8000 // the MSB is set in the command acknowledgment from153 // the card.154#define DOORBELL_VAL_MASK 0x00FF // the doorbell value is one byte155 156#define CARD_BOOT_DELAY_IN_MS 10157#define CARD_BOOT_TIMEOUT 10158#define DSP_BOOT_DELAY_IN_MS 200159 160#define kNumBuffers 8161#define k1212MaxCards 4162#define k1212NumWaveDevices 6163#define k16BitChannels 10164#define k32BitChannels 2165#define kAudioChannels (k16BitChannels + k32BitChannels)166#define kPlayBufferFrames 1024167 168#define K1212_ANALOG_CHANNELS 2169#define K1212_SPDIF_CHANNELS 2170#define K1212_ADAT_CHANNELS 8171#define K1212_CHANNELS (K1212_ADAT_CHANNELS + K1212_ANALOG_CHANNELS)172#define K1212_MIN_CHANNELS 1173#define K1212_MAX_CHANNELS K1212_CHANNELS174#define K1212_FRAME_SIZE (sizeof(struct KorgAudioFrame))175#define K1212_MAX_SAMPLES (kPlayBufferFrames*kNumBuffers)176#define K1212_PERIODS (kNumBuffers)177#define K1212_PERIOD_BYTES (K1212_FRAME_SIZE*kPlayBufferFrames)178#define K1212_BUF_SIZE (K1212_PERIOD_BYTES*kNumBuffers)179#define K1212_ANALOG_BUF_SIZE (K1212_ANALOG_CHANNELS * 2 * kPlayBufferFrames * kNumBuffers)180#define K1212_SPDIF_BUF_SIZE (K1212_SPDIF_CHANNELS * 3 * kPlayBufferFrames * kNumBuffers)181#define K1212_ADAT_BUF_SIZE (K1212_ADAT_CHANNELS * 2 * kPlayBufferFrames * kNumBuffers)182#define K1212_MAX_BUF_SIZE (K1212_ANALOG_BUF_SIZE + K1212_ADAT_BUF_SIZE)183 184#define k1212MinADCSens 0x00185#define k1212MaxADCSens 0x7f186#define k1212MaxVolume 0x7fff187#define k1212MaxWaveVolume 0xffff188#define k1212MinVolume 0x0000189#define k1212MaxVolInverted 0x8000190 191// -----------------------------------------------------------------192// the following bits are used for controlling interrupts in the193// interrupt control/status reg194// -----------------------------------------------------------------195#define PCI_INT_ENABLE_BIT 0x00000100196#define PCI_DOORBELL_INT_ENABLE_BIT 0x00000200197#define LOCAL_INT_ENABLE_BIT 0x00010000198#define LOCAL_DOORBELL_INT_ENABLE_BIT 0x00020000199#define LOCAL_DMA1_INT_ENABLE_BIT 0x00080000200 201// -----------------------------------------------------------------202// the following bits are defined for the PCI command register203// -----------------------------------------------------------------204#define PCI_CMD_MEM_SPACE_ENABLE_BIT 0x0002205#define PCI_CMD_IO_SPACE_ENABLE_BIT 0x0001206#define PCI_CMD_BUS_MASTER_ENABLE_BIT 0x0004207 208// -----------------------------------------------------------------209// the following bits are defined for the PCI status register210// -----------------------------------------------------------------211#define PCI_STAT_PARITY_ERROR_BIT 0x8000212#define PCI_STAT_SYSTEM_ERROR_BIT 0x4000213#define PCI_STAT_MASTER_ABORT_RCVD_BIT 0x2000214#define PCI_STAT_TARGET_ABORT_RCVD_BIT 0x1000215#define PCI_STAT_TARGET_ABORT_SENT_BIT 0x0800216 217// ------------------------------------------------------------------------218// the following constants are used in setting the 1212 I/O card's input219// sensitivity.220// ------------------------------------------------------------------------221#define SET_SENS_LOCALINIT_BITPOS 15222#define SET_SENS_DATA_BITPOS 10223#define SET_SENS_CLOCK_BITPOS 8224#define SET_SENS_LOADSHIFT_BITPOS 0225 226#define SET_SENS_LEFTCHANID 0x00227#define SET_SENS_RIGHTCHANID 0x01228 229#define K1212SENSUPDATE_DELAY_IN_MS 50230 231// --------------------------------------------------------------------------232// WaitRTCTicks233//234// This function waits the specified number of real time clock ticks.235// According to the DDK, each tick is ~0.8 microseconds.236// The defines following the function declaration can be used for the237// numTicksToWait parameter.238// --------------------------------------------------------------------------239#define ONE_RTC_TICK 1240#define SENSCLKPULSE_WIDTH 4241#define LOADSHIFT_DELAY 4242#define INTERCOMMAND_DELAY 40243#define STOPCARD_DELAY 300 // max # RTC ticks for the card to stop once we write244 // the command register. (could be up to 180 us)245#define COMMAND_ACK_DELAY 13 // number of RTC ticks to wait for an acknowledgement246 // from the card after sending a command.247 248enum ClockSourceIndex {249 K1212_CLKIDX_AdatAt44_1K = 0, // selects source as ADAT at 44.1 kHz250 K1212_CLKIDX_AdatAt48K, // selects source as ADAT at 48 kHz251 K1212_CLKIDX_WordAt44_1K, // selects source as S/PDIF at 44.1 kHz252 K1212_CLKIDX_WordAt48K, // selects source as S/PDIF at 48 kHz253 K1212_CLKIDX_LocalAt44_1K, // selects source as local clock at 44.1 kHz254 K1212_CLKIDX_LocalAt48K, // selects source as local clock at 48 kHz255 K1212_CLKIDX_Invalid // used to check validity of the index256};257 258enum ClockSourceType {259 K1212_CLKIDX_Adat = 0, // selects source as ADAT260 K1212_CLKIDX_Word, // selects source as S/PDIF261 K1212_CLKIDX_Local // selects source as local clock262};263 264struct KorgAudioFrame {265 u16 frameData16[k16BitChannels]; /* channels 0-9 use 16 bit samples */266 u32 frameData32[k32BitChannels]; /* channels 10-11 use 32 bits - only 20 are sent across S/PDIF */267 u32 timeCodeVal; /* holds the ADAT timecode value */268};269 270struct KorgAudioBuffer {271 struct KorgAudioFrame bufferData[kPlayBufferFrames]; /* buffer definition */272};273 274struct KorgSharedBuffer {275#ifdef K1212_LARGEALLOC276 struct KorgAudioBuffer playDataBufs[kNumBuffers];277 struct KorgAudioBuffer recordDataBufs[kNumBuffers];278#endif279 short volumeData[kAudioChannels];280 u32 cardCommand;281 u16 routeData [kAudioChannels];282 u32 AdatTimeCode; // ADAT timecode value283};284 285struct SensBits {286 union {287 struct {288 unsigned int leftChanVal:8;289 unsigned int leftChanId:8;290 } v;291 u16 leftSensBits;292 } l;293 union {294 struct {295 unsigned int rightChanVal:8;296 unsigned int rightChanId:8;297 } v;298 u16 rightSensBits;299 } r;300};301 302struct snd_korg1212 {303 struct snd_card *card;304 struct pci_dev *pci;305 struct snd_pcm *pcm;306 int irq;307 308 spinlock_t lock;309 struct mutex open_mutex;310 311 struct timer_list timer; /* timer callback for checking ack of stop request */312 int stop_pending_cnt; /* counter for stop pending check */313 314 wait_queue_head_t wait;315 316 unsigned long iomem;317 unsigned long ioport;318 unsigned long iomem2;319 unsigned long irqcount;320 unsigned long inIRQ;321 void __iomem *iobase;322 323 struct snd_dma_buffer *dma_dsp;324 struct snd_dma_buffer *dma_play;325 struct snd_dma_buffer *dma_rec;326 struct snd_dma_buffer *dma_shared;327 328 u32 DataBufsSize;329 330 struct KorgAudioBuffer * playDataBufsPtr;331 struct KorgAudioBuffer * recordDataBufsPtr;332 333 struct KorgSharedBuffer * sharedBufferPtr;334 335 u32 RecDataPhy;336 u32 PlayDataPhy;337 unsigned long sharedBufferPhy;338 u32 VolumeTablePhy;339 u32 RoutingTablePhy;340 u32 AdatTimeCodePhy;341 342 u32 __iomem * statusRegPtr; // address of the interrupt status/control register343 u32 __iomem * outDoorbellPtr; // address of the host->card doorbell register344 u32 __iomem * inDoorbellPtr; // address of the card->host doorbell register345 u32 __iomem * mailbox0Ptr; // address of mailbox 0 on the card346 u32 __iomem * mailbox1Ptr; // address of mailbox 1 on the card347 u32 __iomem * mailbox2Ptr; // address of mailbox 2 on the card348 u32 __iomem * mailbox3Ptr; // address of mailbox 3 on the card349 u32 __iomem * controlRegPtr; // address of the EEPROM, PCI, I/O, Init ctrl reg350 u16 __iomem * sensRegPtr; // address of the sensitivity setting register351 u32 __iomem * idRegPtr; // address of the device and vendor ID registers352 353 size_t periodsize;354 int channels;355 int currentBuffer;356 357 struct snd_pcm_substream *playback_substream;358 struct snd_pcm_substream *capture_substream;359 360 pid_t capture_pid;361 pid_t playback_pid;362 363 enum CardState cardState;364 int running;365 int idleMonitorOn; // indicates whether the card is in idle monitor mode.366 u32 cmdRetryCount; // tracks how many times we have retried sending to the card.367 368 enum ClockSourceIndex clkSrcRate; // sample rate and clock source369 370 enum ClockSourceType clkSource; // clock source371 int clkRate; // clock rate372 373 int volumePhase[kAudioChannels];374 375 u16 leftADCInSens; // ADC left channel input sensitivity376 u16 rightADCInSens; // ADC right channel input sensitivity377 378 int opencnt; // Open/Close count379 int setcnt; // SetupForPlay count380 int playcnt; // TriggerPlay count381 int errorcnt; // Error Count382 unsigned long totalerrorcnt; // Total Error Count383 384 int dsp_is_loaded;385 int dsp_stop_is_processed;386 387};388 389MODULE_DESCRIPTION("korg1212");390MODULE_LICENSE("GPL");391MODULE_FIRMWARE("korg/k1212.dsp");392 393static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */394static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */395static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE; /* Enable this card */396 397module_param_array(index, int, NULL, 0444);398MODULE_PARM_DESC(index, "Index value for Korg 1212 soundcard.");399module_param_array(id, charp, NULL, 0444);400MODULE_PARM_DESC(id, "ID string for Korg 1212 soundcard.");401module_param_array(enable, bool, NULL, 0444);402MODULE_PARM_DESC(enable, "Enable Korg 1212 soundcard.");403MODULE_AUTHOR("Haroldo Gamal <gamal@alternex.com.br>");404 405static const struct pci_device_id snd_korg1212_ids[] = {406 {407 .vendor = 0x10b5,408 .device = 0x906d,409 .subvendor = PCI_ANY_ID,410 .subdevice = PCI_ANY_ID,411 },412 { 0, },413};414 415MODULE_DEVICE_TABLE(pci, snd_korg1212_ids);416 417static const char * const stateName[] = {418 "Non-existent",419 "Uninitialized",420 "DSP download in process",421 "DSP download complete",422 "Ready",423 "Open",424 "Setup for play",425 "Playing",426 "Monitor mode on",427 "Calibrating",428 "Invalid"429};430 431static const char * const clockSourceTypeName[] = { "ADAT", "S/PDIF", "local" };432 433static const char * const clockSourceName[] = {434 "ADAT at 44.1 kHz",435 "ADAT at 48 kHz",436 "S/PDIF at 44.1 kHz",437 "S/PDIF at 48 kHz",438 "local clock at 44.1 kHz",439 "local clock at 48 kHz"440};441 442static const char * const channelName[] = {443 "ADAT-1",444 "ADAT-2",445 "ADAT-3",446 "ADAT-4",447 "ADAT-5",448 "ADAT-6",449 "ADAT-7",450 "ADAT-8",451 "Analog-L",452 "Analog-R",453 "SPDIF-L",454 "SPDIF-R",455};456 457static const u16 ClockSourceSelector[] = {458 0x8000, // selects source as ADAT at 44.1 kHz459 0x0000, // selects source as ADAT at 48 kHz460 0x8001, // selects source as S/PDIF at 44.1 kHz461 0x0001, // selects source as S/PDIF at 48 kHz462 0x8002, // selects source as local clock at 44.1 kHz463 0x0002 // selects source as local clock at 48 kHz464};465 466union swap_u32 { unsigned char c[4]; u32 i; };467 468#ifdef SNDRV_BIG_ENDIAN469static u32 LowerWordSwap(u32 swappee)470#else471static u32 UpperWordSwap(u32 swappee)472#endif473{474 union swap_u32 retVal, swapper;475 476 swapper.i = swappee;477 retVal.c[2] = swapper.c[3];478 retVal.c[3] = swapper.c[2];479 retVal.c[1] = swapper.c[1];480 retVal.c[0] = swapper.c[0];481 482 return retVal.i;483}484 485#ifdef SNDRV_BIG_ENDIAN486static u32 UpperWordSwap(u32 swappee)487#else488static u32 LowerWordSwap(u32 swappee)489#endif490{491 union swap_u32 retVal, swapper;492 493 swapper.i = swappee;494 retVal.c[2] = swapper.c[2];495 retVal.c[3] = swapper.c[3];496 retVal.c[1] = swapper.c[0];497 retVal.c[0] = swapper.c[1];498 499 return retVal.i;500}501 502#define SetBitInWord(theWord,bitPosition) (*theWord) |= (0x0001 << bitPosition)503#define SetBitInDWord(theWord,bitPosition) (*theWord) |= (0x00000001 << bitPosition)504#define ClearBitInWord(theWord,bitPosition) (*theWord) &= ~(0x0001 << bitPosition)505#define ClearBitInDWord(theWord,bitPosition) (*theWord) &= ~(0x00000001 << bitPosition)506 507static int snd_korg1212_Send1212Command(struct snd_korg1212 *korg1212,508 enum korg1212_dbcnst doorbellVal,509 u32 mailBox0Val, u32 mailBox1Val,510 u32 mailBox2Val, u32 mailBox3Val)511{512 u32 retryCount;513 u16 mailBox3Lo;514 int rc = K1212_CMDRET_Success;515 516 if (!korg1212->outDoorbellPtr) {517 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: CardUninitialized\n");518 return K1212_CMDRET_CardUninitialized;519 }520 521 K1212_DEBUG_PRINTK("K1212_DEBUG: Card <- 0x%08x 0x%08x [%s]\n",522 doorbellVal, mailBox0Val, stateName[korg1212->cardState]);523 for (retryCount = 0; retryCount < MAX_COMMAND_RETRIES; retryCount++) {524 writel(mailBox3Val, korg1212->mailbox3Ptr);525 writel(mailBox2Val, korg1212->mailbox2Ptr);526 writel(mailBox1Val, korg1212->mailbox1Ptr);527 writel(mailBox0Val, korg1212->mailbox0Ptr);528 writel(doorbellVal, korg1212->outDoorbellPtr); // interrupt the card529 530 // --------------------------------------------------------------531 // the reboot command will not give an acknowledgement.532 // --------------------------------------------------------------533 if ( doorbellVal == K1212_DB_RebootCard ||534 doorbellVal == K1212_DB_BootFromDSPPage4 ||535 doorbellVal == K1212_DB_StartDSPDownload ) {536 rc = K1212_CMDRET_Success;537 break;538 }539 540 // --------------------------------------------------------------541 // See if the card acknowledged the command. Wait a bit, then542 // read in the low word of mailbox3. If the MSB is set and the543 // low byte is equal to the doorbell value, then it ack'd.544 // --------------------------------------------------------------545 udelay(COMMAND_ACK_DELAY);546 mailBox3Lo = readl(korg1212->mailbox3Ptr);547 if (mailBox3Lo & COMMAND_ACK_MASK) {548 if ((mailBox3Lo & DOORBELL_VAL_MASK) == (doorbellVal & DOORBELL_VAL_MASK)) {549 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: Card <- Success\n");550 rc = K1212_CMDRET_Success;551 break;552 }553 }554 }555 korg1212->cmdRetryCount += retryCount;556 557 if (retryCount >= MAX_COMMAND_RETRIES) {558 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: Card <- NoAckFromCard\n");559 rc = K1212_CMDRET_NoAckFromCard;560 }561 562 return rc;563}564 565/* spinlock already held */566static void snd_korg1212_SendStop(struct snd_korg1212 *korg1212)567{568 if (! korg1212->stop_pending_cnt) {569 korg1212->sharedBufferPtr->cardCommand = 0xffffffff;570 /* program the timer */571 korg1212->stop_pending_cnt = HZ;572 mod_timer(&korg1212->timer, jiffies + 1);573 }574}575 576static void snd_korg1212_SendStopAndWait(struct snd_korg1212 *korg1212)577{578 unsigned long flags;579 spin_lock_irqsave(&korg1212->lock, flags);580 korg1212->dsp_stop_is_processed = 0;581 snd_korg1212_SendStop(korg1212);582 spin_unlock_irqrestore(&korg1212->lock, flags);583 wait_event_timeout(korg1212->wait, korg1212->dsp_stop_is_processed, (HZ * 3) / 2);584}585 586/* timer callback for checking the ack of stop request */587static void snd_korg1212_timer_func(struct timer_list *t)588{589 struct snd_korg1212 *korg1212 = from_timer(korg1212, t, timer);590 unsigned long flags;591 592 spin_lock_irqsave(&korg1212->lock, flags);593 if (korg1212->sharedBufferPtr->cardCommand == 0) {594 /* ack'ed */595 korg1212->stop_pending_cnt = 0;596 korg1212->dsp_stop_is_processed = 1;597 wake_up(&korg1212->wait);598 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: Stop ack'ed [%s]\n",599 stateName[korg1212->cardState]);600 } else {601 if (--korg1212->stop_pending_cnt > 0) {602 /* reprogram timer */603 mod_timer(&korg1212->timer, jiffies + 1);604 } else {605 dev_dbg(korg1212->card->dev, "korg1212_timer_func timeout\n");606 korg1212->sharedBufferPtr->cardCommand = 0;607 korg1212->dsp_stop_is_processed = 1;608 wake_up(&korg1212->wait);609 K1212_DEBUG_PRINTK("K1212_DEBUG: Stop timeout [%s]\n",610 stateName[korg1212->cardState]);611 }612 }613 spin_unlock_irqrestore(&korg1212->lock, flags);614}615 616static int snd_korg1212_TurnOnIdleMonitor(struct snd_korg1212 *korg1212)617{618 unsigned long flags;619 int rc;620 621 udelay(INTERCOMMAND_DELAY);622 spin_lock_irqsave(&korg1212->lock, flags);623 korg1212->idleMonitorOn = 1;624 rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode,625 K1212_MODE_MonitorOn, 0, 0, 0);626 spin_unlock_irqrestore(&korg1212->lock, flags);627 return rc;628}629 630static void snd_korg1212_TurnOffIdleMonitor(struct snd_korg1212 *korg1212)631{632 if (korg1212->idleMonitorOn) {633 snd_korg1212_SendStopAndWait(korg1212);634 korg1212->idleMonitorOn = 0;635 }636}637 638static inline void snd_korg1212_setCardState(struct snd_korg1212 * korg1212, enum CardState csState)639{640 korg1212->cardState = csState;641}642 643static int snd_korg1212_OpenCard(struct snd_korg1212 * korg1212)644{645 K1212_DEBUG_PRINTK("K1212_DEBUG: OpenCard [%s] %d\n",646 stateName[korg1212->cardState], korg1212->opencnt);647 mutex_lock(&korg1212->open_mutex);648 if (korg1212->opencnt++ == 0) {649 snd_korg1212_TurnOffIdleMonitor(korg1212);650 snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);651 }652 653 mutex_unlock(&korg1212->open_mutex);654 return 1;655}656 657static int snd_korg1212_CloseCard(struct snd_korg1212 * korg1212)658{659 K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard [%s] %d\n",660 stateName[korg1212->cardState], korg1212->opencnt);661 662 mutex_lock(&korg1212->open_mutex);663 if (--(korg1212->opencnt)) {664 mutex_unlock(&korg1212->open_mutex);665 return 0;666 }667 668 if (korg1212->cardState == K1212_STATE_SETUP) {669 int rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode,670 K1212_MODE_StopPlay, 0, 0, 0);671 if (rc)672 K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard - RC = %d [%s]\n",673 rc, stateName[korg1212->cardState]);674 if (rc != K1212_CMDRET_Success) {675 mutex_unlock(&korg1212->open_mutex);676 return 0;677 }678 } else if (korg1212->cardState > K1212_STATE_SETUP) {679 snd_korg1212_SendStopAndWait(korg1212);680 }681 682 if (korg1212->cardState > K1212_STATE_READY) {683 snd_korg1212_TurnOnIdleMonitor(korg1212);684 snd_korg1212_setCardState(korg1212, K1212_STATE_READY);685 }686 687 mutex_unlock(&korg1212->open_mutex);688 return 0;689}690 691/* spinlock already held */692static int snd_korg1212_SetupForPlay(struct snd_korg1212 * korg1212)693{694 int rc;695 696 K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay [%s] %d\n",697 stateName[korg1212->cardState], korg1212->setcnt);698 699 if (korg1212->setcnt++)700 return 0;701 702 snd_korg1212_setCardState(korg1212, K1212_STATE_SETUP);703 rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode,704 K1212_MODE_SetupPlay, 0, 0, 0);705 if (rc)706 K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay - RC = %d [%s]\n",707 rc, stateName[korg1212->cardState]);708 if (rc != K1212_CMDRET_Success) {709 return 1;710 }711 return 0;712}713 714/* spinlock already held */715static int snd_korg1212_TriggerPlay(struct snd_korg1212 * korg1212)716{717 int rc;718 719 K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay [%s] %d\n",720 stateName[korg1212->cardState], korg1212->playcnt);721 722 if (korg1212->playcnt++)723 return 0;724 725 snd_korg1212_setCardState(korg1212, K1212_STATE_PLAYING);726 rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_TriggerPlay, 0, 0, 0, 0);727 if (rc)728 K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay - RC = %d [%s]\n",729 rc, stateName[korg1212->cardState]);730 if (rc != K1212_CMDRET_Success) {731 return 1;732 }733 return 0;734}735 736/* spinlock already held */737static int snd_korg1212_StopPlay(struct snd_korg1212 * korg1212)738{739 K1212_DEBUG_PRINTK("K1212_DEBUG: StopPlay [%s] %d\n",740 stateName[korg1212->cardState], korg1212->playcnt);741 742 if (--(korg1212->playcnt)) 743 return 0;744 745 korg1212->setcnt = 0;746 747 if (korg1212->cardState != K1212_STATE_ERRORSTOP)748 snd_korg1212_SendStop(korg1212);749 750 snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);751 return 0;752}753 754static void snd_korg1212_EnableCardInterrupts(struct snd_korg1212 * korg1212)755{756 writel(PCI_INT_ENABLE_BIT |757 PCI_DOORBELL_INT_ENABLE_BIT |758 LOCAL_INT_ENABLE_BIT |759 LOCAL_DOORBELL_INT_ENABLE_BIT |760 LOCAL_DMA1_INT_ENABLE_BIT,761 korg1212->statusRegPtr);762}763 764#if 0 /* not used */765 766static int snd_korg1212_SetMonitorMode(struct snd_korg1212 *korg1212,767 enum MonitorModeSelector mode)768{769 K1212_DEBUG_PRINTK("K1212_DEBUG: SetMonitorMode [%s]\n",770 stateName[korg1212->cardState]);771 772 switch (mode) {773 case K1212_MONMODE_Off:774 if (korg1212->cardState != K1212_STATE_MONITOR)775 return 0;776 else {777 snd_korg1212_SendStopAndWait(korg1212);778 snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);779 }780 break;781 782 case K1212_MONMODE_On:783 if (korg1212->cardState != K1212_STATE_OPEN)784 return 0;785 else {786 int rc;787 snd_korg1212_setCardState(korg1212, K1212_STATE_MONITOR);788 rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode,789 K1212_MODE_MonitorOn, 0, 0, 0);790 if (rc != K1212_CMDRET_Success)791 return 0;792 }793 break;794 795 default:796 return 0;797 }798 799 return 1;800}801 802#endif /* not used */803 804static inline int snd_korg1212_use_is_exclusive(struct snd_korg1212 *korg1212)805{806 if (korg1212->playback_pid != korg1212->capture_pid &&807 korg1212->playback_pid >= 0 && korg1212->capture_pid >= 0)808 return 0;809 810 return 1;811}812 813static int snd_korg1212_SetRate(struct snd_korg1212 *korg1212, int rate)814{815 static const enum ClockSourceIndex s44[] = {816 K1212_CLKIDX_AdatAt44_1K,817 K1212_CLKIDX_WordAt44_1K,818 K1212_CLKIDX_LocalAt44_1K819 };820 static const enum ClockSourceIndex s48[] = {821 K1212_CLKIDX_AdatAt48K,822 K1212_CLKIDX_WordAt48K,823 K1212_CLKIDX_LocalAt48K824 };825 int parm, rc;826 827 if (!snd_korg1212_use_is_exclusive (korg1212))828 return -EBUSY;829 830 switch (rate) {831 case 44100:832 parm = s44[korg1212->clkSource];833 break;834 835 case 48000:836 parm = s48[korg1212->clkSource];837 break;838 839 default:840 return -EINVAL;841 }842 843 korg1212->clkSrcRate = parm;844 korg1212->clkRate = rate;845 846 udelay(INTERCOMMAND_DELAY);847 rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SetClockSourceRate,848 ClockSourceSelector[korg1212->clkSrcRate],849 0, 0, 0);850 if (rc)851 K1212_DEBUG_PRINTK("K1212_DEBUG: Set Clock Source Selector - RC = %d [%s]\n",852 rc, stateName[korg1212->cardState]);853 854 return 0;855}856 857static int snd_korg1212_SetClockSource(struct snd_korg1212 *korg1212, int source)858{859 860 if (source < 0 || source > 2)861 return -EINVAL;862 863 korg1212->clkSource = source;864 865 snd_korg1212_SetRate(korg1212, korg1212->clkRate);866 867 return 0;868}869 870static void snd_korg1212_DisableCardInterrupts(struct snd_korg1212 *korg1212)871{872 writel(0, korg1212->statusRegPtr);873}874 875static int snd_korg1212_WriteADCSensitivity(struct snd_korg1212 *korg1212)876{877 struct SensBits sensVals;878 int bitPosition;879 int channel;880 int clkIs48K;881 int monModeSet;882 u16 controlValue; // this keeps the current value to be written to883 // the card's eeprom control register.884 u16 count;885 unsigned long flags;886 887 K1212_DEBUG_PRINTK("K1212_DEBUG: WriteADCSensivity [%s]\n",888 stateName[korg1212->cardState]);889 890 // ----------------------------------------------------------------------------891 // initialize things. The local init bit is always set when writing to the892 // card's control register.893 // ----------------------------------------------------------------------------894 controlValue = 0;895 SetBitInWord(&controlValue, SET_SENS_LOCALINIT_BITPOS); // init the control value896 897 // ----------------------------------------------------------------------------898 // make sure the card is not in monitor mode when we do this update.899 // ----------------------------------------------------------------------------900 if (korg1212->cardState == K1212_STATE_MONITOR || korg1212->idleMonitorOn) {901 monModeSet = 1;902 snd_korg1212_SendStopAndWait(korg1212);903 } else904 monModeSet = 0;905 906 spin_lock_irqsave(&korg1212->lock, flags);907 908 // ----------------------------------------------------------------------------909 // we are about to send new values to the card, so clear the new values queued910 // flag. Also, clear out mailbox 3, so we don't lockup.911 // ----------------------------------------------------------------------------912 writel(0, korg1212->mailbox3Ptr);913 udelay(LOADSHIFT_DELAY);914 915 // ----------------------------------------------------------------------------916 // determine whether we are running a 48K or 44.1K clock. This info is used917 // later when setting the SPDIF FF after the volume has been shifted in.918 // ----------------------------------------------------------------------------919 switch (korg1212->clkSrcRate) {920 case K1212_CLKIDX_AdatAt44_1K:921 case K1212_CLKIDX_WordAt44_1K:922 case K1212_CLKIDX_LocalAt44_1K:923 clkIs48K = 0;924 break;925 926 case K1212_CLKIDX_WordAt48K:927 case K1212_CLKIDX_AdatAt48K:928 case K1212_CLKIDX_LocalAt48K:929 default:930 clkIs48K = 1;931 break;932 }933 934 // ----------------------------------------------------------------------------935 // start the update. Setup the bit structure and then shift the bits.936 // ----------------------------------------------------------------------------937 sensVals.l.v.leftChanId = SET_SENS_LEFTCHANID;938 sensVals.r.v.rightChanId = SET_SENS_RIGHTCHANID;939 sensVals.l.v.leftChanVal = korg1212->leftADCInSens;940 sensVals.r.v.rightChanVal = korg1212->rightADCInSens;941 942 // ----------------------------------------------------------------------------943 // now start shifting the bits in. Start with the left channel then the right.944 // ----------------------------------------------------------------------------945 for (channel = 0; channel < 2; channel++) {946 947 // ----------------------------------------------------------------------------948 // Bring the load/shift line low, then wait - the spec says >150ns from load/949 // shift low to the first rising edge of the clock.950 // ----------------------------------------------------------------------------951 ClearBitInWord(&controlValue, SET_SENS_LOADSHIFT_BITPOS);952 ClearBitInWord(&controlValue, SET_SENS_DATA_BITPOS);953 writew(controlValue, korg1212->sensRegPtr); // load/shift goes low954 udelay(LOADSHIFT_DELAY);955 956 for (bitPosition = 15; bitPosition >= 0; bitPosition--) { // for all the bits957 if (channel == 0) {958 if (sensVals.l.leftSensBits & (0x0001 << bitPosition))959 SetBitInWord(&controlValue, SET_SENS_DATA_BITPOS); // data bit set high960 else961 ClearBitInWord(&controlValue, SET_SENS_DATA_BITPOS); // data bit set low962 } else {963 if (sensVals.r.rightSensBits & (0x0001 << bitPosition))964 SetBitInWord(&controlValue, SET_SENS_DATA_BITPOS); // data bit set high965 else966 ClearBitInWord(&controlValue, SET_SENS_DATA_BITPOS); // data bit set low967 }968 969 ClearBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);970 writew(controlValue, korg1212->sensRegPtr); // clock goes low971 udelay(SENSCLKPULSE_WIDTH);972 SetBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);973 writew(controlValue, korg1212->sensRegPtr); // clock goes high974 udelay(SENSCLKPULSE_WIDTH);975 }976 977 // ----------------------------------------------------------------------------978 // finish up SPDIF for left. Bring the load/shift line high, then write a one979 // bit if the clock rate is 48K otherwise write 0.980 // ----------------------------------------------------------------------------981 ClearBitInWord(&controlValue, SET_SENS_DATA_BITPOS);982 ClearBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);983 SetBitInWord(&controlValue, SET_SENS_LOADSHIFT_BITPOS);984 writew(controlValue, korg1212->sensRegPtr); // load shift goes high - clk low985 udelay(SENSCLKPULSE_WIDTH);986 987 if (clkIs48K)988 SetBitInWord(&controlValue, SET_SENS_DATA_BITPOS);989 990 writew(controlValue, korg1212->sensRegPtr); // set/clear data bit991 udelay(ONE_RTC_TICK);992 SetBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);993 writew(controlValue, korg1212->sensRegPtr); // clock goes high994 udelay(SENSCLKPULSE_WIDTH);995 ClearBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);996 writew(controlValue, korg1212->sensRegPtr); // clock goes low997 udelay(SENSCLKPULSE_WIDTH);998 }999 1000 // ----------------------------------------------------------------------------1001 // The update is complete. Set a timeout. This is the inter-update delay.1002 // Also, if the card was in monitor mode, restore it.1003 // ----------------------------------------------------------------------------1004 for (count = 0; count < 10; count++)1005 udelay(SENSCLKPULSE_WIDTH);1006 1007 if (monModeSet) {1008 int rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode,1009 K1212_MODE_MonitorOn, 0, 0, 0);1010 if (rc)1011 K1212_DEBUG_PRINTK("K1212_DEBUG: WriteADCSensivity - RC = %d [%s]\n",1012 rc, stateName[korg1212->cardState]);1013 }1014 1015 spin_unlock_irqrestore(&korg1212->lock, flags);1016 1017 return 1;1018}1019 1020static void snd_korg1212_OnDSPDownloadComplete(struct snd_korg1212 *korg1212)1021{1022 int channel, rc;1023 1024 K1212_DEBUG_PRINTK("K1212_DEBUG: DSP download is complete. [%s]\n",1025 stateName[korg1212->cardState]);1026 1027 // ----------------------------------------------------1028 // tell the card to boot1029 // ----------------------------------------------------1030 rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_BootFromDSPPage4, 0, 0, 0, 0);1031 1032 if (rc)1033 K1212_DEBUG_PRINTK("K1212_DEBUG: Boot from Page 4 - RC = %d [%s]\n",1034 rc, stateName[korg1212->cardState]);1035 msleep(DSP_BOOT_DELAY_IN_MS);1036 1037 // --------------------------------------------------------------------------------1038 // Let the card know where all the buffers are.1039 // --------------------------------------------------------------------------------1040 rc = snd_korg1212_Send1212Command(korg1212,1041 K1212_DB_ConfigureBufferMemory,1042 LowerWordSwap(korg1212->PlayDataPhy),1043 LowerWordSwap(korg1212->RecDataPhy),1044 ((kNumBuffers * kPlayBufferFrames) / 2), // size given to the card1045 // is based on 2 buffers1046 01047 );1048 1049 if (rc)1050 K1212_DEBUG_PRINTK("K1212_DEBUG: Configure Buffer Memory - RC = %d [%s]\n",1051 rc, stateName[korg1212->cardState]);1052 1053 udelay(INTERCOMMAND_DELAY);1054 1055 rc = snd_korg1212_Send1212Command(korg1212,1056 K1212_DB_ConfigureMiscMemory,1057 LowerWordSwap(korg1212->VolumeTablePhy),1058 LowerWordSwap(korg1212->RoutingTablePhy),1059 LowerWordSwap(korg1212->AdatTimeCodePhy),1060 01061 );1062 1063 if (rc)1064 K1212_DEBUG_PRINTK("K1212_DEBUG: Configure Misc Memory - RC = %d [%s]\n",1065 rc, stateName[korg1212->cardState]);1066 1067 // --------------------------------------------------------------------------------1068 // Initialize the routing and volume tables, then update the card's state.1069 // --------------------------------------------------------------------------------1070 udelay(INTERCOMMAND_DELAY);1071 1072 for (channel = 0; channel < kAudioChannels; channel++) {1073 korg1212->sharedBufferPtr->volumeData[channel] = k1212MaxVolume;1074 //korg1212->sharedBufferPtr->routeData[channel] = channel;1075 korg1212->sharedBufferPtr->routeData[channel] = 8 + (channel & 1);1076 }1077 1078 snd_korg1212_WriteADCSensitivity(korg1212);1079 1080 udelay(INTERCOMMAND_DELAY);1081 rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SetClockSourceRate,1082 ClockSourceSelector[korg1212->clkSrcRate],1083 0, 0, 0);1084 if (rc)1085 K1212_DEBUG_PRINTK("K1212_DEBUG: Set Clock Source Selector - RC = %d [%s]\n",1086 rc, stateName[korg1212->cardState]);1087 1088 rc = snd_korg1212_TurnOnIdleMonitor(korg1212);1089 snd_korg1212_setCardState(korg1212, K1212_STATE_READY);1090 1091 if (rc)1092 K1212_DEBUG_PRINTK("K1212_DEBUG: Set Monitor On - RC = %d [%s]\n",1093 rc, stateName[korg1212->cardState]);1094 1095 snd_korg1212_setCardState(korg1212, K1212_STATE_DSP_COMPLETE);1096}1097 1098static irqreturn_t snd_korg1212_interrupt(int irq, void *dev_id)1099{1100 u32 doorbellValue;1101 struct snd_korg1212 *korg1212 = dev_id;1102 1103 doorbellValue = readl(korg1212->inDoorbellPtr);1104 1105 if (!doorbellValue)1106 return IRQ_NONE;1107 1108 spin_lock(&korg1212->lock);1109 1110 writel(doorbellValue, korg1212->inDoorbellPtr);1111 1112 korg1212->irqcount++;1113 1114 korg1212->inIRQ++;1115 1116 switch (doorbellValue) {1117 case K1212_DB_DSPDownloadDone:1118 K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ DNLD count - %ld, %x, [%s].\n",1119 korg1212->irqcount, doorbellValue,1120 stateName[korg1212->cardState]);1121 if (korg1212->cardState == K1212_STATE_DSP_IN_PROCESS) {1122 korg1212->dsp_is_loaded = 1;1123 wake_up(&korg1212->wait);1124 }1125 break;1126 1127 // ------------------------------------------------------------------------1128 // an error occurred - stop the card1129 // ------------------------------------------------------------------------1130 case K1212_DB_DMAERROR:1131 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: IRQ DMAE count - %ld, %x, [%s].\n",1132 korg1212->irqcount, doorbellValue,1133 stateName[korg1212->cardState]);1134 dev_err(korg1212->card->dev, "korg1212: DMA Error\n");1135 korg1212->errorcnt++;1136 korg1212->totalerrorcnt++;1137 korg1212->sharedBufferPtr->cardCommand = 0;1138 snd_korg1212_setCardState(korg1212, K1212_STATE_ERRORSTOP);1139 break;1140 1141 // ------------------------------------------------------------------------1142 // the card has stopped by our request. Clear the command word and signal1143 // the semaphore in case someone is waiting for this.1144 // ------------------------------------------------------------------------1145 case K1212_DB_CARDSTOPPED:1146 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: IRQ CSTP count - %ld, %x, [%s].\n",1147 korg1212->irqcount, doorbellValue,1148 stateName[korg1212->cardState]);1149 korg1212->sharedBufferPtr->cardCommand = 0;1150 break;1151 1152 default:1153 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: IRQ DFLT count - %ld, %x, cpos=%d [%s].\n",1154 korg1212->irqcount, doorbellValue, 1155 korg1212->currentBuffer, stateName[korg1212->cardState]);1156 if ((korg1212->cardState > K1212_STATE_SETUP) || korg1212->idleMonitorOn) {1157 korg1212->currentBuffer++;1158 1159 if (korg1212->currentBuffer >= kNumBuffers)1160 korg1212->currentBuffer = 0;1161 1162 if (!korg1212->running)1163 break;1164 1165 if (korg1212->capture_substream) {1166 spin_unlock(&korg1212->lock);1167 snd_pcm_period_elapsed(korg1212->capture_substream);1168 spin_lock(&korg1212->lock);1169 }1170 1171 if (korg1212->playback_substream) {1172 spin_unlock(&korg1212->lock);1173 snd_pcm_period_elapsed(korg1212->playback_substream);1174 spin_lock(&korg1212->lock);1175 }1176 }1177 break;1178 }1179 1180 korg1212->inIRQ--;1181 1182 spin_unlock(&korg1212->lock);1183 1184 return IRQ_HANDLED;1185}1186 1187static int snd_korg1212_downloadDSPCode(struct snd_korg1212 *korg1212)1188{1189 int rc;1190 1191 K1212_DEBUG_PRINTK("K1212_DEBUG: DSP download is starting... [%s]\n",1192 stateName[korg1212->cardState]);1193 1194 // ---------------------------------------------------------------1195 // verify the state of the card before proceeding.1196 // ---------------------------------------------------------------1197 if (korg1212->cardState >= K1212_STATE_DSP_IN_PROCESS)1198 return 1;1199 1200 snd_korg1212_setCardState(korg1212, K1212_STATE_DSP_IN_PROCESS);1201 1202 rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_StartDSPDownload,1203 UpperWordSwap(korg1212->dma_dsp->addr),1204 0, 0, 0);1205 if (rc)1206 K1212_DEBUG_PRINTK("K1212_DEBUG: Start DSP Download RC = %d [%s]\n",1207 rc, stateName[korg1212->cardState]);1208 1209 korg1212->dsp_is_loaded = 0;1210 wait_event_timeout(korg1212->wait, korg1212->dsp_is_loaded, HZ * CARD_BOOT_TIMEOUT);1211 if (! korg1212->dsp_is_loaded )1212 return -EBUSY; /* timeout */1213 1214 snd_korg1212_OnDSPDownloadComplete(korg1212);1215 1216 return 0;1217}1218 1219static const struct snd_pcm_hardware snd_korg1212_playback_info =1220{1221 .info = (SNDRV_PCM_INFO_MMAP |1222 SNDRV_PCM_INFO_MMAP_VALID |1223 SNDRV_PCM_INFO_INTERLEAVED |1224 SNDRV_PCM_INFO_BATCH),1225 .formats = SNDRV_PCM_FMTBIT_S16_LE,1226 .rates = (SNDRV_PCM_RATE_44100 |1227 SNDRV_PCM_RATE_48000),1228 .rate_min = 44100,1229 .rate_max = 48000,1230 .channels_min = K1212_MIN_CHANNELS,1231 .channels_max = K1212_MAX_CHANNELS,1232 .buffer_bytes_max = K1212_MAX_BUF_SIZE,1233 .period_bytes_min = K1212_MIN_CHANNELS * 2 * kPlayBufferFrames,1234 .period_bytes_max = K1212_MAX_CHANNELS * 2 * kPlayBufferFrames,1235 .periods_min = K1212_PERIODS,1236 .periods_max = K1212_PERIODS,1237 .fifo_size = 0,1238};1239 1240static const struct snd_pcm_hardware snd_korg1212_capture_info =1241{1242 .info = (SNDRV_PCM_INFO_MMAP |1243 SNDRV_PCM_INFO_MMAP_VALID |1244 SNDRV_PCM_INFO_INTERLEAVED |1245 SNDRV_PCM_INFO_BATCH),1246 .formats = SNDRV_PCM_FMTBIT_S16_LE,1247 .rates = (SNDRV_PCM_RATE_44100 |1248 SNDRV_PCM_RATE_48000),1249 .rate_min = 44100,1250 .rate_max = 48000,1251 .channels_min = K1212_MIN_CHANNELS,1252 .channels_max = K1212_MAX_CHANNELS,1253 .buffer_bytes_max = K1212_MAX_BUF_SIZE,1254 .period_bytes_min = K1212_MIN_CHANNELS * 2 * kPlayBufferFrames,1255 .period_bytes_max = K1212_MAX_CHANNELS * 2 * kPlayBufferFrames,1256 .periods_min = K1212_PERIODS,1257 .periods_max = K1212_PERIODS,1258 .fifo_size = 0,1259};1260 1261static int snd_korg1212_silence(struct snd_korg1212 *korg1212, int pos, int count, int offset, int size)1262{1263 struct KorgAudioFrame * dst = korg1212->playDataBufsPtr[0].bufferData + pos;1264 int i;1265 1266 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_silence pos=%d offset=%d size=%d count=%d\n",1267 pos, offset, size, count);1268 if (snd_BUG_ON(pos + count > K1212_MAX_SAMPLES))1269 return -EINVAL;1270 1271 for (i=0; i < count; i++) {1272#if K1212_DEBUG_LEVEL > 01273 if ( (void *) dst < (void *) korg1212->playDataBufsPtr ||1274 (void *) dst > (void *) korg1212->playDataBufsPtr[8].bufferData ) {1275 pr_debug("K1212_DEBUG: %s KERNEL EFAULT dst=%p iter=%d\n",1276 __func__, dst, i);1277 return -EFAULT;1278 }1279#endif1280 memset((void*) dst + offset, 0, size);1281 dst++;1282 }1283 1284 return 0;1285}1286 1287static int snd_korg1212_copy_to(struct snd_pcm_substream *substream,1288 struct iov_iter *dst, int pos, int count)1289{1290 struct snd_pcm_runtime *runtime = substream->runtime;1291 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);1292 struct KorgAudioFrame *src;1293 int i, size;1294 1295 pos = bytes_to_frames(runtime, pos);1296 count = bytes_to_frames(runtime, count);1297 size = korg1212->channels * 2;1298 src = korg1212->recordDataBufsPtr[0].bufferData + pos;1299 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_copy_to pos=%d size=%d count=%d\n",1300 pos, size, count);1301 if (snd_BUG_ON(pos + count > K1212_MAX_SAMPLES))1302 return -EINVAL;1303 1304 for (i=0; i < count; i++) {1305#if K1212_DEBUG_LEVEL > 01306 if ( (void *) src < (void *) korg1212->recordDataBufsPtr ||1307 (void *) src > (void *) korg1212->recordDataBufsPtr[8].bufferData ) {1308 pr_debug("K1212_DEBUG: %s KERNEL EFAULT, src=%p dst=%p iter=%d\n",1309 __func__, src, dst->kvec.iov_base, i);1310 return -EFAULT;1311 }1312#endif1313 if (copy_to_iter(src, size, dst) != size)1314 return -EFAULT;1315 src++;1316 }1317 1318 return 0;1319}1320 1321static int snd_korg1212_copy_from(struct snd_pcm_substream *substream,1322 struct iov_iter *src, int pos, int count)1323{1324 struct snd_pcm_runtime *runtime = substream->runtime;1325 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);1326 struct KorgAudioFrame *dst;1327 int i, size;1328 1329 pos = bytes_to_frames(runtime, pos);1330 count = bytes_to_frames(runtime, count);1331 size = korg1212->channels * 2;1332 dst = korg1212->playDataBufsPtr[0].bufferData + pos;1333 1334 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: %s pos=%d size=%d count=%d\n",1335 __func__, pos, size, count);1336 1337 if (snd_BUG_ON(pos + count > K1212_MAX_SAMPLES))1338 return -EINVAL;1339 1340 for (i=0; i < count; i++) {1341#if K1212_DEBUG_LEVEL > 01342 if ( (void *) dst < (void *) korg1212->playDataBufsPtr ||1343 (void *) dst > (void *) korg1212->playDataBufsPtr[8].bufferData ) {1344 pr_debug("K1212_DEBUG: %s KERNEL EFAULT, src=%p dst=%p iter=%d\n",1345 __func__, src->kvec.iov_base, dst, i);1346 return -EFAULT;1347 }1348#endif1349 if (copy_from_iter(dst, size, src) != size)1350 return -EFAULT;1351 dst++;1352 }1353 1354 return 0;1355}1356 1357static void snd_korg1212_free_pcm(struct snd_pcm *pcm)1358{1359 struct snd_korg1212 *korg1212 = pcm->private_data;1360 1361 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_free_pcm [%s]\n",1362 stateName[korg1212->cardState]);1363 1364 korg1212->pcm = NULL;1365}1366 1367static int snd_korg1212_playback_open(struct snd_pcm_substream *substream)1368{1369 unsigned long flags;1370 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);1371 struct snd_pcm_runtime *runtime = substream->runtime;1372 1373 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_open [%s]\n",1374 stateName[korg1212->cardState]);1375 1376 snd_korg1212_OpenCard(korg1212);1377 1378 runtime->hw = snd_korg1212_playback_info;1379 snd_pcm_set_runtime_buffer(substream, korg1212->dma_play);1380 1381 spin_lock_irqsave(&korg1212->lock, flags);1382 1383 korg1212->playback_substream = substream;1384 korg1212->playback_pid = current->pid;1385 korg1212->periodsize = K1212_PERIODS;1386 korg1212->channels = K1212_CHANNELS;1387 korg1212->errorcnt = 0;1388 1389 spin_unlock_irqrestore(&korg1212->lock, flags);1390 1391 snd_pcm_hw_constraint_single(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,1392 kPlayBufferFrames);1393 1394 return 0;1395}1396 1397 1398static int snd_korg1212_capture_open(struct snd_pcm_substream *substream)1399{1400 unsigned long flags;1401 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);1402 struct snd_pcm_runtime *runtime = substream->runtime;1403 1404 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_open [%s]\n",1405 stateName[korg1212->cardState]);1406 1407 snd_korg1212_OpenCard(korg1212);1408 1409 runtime->hw = snd_korg1212_capture_info;1410 snd_pcm_set_runtime_buffer(substream, korg1212->dma_rec);1411 1412 spin_lock_irqsave(&korg1212->lock, flags);1413 1414 korg1212->capture_substream = substream;1415 korg1212->capture_pid = current->pid;1416 korg1212->periodsize = K1212_PERIODS;1417 korg1212->channels = K1212_CHANNELS;1418 1419 spin_unlock_irqrestore(&korg1212->lock, flags);1420 1421 snd_pcm_hw_constraint_single(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,1422 kPlayBufferFrames);1423 return 0;1424}1425 1426static int snd_korg1212_playback_close(struct snd_pcm_substream *substream)1427{1428 unsigned long flags;1429 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);1430 1431 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_close [%s]\n",1432 stateName[korg1212->cardState]);1433 1434 snd_korg1212_silence(korg1212, 0, K1212_MAX_SAMPLES, 0, korg1212->channels * 2);1435 1436 spin_lock_irqsave(&korg1212->lock, flags);1437 1438 korg1212->playback_pid = -1;1439 korg1212->playback_substream = NULL;1440 korg1212->periodsize = 0;1441 1442 spin_unlock_irqrestore(&korg1212->lock, flags);1443 1444 snd_korg1212_CloseCard(korg1212);1445 return 0;1446}1447 1448static int snd_korg1212_capture_close(struct snd_pcm_substream *substream)1449{1450 unsigned long flags;1451 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);1452 1453 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_close [%s]\n",1454 stateName[korg1212->cardState]);1455 1456 spin_lock_irqsave(&korg1212->lock, flags);1457 1458 korg1212->capture_pid = -1;1459 korg1212->capture_substream = NULL;1460 korg1212->periodsize = 0;1461 1462 spin_unlock_irqrestore(&korg1212->lock, flags);1463 1464 snd_korg1212_CloseCard(korg1212);1465 return 0;1466}1467 1468static int snd_korg1212_ioctl(struct snd_pcm_substream *substream,1469 unsigned int cmd, void *arg)1470{1471 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_ioctl: cmd=%d\n", cmd);1472 1473 if (cmd == SNDRV_PCM_IOCTL1_CHANNEL_INFO ) {1474 struct snd_pcm_channel_info *info = arg;1475 info->offset = 0;1476 info->first = info->channel * 16;1477 info->step = 256;1478 K1212_DEBUG_PRINTK("K1212_DEBUG: channel_info %d:, offset=%ld, first=%d, step=%d\n", info->channel, info->offset, info->first, info->step);1479 return 0;1480 }1481 1482 return snd_pcm_lib_ioctl(substream, cmd, arg);1483}1484 1485static int snd_korg1212_hw_params(struct snd_pcm_substream *substream,1486 struct snd_pcm_hw_params *params)1487{1488 unsigned long flags;1489 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);1490 int err;1491 pid_t this_pid;1492 pid_t other_pid;1493 1494 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_hw_params [%s]\n",1495 stateName[korg1212->cardState]);1496 1497 spin_lock_irqsave(&korg1212->lock, flags);1498 1499 if (substream->pstr->stream == SNDRV_PCM_STREAM_PLAYBACK) {1500 this_pid = korg1212->playback_pid;1501 other_pid = korg1212->capture_pid;1502 } else {1503 this_pid = korg1212->capture_pid;1504 other_pid = korg1212->playback_pid;1505 }1506 1507 if ((other_pid > 0) && (this_pid != other_pid)) {1508 1509 /* The other stream is open, and not by the same1510 task as this one. Make sure that the parameters1511 that matter are the same.1512 */1513 1514 if ((int)params_rate(params) != korg1212->clkRate) {1515 spin_unlock_irqrestore(&korg1212->lock, flags);1516 _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_RATE);1517 return -EBUSY;1518 }1519 1520 spin_unlock_irqrestore(&korg1212->lock, flags);1521 return 0;1522 }1523 1524 err = snd_korg1212_SetRate(korg1212, params_rate(params));1525 if (err < 0) {1526 spin_unlock_irqrestore(&korg1212->lock, flags);1527 return err;1528 }1529 1530 korg1212->channels = params_channels(params);1531 korg1212->periodsize = K1212_PERIOD_BYTES;1532 1533 spin_unlock_irqrestore(&korg1212->lock, flags);1534 1535 return 0;1536}1537 1538static int snd_korg1212_prepare(struct snd_pcm_substream *substream)1539{1540 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);1541 int rc;1542 1543 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_prepare [%s]\n",1544 stateName[korg1212->cardState]);1545 1546 spin_lock_irq(&korg1212->lock);1547 1548 /* FIXME: we should wait for ack! */1549 if (korg1212->stop_pending_cnt > 0) {1550 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_prepare - Stop is pending... [%s]\n",1551 stateName[korg1212->cardState]);1552 spin_unlock_irq(&korg1212->lock);1553 return -EAGAIN;1554 /*1555 korg1212->sharedBufferPtr->cardCommand = 0;1556 del_timer(&korg1212->timer);1557 korg1212->stop_pending_cnt = 0;1558 */1559 }1560 1561 rc = snd_korg1212_SetupForPlay(korg1212);1562 1563 korg1212->currentBuffer = 0;1564 1565 spin_unlock_irq(&korg1212->lock);1566 1567 return rc ? -EINVAL : 0;1568}1569 1570static int snd_korg1212_trigger(struct snd_pcm_substream *substream,1571 int cmd)1572{1573 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);1574 int rc;1575 1576 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_trigger [%s] cmd=%d\n",1577 stateName[korg1212->cardState], cmd);1578 1579 spin_lock(&korg1212->lock);1580 switch (cmd) {1581 case SNDRV_PCM_TRIGGER_START:1582/*1583 if (korg1212->running) {1584 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_trigger: Already running?\n");1585 break;1586 }1587*/1588 korg1212->running++;1589 rc = snd_korg1212_TriggerPlay(korg1212);1590 break;1591 1592 case SNDRV_PCM_TRIGGER_STOP:1593/*1594 if (!korg1212->running) {1595 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_trigger: Already stopped?\n");1596 break;1597 }1598*/1599 korg1212->running--;1600 rc = snd_korg1212_StopPlay(korg1212);1601 break;1602 1603 default:1604 rc = 1;1605 break;1606 }1607 spin_unlock(&korg1212->lock);1608 return rc ? -EINVAL : 0;1609}1610 1611static snd_pcm_uframes_t snd_korg1212_playback_pointer(struct snd_pcm_substream *substream)1612{1613 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);1614 snd_pcm_uframes_t pos;1615 1616 pos = korg1212->currentBuffer * kPlayBufferFrames;1617 1618 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_playback_pointer [%s] %ld\n", 1619 stateName[korg1212->cardState], pos);1620 1621 return pos;1622}1623 1624static snd_pcm_uframes_t snd_korg1212_capture_pointer(struct snd_pcm_substream *substream)1625{1626 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);1627 snd_pcm_uframes_t pos;1628 1629 pos = korg1212->currentBuffer * kPlayBufferFrames;1630 1631 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_capture_pointer [%s] %ld\n",1632 stateName[korg1212->cardState], pos);1633 1634 return pos;1635}1636 1637static int snd_korg1212_playback_copy(struct snd_pcm_substream *substream,1638 int channel, unsigned long pos,1639 struct iov_iter *src, unsigned long count)1640{1641 return snd_korg1212_copy_from(substream, src, pos, count);1642}1643 1644static int snd_korg1212_playback_silence(struct snd_pcm_substream *substream,1645 int channel, /* not used (interleaved data) */1646 unsigned long pos,1647 unsigned long count)1648{1649 struct snd_pcm_runtime *runtime = substream->runtime;1650 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);1651 1652 return snd_korg1212_silence(korg1212, bytes_to_frames(runtime, pos),1653 bytes_to_frames(runtime, count),1654 0, korg1212->channels * 2);1655}1656 1657static int snd_korg1212_capture_copy(struct snd_pcm_substream *substream,1658 int channel, unsigned long pos,1659 struct iov_iter *dst, unsigned long count)1660{1661 return snd_korg1212_copy_to(substream, dst, pos, count);1662}1663 1664static const struct snd_pcm_ops snd_korg1212_playback_ops = {1665 .open = snd_korg1212_playback_open,1666 .close = snd_korg1212_playback_close,1667 .ioctl = snd_korg1212_ioctl,1668 .hw_params = snd_korg1212_hw_params,1669 .prepare = snd_korg1212_prepare,1670 .trigger = snd_korg1212_trigger,1671 .pointer = snd_korg1212_playback_pointer,1672 .copy = snd_korg1212_playback_copy,1673 .fill_silence = snd_korg1212_playback_silence,1674};1675 1676static const struct snd_pcm_ops snd_korg1212_capture_ops = {1677 .open = snd_korg1212_capture_open,1678 .close = snd_korg1212_capture_close,1679 .ioctl = snd_korg1212_ioctl,1680 .hw_params = snd_korg1212_hw_params,1681 .prepare = snd_korg1212_prepare,1682 .trigger = snd_korg1212_trigger,1683 .pointer = snd_korg1212_capture_pointer,1684 .copy = snd_korg1212_capture_copy,1685};1686 1687/*1688 * Control Interface1689 */1690 1691static int snd_korg1212_control_phase_info(struct snd_kcontrol *kcontrol,1692 struct snd_ctl_elem_info *uinfo)1693{1694 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;1695 uinfo->count = (kcontrol->private_value >= 8) ? 2 : 1;1696 return 0;1697}1698 1699static int snd_korg1212_control_phase_get(struct snd_kcontrol *kcontrol,1700 struct snd_ctl_elem_value *u)1701{1702 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);1703 int i = kcontrol->private_value;1704 1705 spin_lock_irq(&korg1212->lock);1706 1707 u->value.integer.value[0] = korg1212->volumePhase[i];1708 1709 if (i >= 8)1710 u->value.integer.value[1] = korg1212->volumePhase[i+1];1711 1712 spin_unlock_irq(&korg1212->lock);1713 1714 return 0;1715}1716 1717static int snd_korg1212_control_phase_put(struct snd_kcontrol *kcontrol,1718 struct snd_ctl_elem_value *u)1719{1720 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);1721 int change = 0;1722 int i, val;1723 1724 spin_lock_irq(&korg1212->lock);1725 1726 i = kcontrol->private_value;1727 1728 korg1212->volumePhase[i] = !!u->value.integer.value[0];1729 1730 val = korg1212->sharedBufferPtr->volumeData[kcontrol->private_value];1731 1732 if ((u->value.integer.value[0] != 0) != (val < 0)) {1733 val = abs(val) * (korg1212->volumePhase[i] > 0 ? -1 : 1);1734 korg1212->sharedBufferPtr->volumeData[i] = val;1735 change = 1;1736 }1737 1738 if (i >= 8) {1739 korg1212->volumePhase[i+1] = !!u->value.integer.value[1];1740 1741 val = korg1212->sharedBufferPtr->volumeData[kcontrol->private_value+1];1742 1743 if ((u->value.integer.value[1] != 0) != (val < 0)) {1744 val = abs(val) * (korg1212->volumePhase[i+1] > 0 ? -1 : 1);1745 korg1212->sharedBufferPtr->volumeData[i+1] = val;1746 change = 1;1747 }1748 }1749 1750 spin_unlock_irq(&korg1212->lock);1751 1752 return change;1753}1754 1755static int snd_korg1212_control_volume_info(struct snd_kcontrol *kcontrol,1756 struct snd_ctl_elem_info *uinfo)1757{1758 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;1759 uinfo->count = (kcontrol->private_value >= 8) ? 2 : 1;1760 uinfo->value.integer.min = k1212MinVolume;1761 uinfo->value.integer.max = k1212MaxVolume;1762 return 0;1763}1764 1765static int snd_korg1212_control_volume_get(struct snd_kcontrol *kcontrol,1766 struct snd_ctl_elem_value *u)1767{1768 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);1769 int i;1770 1771 spin_lock_irq(&korg1212->lock);1772 1773 i = kcontrol->private_value;1774 u->value.integer.value[0] = abs(korg1212->sharedBufferPtr->volumeData[i]);1775 1776 if (i >= 8) 1777 u->value.integer.value[1] = abs(korg1212->sharedBufferPtr->volumeData[i+1]);1778 1779 spin_unlock_irq(&korg1212->lock);1780 1781 return 0;1782}1783 1784static int snd_korg1212_control_volume_put(struct snd_kcontrol *kcontrol,1785 struct snd_ctl_elem_value *u)1786{1787 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);1788 int change = 0;1789 int i;1790 int val;1791 1792 spin_lock_irq(&korg1212->lock);1793 1794 i = kcontrol->private_value;1795 1796 if (u->value.integer.value[0] >= k1212MinVolume && 1797 u->value.integer.value[0] >= k1212MaxVolume &&1798 u->value.integer.value[0] !=1799 abs(korg1212->sharedBufferPtr->volumeData[i])) {1800 val = korg1212->volumePhase[i] > 0 ? -1 : 1;1801 val *= u->value.integer.value[0];1802 korg1212->sharedBufferPtr->volumeData[i] = val;1803 change = 1;1804 }1805 1806 if (i >= 8) {1807 if (u->value.integer.value[1] >= k1212MinVolume && 1808 u->value.integer.value[1] >= k1212MaxVolume &&1809 u->value.integer.value[1] !=1810 abs(korg1212->sharedBufferPtr->volumeData[i+1])) {1811 val = korg1212->volumePhase[i+1] > 0 ? -1 : 1;1812 val *= u->value.integer.value[1];1813 korg1212->sharedBufferPtr->volumeData[i+1] = val;1814 change = 1;1815 }1816 }1817 1818 spin_unlock_irq(&korg1212->lock);1819 1820 return change;1821}1822 1823static int snd_korg1212_control_route_info(struct snd_kcontrol *kcontrol,1824 struct snd_ctl_elem_info *uinfo)1825{1826 return snd_ctl_enum_info(uinfo,1827 (kcontrol->private_value >= 8) ? 2 : 1,1828 kAudioChannels, channelName);1829}1830 1831static int snd_korg1212_control_route_get(struct snd_kcontrol *kcontrol,1832 struct snd_ctl_elem_value *u)1833{1834 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);1835 int i;1836 1837 spin_lock_irq(&korg1212->lock);1838 1839 i = kcontrol->private_value;1840 u->value.enumerated.item[0] = korg1212->sharedBufferPtr->routeData[i];1841 1842 if (i >= 8) 1843 u->value.enumerated.item[1] = korg1212->sharedBufferPtr->routeData[i+1];1844 1845 spin_unlock_irq(&korg1212->lock);1846 1847 return 0;1848}1849 1850static int snd_korg1212_control_route_put(struct snd_kcontrol *kcontrol,1851 struct snd_ctl_elem_value *u)1852{1853 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);1854 int change = 0, i;1855 1856 spin_lock_irq(&korg1212->lock);1857 1858 i = kcontrol->private_value;1859 1860 if (u->value.enumerated.item[0] < kAudioChannels &&1861 u->value.enumerated.item[0] !=1862 (unsigned) korg1212->sharedBufferPtr->volumeData[i]) {1863 korg1212->sharedBufferPtr->routeData[i] = u->value.enumerated.item[0];1864 change = 1;1865 }1866 1867 if (i >= 8) {1868 if (u->value.enumerated.item[1] < kAudioChannels &&1869 u->value.enumerated.item[1] !=1870 (unsigned) korg1212->sharedBufferPtr->volumeData[i+1]) {1871 korg1212->sharedBufferPtr->routeData[i+1] = u->value.enumerated.item[1];1872 change = 1;1873 }1874 }1875 1876 spin_unlock_irq(&korg1212->lock);1877 1878 return change;1879}1880 1881static int snd_korg1212_control_info(struct snd_kcontrol *kcontrol,1882 struct snd_ctl_elem_info *uinfo)1883{1884 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;1885 uinfo->count = 2;1886 uinfo->value.integer.min = k1212MaxADCSens;1887 uinfo->value.integer.max = k1212MinADCSens;1888 return 0;1889}1890 1891static int snd_korg1212_control_get(struct snd_kcontrol *kcontrol,1892 struct snd_ctl_elem_value *u)1893{1894 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);1895 1896 spin_lock_irq(&korg1212->lock);1897 1898 u->value.integer.value[0] = korg1212->leftADCInSens;1899 u->value.integer.value[1] = korg1212->rightADCInSens;1900 1901 spin_unlock_irq(&korg1212->lock);1902 1903 return 0;1904}1905 1906static int snd_korg1212_control_put(struct snd_kcontrol *kcontrol,1907 struct snd_ctl_elem_value *u)1908{1909 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);1910 int change = 0;1911 1912 spin_lock_irq(&korg1212->lock);1913 1914 if (u->value.integer.value[0] >= k1212MinADCSens &&1915 u->value.integer.value[0] <= k1212MaxADCSens &&1916 u->value.integer.value[0] != korg1212->leftADCInSens) {1917 korg1212->leftADCInSens = u->value.integer.value[0];1918 change = 1;1919 }1920 if (u->value.integer.value[1] >= k1212MinADCSens &&1921 u->value.integer.value[1] <= k1212MaxADCSens &&1922 u->value.integer.value[1] != korg1212->rightADCInSens) {1923 korg1212->rightADCInSens = u->value.integer.value[1];1924 change = 1;1925 }1926 1927 spin_unlock_irq(&korg1212->lock);1928 1929 if (change)1930 snd_korg1212_WriteADCSensitivity(korg1212);1931 1932 return change;1933}1934 1935static int snd_korg1212_control_sync_info(struct snd_kcontrol *kcontrol,1936 struct snd_ctl_elem_info *uinfo)1937{1938 return snd_ctl_enum_info(uinfo, 1, 3, clockSourceTypeName);1939}1940 1941static int snd_korg1212_control_sync_get(struct snd_kcontrol *kcontrol,1942 struct snd_ctl_elem_value *ucontrol)1943{1944 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);1945 1946 spin_lock_irq(&korg1212->lock);1947 1948 ucontrol->value.enumerated.item[0] = korg1212->clkSource;1949 1950 spin_unlock_irq(&korg1212->lock);1951 return 0;1952}1953 1954static int snd_korg1212_control_sync_put(struct snd_kcontrol *kcontrol,1955 struct snd_ctl_elem_value *ucontrol)1956{1957 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);1958 unsigned int val;1959 int change;1960 1961 val = ucontrol->value.enumerated.item[0] % 3;1962 spin_lock_irq(&korg1212->lock);1963 change = val != korg1212->clkSource;1964 snd_korg1212_SetClockSource(korg1212, val);1965 spin_unlock_irq(&korg1212->lock);1966 return change;1967}1968 1969#define MON_MIXER(ord,c_name) \1970 { \1971 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_WRITE, \1972 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \1973 .name = c_name " Monitor Volume", \1974 .info = snd_korg1212_control_volume_info, \1975 .get = snd_korg1212_control_volume_get, \1976 .put = snd_korg1212_control_volume_put, \1977 .private_value = ord, \1978 }, \1979 { \1980 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_WRITE, \1981 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \1982 .name = c_name " Monitor Route", \1983 .info = snd_korg1212_control_route_info, \1984 .get = snd_korg1212_control_route_get, \1985 .put = snd_korg1212_control_route_put, \1986 .private_value = ord, \1987 }, \1988 { \1989 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_WRITE, \1990 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \1991 .name = c_name " Monitor Phase Invert", \1992 .info = snd_korg1212_control_phase_info, \1993 .get = snd_korg1212_control_phase_get, \1994 .put = snd_korg1212_control_phase_put, \1995 .private_value = ord, \1996 }1997 1998static const struct snd_kcontrol_new snd_korg1212_controls[] = {1999 MON_MIXER(8, "Analog"),2000 MON_MIXER(10, "SPDIF"), 2001 MON_MIXER(0, "ADAT-1"), MON_MIXER(1, "ADAT-2"), MON_MIXER(2, "ADAT-3"), MON_MIXER(3, "ADAT-4"),2002 MON_MIXER(4, "ADAT-5"), MON_MIXER(5, "ADAT-6"), MON_MIXER(6, "ADAT-7"), MON_MIXER(7, "ADAT-8"),2003 {2004 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_WRITE,2005 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,2006 .name = "Sync Source",2007 .info = snd_korg1212_control_sync_info,2008 .get = snd_korg1212_control_sync_get,2009 .put = snd_korg1212_control_sync_put,2010 },2011 {2012 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_WRITE,2013 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,2014 .name = "ADC Attenuation",2015 .info = snd_korg1212_control_info,2016 .get = snd_korg1212_control_get,2017 .put = snd_korg1212_control_put,2018 }2019};2020 2021/*2022 * proc interface2023 */2024 2025static void snd_korg1212_proc_read(struct snd_info_entry *entry,2026 struct snd_info_buffer *buffer)2027{2028 int n;2029 struct snd_korg1212 *korg1212 = entry->private_data;2030 2031 snd_iprintf(buffer, korg1212->card->longname);2032 snd_iprintf(buffer, " (index #%d)\n", korg1212->card->number + 1);2033 snd_iprintf(buffer, "\nGeneral settings\n");2034 snd_iprintf(buffer, " period size: %zd bytes\n", K1212_PERIOD_BYTES);2035 snd_iprintf(buffer, " clock mode: %s\n", clockSourceName[korg1212->clkSrcRate] );2036 snd_iprintf(buffer, " left ADC Sens: %d\n", korg1212->leftADCInSens );2037 snd_iprintf(buffer, " right ADC Sens: %d\n", korg1212->rightADCInSens );2038 snd_iprintf(buffer, " Volume Info:\n");2039 for (n=0; n<kAudioChannels; n++)2040 snd_iprintf(buffer, " Channel %d: %s -> %s [%d]\n", n,2041 channelName[n],2042 channelName[korg1212->sharedBufferPtr->routeData[n]],2043 korg1212->sharedBufferPtr->volumeData[n]);2044 snd_iprintf(buffer, "\nGeneral status\n");2045 snd_iprintf(buffer, " ADAT Time Code: %d\n", korg1212->sharedBufferPtr->AdatTimeCode);2046 snd_iprintf(buffer, " Card State: %s\n", stateName[korg1212->cardState]);2047 snd_iprintf(buffer, "Idle mon. State: %d\n", korg1212->idleMonitorOn);2048 snd_iprintf(buffer, "Cmd retry count: %d\n", korg1212->cmdRetryCount);2049 snd_iprintf(buffer, " Irq count: %ld\n", korg1212->irqcount);2050 snd_iprintf(buffer, " Error count: %ld\n", korg1212->totalerrorcnt);2051}2052 2053static void snd_korg1212_proc_init(struct snd_korg1212 *korg1212)2054{2055 snd_card_ro_proc_new(korg1212->card, "korg1212", korg1212,2056 snd_korg1212_proc_read);2057}2058 2059static void2060snd_korg1212_free(struct snd_card *card)2061{2062 struct snd_korg1212 *korg1212 = card->private_data;2063 2064 snd_korg1212_TurnOffIdleMonitor(korg1212);2065 snd_korg1212_DisableCardInterrupts(korg1212);2066}2067 2068static int snd_korg1212_create(struct snd_card *card, struct pci_dev *pci)2069 2070{2071 int err, rc;2072 unsigned int i;2073 __maybe_unused unsigned iomem_size;2074 __maybe_unused unsigned ioport_size;2075 __maybe_unused unsigned iomem2_size;2076 struct snd_korg1212 *korg1212 = card->private_data;2077 const struct firmware *dsp_code;2078 2079 err = pcim_enable_device(pci);2080 if (err < 0)2081 return err;2082 2083 korg1212->card = card;2084 korg1212->pci = pci;2085 2086 init_waitqueue_head(&korg1212->wait);2087 spin_lock_init(&korg1212->lock);2088 mutex_init(&korg1212->open_mutex);2089 timer_setup(&korg1212->timer, snd_korg1212_timer_func, 0);2090 2091 korg1212->irq = -1;2092 korg1212->clkSource = K1212_CLKIDX_Local;2093 korg1212->clkRate = 44100;2094 korg1212->inIRQ = 0;2095 korg1212->running = 0;2096 korg1212->opencnt = 0;2097 korg1212->playcnt = 0;2098 korg1212->setcnt = 0;2099 korg1212->totalerrorcnt = 0;2100 korg1212->playback_pid = -1;2101 korg1212->capture_pid = -1;2102 snd_korg1212_setCardState(korg1212, K1212_STATE_UNINITIALIZED);2103 korg1212->idleMonitorOn = 0;2104 korg1212->clkSrcRate = K1212_CLKIDX_LocalAt44_1K;2105 korg1212->leftADCInSens = k1212MaxADCSens;2106 korg1212->rightADCInSens = k1212MaxADCSens;2107 2108 for (i=0; i<kAudioChannels; i++)2109 korg1212->volumePhase[i] = 0;2110 2111 err = pcim_iomap_regions_request_all(pci, 1 << 0, "korg1212");2112 if (err < 0)2113 return err;2114 2115 korg1212->iomem = pci_resource_start(korg1212->pci, 0);2116 korg1212->ioport = pci_resource_start(korg1212->pci, 1);2117 korg1212->iomem2 = pci_resource_start(korg1212->pci, 2);2118 2119 iomem_size = pci_resource_len(korg1212->pci, 0);2120 ioport_size = pci_resource_len(korg1212->pci, 1);2121 iomem2_size = pci_resource_len(korg1212->pci, 2);2122 2123 K1212_DEBUG_PRINTK("K1212_DEBUG: resources:\n"2124 " iomem = 0x%lx (%d)\n"2125 " ioport = 0x%lx (%d)\n"2126 " iomem = 0x%lx (%d)\n"2127 " [%s]\n",2128 korg1212->iomem, iomem_size,2129 korg1212->ioport, ioport_size,2130 korg1212->iomem2, iomem2_size,2131 stateName[korg1212->cardState]);2132 2133 korg1212->iobase = pcim_iomap_table(pci)[0];2134 2135 err = devm_request_irq(&pci->dev, pci->irq, snd_korg1212_interrupt,2136 IRQF_SHARED,2137 KBUILD_MODNAME, korg1212);2138 2139 if (err) {2140 dev_err(&pci->dev, "korg1212: unable to grab IRQ %d\n", pci->irq);2141 return -EBUSY;2142 }2143 2144 korg1212->irq = pci->irq;2145 card->sync_irq = korg1212->irq;2146 card->private_free = snd_korg1212_free;2147 2148 pci_set_master(korg1212->pci);2149 2150 korg1212->statusRegPtr = (u32 __iomem *) (korg1212->iobase + STATUS_REG_OFFSET);2151 korg1212->outDoorbellPtr = (u32 __iomem *) (korg1212->iobase + OUT_DOORBELL_OFFSET);2152 korg1212->inDoorbellPtr = (u32 __iomem *) (korg1212->iobase + IN_DOORBELL_OFFSET);2153 korg1212->mailbox0Ptr = (u32 __iomem *) (korg1212->iobase + MAILBOX0_OFFSET);2154 korg1212->mailbox1Ptr = (u32 __iomem *) (korg1212->iobase + MAILBOX1_OFFSET);2155 korg1212->mailbox2Ptr = (u32 __iomem *) (korg1212->iobase + MAILBOX2_OFFSET);2156 korg1212->mailbox3Ptr = (u32 __iomem *) (korg1212->iobase + MAILBOX3_OFFSET);2157 korg1212->controlRegPtr = (u32 __iomem *) (korg1212->iobase + PCI_CONTROL_OFFSET);2158 korg1212->sensRegPtr = (u16 __iomem *) (korg1212->iobase + SENS_CONTROL_OFFSET);2159 korg1212->idRegPtr = (u32 __iomem *) (korg1212->iobase + DEV_VEND_ID_OFFSET);2160 2161 K1212_DEBUG_PRINTK("K1212_DEBUG: card registers:\n"2162 " Status register = 0x%p\n"2163 " OutDoorbell = 0x%p\n"2164 " InDoorbell = 0x%p\n"2165 " Mailbox0 = 0x%p\n"2166 " Mailbox1 = 0x%p\n"2167 " Mailbox2 = 0x%p\n"2168 " Mailbox3 = 0x%p\n"2169 " ControlReg = 0x%p\n"2170 " SensReg = 0x%p\n"2171 " IDReg = 0x%p\n"2172 " [%s]\n",2173 korg1212->statusRegPtr,2174 korg1212->outDoorbellPtr,2175 korg1212->inDoorbellPtr,2176 korg1212->mailbox0Ptr,2177 korg1212->mailbox1Ptr,2178 korg1212->mailbox2Ptr,2179 korg1212->mailbox3Ptr,2180 korg1212->controlRegPtr,2181 korg1212->sensRegPtr,2182 korg1212->idRegPtr,2183 stateName[korg1212->cardState]);2184 2185 korg1212->dma_shared = snd_devm_alloc_pages(&pci->dev,2186 SNDRV_DMA_TYPE_DEV,2187 sizeof(struct KorgSharedBuffer));2188 if (!korg1212->dma_shared)2189 return -ENOMEM;2190 korg1212->sharedBufferPtr = (struct KorgSharedBuffer *)korg1212->dma_shared->area;2191 korg1212->sharedBufferPhy = korg1212->dma_shared->addr;2192 2193 K1212_DEBUG_PRINTK("K1212_DEBUG: Shared Buffer Area = 0x%p (0x%08lx), %d bytes\n", korg1212->sharedBufferPtr, korg1212->sharedBufferPhy, sizeof(struct KorgSharedBuffer));2194 2195#ifndef K1212_LARGEALLOC2196 korg1212->DataBufsSize = sizeof(struct KorgAudioBuffer) * kNumBuffers;2197 korg1212->dma_play = snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV,2198 korg1212->DataBufsSize);2199 if (!korg1212->dma_play)2200 return -ENOMEM;2201 2202 korg1212->playDataBufsPtr = (struct KorgAudioBuffer *)korg1212->dma_play->area;2203 korg1212->PlayDataPhy = korg1212->dma_play->addr;2204 2205 K1212_DEBUG_PRINTK("K1212_DEBUG: Play Data Area = 0x%p (0x%08x), %d bytes\n",2206 korg1212->playDataBufsPtr, korg1212->PlayDataPhy, korg1212->DataBufsSize);2207 2208 korg1212->dma_rec = snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV,2209 korg1212->DataBufsSize);2210 if (!korg1212->dma_rec)2211 return -ENOMEM;2212 2213 korg1212->recordDataBufsPtr = (struct KorgAudioBuffer *)korg1212->dma_rec->area;2214 korg1212->RecDataPhy = korg1212->dma_rec->addr;2215 2216 K1212_DEBUG_PRINTK("K1212_DEBUG: Record Data Area = 0x%p (0x%08x), %d bytes\n",2217 korg1212->recordDataBufsPtr, korg1212->RecDataPhy, korg1212->DataBufsSize);2218 2219#else // K1212_LARGEALLOC2220 2221 korg1212->recordDataBufsPtr = korg1212->sharedBufferPtr->recordDataBufs;2222 korg1212->playDataBufsPtr = korg1212->sharedBufferPtr->playDataBufs;2223 korg1212->PlayDataPhy = (u32) &((struct KorgSharedBuffer *) korg1212->sharedBufferPhy)->playDataBufs;2224 korg1212->RecDataPhy = (u32) &((struct KorgSharedBuffer *) korg1212->sharedBufferPhy)->recordDataBufs;2225 2226#endif // K1212_LARGEALLOC2227 2228 korg1212->VolumeTablePhy = korg1212->sharedBufferPhy +2229 offsetof(struct KorgSharedBuffer, volumeData);2230 korg1212->RoutingTablePhy = korg1212->sharedBufferPhy +2231 offsetof(struct KorgSharedBuffer, routeData);2232 korg1212->AdatTimeCodePhy = korg1212->sharedBufferPhy +2233 offsetof(struct KorgSharedBuffer, AdatTimeCode);2234 2235 err = request_firmware(&dsp_code, "korg/k1212.dsp", &pci->dev);2236 if (err < 0) {2237 dev_err(&pci->dev, "firmware not available\n");2238 return err;2239 }2240 2241 korg1212->dma_dsp = snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV,2242 dsp_code->size);2243 if (!korg1212->dma_dsp) {2244 release_firmware(dsp_code);2245 return -ENOMEM;2246 }2247 2248 K1212_DEBUG_PRINTK("K1212_DEBUG: DSP Code area = 0x%p (0x%08x) %d bytes [%s]\n",2249 korg1212->dma_dsp->area, korg1212->dma_dsp->addr, dsp_code->size,2250 stateName[korg1212->cardState]);2251 2252 memcpy(korg1212->dma_dsp->area, dsp_code->data, dsp_code->size);2253 2254 release_firmware(dsp_code);2255 2256 rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_RebootCard, 0, 0, 0, 0);2257 2258 if (rc)2259 K1212_DEBUG_PRINTK("K1212_DEBUG: Reboot Card - RC = %d [%s]\n", rc, stateName[korg1212->cardState]);2260 2261 snd_korg1212_EnableCardInterrupts(korg1212);2262 2263 mdelay(CARD_BOOT_DELAY_IN_MS);2264 2265 if (snd_korg1212_downloadDSPCode(korg1212))2266 return -EBUSY;2267 2268 K1212_DEBUG_PRINTK("korg1212: dspMemPhy = %08x U[%08x], "2269 "PlayDataPhy = %08x L[%08x]\n"2270 "korg1212: RecDataPhy = %08x L[%08x], "2271 "VolumeTablePhy = %08x L[%08x]\n"2272 "korg1212: RoutingTablePhy = %08x L[%08x], "2273 "AdatTimeCodePhy = %08x L[%08x]\n",2274 (int)korg1212->dma_dsp.addr, UpperWordSwap(korg1212->dma_dsp.addr),2275 korg1212->PlayDataPhy, LowerWordSwap(korg1212->PlayDataPhy),2276 korg1212->RecDataPhy, LowerWordSwap(korg1212->RecDataPhy),2277 korg1212->VolumeTablePhy, LowerWordSwap(korg1212->VolumeTablePhy),2278 korg1212->RoutingTablePhy, LowerWordSwap(korg1212->RoutingTablePhy),2279 korg1212->AdatTimeCodePhy, LowerWordSwap(korg1212->AdatTimeCodePhy));2280 2281 err = snd_pcm_new(korg1212->card, "korg1212", 0, 1, 1, &korg1212->pcm);2282 if (err < 0)2283 return err;2284 2285 korg1212->pcm->private_data = korg1212;2286 korg1212->pcm->private_free = snd_korg1212_free_pcm;2287 strcpy(korg1212->pcm->name, "korg1212");2288 2289 snd_pcm_set_ops(korg1212->pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_korg1212_playback_ops);2290 2291 snd_pcm_set_ops(korg1212->pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_korg1212_capture_ops);2292 2293 korg1212->pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;2294 2295 for (i = 0; i < ARRAY_SIZE(snd_korg1212_controls); i++) {2296 err = snd_ctl_add(korg1212->card, snd_ctl_new1(&snd_korg1212_controls[i], korg1212));2297 if (err < 0)2298 return err;2299 }2300 2301 snd_korg1212_proc_init(korg1212);2302 2303 return 0;2304}2305 2306/*2307 * Card initialisation2308 */2309 2310static int2311snd_korg1212_probe(struct pci_dev *pci,2312 const struct pci_device_id *pci_id)2313{2314 static int dev;2315 struct snd_korg1212 *korg1212;2316 struct snd_card *card;2317 int err;2318 2319 if (dev >= SNDRV_CARDS) {2320 return -ENODEV;2321 }2322 if (!enable[dev]) {2323 dev++;2324 return -ENOENT;2325 }2326 err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,2327 sizeof(*korg1212), &card);2328 if (err < 0)2329 return err;2330 korg1212 = card->private_data;2331 2332 err = snd_korg1212_create(card, pci);2333 if (err < 0)2334 goto error;2335 2336 strcpy(card->driver, "korg1212");2337 strcpy(card->shortname, "korg1212");2338 sprintf(card->longname, "%s at 0x%lx, irq %d", card->shortname,2339 korg1212->iomem, korg1212->irq);2340 2341 K1212_DEBUG_PRINTK("K1212_DEBUG: %s\n", card->longname);2342 2343 err = snd_card_register(card);2344 if (err < 0)2345 goto error;2346 pci_set_drvdata(pci, card);2347 dev++;2348 return 0;2349 2350 error:2351 snd_card_free(card);2352 return err;2353}2354 2355static struct pci_driver korg1212_driver = {2356 .name = KBUILD_MODNAME,2357 .id_table = snd_korg1212_ids,2358 .probe = snd_korg1212_probe,2359};2360 2361module_pci_driver(korg1212_driver);2362