2 * Driver for the Korg 1212 IO PCI card
4 * Copyright (c) 2001 Haroldo Gamal <gamal@alternex.com.br>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/delay.h>
23 #include <linux/init.h>
24 #include <linux/interrupt.h>
25 #include <linux/pci.h>
26 #include <linux/slab.h>
27 #include <linux/wait.h>
28 #include <linux/module.h>
29 #include <linux/mutex.h>
30 #include <linux/firmware.h>
32 #include <sound/core.h>
33 #include <sound/info.h>
34 #include <sound/control.h>
35 #include <sound/pcm.h>
36 #include <sound/pcm_params.h>
37 #include <sound/initval.h>
41 // ----------------------------------------------------------------------------
43 // ----------------------------------------------------------------------------
44 #define K1212_DEBUG_LEVEL 0
45 #if K1212_DEBUG_LEVEL > 0
46 #define K1212_DEBUG_PRINTK(fmt,args...) printk(KERN_DEBUG fmt,##args)
48 #define K1212_DEBUG_PRINTK(fmt,...)
50 #if K1212_DEBUG_LEVEL > 1
51 #define K1212_DEBUG_PRINTK_VERBOSE(fmt,args...) printk(KERN_DEBUG fmt,##args)
53 #define K1212_DEBUG_PRINTK_VERBOSE(fmt,...)
56 // ----------------------------------------------------------------------------
57 // Record/Play Buffer Allocation Method. If K1212_LARGEALLOC is defined all
58 // buffers are alocated as a large piece inside KorgSharedBuffer.
59 // ----------------------------------------------------------------------------
60 //#define K1212_LARGEALLOC 1
62 // ----------------------------------------------------------------------------
63 // Valid states of the Korg 1212 I/O card.
64 // ----------------------------------------------------------------------------
66 K1212_STATE_NONEXISTENT
, // there is no card here
67 K1212_STATE_UNINITIALIZED
, // the card is awaiting DSP download
68 K1212_STATE_DSP_IN_PROCESS
, // the card is currently downloading its DSP code
69 K1212_STATE_DSP_COMPLETE
, // the card has finished the DSP download
70 K1212_STATE_READY
, // the card can be opened by an application. Any application
71 // requests prior to this state should fail. Only an open
72 // request can be made at this state.
73 K1212_STATE_OPEN
, // an application has opened the card
74 K1212_STATE_SETUP
, // the card has been setup for play
75 K1212_STATE_PLAYING
, // the card is playing
76 K1212_STATE_MONITOR
, // the card is in the monitor mode
77 K1212_STATE_CALIBRATING
, // the card is currently calibrating
78 K1212_STATE_ERRORSTOP
, // the card has stopped itself because of an error and we
79 // are in the process of cleaning things up.
80 K1212_STATE_MAX_STATE
// state values of this and beyond are invalid
83 // ----------------------------------------------------------------------------
84 // The following enumeration defines the constants written to the card's
85 // host-to-card doorbell to initiate a command.
86 // ----------------------------------------------------------------------------
87 enum korg1212_dbcnst
{
88 K1212_DB_RequestForData
= 0, // sent by the card to request a buffer fill.
89 K1212_DB_TriggerPlay
= 1, // starts playback/record on the card.
90 K1212_DB_SelectPlayMode
= 2, // select monitor, playback setup, or stop.
91 K1212_DB_ConfigureBufferMemory
= 3, // tells card where the host audio buffers are.
92 K1212_DB_RequestAdatTimecode
= 4, // asks the card for the latest ADAT timecode value.
93 K1212_DB_SetClockSourceRate
= 5, // sets the clock source and rate for the card.
94 K1212_DB_ConfigureMiscMemory
= 6, // tells card where other buffers are.
95 K1212_DB_TriggerFromAdat
= 7, // tells card to trigger from Adat at a specific
97 K1212_DB_DMAERROR
= 0x80, // DMA Error - the PCI bus is congestioned.
98 K1212_DB_CARDSTOPPED
= 0x81, // Card has stopped by user request.
99 K1212_DB_RebootCard
= 0xA0, // instructs the card to reboot.
100 K1212_DB_BootFromDSPPage4
= 0xA4, // instructs the card to boot from the DSP microcode
101 // on page 4 (local page to card).
102 K1212_DB_DSPDownloadDone
= 0xAE, // sent by the card to indicate the download has
104 K1212_DB_StartDSPDownload
= 0xAF // tells the card to download its DSP firmware.
108 // ----------------------------------------------------------------------------
109 // The following enumeration defines return codes
110 // to the Korg 1212 I/O driver.
111 // ----------------------------------------------------------------------------
112 enum snd_korg1212rc
{
113 K1212_CMDRET_Success
= 0, // command was successfully placed
114 K1212_CMDRET_DIOCFailure
, // the DeviceIoControl call failed
115 K1212_CMDRET_PMFailure
, // the protected mode call failed
116 K1212_CMDRET_FailUnspecified
, // unspecified failure
117 K1212_CMDRET_FailBadState
, // the specified command can not be given in
118 // the card's current state. (or the wave device's
120 K1212_CMDRET_CardUninitialized
, // the card is uninitialized and cannot be used
121 K1212_CMDRET_BadIndex
, // an out of range card index was specified
122 K1212_CMDRET_BadHandle
, // an invalid card handle was specified
123 K1212_CMDRET_NoFillRoutine
, // a play request has been made before a fill routine set
124 K1212_CMDRET_FillRoutineInUse
, // can't set a new fill routine while one is in use
125 K1212_CMDRET_NoAckFromCard
, // the card never acknowledged a command
126 K1212_CMDRET_BadParams
, // bad parameters were provided by the caller
128 K1212_CMDRET_BadDevice
, // the specified wave device was out of range
129 K1212_CMDRET_BadFormat
// the specified wave format is unsupported
132 // ----------------------------------------------------------------------------
133 // The following enumeration defines the constants used to select the play
134 // mode for the card in the SelectPlayMode command.
135 // ----------------------------------------------------------------------------
136 enum PlayModeSelector
{
137 K1212_MODE_SetupPlay
= 0x00000001, // provides card with pre-play information
138 K1212_MODE_MonitorOn
= 0x00000002, // tells card to turn on monitor mode
139 K1212_MODE_MonitorOff
= 0x00000004, // tells card to turn off monitor mode
140 K1212_MODE_StopPlay
= 0x00000008 // stops playback on the card
143 // ----------------------------------------------------------------------------
144 // The following enumeration defines the constants used to select the monitor
145 // mode for the card in the SetMonitorMode command.
146 // ----------------------------------------------------------------------------
147 enum MonitorModeSelector
{
148 K1212_MONMODE_Off
= 0, // tells card to turn off monitor mode
149 K1212_MONMODE_On
// tells card to turn on monitor mode
152 #define MAILBOX0_OFFSET 0x40 // location of mailbox 0 relative to base address
153 #define MAILBOX1_OFFSET 0x44 // location of mailbox 1 relative to base address
154 #define MAILBOX2_OFFSET 0x48 // location of mailbox 2 relative to base address
155 #define MAILBOX3_OFFSET 0x4c // location of mailbox 3 relative to base address
156 #define OUT_DOORBELL_OFFSET 0x60 // location of PCI to local doorbell
157 #define IN_DOORBELL_OFFSET 0x64 // location of local to PCI doorbell
158 #define STATUS_REG_OFFSET 0x68 // location of interrupt control/status register
159 #define PCI_CONTROL_OFFSET 0x6c // location of the EEPROM, PCI, User I/O, init control
161 #define SENS_CONTROL_OFFSET 0x6e // location of the input sensitivity setting register.
162 // this is the upper word of the PCI control reg.
163 #define DEV_VEND_ID_OFFSET 0x70 // location of the device and vendor ID register
165 #define MAX_COMMAND_RETRIES 5 // maximum number of times the driver will attempt
166 // to send a command before giving up.
167 #define COMMAND_ACK_MASK 0x8000 // the MSB is set in the command acknowledgment from
169 #define DOORBELL_VAL_MASK 0x00FF // the doorbell value is one byte
171 #define CARD_BOOT_DELAY_IN_MS 10
172 #define CARD_BOOT_TIMEOUT 10
173 #define DSP_BOOT_DELAY_IN_MS 200
175 #define kNumBuffers 8
176 #define k1212MaxCards 4
177 #define k1212NumWaveDevices 6
178 #define k16BitChannels 10
179 #define k32BitChannels 2
180 #define kAudioChannels (k16BitChannels + k32BitChannels)
181 #define kPlayBufferFrames 1024
183 #define K1212_ANALOG_CHANNELS 2
184 #define K1212_SPDIF_CHANNELS 2
185 #define K1212_ADAT_CHANNELS 8
186 #define K1212_CHANNELS (K1212_ADAT_CHANNELS + K1212_ANALOG_CHANNELS)
187 #define K1212_MIN_CHANNELS 1
188 #define K1212_MAX_CHANNELS K1212_CHANNELS
189 #define K1212_FRAME_SIZE (sizeof(struct KorgAudioFrame))
190 #define K1212_MAX_SAMPLES (kPlayBufferFrames*kNumBuffers)
191 #define K1212_PERIODS (kNumBuffers)
192 #define K1212_PERIOD_BYTES (K1212_FRAME_SIZE*kPlayBufferFrames)
193 #define K1212_BUF_SIZE (K1212_PERIOD_BYTES*kNumBuffers)
194 #define K1212_ANALOG_BUF_SIZE (K1212_ANALOG_CHANNELS * 2 * kPlayBufferFrames * kNumBuffers)
195 #define K1212_SPDIF_BUF_SIZE (K1212_SPDIF_CHANNELS * 3 * kPlayBufferFrames * kNumBuffers)
196 #define K1212_ADAT_BUF_SIZE (K1212_ADAT_CHANNELS * 2 * kPlayBufferFrames * kNumBuffers)
197 #define K1212_MAX_BUF_SIZE (K1212_ANALOG_BUF_SIZE + K1212_ADAT_BUF_SIZE)
199 #define k1212MinADCSens 0x7f
200 #define k1212MaxADCSens 0x00
201 #define k1212MaxVolume 0x7fff
202 #define k1212MaxWaveVolume 0xffff
203 #define k1212MinVolume 0x0000
204 #define k1212MaxVolInverted 0x8000
206 // -----------------------------------------------------------------
207 // the following bits are used for controlling interrupts in the
208 // interrupt control/status reg
209 // -----------------------------------------------------------------
210 #define PCI_INT_ENABLE_BIT 0x00000100
211 #define PCI_DOORBELL_INT_ENABLE_BIT 0x00000200
212 #define LOCAL_INT_ENABLE_BIT 0x00010000
213 #define LOCAL_DOORBELL_INT_ENABLE_BIT 0x00020000
214 #define LOCAL_DMA1_INT_ENABLE_BIT 0x00080000
216 // -----------------------------------------------------------------
217 // the following bits are defined for the PCI command register
218 // -----------------------------------------------------------------
219 #define PCI_CMD_MEM_SPACE_ENABLE_BIT 0x0002
220 #define PCI_CMD_IO_SPACE_ENABLE_BIT 0x0001
221 #define PCI_CMD_BUS_MASTER_ENABLE_BIT 0x0004
223 // -----------------------------------------------------------------
224 // the following bits are defined for the PCI status register
225 // -----------------------------------------------------------------
226 #define PCI_STAT_PARITY_ERROR_BIT 0x8000
227 #define PCI_STAT_SYSTEM_ERROR_BIT 0x4000
228 #define PCI_STAT_MASTER_ABORT_RCVD_BIT 0x2000
229 #define PCI_STAT_TARGET_ABORT_RCVD_BIT 0x1000
230 #define PCI_STAT_TARGET_ABORT_SENT_BIT 0x0800
232 // ------------------------------------------------------------------------
233 // the following constants are used in setting the 1212 I/O card's input
235 // ------------------------------------------------------------------------
236 #define SET_SENS_LOCALINIT_BITPOS 15
237 #define SET_SENS_DATA_BITPOS 10
238 #define SET_SENS_CLOCK_BITPOS 8
239 #define SET_SENS_LOADSHIFT_BITPOS 0
241 #define SET_SENS_LEFTCHANID 0x00
242 #define SET_SENS_RIGHTCHANID 0x01
244 #define K1212SENSUPDATE_DELAY_IN_MS 50
246 // --------------------------------------------------------------------------
249 // This function waits the specified number of real time clock ticks.
250 // According to the DDK, each tick is ~0.8 microseconds.
251 // The defines following the function declaration can be used for the
252 // numTicksToWait parameter.
253 // --------------------------------------------------------------------------
254 #define ONE_RTC_TICK 1
255 #define SENSCLKPULSE_WIDTH 4
256 #define LOADSHIFT_DELAY 4
257 #define INTERCOMMAND_DELAY 40
258 #define STOPCARD_DELAY 300 // max # RTC ticks for the card to stop once we write
259 // the command register. (could be up to 180 us)
260 #define COMMAND_ACK_DELAY 13 // number of RTC ticks to wait for an acknowledgement
261 // from the card after sending a command.
263 enum ClockSourceIndex
{
264 K1212_CLKIDX_AdatAt44_1K
= 0, // selects source as ADAT at 44.1 kHz
265 K1212_CLKIDX_AdatAt48K
, // selects source as ADAT at 48 kHz
266 K1212_CLKIDX_WordAt44_1K
, // selects source as S/PDIF at 44.1 kHz
267 K1212_CLKIDX_WordAt48K
, // selects source as S/PDIF at 48 kHz
268 K1212_CLKIDX_LocalAt44_1K
, // selects source as local clock at 44.1 kHz
269 K1212_CLKIDX_LocalAt48K
, // selects source as local clock at 48 kHz
270 K1212_CLKIDX_Invalid
// used to check validity of the index
273 enum ClockSourceType
{
274 K1212_CLKIDX_Adat
= 0, // selects source as ADAT
275 K1212_CLKIDX_Word
, // selects source as S/PDIF
276 K1212_CLKIDX_Local
// selects source as local clock
279 struct KorgAudioFrame
{
280 u16 frameData16
[k16BitChannels
]; /* channels 0-9 use 16 bit samples */
281 u32 frameData32
[k32BitChannels
]; /* channels 10-11 use 32 bits - only 20 are sent across S/PDIF */
282 u32 timeCodeVal
; /* holds the ADAT timecode value */
285 struct KorgAudioBuffer
{
286 struct KorgAudioFrame bufferData
[kPlayBufferFrames
]; /* buffer definition */
289 struct KorgSharedBuffer
{
290 #ifdef K1212_LARGEALLOC
291 struct KorgAudioBuffer playDataBufs
[kNumBuffers
];
292 struct KorgAudioBuffer recordDataBufs
[kNumBuffers
];
294 short volumeData
[kAudioChannels
];
296 u16 routeData
[kAudioChannels
];
297 u32 AdatTimeCode
; // ADAT timecode value
303 unsigned int leftChanVal
:8;
304 unsigned int leftChanId
:8;
310 unsigned int rightChanVal
:8;
311 unsigned int rightChanId
:8;
317 struct snd_korg1212
{
318 struct snd_card
*card
;
324 struct mutex open_mutex
;
326 struct timer_list timer
; /* timer callback for checking ack of stop request */
327 int stop_pending_cnt
; /* counter for stop pending check */
329 wait_queue_head_t wait
;
332 unsigned long ioport
;
333 unsigned long iomem2
;
334 unsigned long irqcount
;
336 void __iomem
*iobase
;
338 struct snd_dma_buffer dma_dsp
;
339 struct snd_dma_buffer dma_play
;
340 struct snd_dma_buffer dma_rec
;
341 struct snd_dma_buffer dma_shared
;
345 struct KorgAudioBuffer
* playDataBufsPtr
;
346 struct KorgAudioBuffer
* recordDataBufsPtr
;
348 struct KorgSharedBuffer
* sharedBufferPtr
;
352 unsigned long sharedBufferPhy
;
357 u32 __iomem
* statusRegPtr
; // address of the interrupt status/control register
358 u32 __iomem
* outDoorbellPtr
; // address of the host->card doorbell register
359 u32 __iomem
* inDoorbellPtr
; // address of the card->host doorbell register
360 u32 __iomem
* mailbox0Ptr
; // address of mailbox 0 on the card
361 u32 __iomem
* mailbox1Ptr
; // address of mailbox 1 on the card
362 u32 __iomem
* mailbox2Ptr
; // address of mailbox 2 on the card
363 u32 __iomem
* mailbox3Ptr
; // address of mailbox 3 on the card
364 u32 __iomem
* controlRegPtr
; // address of the EEPROM, PCI, I/O, Init ctrl reg
365 u16 __iomem
* sensRegPtr
; // address of the sensitivity setting register
366 u32 __iomem
* idRegPtr
; // address of the device and vendor ID registers
372 struct snd_pcm_substream
*playback_substream
;
373 struct snd_pcm_substream
*capture_substream
;
378 enum CardState cardState
;
380 int idleMonitorOn
; // indicates whether the card is in idle monitor mode.
381 u32 cmdRetryCount
; // tracks how many times we have retried sending to the card.
383 enum ClockSourceIndex clkSrcRate
; // sample rate and clock source
385 enum ClockSourceType clkSource
; // clock source
386 int clkRate
; // clock rate
388 int volumePhase
[kAudioChannels
];
390 u16 leftADCInSens
; // ADC left channel input sensitivity
391 u16 rightADCInSens
; // ADC right channel input sensitivity
393 int opencnt
; // Open/Close count
394 int setcnt
; // SetupForPlay count
395 int playcnt
; // TriggerPlay count
396 int errorcnt
; // Error Count
397 unsigned long totalerrorcnt
; // Total Error Count
400 int dsp_stop_is_processed
;
404 MODULE_DESCRIPTION("korg1212");
405 MODULE_LICENSE("GPL");
406 MODULE_SUPPORTED_DEVICE("{{KORG,korg1212}}");
407 MODULE_FIRMWARE("korg/k1212.dsp");
409 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-MAX */
410 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
411 static bool enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE
; /* Enable this card */
413 module_param_array(index
, int, NULL
, 0444);
414 MODULE_PARM_DESC(index
, "Index value for Korg 1212 soundcard.");
415 module_param_array(id
, charp
, NULL
, 0444);
416 MODULE_PARM_DESC(id
, "ID string for Korg 1212 soundcard.");
417 module_param_array(enable
, bool, NULL
, 0444);
418 MODULE_PARM_DESC(enable
, "Enable Korg 1212 soundcard.");
419 MODULE_AUTHOR("Haroldo Gamal <gamal@alternex.com.br>");
421 static DEFINE_PCI_DEVICE_TABLE(snd_korg1212_ids
) = {
425 .subvendor
= PCI_ANY_ID
,
426 .subdevice
= PCI_ANY_ID
,
431 MODULE_DEVICE_TABLE(pci
, snd_korg1212_ids
);
433 static char *stateName
[] = {
436 "DSP download in process",
437 "DSP download complete",
447 static char *clockSourceTypeName
[] = { "ADAT", "S/PDIF", "local" };
449 static char *clockSourceName
[] = {
452 "S/PDIF at 44.1 kHz",
454 "local clock at 44.1 kHz",
455 "local clock at 48 kHz"
458 static char *channelName
[] = {
473 static u16 ClockSourceSelector
[] = {
474 0x8000, // selects source as ADAT at 44.1 kHz
475 0x0000, // selects source as ADAT at 48 kHz
476 0x8001, // selects source as S/PDIF at 44.1 kHz
477 0x0001, // selects source as S/PDIF at 48 kHz
478 0x8002, // selects source as local clock at 44.1 kHz
479 0x0002 // selects source as local clock at 48 kHz
482 union swap_u32
{ unsigned char c
[4]; u32 i
; };
484 #ifdef SNDRV_BIG_ENDIAN
485 static u32
LowerWordSwap(u32 swappee
)
487 static u32
UpperWordSwap(u32 swappee
)
490 union swap_u32 retVal
, swapper
;
493 retVal
.c
[2] = swapper
.c
[3];
494 retVal
.c
[3] = swapper
.c
[2];
495 retVal
.c
[1] = swapper
.c
[1];
496 retVal
.c
[0] = swapper
.c
[0];
501 #ifdef SNDRV_BIG_ENDIAN
502 static u32
UpperWordSwap(u32 swappee
)
504 static u32
LowerWordSwap(u32 swappee
)
507 union swap_u32 retVal
, swapper
;
510 retVal
.c
[2] = swapper
.c
[2];
511 retVal
.c
[3] = swapper
.c
[3];
512 retVal
.c
[1] = swapper
.c
[0];
513 retVal
.c
[0] = swapper
.c
[1];
518 #define SetBitInWord(theWord,bitPosition) (*theWord) |= (0x0001 << bitPosition)
519 #define SetBitInDWord(theWord,bitPosition) (*theWord) |= (0x00000001 << bitPosition)
520 #define ClearBitInWord(theWord,bitPosition) (*theWord) &= ~(0x0001 << bitPosition)
521 #define ClearBitInDWord(theWord,bitPosition) (*theWord) &= ~(0x00000001 << bitPosition)
523 static int snd_korg1212_Send1212Command(struct snd_korg1212
*korg1212
,
524 enum korg1212_dbcnst doorbellVal
,
525 u32 mailBox0Val
, u32 mailBox1Val
,
526 u32 mailBox2Val
, u32 mailBox3Val
)
530 int rc
= K1212_CMDRET_Success
;
532 if (!korg1212
->outDoorbellPtr
) {
533 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: CardUninitialized\n");
534 return K1212_CMDRET_CardUninitialized
;
537 K1212_DEBUG_PRINTK("K1212_DEBUG: Card <- 0x%08x 0x%08x [%s]\n",
538 doorbellVal
, mailBox0Val
, stateName
[korg1212
->cardState
]);
539 for (retryCount
= 0; retryCount
< MAX_COMMAND_RETRIES
; retryCount
++) {
540 writel(mailBox3Val
, korg1212
->mailbox3Ptr
);
541 writel(mailBox2Val
, korg1212
->mailbox2Ptr
);
542 writel(mailBox1Val
, korg1212
->mailbox1Ptr
);
543 writel(mailBox0Val
, korg1212
->mailbox0Ptr
);
544 writel(doorbellVal
, korg1212
->outDoorbellPtr
); // interrupt the card
546 // --------------------------------------------------------------
547 // the reboot command will not give an acknowledgement.
548 // --------------------------------------------------------------
549 if ( doorbellVal
== K1212_DB_RebootCard
||
550 doorbellVal
== K1212_DB_BootFromDSPPage4
||
551 doorbellVal
== K1212_DB_StartDSPDownload
) {
552 rc
= K1212_CMDRET_Success
;
556 // --------------------------------------------------------------
557 // See if the card acknowledged the command. Wait a bit, then
558 // read in the low word of mailbox3. If the MSB is set and the
559 // low byte is equal to the doorbell value, then it ack'd.
560 // --------------------------------------------------------------
561 udelay(COMMAND_ACK_DELAY
);
562 mailBox3Lo
= readl(korg1212
->mailbox3Ptr
);
563 if (mailBox3Lo
& COMMAND_ACK_MASK
) {
564 if ((mailBox3Lo
& DOORBELL_VAL_MASK
) == (doorbellVal
& DOORBELL_VAL_MASK
)) {
565 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: Card <- Success\n");
566 rc
= K1212_CMDRET_Success
;
571 korg1212
->cmdRetryCount
+= retryCount
;
573 if (retryCount
>= MAX_COMMAND_RETRIES
) {
574 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: Card <- NoAckFromCard\n");
575 rc
= K1212_CMDRET_NoAckFromCard
;
581 /* spinlock already held */
582 static void snd_korg1212_SendStop(struct snd_korg1212
*korg1212
)
584 if (! korg1212
->stop_pending_cnt
) {
585 korg1212
->sharedBufferPtr
->cardCommand
= 0xffffffff;
586 /* program the timer */
587 korg1212
->stop_pending_cnt
= HZ
;
588 korg1212
->timer
.expires
= jiffies
+ 1;
589 add_timer(&korg1212
->timer
);
593 static void snd_korg1212_SendStopAndWait(struct snd_korg1212
*korg1212
)
596 spin_lock_irqsave(&korg1212
->lock
, flags
);
597 korg1212
->dsp_stop_is_processed
= 0;
598 snd_korg1212_SendStop(korg1212
);
599 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
600 wait_event_timeout(korg1212
->wait
, korg1212
->dsp_stop_is_processed
, (HZ
* 3) / 2);
603 /* timer callback for checking the ack of stop request */
604 static void snd_korg1212_timer_func(unsigned long data
)
606 struct snd_korg1212
*korg1212
= (struct snd_korg1212
*) data
;
609 spin_lock_irqsave(&korg1212
->lock
, flags
);
610 if (korg1212
->sharedBufferPtr
->cardCommand
== 0) {
612 korg1212
->stop_pending_cnt
= 0;
613 korg1212
->dsp_stop_is_processed
= 1;
614 wake_up(&korg1212
->wait
);
615 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: Stop ack'ed [%s]\n",
616 stateName
[korg1212
->cardState
]);
618 if (--korg1212
->stop_pending_cnt
> 0) {
619 /* reprogram timer */
620 korg1212
->timer
.expires
= jiffies
+ 1;
621 add_timer(&korg1212
->timer
);
623 snd_printd("korg1212_timer_func timeout\n");
624 korg1212
->sharedBufferPtr
->cardCommand
= 0;
625 korg1212
->dsp_stop_is_processed
= 1;
626 wake_up(&korg1212
->wait
);
627 K1212_DEBUG_PRINTK("K1212_DEBUG: Stop timeout [%s]\n",
628 stateName
[korg1212
->cardState
]);
631 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
634 static int snd_korg1212_TurnOnIdleMonitor(struct snd_korg1212
*korg1212
)
639 udelay(INTERCOMMAND_DELAY
);
640 spin_lock_irqsave(&korg1212
->lock
, flags
);
641 korg1212
->idleMonitorOn
= 1;
642 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_SelectPlayMode
,
643 K1212_MODE_MonitorOn
, 0, 0, 0);
644 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
648 static void snd_korg1212_TurnOffIdleMonitor(struct snd_korg1212
*korg1212
)
650 if (korg1212
->idleMonitorOn
) {
651 snd_korg1212_SendStopAndWait(korg1212
);
652 korg1212
->idleMonitorOn
= 0;
656 static inline void snd_korg1212_setCardState(struct snd_korg1212
* korg1212
, enum CardState csState
)
658 korg1212
->cardState
= csState
;
661 static int snd_korg1212_OpenCard(struct snd_korg1212
* korg1212
)
663 K1212_DEBUG_PRINTK("K1212_DEBUG: OpenCard [%s] %d\n",
664 stateName
[korg1212
->cardState
], korg1212
->opencnt
);
665 mutex_lock(&korg1212
->open_mutex
);
666 if (korg1212
->opencnt
++ == 0) {
667 snd_korg1212_TurnOffIdleMonitor(korg1212
);
668 snd_korg1212_setCardState(korg1212
, K1212_STATE_OPEN
);
671 mutex_unlock(&korg1212
->open_mutex
);
675 static int snd_korg1212_CloseCard(struct snd_korg1212
* korg1212
)
677 K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard [%s] %d\n",
678 stateName
[korg1212
->cardState
], korg1212
->opencnt
);
680 mutex_lock(&korg1212
->open_mutex
);
681 if (--(korg1212
->opencnt
)) {
682 mutex_unlock(&korg1212
->open_mutex
);
686 if (korg1212
->cardState
== K1212_STATE_SETUP
) {
687 int rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_SelectPlayMode
,
688 K1212_MODE_StopPlay
, 0, 0, 0);
690 K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard - RC = %d [%s]\n",
691 rc
, stateName
[korg1212
->cardState
]);
692 if (rc
!= K1212_CMDRET_Success
) {
693 mutex_unlock(&korg1212
->open_mutex
);
696 } else if (korg1212
->cardState
> K1212_STATE_SETUP
) {
697 snd_korg1212_SendStopAndWait(korg1212
);
700 if (korg1212
->cardState
> K1212_STATE_READY
) {
701 snd_korg1212_TurnOnIdleMonitor(korg1212
);
702 snd_korg1212_setCardState(korg1212
, K1212_STATE_READY
);
705 mutex_unlock(&korg1212
->open_mutex
);
709 /* spinlock already held */
710 static int snd_korg1212_SetupForPlay(struct snd_korg1212
* korg1212
)
714 K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay [%s] %d\n",
715 stateName
[korg1212
->cardState
], korg1212
->setcnt
);
717 if (korg1212
->setcnt
++)
720 snd_korg1212_setCardState(korg1212
, K1212_STATE_SETUP
);
721 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_SelectPlayMode
,
722 K1212_MODE_SetupPlay
, 0, 0, 0);
724 K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay - RC = %d [%s]\n",
725 rc
, stateName
[korg1212
->cardState
]);
726 if (rc
!= K1212_CMDRET_Success
) {
732 /* spinlock already held */
733 static int snd_korg1212_TriggerPlay(struct snd_korg1212
* korg1212
)
737 K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay [%s] %d\n",
738 stateName
[korg1212
->cardState
], korg1212
->playcnt
);
740 if (korg1212
->playcnt
++)
743 snd_korg1212_setCardState(korg1212
, K1212_STATE_PLAYING
);
744 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_TriggerPlay
, 0, 0, 0, 0);
746 K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay - RC = %d [%s]\n",
747 rc
, stateName
[korg1212
->cardState
]);
748 if (rc
!= K1212_CMDRET_Success
) {
754 /* spinlock already held */
755 static int snd_korg1212_StopPlay(struct snd_korg1212
* korg1212
)
757 K1212_DEBUG_PRINTK("K1212_DEBUG: StopPlay [%s] %d\n",
758 stateName
[korg1212
->cardState
], korg1212
->playcnt
);
760 if (--(korg1212
->playcnt
))
763 korg1212
->setcnt
= 0;
765 if (korg1212
->cardState
!= K1212_STATE_ERRORSTOP
)
766 snd_korg1212_SendStop(korg1212
);
768 snd_korg1212_setCardState(korg1212
, K1212_STATE_OPEN
);
772 static void snd_korg1212_EnableCardInterrupts(struct snd_korg1212
* korg1212
)
774 writel(PCI_INT_ENABLE_BIT
|
775 PCI_DOORBELL_INT_ENABLE_BIT
|
776 LOCAL_INT_ENABLE_BIT
|
777 LOCAL_DOORBELL_INT_ENABLE_BIT
|
778 LOCAL_DMA1_INT_ENABLE_BIT
,
779 korg1212
->statusRegPtr
);
784 static int snd_korg1212_SetMonitorMode(struct snd_korg1212
*korg1212
,
785 enum MonitorModeSelector mode
)
787 K1212_DEBUG_PRINTK("K1212_DEBUG: SetMonitorMode [%s]\n",
788 stateName
[korg1212
->cardState
]);
791 case K1212_MONMODE_Off
:
792 if (korg1212
->cardState
!= K1212_STATE_MONITOR
)
795 snd_korg1212_SendStopAndWait(korg1212
);
796 snd_korg1212_setCardState(korg1212
, K1212_STATE_OPEN
);
800 case K1212_MONMODE_On
:
801 if (korg1212
->cardState
!= K1212_STATE_OPEN
)
805 snd_korg1212_setCardState(korg1212
, K1212_STATE_MONITOR
);
806 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_SelectPlayMode
,
807 K1212_MODE_MonitorOn
, 0, 0, 0);
808 if (rc
!= K1212_CMDRET_Success
)
820 #endif /* not used */
822 static inline int snd_korg1212_use_is_exclusive(struct snd_korg1212
*korg1212
)
824 if (korg1212
->playback_pid
!= korg1212
->capture_pid
&&
825 korg1212
->playback_pid
>= 0 && korg1212
->capture_pid
>= 0)
831 static int snd_korg1212_SetRate(struct snd_korg1212
*korg1212
, int rate
)
833 static enum ClockSourceIndex s44
[] = {
834 K1212_CLKIDX_AdatAt44_1K
,
835 K1212_CLKIDX_WordAt44_1K
,
836 K1212_CLKIDX_LocalAt44_1K
838 static enum ClockSourceIndex s48
[] = {
839 K1212_CLKIDX_AdatAt48K
,
840 K1212_CLKIDX_WordAt48K
,
841 K1212_CLKIDX_LocalAt48K
845 if (!snd_korg1212_use_is_exclusive (korg1212
))
850 parm
= s44
[korg1212
->clkSource
];
854 parm
= s48
[korg1212
->clkSource
];
861 korg1212
->clkSrcRate
= parm
;
862 korg1212
->clkRate
= rate
;
864 udelay(INTERCOMMAND_DELAY
);
865 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_SetClockSourceRate
,
866 ClockSourceSelector
[korg1212
->clkSrcRate
],
869 K1212_DEBUG_PRINTK("K1212_DEBUG: Set Clock Source Selector - RC = %d [%s]\n",
870 rc
, stateName
[korg1212
->cardState
]);
875 static int snd_korg1212_SetClockSource(struct snd_korg1212
*korg1212
, int source
)
878 if (source
< 0 || source
> 2)
881 korg1212
->clkSource
= source
;
883 snd_korg1212_SetRate(korg1212
, korg1212
->clkRate
);
888 static void snd_korg1212_DisableCardInterrupts(struct snd_korg1212
*korg1212
)
890 writel(0, korg1212
->statusRegPtr
);
893 static int snd_korg1212_WriteADCSensitivity(struct snd_korg1212
*korg1212
)
895 struct SensBits sensVals
;
900 u16 controlValue
; // this keeps the current value to be written to
901 // the card's eeprom control register.
905 K1212_DEBUG_PRINTK("K1212_DEBUG: WriteADCSensivity [%s]\n",
906 stateName
[korg1212
->cardState
]);
908 // ----------------------------------------------------------------------------
909 // initialize things. The local init bit is always set when writing to the
910 // card's control register.
911 // ----------------------------------------------------------------------------
913 SetBitInWord(&controlValue
, SET_SENS_LOCALINIT_BITPOS
); // init the control value
915 // ----------------------------------------------------------------------------
916 // make sure the card is not in monitor mode when we do this update.
917 // ----------------------------------------------------------------------------
918 if (korg1212
->cardState
== K1212_STATE_MONITOR
|| korg1212
->idleMonitorOn
) {
920 snd_korg1212_SendStopAndWait(korg1212
);
924 spin_lock_irqsave(&korg1212
->lock
, flags
);
926 // ----------------------------------------------------------------------------
927 // we are about to send new values to the card, so clear the new values queued
928 // flag. Also, clear out mailbox 3, so we don't lockup.
929 // ----------------------------------------------------------------------------
930 writel(0, korg1212
->mailbox3Ptr
);
931 udelay(LOADSHIFT_DELAY
);
933 // ----------------------------------------------------------------------------
934 // determine whether we are running a 48K or 44.1K clock. This info is used
935 // later when setting the SPDIF FF after the volume has been shifted in.
936 // ----------------------------------------------------------------------------
937 switch (korg1212
->clkSrcRate
) {
938 case K1212_CLKIDX_AdatAt44_1K
:
939 case K1212_CLKIDX_WordAt44_1K
:
940 case K1212_CLKIDX_LocalAt44_1K
:
944 case K1212_CLKIDX_WordAt48K
:
945 case K1212_CLKIDX_AdatAt48K
:
946 case K1212_CLKIDX_LocalAt48K
:
952 // ----------------------------------------------------------------------------
953 // start the update. Setup the bit structure and then shift the bits.
954 // ----------------------------------------------------------------------------
955 sensVals
.l
.v
.leftChanId
= SET_SENS_LEFTCHANID
;
956 sensVals
.r
.v
.rightChanId
= SET_SENS_RIGHTCHANID
;
957 sensVals
.l
.v
.leftChanVal
= korg1212
->leftADCInSens
;
958 sensVals
.r
.v
.rightChanVal
= korg1212
->rightADCInSens
;
960 // ----------------------------------------------------------------------------
961 // now start shifting the bits in. Start with the left channel then the right.
962 // ----------------------------------------------------------------------------
963 for (channel
= 0; channel
< 2; channel
++) {
965 // ----------------------------------------------------------------------------
966 // Bring the load/shift line low, then wait - the spec says >150ns from load/
967 // shift low to the first rising edge of the clock.
968 // ----------------------------------------------------------------------------
969 ClearBitInWord(&controlValue
, SET_SENS_LOADSHIFT_BITPOS
);
970 ClearBitInWord(&controlValue
, SET_SENS_DATA_BITPOS
);
971 writew(controlValue
, korg1212
->sensRegPtr
); // load/shift goes low
972 udelay(LOADSHIFT_DELAY
);
974 for (bitPosition
= 15; bitPosition
>= 0; bitPosition
--) { // for all the bits
976 if (sensVals
.l
.leftSensBits
& (0x0001 << bitPosition
))
977 SetBitInWord(&controlValue
, SET_SENS_DATA_BITPOS
); // data bit set high
979 ClearBitInWord(&controlValue
, SET_SENS_DATA_BITPOS
); // data bit set low
981 if (sensVals
.r
.rightSensBits
& (0x0001 << bitPosition
))
982 SetBitInWord(&controlValue
, SET_SENS_DATA_BITPOS
); // data bit set high
984 ClearBitInWord(&controlValue
, SET_SENS_DATA_BITPOS
); // data bit set low
987 ClearBitInWord(&controlValue
, SET_SENS_CLOCK_BITPOS
);
988 writew(controlValue
, korg1212
->sensRegPtr
); // clock goes low
989 udelay(SENSCLKPULSE_WIDTH
);
990 SetBitInWord(&controlValue
, SET_SENS_CLOCK_BITPOS
);
991 writew(controlValue
, korg1212
->sensRegPtr
); // clock goes high
992 udelay(SENSCLKPULSE_WIDTH
);
995 // ----------------------------------------------------------------------------
996 // finish up SPDIF for left. Bring the load/shift line high, then write a one
997 // bit if the clock rate is 48K otherwise write 0.
998 // ----------------------------------------------------------------------------
999 ClearBitInWord(&controlValue
, SET_SENS_DATA_BITPOS
);
1000 ClearBitInWord(&controlValue
, SET_SENS_CLOCK_BITPOS
);
1001 SetBitInWord(&controlValue
, SET_SENS_LOADSHIFT_BITPOS
);
1002 writew(controlValue
, korg1212
->sensRegPtr
); // load shift goes high - clk low
1003 udelay(SENSCLKPULSE_WIDTH
);
1006 SetBitInWord(&controlValue
, SET_SENS_DATA_BITPOS
);
1008 writew(controlValue
, korg1212
->sensRegPtr
); // set/clear data bit
1009 udelay(ONE_RTC_TICK
);
1010 SetBitInWord(&controlValue
, SET_SENS_CLOCK_BITPOS
);
1011 writew(controlValue
, korg1212
->sensRegPtr
); // clock goes high
1012 udelay(SENSCLKPULSE_WIDTH
);
1013 ClearBitInWord(&controlValue
, SET_SENS_CLOCK_BITPOS
);
1014 writew(controlValue
, korg1212
->sensRegPtr
); // clock goes low
1015 udelay(SENSCLKPULSE_WIDTH
);
1018 // ----------------------------------------------------------------------------
1019 // The update is complete. Set a timeout. This is the inter-update delay.
1020 // Also, if the card was in monitor mode, restore it.
1021 // ----------------------------------------------------------------------------
1022 for (count
= 0; count
< 10; count
++)
1023 udelay(SENSCLKPULSE_WIDTH
);
1026 int rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_SelectPlayMode
,
1027 K1212_MODE_MonitorOn
, 0, 0, 0);
1029 K1212_DEBUG_PRINTK("K1212_DEBUG: WriteADCSensivity - RC = %d [%s]\n",
1030 rc
, stateName
[korg1212
->cardState
]);
1033 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1038 static void snd_korg1212_OnDSPDownloadComplete(struct snd_korg1212
*korg1212
)
1042 K1212_DEBUG_PRINTK("K1212_DEBUG: DSP download is complete. [%s]\n",
1043 stateName
[korg1212
->cardState
]);
1045 // ----------------------------------------------------
1046 // tell the card to boot
1047 // ----------------------------------------------------
1048 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_BootFromDSPPage4
, 0, 0, 0, 0);
1051 K1212_DEBUG_PRINTK("K1212_DEBUG: Boot from Page 4 - RC = %d [%s]\n",
1052 rc
, stateName
[korg1212
->cardState
]);
1053 msleep(DSP_BOOT_DELAY_IN_MS
);
1055 // --------------------------------------------------------------------------------
1056 // Let the card know where all the buffers are.
1057 // --------------------------------------------------------------------------------
1058 rc
= snd_korg1212_Send1212Command(korg1212
,
1059 K1212_DB_ConfigureBufferMemory
,
1060 LowerWordSwap(korg1212
->PlayDataPhy
),
1061 LowerWordSwap(korg1212
->RecDataPhy
),
1062 ((kNumBuffers
* kPlayBufferFrames
) / 2), // size given to the card
1063 // is based on 2 buffers
1068 K1212_DEBUG_PRINTK("K1212_DEBUG: Configure Buffer Memory - RC = %d [%s]\n",
1069 rc
, stateName
[korg1212
->cardState
]);
1071 udelay(INTERCOMMAND_DELAY
);
1073 rc
= snd_korg1212_Send1212Command(korg1212
,
1074 K1212_DB_ConfigureMiscMemory
,
1075 LowerWordSwap(korg1212
->VolumeTablePhy
),
1076 LowerWordSwap(korg1212
->RoutingTablePhy
),
1077 LowerWordSwap(korg1212
->AdatTimeCodePhy
),
1082 K1212_DEBUG_PRINTK("K1212_DEBUG: Configure Misc Memory - RC = %d [%s]\n",
1083 rc
, stateName
[korg1212
->cardState
]);
1085 // --------------------------------------------------------------------------------
1086 // Initialize the routing and volume tables, then update the card's state.
1087 // --------------------------------------------------------------------------------
1088 udelay(INTERCOMMAND_DELAY
);
1090 for (channel
= 0; channel
< kAudioChannels
; channel
++) {
1091 korg1212
->sharedBufferPtr
->volumeData
[channel
] = k1212MaxVolume
;
1092 //korg1212->sharedBufferPtr->routeData[channel] = channel;
1093 korg1212
->sharedBufferPtr
->routeData
[channel
] = 8 + (channel
& 1);
1096 snd_korg1212_WriteADCSensitivity(korg1212
);
1098 udelay(INTERCOMMAND_DELAY
);
1099 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_SetClockSourceRate
,
1100 ClockSourceSelector
[korg1212
->clkSrcRate
],
1103 K1212_DEBUG_PRINTK("K1212_DEBUG: Set Clock Source Selector - RC = %d [%s]\n",
1104 rc
, stateName
[korg1212
->cardState
]);
1106 rc
= snd_korg1212_TurnOnIdleMonitor(korg1212
);
1107 snd_korg1212_setCardState(korg1212
, K1212_STATE_READY
);
1110 K1212_DEBUG_PRINTK("K1212_DEBUG: Set Monitor On - RC = %d [%s]\n",
1111 rc
, stateName
[korg1212
->cardState
]);
1113 snd_korg1212_setCardState(korg1212
, K1212_STATE_DSP_COMPLETE
);
1116 static irqreturn_t
snd_korg1212_interrupt(int irq
, void *dev_id
)
1119 struct snd_korg1212
*korg1212
= dev_id
;
1121 doorbellValue
= readl(korg1212
->inDoorbellPtr
);
1126 spin_lock(&korg1212
->lock
);
1128 writel(doorbellValue
, korg1212
->inDoorbellPtr
);
1130 korg1212
->irqcount
++;
1134 switch (doorbellValue
) {
1135 case K1212_DB_DSPDownloadDone
:
1136 K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ DNLD count - %ld, %x, [%s].\n",
1137 korg1212
->irqcount
, doorbellValue
,
1138 stateName
[korg1212
->cardState
]);
1139 if (korg1212
->cardState
== K1212_STATE_DSP_IN_PROCESS
) {
1140 korg1212
->dsp_is_loaded
= 1;
1141 wake_up(&korg1212
->wait
);
1145 // ------------------------------------------------------------------------
1146 // an error occurred - stop the card
1147 // ------------------------------------------------------------------------
1148 case K1212_DB_DMAERROR
:
1149 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: IRQ DMAE count - %ld, %x, [%s].\n",
1150 korg1212
->irqcount
, doorbellValue
,
1151 stateName
[korg1212
->cardState
]);
1152 snd_printk(KERN_ERR
"korg1212: DMA Error\n");
1153 korg1212
->errorcnt
++;
1154 korg1212
->totalerrorcnt
++;
1155 korg1212
->sharedBufferPtr
->cardCommand
= 0;
1156 snd_korg1212_setCardState(korg1212
, K1212_STATE_ERRORSTOP
);
1159 // ------------------------------------------------------------------------
1160 // the card has stopped by our request. Clear the command word and signal
1161 // the semaphore in case someone is waiting for this.
1162 // ------------------------------------------------------------------------
1163 case K1212_DB_CARDSTOPPED
:
1164 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: IRQ CSTP count - %ld, %x, [%s].\n",
1165 korg1212
->irqcount
, doorbellValue
,
1166 stateName
[korg1212
->cardState
]);
1167 korg1212
->sharedBufferPtr
->cardCommand
= 0;
1171 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: IRQ DFLT count - %ld, %x, cpos=%d [%s].\n",
1172 korg1212
->irqcount
, doorbellValue
,
1173 korg1212
->currentBuffer
, stateName
[korg1212
->cardState
]);
1174 if ((korg1212
->cardState
> K1212_STATE_SETUP
) || korg1212
->idleMonitorOn
) {
1175 korg1212
->currentBuffer
++;
1177 if (korg1212
->currentBuffer
>= kNumBuffers
)
1178 korg1212
->currentBuffer
= 0;
1180 if (!korg1212
->running
)
1183 if (korg1212
->capture_substream
) {
1184 spin_unlock(&korg1212
->lock
);
1185 snd_pcm_period_elapsed(korg1212
->capture_substream
);
1186 spin_lock(&korg1212
->lock
);
1189 if (korg1212
->playback_substream
) {
1190 spin_unlock(&korg1212
->lock
);
1191 snd_pcm_period_elapsed(korg1212
->playback_substream
);
1192 spin_lock(&korg1212
->lock
);
1200 spin_unlock(&korg1212
->lock
);
1205 static int snd_korg1212_downloadDSPCode(struct snd_korg1212
*korg1212
)
1209 K1212_DEBUG_PRINTK("K1212_DEBUG: DSP download is starting... [%s]\n",
1210 stateName
[korg1212
->cardState
]);
1212 // ---------------------------------------------------------------
1213 // verify the state of the card before proceeding.
1214 // ---------------------------------------------------------------
1215 if (korg1212
->cardState
>= K1212_STATE_DSP_IN_PROCESS
)
1218 snd_korg1212_setCardState(korg1212
, K1212_STATE_DSP_IN_PROCESS
);
1220 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_StartDSPDownload
,
1221 UpperWordSwap(korg1212
->dma_dsp
.addr
),
1224 K1212_DEBUG_PRINTK("K1212_DEBUG: Start DSP Download RC = %d [%s]\n",
1225 rc
, stateName
[korg1212
->cardState
]);
1227 korg1212
->dsp_is_loaded
= 0;
1228 wait_event_timeout(korg1212
->wait
, korg1212
->dsp_is_loaded
, HZ
* CARD_BOOT_TIMEOUT
);
1229 if (! korg1212
->dsp_is_loaded
)
1230 return -EBUSY
; /* timeout */
1232 snd_korg1212_OnDSPDownloadComplete(korg1212
);
1237 static struct snd_pcm_hardware snd_korg1212_playback_info
=
1239 .info
= (SNDRV_PCM_INFO_MMAP
|
1240 SNDRV_PCM_INFO_MMAP_VALID
|
1241 SNDRV_PCM_INFO_INTERLEAVED
|
1242 SNDRV_PCM_INFO_BATCH
),
1243 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
1244 .rates
= (SNDRV_PCM_RATE_44100
|
1245 SNDRV_PCM_RATE_48000
),
1248 .channels_min
= K1212_MIN_CHANNELS
,
1249 .channels_max
= K1212_MAX_CHANNELS
,
1250 .buffer_bytes_max
= K1212_MAX_BUF_SIZE
,
1251 .period_bytes_min
= K1212_MIN_CHANNELS
* 2 * kPlayBufferFrames
,
1252 .period_bytes_max
= K1212_MAX_CHANNELS
* 2 * kPlayBufferFrames
,
1253 .periods_min
= K1212_PERIODS
,
1254 .periods_max
= K1212_PERIODS
,
1258 static struct snd_pcm_hardware snd_korg1212_capture_info
=
1260 .info
= (SNDRV_PCM_INFO_MMAP
|
1261 SNDRV_PCM_INFO_MMAP_VALID
|
1262 SNDRV_PCM_INFO_INTERLEAVED
|
1263 SNDRV_PCM_INFO_BATCH
),
1264 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
1265 .rates
= (SNDRV_PCM_RATE_44100
|
1266 SNDRV_PCM_RATE_48000
),
1269 .channels_min
= K1212_MIN_CHANNELS
,
1270 .channels_max
= K1212_MAX_CHANNELS
,
1271 .buffer_bytes_max
= K1212_MAX_BUF_SIZE
,
1272 .period_bytes_min
= K1212_MIN_CHANNELS
* 2 * kPlayBufferFrames
,
1273 .period_bytes_max
= K1212_MAX_CHANNELS
* 2 * kPlayBufferFrames
,
1274 .periods_min
= K1212_PERIODS
,
1275 .periods_max
= K1212_PERIODS
,
1279 static int snd_korg1212_silence(struct snd_korg1212
*korg1212
, int pos
, int count
, int offset
, int size
)
1281 struct KorgAudioFrame
* dst
= korg1212
->playDataBufsPtr
[0].bufferData
+ pos
;
1284 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_silence pos=%d offset=%d size=%d count=%d\n",
1285 pos
, offset
, size
, count
);
1286 if (snd_BUG_ON(pos
+ count
> K1212_MAX_SAMPLES
))
1289 for (i
=0; i
< count
; i
++) {
1290 #if K1212_DEBUG_LEVEL > 0
1291 if ( (void *) dst
< (void *) korg1212
->playDataBufsPtr
||
1292 (void *) dst
> (void *) korg1212
->playDataBufsPtr
[8].bufferData
) {
1293 printk(KERN_DEBUG
"K1212_DEBUG: snd_korg1212_silence KERNEL EFAULT dst=%p iter=%d\n",
1298 memset((void*) dst
+ offset
, 0, size
);
1305 static int snd_korg1212_copy_to(struct snd_korg1212
*korg1212
, void __user
*dst
, int pos
, int count
, int offset
, int size
)
1307 struct KorgAudioFrame
* src
= korg1212
->recordDataBufsPtr
[0].bufferData
+ pos
;
1310 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_copy_to pos=%d offset=%d size=%d\n",
1312 if (snd_BUG_ON(pos
+ count
> K1212_MAX_SAMPLES
))
1315 for (i
=0; i
< count
; i
++) {
1316 #if K1212_DEBUG_LEVEL > 0
1317 if ( (void *) src
< (void *) korg1212
->recordDataBufsPtr
||
1318 (void *) src
> (void *) korg1212
->recordDataBufsPtr
[8].bufferData
) {
1319 printk(KERN_DEBUG
"K1212_DEBUG: snd_korg1212_copy_to KERNEL EFAULT, src=%p dst=%p iter=%d\n", src
, dst
, i
);
1323 rc
= copy_to_user(dst
+ offset
, src
, size
);
1325 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_to USER EFAULT src=%p dst=%p iter=%d\n", src
, dst
, i
);
1335 static int snd_korg1212_copy_from(struct snd_korg1212
*korg1212
, void __user
*src
, int pos
, int count
, int offset
, int size
)
1337 struct KorgAudioFrame
* dst
= korg1212
->playDataBufsPtr
[0].bufferData
+ pos
;
1340 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_copy_from pos=%d offset=%d size=%d count=%d\n",
1341 pos
, offset
, size
, count
);
1343 if (snd_BUG_ON(pos
+ count
> K1212_MAX_SAMPLES
))
1346 for (i
=0; i
< count
; i
++) {
1347 #if K1212_DEBUG_LEVEL > 0
1348 if ( (void *) dst
< (void *) korg1212
->playDataBufsPtr
||
1349 (void *) dst
> (void *) korg1212
->playDataBufsPtr
[8].bufferData
) {
1350 printk(KERN_DEBUG
"K1212_DEBUG: snd_korg1212_copy_from KERNEL EFAULT, src=%p dst=%p iter=%d\n", src
, dst
, i
);
1354 rc
= copy_from_user((void*) dst
+ offset
, src
, size
);
1356 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_from USER EFAULT src=%p dst=%p iter=%d\n", src
, dst
, i
);
1366 static void snd_korg1212_free_pcm(struct snd_pcm
*pcm
)
1368 struct snd_korg1212
*korg1212
= pcm
->private_data
;
1370 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_free_pcm [%s]\n",
1371 stateName
[korg1212
->cardState
]);
1373 korg1212
->pcm
= NULL
;
1376 static int snd_korg1212_playback_open(struct snd_pcm_substream
*substream
)
1378 unsigned long flags
;
1379 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1380 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1382 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_open [%s]\n",
1383 stateName
[korg1212
->cardState
]);
1385 snd_korg1212_OpenCard(korg1212
);
1387 runtime
->hw
= snd_korg1212_playback_info
;
1388 snd_pcm_set_runtime_buffer(substream
, &korg1212
->dma_play
);
1390 spin_lock_irqsave(&korg1212
->lock
, flags
);
1392 korg1212
->playback_substream
= substream
;
1393 korg1212
->playback_pid
= current
->pid
;
1394 korg1212
->periodsize
= K1212_PERIODS
;
1395 korg1212
->channels
= K1212_CHANNELS
;
1396 korg1212
->errorcnt
= 0;
1398 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1400 snd_pcm_hw_constraint_minmax(runtime
, SNDRV_PCM_HW_PARAM_PERIOD_SIZE
, kPlayBufferFrames
, kPlayBufferFrames
);
1405 static int snd_korg1212_capture_open(struct snd_pcm_substream
*substream
)
1407 unsigned long flags
;
1408 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1409 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1411 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_open [%s]\n",
1412 stateName
[korg1212
->cardState
]);
1414 snd_korg1212_OpenCard(korg1212
);
1416 runtime
->hw
= snd_korg1212_capture_info
;
1417 snd_pcm_set_runtime_buffer(substream
, &korg1212
->dma_rec
);
1419 spin_lock_irqsave(&korg1212
->lock
, flags
);
1421 korg1212
->capture_substream
= substream
;
1422 korg1212
->capture_pid
= current
->pid
;
1423 korg1212
->periodsize
= K1212_PERIODS
;
1424 korg1212
->channels
= K1212_CHANNELS
;
1426 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1428 snd_pcm_hw_constraint_minmax(runtime
, SNDRV_PCM_HW_PARAM_PERIOD_SIZE
,
1429 kPlayBufferFrames
, kPlayBufferFrames
);
1433 static int snd_korg1212_playback_close(struct snd_pcm_substream
*substream
)
1435 unsigned long flags
;
1436 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1438 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_close [%s]\n",
1439 stateName
[korg1212
->cardState
]);
1441 snd_korg1212_silence(korg1212
, 0, K1212_MAX_SAMPLES
, 0, korg1212
->channels
* 2);
1443 spin_lock_irqsave(&korg1212
->lock
, flags
);
1445 korg1212
->playback_pid
= -1;
1446 korg1212
->playback_substream
= NULL
;
1447 korg1212
->periodsize
= 0;
1449 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1451 snd_korg1212_CloseCard(korg1212
);
1455 static int snd_korg1212_capture_close(struct snd_pcm_substream
*substream
)
1457 unsigned long flags
;
1458 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1460 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_close [%s]\n",
1461 stateName
[korg1212
->cardState
]);
1463 spin_lock_irqsave(&korg1212
->lock
, flags
);
1465 korg1212
->capture_pid
= -1;
1466 korg1212
->capture_substream
= NULL
;
1467 korg1212
->periodsize
= 0;
1469 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1471 snd_korg1212_CloseCard(korg1212
);
1475 static int snd_korg1212_ioctl(struct snd_pcm_substream
*substream
,
1476 unsigned int cmd
, void *arg
)
1478 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_ioctl: cmd=%d\n", cmd
);
1480 if (cmd
== SNDRV_PCM_IOCTL1_CHANNEL_INFO
) {
1481 struct snd_pcm_channel_info
*info
= arg
;
1483 info
->first
= info
->channel
* 16;
1485 K1212_DEBUG_PRINTK("K1212_DEBUG: channel_info %d:, offset=%ld, first=%d, step=%d\n", info
->channel
, info
->offset
, info
->first
, info
->step
);
1489 return snd_pcm_lib_ioctl(substream
, cmd
, arg
);
1492 static int snd_korg1212_hw_params(struct snd_pcm_substream
*substream
,
1493 struct snd_pcm_hw_params
*params
)
1495 unsigned long flags
;
1496 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1501 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_hw_params [%s]\n",
1502 stateName
[korg1212
->cardState
]);
1504 spin_lock_irqsave(&korg1212
->lock
, flags
);
1506 if (substream
->pstr
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
1507 this_pid
= korg1212
->playback_pid
;
1508 other_pid
= korg1212
->capture_pid
;
1510 this_pid
= korg1212
->capture_pid
;
1511 other_pid
= korg1212
->playback_pid
;
1514 if ((other_pid
> 0) && (this_pid
!= other_pid
)) {
1516 /* The other stream is open, and not by the same
1517 task as this one. Make sure that the parameters
1518 that matter are the same.
1521 if ((int)params_rate(params
) != korg1212
->clkRate
) {
1522 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1523 _snd_pcm_hw_param_setempty(params
, SNDRV_PCM_HW_PARAM_RATE
);
1527 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1531 if ((err
= snd_korg1212_SetRate(korg1212
, params_rate(params
))) < 0) {
1532 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1536 korg1212
->channels
= params_channels(params
);
1537 korg1212
->periodsize
= K1212_PERIOD_BYTES
;
1539 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1544 static int snd_korg1212_prepare(struct snd_pcm_substream
*substream
)
1546 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1549 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_prepare [%s]\n",
1550 stateName
[korg1212
->cardState
]);
1552 spin_lock_irq(&korg1212
->lock
);
1554 /* FIXME: we should wait for ack! */
1555 if (korg1212
->stop_pending_cnt
> 0) {
1556 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_prepare - Stop is pending... [%s]\n",
1557 stateName
[korg1212
->cardState
]);
1558 spin_unlock_irq(&korg1212
->lock
);
1561 korg1212->sharedBufferPtr->cardCommand = 0;
1562 del_timer(&korg1212->timer);
1563 korg1212->stop_pending_cnt = 0;
1567 rc
= snd_korg1212_SetupForPlay(korg1212
);
1569 korg1212
->currentBuffer
= 0;
1571 spin_unlock_irq(&korg1212
->lock
);
1573 return rc
? -EINVAL
: 0;
1576 static int snd_korg1212_trigger(struct snd_pcm_substream
*substream
,
1579 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1582 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_trigger [%s] cmd=%d\n",
1583 stateName
[korg1212
->cardState
], cmd
);
1585 spin_lock(&korg1212
->lock
);
1587 case SNDRV_PCM_TRIGGER_START
:
1589 if (korg1212->running) {
1590 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_trigger: Already running?\n");
1594 korg1212
->running
++;
1595 rc
= snd_korg1212_TriggerPlay(korg1212
);
1598 case SNDRV_PCM_TRIGGER_STOP
:
1600 if (!korg1212->running) {
1601 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_trigger: Already stopped?\n");
1605 korg1212
->running
--;
1606 rc
= snd_korg1212_StopPlay(korg1212
);
1613 spin_unlock(&korg1212
->lock
);
1614 return rc
? -EINVAL
: 0;
1617 static snd_pcm_uframes_t
snd_korg1212_playback_pointer(struct snd_pcm_substream
*substream
)
1619 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1620 snd_pcm_uframes_t pos
;
1622 pos
= korg1212
->currentBuffer
* kPlayBufferFrames
;
1624 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_playback_pointer [%s] %ld\n",
1625 stateName
[korg1212
->cardState
], pos
);
1630 static snd_pcm_uframes_t
snd_korg1212_capture_pointer(struct snd_pcm_substream
*substream
)
1632 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1633 snd_pcm_uframes_t pos
;
1635 pos
= korg1212
->currentBuffer
* kPlayBufferFrames
;
1637 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_capture_pointer [%s] %ld\n",
1638 stateName
[korg1212
->cardState
], pos
);
1643 static int snd_korg1212_playback_copy(struct snd_pcm_substream
*substream
,
1644 int channel
, /* not used (interleaved data) */
1645 snd_pcm_uframes_t pos
,
1647 snd_pcm_uframes_t count
)
1649 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1651 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_playback_copy [%s] %ld %ld\n",
1652 stateName
[korg1212
->cardState
], pos
, count
);
1654 return snd_korg1212_copy_from(korg1212
, src
, pos
, count
, 0, korg1212
->channels
* 2);
1658 static int snd_korg1212_playback_silence(struct snd_pcm_substream
*substream
,
1659 int channel
, /* not used (interleaved data) */
1660 snd_pcm_uframes_t pos
,
1661 snd_pcm_uframes_t count
)
1663 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1665 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_playback_silence [%s]\n",
1666 stateName
[korg1212
->cardState
]);
1668 return snd_korg1212_silence(korg1212
, pos
, count
, 0, korg1212
->channels
* 2);
1671 static int snd_korg1212_capture_copy(struct snd_pcm_substream
*substream
,
1672 int channel
, /* not used (interleaved data) */
1673 snd_pcm_uframes_t pos
,
1675 snd_pcm_uframes_t count
)
1677 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1679 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_capture_copy [%s] %ld %ld\n",
1680 stateName
[korg1212
->cardState
], pos
, count
);
1682 return snd_korg1212_copy_to(korg1212
, dst
, pos
, count
, 0, korg1212
->channels
* 2);
1685 static struct snd_pcm_ops snd_korg1212_playback_ops
= {
1686 .open
= snd_korg1212_playback_open
,
1687 .close
= snd_korg1212_playback_close
,
1688 .ioctl
= snd_korg1212_ioctl
,
1689 .hw_params
= snd_korg1212_hw_params
,
1690 .prepare
= snd_korg1212_prepare
,
1691 .trigger
= snd_korg1212_trigger
,
1692 .pointer
= snd_korg1212_playback_pointer
,
1693 .copy
= snd_korg1212_playback_copy
,
1694 .silence
= snd_korg1212_playback_silence
,
1697 static struct snd_pcm_ops snd_korg1212_capture_ops
= {
1698 .open
= snd_korg1212_capture_open
,
1699 .close
= snd_korg1212_capture_close
,
1700 .ioctl
= snd_korg1212_ioctl
,
1701 .hw_params
= snd_korg1212_hw_params
,
1702 .prepare
= snd_korg1212_prepare
,
1703 .trigger
= snd_korg1212_trigger
,
1704 .pointer
= snd_korg1212_capture_pointer
,
1705 .copy
= snd_korg1212_capture_copy
,
1712 static int snd_korg1212_control_phase_info(struct snd_kcontrol
*kcontrol
,
1713 struct snd_ctl_elem_info
*uinfo
)
1715 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
1716 uinfo
->count
= (kcontrol
->private_value
>= 8) ? 2 : 1;
1720 static int snd_korg1212_control_phase_get(struct snd_kcontrol
*kcontrol
,
1721 struct snd_ctl_elem_value
*u
)
1723 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1724 int i
= kcontrol
->private_value
;
1726 spin_lock_irq(&korg1212
->lock
);
1728 u
->value
.integer
.value
[0] = korg1212
->volumePhase
[i
];
1731 u
->value
.integer
.value
[1] = korg1212
->volumePhase
[i
+1];
1733 spin_unlock_irq(&korg1212
->lock
);
1738 static int snd_korg1212_control_phase_put(struct snd_kcontrol
*kcontrol
,
1739 struct snd_ctl_elem_value
*u
)
1741 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1745 spin_lock_irq(&korg1212
->lock
);
1747 i
= kcontrol
->private_value
;
1749 korg1212
->volumePhase
[i
] = !!u
->value
.integer
.value
[0];
1751 val
= korg1212
->sharedBufferPtr
->volumeData
[kcontrol
->private_value
];
1753 if ((u
->value
.integer
.value
[0] != 0) != (val
< 0)) {
1754 val
= abs(val
) * (korg1212
->volumePhase
[i
] > 0 ? -1 : 1);
1755 korg1212
->sharedBufferPtr
->volumeData
[i
] = val
;
1760 korg1212
->volumePhase
[i
+1] = !!u
->value
.integer
.value
[1];
1762 val
= korg1212
->sharedBufferPtr
->volumeData
[kcontrol
->private_value
+1];
1764 if ((u
->value
.integer
.value
[1] != 0) != (val
< 0)) {
1765 val
= abs(val
) * (korg1212
->volumePhase
[i
+1] > 0 ? -1 : 1);
1766 korg1212
->sharedBufferPtr
->volumeData
[i
+1] = val
;
1771 spin_unlock_irq(&korg1212
->lock
);
1776 static int snd_korg1212_control_volume_info(struct snd_kcontrol
*kcontrol
,
1777 struct snd_ctl_elem_info
*uinfo
)
1779 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
1780 uinfo
->count
= (kcontrol
->private_value
>= 8) ? 2 : 1;
1781 uinfo
->value
.integer
.min
= k1212MinVolume
;
1782 uinfo
->value
.integer
.max
= k1212MaxVolume
;
1786 static int snd_korg1212_control_volume_get(struct snd_kcontrol
*kcontrol
,
1787 struct snd_ctl_elem_value
*u
)
1789 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1792 spin_lock_irq(&korg1212
->lock
);
1794 i
= kcontrol
->private_value
;
1795 u
->value
.integer
.value
[0] = abs(korg1212
->sharedBufferPtr
->volumeData
[i
]);
1798 u
->value
.integer
.value
[1] = abs(korg1212
->sharedBufferPtr
->volumeData
[i
+1]);
1800 spin_unlock_irq(&korg1212
->lock
);
1805 static int snd_korg1212_control_volume_put(struct snd_kcontrol
*kcontrol
,
1806 struct snd_ctl_elem_value
*u
)
1808 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1813 spin_lock_irq(&korg1212
->lock
);
1815 i
= kcontrol
->private_value
;
1817 if (u
->value
.integer
.value
[0] >= k1212MinVolume
&&
1818 u
->value
.integer
.value
[0] >= k1212MaxVolume
&&
1819 u
->value
.integer
.value
[0] !=
1820 abs(korg1212
->sharedBufferPtr
->volumeData
[i
])) {
1821 val
= korg1212
->volumePhase
[i
] > 0 ? -1 : 1;
1822 val
*= u
->value
.integer
.value
[0];
1823 korg1212
->sharedBufferPtr
->volumeData
[i
] = val
;
1828 if (u
->value
.integer
.value
[1] >= k1212MinVolume
&&
1829 u
->value
.integer
.value
[1] >= k1212MaxVolume
&&
1830 u
->value
.integer
.value
[1] !=
1831 abs(korg1212
->sharedBufferPtr
->volumeData
[i
+1])) {
1832 val
= korg1212
->volumePhase
[i
+1] > 0 ? -1 : 1;
1833 val
*= u
->value
.integer
.value
[1];
1834 korg1212
->sharedBufferPtr
->volumeData
[i
+1] = val
;
1839 spin_unlock_irq(&korg1212
->lock
);
1844 static int snd_korg1212_control_route_info(struct snd_kcontrol
*kcontrol
,
1845 struct snd_ctl_elem_info
*uinfo
)
1847 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
1848 uinfo
->count
= (kcontrol
->private_value
>= 8) ? 2 : 1;
1849 uinfo
->value
.enumerated
.items
= kAudioChannels
;
1850 if (uinfo
->value
.enumerated
.item
> kAudioChannels
-1) {
1851 uinfo
->value
.enumerated
.item
= kAudioChannels
-1;
1853 strcpy(uinfo
->value
.enumerated
.name
, channelName
[uinfo
->value
.enumerated
.item
]);
1857 static int snd_korg1212_control_route_get(struct snd_kcontrol
*kcontrol
,
1858 struct snd_ctl_elem_value
*u
)
1860 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1863 spin_lock_irq(&korg1212
->lock
);
1865 i
= kcontrol
->private_value
;
1866 u
->value
.enumerated
.item
[0] = korg1212
->sharedBufferPtr
->routeData
[i
];
1869 u
->value
.enumerated
.item
[1] = korg1212
->sharedBufferPtr
->routeData
[i
+1];
1871 spin_unlock_irq(&korg1212
->lock
);
1876 static int snd_korg1212_control_route_put(struct snd_kcontrol
*kcontrol
,
1877 struct snd_ctl_elem_value
*u
)
1879 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1882 spin_lock_irq(&korg1212
->lock
);
1884 i
= kcontrol
->private_value
;
1886 if (u
->value
.enumerated
.item
[0] < kAudioChannels
&&
1887 u
->value
.enumerated
.item
[0] !=
1888 (unsigned) korg1212
->sharedBufferPtr
->volumeData
[i
]) {
1889 korg1212
->sharedBufferPtr
->routeData
[i
] = u
->value
.enumerated
.item
[0];
1894 if (u
->value
.enumerated
.item
[1] < kAudioChannels
&&
1895 u
->value
.enumerated
.item
[1] !=
1896 (unsigned) korg1212
->sharedBufferPtr
->volumeData
[i
+1]) {
1897 korg1212
->sharedBufferPtr
->routeData
[i
+1] = u
->value
.enumerated
.item
[1];
1902 spin_unlock_irq(&korg1212
->lock
);
1907 static int snd_korg1212_control_info(struct snd_kcontrol
*kcontrol
,
1908 struct snd_ctl_elem_info
*uinfo
)
1910 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
1912 uinfo
->value
.integer
.min
= k1212MaxADCSens
;
1913 uinfo
->value
.integer
.max
= k1212MinADCSens
;
1917 static int snd_korg1212_control_get(struct snd_kcontrol
*kcontrol
,
1918 struct snd_ctl_elem_value
*u
)
1920 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1922 spin_lock_irq(&korg1212
->lock
);
1924 u
->value
.integer
.value
[0] = korg1212
->leftADCInSens
;
1925 u
->value
.integer
.value
[1] = korg1212
->rightADCInSens
;
1927 spin_unlock_irq(&korg1212
->lock
);
1932 static int snd_korg1212_control_put(struct snd_kcontrol
*kcontrol
,
1933 struct snd_ctl_elem_value
*u
)
1935 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1938 spin_lock_irq(&korg1212
->lock
);
1940 if (u
->value
.integer
.value
[0] >= k1212MinADCSens
&&
1941 u
->value
.integer
.value
[0] <= k1212MaxADCSens
&&
1942 u
->value
.integer
.value
[0] != korg1212
->leftADCInSens
) {
1943 korg1212
->leftADCInSens
= u
->value
.integer
.value
[0];
1946 if (u
->value
.integer
.value
[1] >= k1212MinADCSens
&&
1947 u
->value
.integer
.value
[1] <= k1212MaxADCSens
&&
1948 u
->value
.integer
.value
[1] != korg1212
->rightADCInSens
) {
1949 korg1212
->rightADCInSens
= u
->value
.integer
.value
[1];
1953 spin_unlock_irq(&korg1212
->lock
);
1956 snd_korg1212_WriteADCSensitivity(korg1212
);
1961 static int snd_korg1212_control_sync_info(struct snd_kcontrol
*kcontrol
,
1962 struct snd_ctl_elem_info
*uinfo
)
1964 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
1966 uinfo
->value
.enumerated
.items
= 3;
1967 if (uinfo
->value
.enumerated
.item
> 2) {
1968 uinfo
->value
.enumerated
.item
= 2;
1970 strcpy(uinfo
->value
.enumerated
.name
, clockSourceTypeName
[uinfo
->value
.enumerated
.item
]);
1974 static int snd_korg1212_control_sync_get(struct snd_kcontrol
*kcontrol
,
1975 struct snd_ctl_elem_value
*ucontrol
)
1977 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1979 spin_lock_irq(&korg1212
->lock
);
1981 ucontrol
->value
.enumerated
.item
[0] = korg1212
->clkSource
;
1983 spin_unlock_irq(&korg1212
->lock
);
1987 static int snd_korg1212_control_sync_put(struct snd_kcontrol
*kcontrol
,
1988 struct snd_ctl_elem_value
*ucontrol
)
1990 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1994 val
= ucontrol
->value
.enumerated
.item
[0] % 3;
1995 spin_lock_irq(&korg1212
->lock
);
1996 change
= val
!= korg1212
->clkSource
;
1997 snd_korg1212_SetClockSource(korg1212
, val
);
1998 spin_unlock_irq(&korg1212
->lock
);
2002 #define MON_MIXER(ord,c_name) \
2004 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_WRITE, \
2005 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2006 .name = c_name " Monitor Volume", \
2007 .info = snd_korg1212_control_volume_info, \
2008 .get = snd_korg1212_control_volume_get, \
2009 .put = snd_korg1212_control_volume_put, \
2010 .private_value = ord, \
2013 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_WRITE, \
2014 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2015 .name = c_name " Monitor Route", \
2016 .info = snd_korg1212_control_route_info, \
2017 .get = snd_korg1212_control_route_get, \
2018 .put = snd_korg1212_control_route_put, \
2019 .private_value = ord, \
2022 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_WRITE, \
2023 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2024 .name = c_name " Monitor Phase Invert", \
2025 .info = snd_korg1212_control_phase_info, \
2026 .get = snd_korg1212_control_phase_get, \
2027 .put = snd_korg1212_control_phase_put, \
2028 .private_value = ord, \
2031 static struct snd_kcontrol_new snd_korg1212_controls
[] = {
2032 MON_MIXER(8, "Analog"),
2033 MON_MIXER(10, "SPDIF"),
2034 MON_MIXER(0, "ADAT-1"), MON_MIXER(1, "ADAT-2"), MON_MIXER(2, "ADAT-3"), MON_MIXER(3, "ADAT-4"),
2035 MON_MIXER(4, "ADAT-5"), MON_MIXER(5, "ADAT-6"), MON_MIXER(6, "ADAT-7"), MON_MIXER(7, "ADAT-8"),
2037 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_WRITE
,
2038 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2039 .name
= "Sync Source",
2040 .info
= snd_korg1212_control_sync_info
,
2041 .get
= snd_korg1212_control_sync_get
,
2042 .put
= snd_korg1212_control_sync_put
,
2045 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_WRITE
,
2046 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2047 .name
= "ADC Attenuation",
2048 .info
= snd_korg1212_control_info
,
2049 .get
= snd_korg1212_control_get
,
2050 .put
= snd_korg1212_control_put
,
2058 static void snd_korg1212_proc_read(struct snd_info_entry
*entry
,
2059 struct snd_info_buffer
*buffer
)
2062 struct snd_korg1212
*korg1212
= entry
->private_data
;
2064 snd_iprintf(buffer
, korg1212
->card
->longname
);
2065 snd_iprintf(buffer
, " (index #%d)\n", korg1212
->card
->number
+ 1);
2066 snd_iprintf(buffer
, "\nGeneral settings\n");
2067 snd_iprintf(buffer
, " period size: %Zd bytes\n", K1212_PERIOD_BYTES
);
2068 snd_iprintf(buffer
, " clock mode: %s\n", clockSourceName
[korg1212
->clkSrcRate
] );
2069 snd_iprintf(buffer
, " left ADC Sens: %d\n", korg1212
->leftADCInSens
);
2070 snd_iprintf(buffer
, " right ADC Sens: %d\n", korg1212
->rightADCInSens
);
2071 snd_iprintf(buffer
, " Volume Info:\n");
2072 for (n
=0; n
<kAudioChannels
; n
++)
2073 snd_iprintf(buffer
, " Channel %d: %s -> %s [%d]\n", n
,
2075 channelName
[korg1212
->sharedBufferPtr
->routeData
[n
]],
2076 korg1212
->sharedBufferPtr
->volumeData
[n
]);
2077 snd_iprintf(buffer
, "\nGeneral status\n");
2078 snd_iprintf(buffer
, " ADAT Time Code: %d\n", korg1212
->sharedBufferPtr
->AdatTimeCode
);
2079 snd_iprintf(buffer
, " Card State: %s\n", stateName
[korg1212
->cardState
]);
2080 snd_iprintf(buffer
, "Idle mon. State: %d\n", korg1212
->idleMonitorOn
);
2081 snd_iprintf(buffer
, "Cmd retry count: %d\n", korg1212
->cmdRetryCount
);
2082 snd_iprintf(buffer
, " Irq count: %ld\n", korg1212
->irqcount
);
2083 snd_iprintf(buffer
, " Error count: %ld\n", korg1212
->totalerrorcnt
);
2086 static void __devinit
snd_korg1212_proc_init(struct snd_korg1212
*korg1212
)
2088 struct snd_info_entry
*entry
;
2090 if (! snd_card_proc_new(korg1212
->card
, "korg1212", &entry
))
2091 snd_info_set_text_ops(entry
, korg1212
, snd_korg1212_proc_read
);
2095 snd_korg1212_free(struct snd_korg1212
*korg1212
)
2097 snd_korg1212_TurnOffIdleMonitor(korg1212
);
2099 if (korg1212
->irq
>= 0) {
2100 snd_korg1212_DisableCardInterrupts(korg1212
);
2101 free_irq(korg1212
->irq
, korg1212
);
2105 if (korg1212
->iobase
!= NULL
) {
2106 iounmap(korg1212
->iobase
);
2107 korg1212
->iobase
= NULL
;
2110 pci_release_regions(korg1212
->pci
);
2112 // ----------------------------------------------------
2113 // free up memory resources used for the DSP download.
2114 // ----------------------------------------------------
2115 if (korg1212
->dma_dsp
.area
) {
2116 snd_dma_free_pages(&korg1212
->dma_dsp
);
2117 korg1212
->dma_dsp
.area
= NULL
;
2120 #ifndef K1212_LARGEALLOC
2122 // ------------------------------------------------------
2123 // free up memory resources used for the Play/Rec Buffers
2124 // ------------------------------------------------------
2125 if (korg1212
->dma_play
.area
) {
2126 snd_dma_free_pages(&korg1212
->dma_play
);
2127 korg1212
->dma_play
.area
= NULL
;
2130 if (korg1212
->dma_rec
.area
) {
2131 snd_dma_free_pages(&korg1212
->dma_rec
);
2132 korg1212
->dma_rec
.area
= NULL
;
2137 // ----------------------------------------------------
2138 // free up memory resources used for the Shared Buffers
2139 // ----------------------------------------------------
2140 if (korg1212
->dma_shared
.area
) {
2141 snd_dma_free_pages(&korg1212
->dma_shared
);
2142 korg1212
->dma_shared
.area
= NULL
;
2145 pci_disable_device(korg1212
->pci
);
2150 static int snd_korg1212_dev_free(struct snd_device
*device
)
2152 struct snd_korg1212
*korg1212
= device
->device_data
;
2153 K1212_DEBUG_PRINTK("K1212_DEBUG: Freeing device\n");
2154 return snd_korg1212_free(korg1212
);
2157 static int __devinit
snd_korg1212_create(struct snd_card
*card
, struct pci_dev
*pci
,
2158 struct snd_korg1212
** rchip
)
2163 unsigned ioport_size
, iomem_size
, iomem2_size
;
2164 struct snd_korg1212
* korg1212
;
2165 const struct firmware
*dsp_code
;
2167 static struct snd_device_ops ops
= {
2168 .dev_free
= snd_korg1212_dev_free
,
2172 if ((err
= pci_enable_device(pci
)) < 0)
2175 korg1212
= kzalloc(sizeof(*korg1212
), GFP_KERNEL
);
2176 if (korg1212
== NULL
) {
2177 pci_disable_device(pci
);
2181 korg1212
->card
= card
;
2182 korg1212
->pci
= pci
;
2184 init_waitqueue_head(&korg1212
->wait
);
2185 spin_lock_init(&korg1212
->lock
);
2186 mutex_init(&korg1212
->open_mutex
);
2187 init_timer(&korg1212
->timer
);
2188 korg1212
->timer
.function
= snd_korg1212_timer_func
;
2189 korg1212
->timer
.data
= (unsigned long)korg1212
;
2192 korg1212
->clkSource
= K1212_CLKIDX_Local
;
2193 korg1212
->clkRate
= 44100;
2194 korg1212
->inIRQ
= 0;
2195 korg1212
->running
= 0;
2196 korg1212
->opencnt
= 0;
2197 korg1212
->playcnt
= 0;
2198 korg1212
->setcnt
= 0;
2199 korg1212
->totalerrorcnt
= 0;
2200 korg1212
->playback_pid
= -1;
2201 korg1212
->capture_pid
= -1;
2202 snd_korg1212_setCardState(korg1212
, K1212_STATE_UNINITIALIZED
);
2203 korg1212
->idleMonitorOn
= 0;
2204 korg1212
->clkSrcRate
= K1212_CLKIDX_LocalAt44_1K
;
2205 korg1212
->leftADCInSens
= k1212MaxADCSens
;
2206 korg1212
->rightADCInSens
= k1212MaxADCSens
;
2208 for (i
=0; i
<kAudioChannels
; i
++)
2209 korg1212
->volumePhase
[i
] = 0;
2211 if ((err
= pci_request_regions(pci
, "korg1212")) < 0) {
2213 pci_disable_device(pci
);
2217 korg1212
->iomem
= pci_resource_start(korg1212
->pci
, 0);
2218 korg1212
->ioport
= pci_resource_start(korg1212
->pci
, 1);
2219 korg1212
->iomem2
= pci_resource_start(korg1212
->pci
, 2);
2221 iomem_size
= pci_resource_len(korg1212
->pci
, 0);
2222 ioport_size
= pci_resource_len(korg1212
->pci
, 1);
2223 iomem2_size
= pci_resource_len(korg1212
->pci
, 2);
2225 K1212_DEBUG_PRINTK("K1212_DEBUG: resources:\n"
2226 " iomem = 0x%lx (%d)\n"
2227 " ioport = 0x%lx (%d)\n"
2228 " iomem = 0x%lx (%d)\n"
2230 korg1212
->iomem
, iomem_size
,
2231 korg1212
->ioport
, ioport_size
,
2232 korg1212
->iomem2
, iomem2_size
,
2233 stateName
[korg1212
->cardState
]);
2235 if ((korg1212
->iobase
= ioremap(korg1212
->iomem
, iomem_size
)) == NULL
) {
2236 snd_printk(KERN_ERR
"korg1212: unable to remap memory region 0x%lx-0x%lx\n", korg1212
->iomem
,
2237 korg1212
->iomem
+ iomem_size
- 1);
2238 snd_korg1212_free(korg1212
);
2242 err
= request_irq(pci
->irq
, snd_korg1212_interrupt
,
2244 KBUILD_MODNAME
, korg1212
);
2247 snd_printk(KERN_ERR
"korg1212: unable to grab IRQ %d\n", pci
->irq
);
2248 snd_korg1212_free(korg1212
);
2252 korg1212
->irq
= pci
->irq
;
2254 pci_set_master(korg1212
->pci
);
2256 korg1212
->statusRegPtr
= (u32 __iomem
*) (korg1212
->iobase
+ STATUS_REG_OFFSET
);
2257 korg1212
->outDoorbellPtr
= (u32 __iomem
*) (korg1212
->iobase
+ OUT_DOORBELL_OFFSET
);
2258 korg1212
->inDoorbellPtr
= (u32 __iomem
*) (korg1212
->iobase
+ IN_DOORBELL_OFFSET
);
2259 korg1212
->mailbox0Ptr
= (u32 __iomem
*) (korg1212
->iobase
+ MAILBOX0_OFFSET
);
2260 korg1212
->mailbox1Ptr
= (u32 __iomem
*) (korg1212
->iobase
+ MAILBOX1_OFFSET
);
2261 korg1212
->mailbox2Ptr
= (u32 __iomem
*) (korg1212
->iobase
+ MAILBOX2_OFFSET
);
2262 korg1212
->mailbox3Ptr
= (u32 __iomem
*) (korg1212
->iobase
+ MAILBOX3_OFFSET
);
2263 korg1212
->controlRegPtr
= (u32 __iomem
*) (korg1212
->iobase
+ PCI_CONTROL_OFFSET
);
2264 korg1212
->sensRegPtr
= (u16 __iomem
*) (korg1212
->iobase
+ SENS_CONTROL_OFFSET
);
2265 korg1212
->idRegPtr
= (u32 __iomem
*) (korg1212
->iobase
+ DEV_VEND_ID_OFFSET
);
2267 K1212_DEBUG_PRINTK("K1212_DEBUG: card registers:\n"
2268 " Status register = 0x%p\n"
2269 " OutDoorbell = 0x%p\n"
2270 " InDoorbell = 0x%p\n"
2271 " Mailbox0 = 0x%p\n"
2272 " Mailbox1 = 0x%p\n"
2273 " Mailbox2 = 0x%p\n"
2274 " Mailbox3 = 0x%p\n"
2275 " ControlReg = 0x%p\n"
2279 korg1212
->statusRegPtr
,
2280 korg1212
->outDoorbellPtr
,
2281 korg1212
->inDoorbellPtr
,
2282 korg1212
->mailbox0Ptr
,
2283 korg1212
->mailbox1Ptr
,
2284 korg1212
->mailbox2Ptr
,
2285 korg1212
->mailbox3Ptr
,
2286 korg1212
->controlRegPtr
,
2287 korg1212
->sensRegPtr
,
2289 stateName
[korg1212
->cardState
]);
2291 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(pci
),
2292 sizeof(struct KorgSharedBuffer
), &korg1212
->dma_shared
) < 0) {
2293 snd_printk(KERN_ERR
"korg1212: can not allocate shared buffer memory (%Zd bytes)\n", sizeof(struct KorgSharedBuffer
));
2294 snd_korg1212_free(korg1212
);
2297 korg1212
->sharedBufferPtr
= (struct KorgSharedBuffer
*)korg1212
->dma_shared
.area
;
2298 korg1212
->sharedBufferPhy
= korg1212
->dma_shared
.addr
;
2300 K1212_DEBUG_PRINTK("K1212_DEBUG: Shared Buffer Area = 0x%p (0x%08lx), %d bytes\n", korg1212
->sharedBufferPtr
, korg1212
->sharedBufferPhy
, sizeof(struct KorgSharedBuffer
));
2302 #ifndef K1212_LARGEALLOC
2304 korg1212
->DataBufsSize
= sizeof(struct KorgAudioBuffer
) * kNumBuffers
;
2306 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(pci
),
2307 korg1212
->DataBufsSize
, &korg1212
->dma_play
) < 0) {
2308 snd_printk(KERN_ERR
"korg1212: can not allocate play data buffer memory (%d bytes)\n", korg1212
->DataBufsSize
);
2309 snd_korg1212_free(korg1212
);
2312 korg1212
->playDataBufsPtr
= (struct KorgAudioBuffer
*)korg1212
->dma_play
.area
;
2313 korg1212
->PlayDataPhy
= korg1212
->dma_play
.addr
;
2315 K1212_DEBUG_PRINTK("K1212_DEBUG: Play Data Area = 0x%p (0x%08x), %d bytes\n",
2316 korg1212
->playDataBufsPtr
, korg1212
->PlayDataPhy
, korg1212
->DataBufsSize
);
2318 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(pci
),
2319 korg1212
->DataBufsSize
, &korg1212
->dma_rec
) < 0) {
2320 snd_printk(KERN_ERR
"korg1212: can not allocate record data buffer memory (%d bytes)\n", korg1212
->DataBufsSize
);
2321 snd_korg1212_free(korg1212
);
2324 korg1212
->recordDataBufsPtr
= (struct KorgAudioBuffer
*)korg1212
->dma_rec
.area
;
2325 korg1212
->RecDataPhy
= korg1212
->dma_rec
.addr
;
2327 K1212_DEBUG_PRINTK("K1212_DEBUG: Record Data Area = 0x%p (0x%08x), %d bytes\n",
2328 korg1212
->recordDataBufsPtr
, korg1212
->RecDataPhy
, korg1212
->DataBufsSize
);
2330 #else // K1212_LARGEALLOC
2332 korg1212
->recordDataBufsPtr
= korg1212
->sharedBufferPtr
->recordDataBufs
;
2333 korg1212
->playDataBufsPtr
= korg1212
->sharedBufferPtr
->playDataBufs
;
2334 korg1212
->PlayDataPhy
= (u32
) &((struct KorgSharedBuffer
*) korg1212
->sharedBufferPhy
)->playDataBufs
;
2335 korg1212
->RecDataPhy
= (u32
) &((struct KorgSharedBuffer
*) korg1212
->sharedBufferPhy
)->recordDataBufs
;
2337 #endif // K1212_LARGEALLOC
2339 korg1212
->VolumeTablePhy
= korg1212
->sharedBufferPhy
+
2340 offsetof(struct KorgSharedBuffer
, volumeData
);
2341 korg1212
->RoutingTablePhy
= korg1212
->sharedBufferPhy
+
2342 offsetof(struct KorgSharedBuffer
, routeData
);
2343 korg1212
->AdatTimeCodePhy
= korg1212
->sharedBufferPhy
+
2344 offsetof(struct KorgSharedBuffer
, AdatTimeCode
);
2346 err
= request_firmware(&dsp_code
, "korg/k1212.dsp", &pci
->dev
);
2348 release_firmware(dsp_code
);
2349 snd_printk(KERN_ERR
"firmware not available\n");
2350 snd_korg1212_free(korg1212
);
2354 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(pci
),
2355 dsp_code
->size
, &korg1212
->dma_dsp
) < 0) {
2356 snd_printk(KERN_ERR
"korg1212: cannot allocate dsp code memory (%zd bytes)\n", dsp_code
->size
);
2357 snd_korg1212_free(korg1212
);
2358 release_firmware(dsp_code
);
2362 K1212_DEBUG_PRINTK("K1212_DEBUG: DSP Code area = 0x%p (0x%08x) %d bytes [%s]\n",
2363 korg1212
->dma_dsp
.area
, korg1212
->dma_dsp
.addr
, dsp_code
->size
,
2364 stateName
[korg1212
->cardState
]);
2366 memcpy(korg1212
->dma_dsp
.area
, dsp_code
->data
, dsp_code
->size
);
2368 release_firmware(dsp_code
);
2370 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_RebootCard
, 0, 0, 0, 0);
2373 K1212_DEBUG_PRINTK("K1212_DEBUG: Reboot Card - RC = %d [%s]\n", rc
, stateName
[korg1212
->cardState
]);
2375 if ((err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, korg1212
, &ops
)) < 0) {
2376 snd_korg1212_free(korg1212
);
2380 snd_korg1212_EnableCardInterrupts(korg1212
);
2382 mdelay(CARD_BOOT_DELAY_IN_MS
);
2384 if (snd_korg1212_downloadDSPCode(korg1212
))
2387 K1212_DEBUG_PRINTK("korg1212: dspMemPhy = %08x U[%08x], "
2388 "PlayDataPhy = %08x L[%08x]\n"
2389 "korg1212: RecDataPhy = %08x L[%08x], "
2390 "VolumeTablePhy = %08x L[%08x]\n"
2391 "korg1212: RoutingTablePhy = %08x L[%08x], "
2392 "AdatTimeCodePhy = %08x L[%08x]\n",
2393 (int)korg1212
->dma_dsp
.addr
, UpperWordSwap(korg1212
->dma_dsp
.addr
),
2394 korg1212
->PlayDataPhy
, LowerWordSwap(korg1212
->PlayDataPhy
),
2395 korg1212
->RecDataPhy
, LowerWordSwap(korg1212
->RecDataPhy
),
2396 korg1212
->VolumeTablePhy
, LowerWordSwap(korg1212
->VolumeTablePhy
),
2397 korg1212
->RoutingTablePhy
, LowerWordSwap(korg1212
->RoutingTablePhy
),
2398 korg1212
->AdatTimeCodePhy
, LowerWordSwap(korg1212
->AdatTimeCodePhy
));
2400 if ((err
= snd_pcm_new(korg1212
->card
, "korg1212", 0, 1, 1, &korg1212
->pcm
)) < 0)
2403 korg1212
->pcm
->private_data
= korg1212
;
2404 korg1212
->pcm
->private_free
= snd_korg1212_free_pcm
;
2405 strcpy(korg1212
->pcm
->name
, "korg1212");
2407 snd_pcm_set_ops(korg1212
->pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_korg1212_playback_ops
);
2409 snd_pcm_set_ops(korg1212
->pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_korg1212_capture_ops
);
2411 korg1212
->pcm
->info_flags
= SNDRV_PCM_INFO_JOINT_DUPLEX
;
2413 for (i
= 0; i
< ARRAY_SIZE(snd_korg1212_controls
); i
++) {
2414 err
= snd_ctl_add(korg1212
->card
, snd_ctl_new1(&snd_korg1212_controls
[i
], korg1212
));
2419 snd_korg1212_proc_init(korg1212
);
2421 snd_card_set_dev(card
, &pci
->dev
);
2429 * Card initialisation
2432 static int __devinit
2433 snd_korg1212_probe(struct pci_dev
*pci
,
2434 const struct pci_device_id
*pci_id
)
2437 struct snd_korg1212
*korg1212
;
2438 struct snd_card
*card
;
2441 if (dev
>= SNDRV_CARDS
) {
2448 err
= snd_card_create(index
[dev
], id
[dev
], THIS_MODULE
, 0, &card
);
2452 if ((err
= snd_korg1212_create(card
, pci
, &korg1212
)) < 0) {
2453 snd_card_free(card
);
2457 strcpy(card
->driver
, "korg1212");
2458 strcpy(card
->shortname
, "korg1212");
2459 sprintf(card
->longname
, "%s at 0x%lx, irq %d", card
->shortname
,
2460 korg1212
->iomem
, korg1212
->irq
);
2462 K1212_DEBUG_PRINTK("K1212_DEBUG: %s\n", card
->longname
);
2464 if ((err
= snd_card_register(card
)) < 0) {
2465 snd_card_free(card
);
2468 pci_set_drvdata(pci
, card
);
2473 static void __devexit
snd_korg1212_remove(struct pci_dev
*pci
)
2475 snd_card_free(pci_get_drvdata(pci
));
2476 pci_set_drvdata(pci
, NULL
);
2479 static struct pci_driver korg1212_driver
= {
2480 .name
= KBUILD_MODNAME
,
2481 .id_table
= snd_korg1212_ids
,
2482 .probe
= snd_korg1212_probe
,
2483 .remove
= __devexit_p(snd_korg1212_remove
),
2486 module_pci_driver(korg1212_driver
);