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>
33 #include <sound/core.h>
34 #include <sound/info.h>
35 #include <sound/control.h>
36 #include <sound/pcm.h>
37 #include <sound/pcm_params.h>
38 #include <sound/initval.h>
40 // ----------------------------------------------------------------------------
42 // ----------------------------------------------------------------------------
43 #define K1212_DEBUG_LEVEL 0
44 #if K1212_DEBUG_LEVEL > 0
45 #define K1212_DEBUG_PRINTK(fmt,args...) printk(KERN_DEBUG fmt,##args)
47 #define K1212_DEBUG_PRINTK(fmt,...)
49 #if K1212_DEBUG_LEVEL > 1
50 #define K1212_DEBUG_PRINTK_VERBOSE(fmt,args...) printk(KERN_DEBUG fmt,##args)
52 #define K1212_DEBUG_PRINTK_VERBOSE(fmt,...)
55 // ----------------------------------------------------------------------------
56 // Record/Play Buffer Allocation Method. If K1212_LARGEALLOC is defined all
57 // buffers are alocated as a large piece inside KorgSharedBuffer.
58 // ----------------------------------------------------------------------------
59 //#define K1212_LARGEALLOC 1
61 // ----------------------------------------------------------------------------
62 // Valid states of the Korg 1212 I/O card.
63 // ----------------------------------------------------------------------------
65 K1212_STATE_NONEXISTENT
, // there is no card here
66 K1212_STATE_UNINITIALIZED
, // the card is awaiting DSP download
67 K1212_STATE_DSP_IN_PROCESS
, // the card is currently downloading its DSP code
68 K1212_STATE_DSP_COMPLETE
, // the card has finished the DSP download
69 K1212_STATE_READY
, // the card can be opened by an application. Any application
70 // requests prior to this state should fail. Only an open
71 // request can be made at this state.
72 K1212_STATE_OPEN
, // an application has opened the card
73 K1212_STATE_SETUP
, // the card has been setup for play
74 K1212_STATE_PLAYING
, // the card is playing
75 K1212_STATE_MONITOR
, // the card is in the monitor mode
76 K1212_STATE_CALIBRATING
, // the card is currently calibrating
77 K1212_STATE_ERRORSTOP
, // the card has stopped itself because of an error and we
78 // are in the process of cleaning things up.
79 K1212_STATE_MAX_STATE
// state values of this and beyond are invalid
82 // ----------------------------------------------------------------------------
83 // The following enumeration defines the constants written to the card's
84 // host-to-card doorbell to initiate a command.
85 // ----------------------------------------------------------------------------
86 enum korg1212_dbcnst
{
87 K1212_DB_RequestForData
= 0, // sent by the card to request a buffer fill.
88 K1212_DB_TriggerPlay
= 1, // starts playback/record on the card.
89 K1212_DB_SelectPlayMode
= 2, // select monitor, playback setup, or stop.
90 K1212_DB_ConfigureBufferMemory
= 3, // tells card where the host audio buffers are.
91 K1212_DB_RequestAdatTimecode
= 4, // asks the card for the latest ADAT timecode value.
92 K1212_DB_SetClockSourceRate
= 5, // sets the clock source and rate for the card.
93 K1212_DB_ConfigureMiscMemory
= 6, // tells card where other buffers are.
94 K1212_DB_TriggerFromAdat
= 7, // tells card to trigger from Adat at a specific
96 K1212_DB_DMAERROR
= 0x80, // DMA Error - the PCI bus is congestioned.
97 K1212_DB_CARDSTOPPED
= 0x81, // Card has stopped by user request.
98 K1212_DB_RebootCard
= 0xA0, // instructs the card to reboot.
99 K1212_DB_BootFromDSPPage4
= 0xA4, // instructs the card to boot from the DSP microcode
100 // on page 4 (local page to card).
101 K1212_DB_DSPDownloadDone
= 0xAE, // sent by the card to indicate the download has
103 K1212_DB_StartDSPDownload
= 0xAF // tells the card to download its DSP firmware.
107 // ----------------------------------------------------------------------------
108 // The following enumeration defines return codes
109 // to the Korg 1212 I/O driver.
110 // ----------------------------------------------------------------------------
111 enum snd_korg1212rc
{
112 K1212_CMDRET_Success
= 0, // command was successfully placed
113 K1212_CMDRET_DIOCFailure
, // the DeviceIoControl call failed
114 K1212_CMDRET_PMFailure
, // the protected mode call failed
115 K1212_CMDRET_FailUnspecified
, // unspecified failure
116 K1212_CMDRET_FailBadState
, // the specified command can not be given in
117 // the card's current state. (or the wave device's
119 K1212_CMDRET_CardUninitialized
, // the card is uninitialized and cannot be used
120 K1212_CMDRET_BadIndex
, // an out of range card index was specified
121 K1212_CMDRET_BadHandle
, // an invalid card handle was specified
122 K1212_CMDRET_NoFillRoutine
, // a play request has been made before a fill routine set
123 K1212_CMDRET_FillRoutineInUse
, // can't set a new fill routine while one is in use
124 K1212_CMDRET_NoAckFromCard
, // the card never acknowledged a command
125 K1212_CMDRET_BadParams
, // bad parameters were provided by the caller
127 K1212_CMDRET_BadDevice
, // the specified wave device was out of range
128 K1212_CMDRET_BadFormat
// the specified wave format is unsupported
131 // ----------------------------------------------------------------------------
132 // The following enumeration defines the constants used to select the play
133 // mode for the card in the SelectPlayMode command.
134 // ----------------------------------------------------------------------------
135 enum PlayModeSelector
{
136 K1212_MODE_SetupPlay
= 0x00000001, // provides card with pre-play information
137 K1212_MODE_MonitorOn
= 0x00000002, // tells card to turn on monitor mode
138 K1212_MODE_MonitorOff
= 0x00000004, // tells card to turn off monitor mode
139 K1212_MODE_StopPlay
= 0x00000008 // stops playback on the card
142 // ----------------------------------------------------------------------------
143 // The following enumeration defines the constants used to select the monitor
144 // mode for the card in the SetMonitorMode command.
145 // ----------------------------------------------------------------------------
146 enum MonitorModeSelector
{
147 K1212_MONMODE_Off
= 0, // tells card to turn off monitor mode
148 K1212_MONMODE_On
// tells card to turn on monitor mode
151 #define MAILBOX0_OFFSET 0x40 // location of mailbox 0 relative to base address
152 #define MAILBOX1_OFFSET 0x44 // location of mailbox 1 relative to base address
153 #define MAILBOX2_OFFSET 0x48 // location of mailbox 2 relative to base address
154 #define MAILBOX3_OFFSET 0x4c // location of mailbox 3 relative to base address
155 #define OUT_DOORBELL_OFFSET 0x60 // location of PCI to local doorbell
156 #define IN_DOORBELL_OFFSET 0x64 // location of local to PCI doorbell
157 #define STATUS_REG_OFFSET 0x68 // location of interrupt control/status register
158 #define PCI_CONTROL_OFFSET 0x6c // location of the EEPROM, PCI, User I/O, init control
160 #define SENS_CONTROL_OFFSET 0x6e // location of the input sensitivity setting register.
161 // this is the upper word of the PCI control reg.
162 #define DEV_VEND_ID_OFFSET 0x70 // location of the device and vendor ID register
164 #define MAX_COMMAND_RETRIES 5 // maximum number of times the driver will attempt
165 // to send a command before giving up.
166 #define COMMAND_ACK_MASK 0x8000 // the MSB is set in the command acknowledgment from
168 #define DOORBELL_VAL_MASK 0x00FF // the doorbell value is one byte
170 #define CARD_BOOT_DELAY_IN_MS 10
171 #define CARD_BOOT_TIMEOUT 10
172 #define DSP_BOOT_DELAY_IN_MS 200
174 #define kNumBuffers 8
175 #define k1212MaxCards 4
176 #define k1212NumWaveDevices 6
177 #define k16BitChannels 10
178 #define k32BitChannels 2
179 #define kAudioChannels (k16BitChannels + k32BitChannels)
180 #define kPlayBufferFrames 1024
182 #define K1212_ANALOG_CHANNELS 2
183 #define K1212_SPDIF_CHANNELS 2
184 #define K1212_ADAT_CHANNELS 8
185 #define K1212_CHANNELS (K1212_ADAT_CHANNELS + K1212_ANALOG_CHANNELS)
186 #define K1212_MIN_CHANNELS 1
187 #define K1212_MAX_CHANNELS K1212_CHANNELS
188 #define K1212_FRAME_SIZE (sizeof(struct KorgAudioFrame))
189 #define K1212_MAX_SAMPLES (kPlayBufferFrames*kNumBuffers)
190 #define K1212_PERIODS (kNumBuffers)
191 #define K1212_PERIOD_BYTES (K1212_FRAME_SIZE*kPlayBufferFrames)
192 #define K1212_BUF_SIZE (K1212_PERIOD_BYTES*kNumBuffers)
193 #define K1212_ANALOG_BUF_SIZE (K1212_ANALOG_CHANNELS * 2 * kPlayBufferFrames * kNumBuffers)
194 #define K1212_SPDIF_BUF_SIZE (K1212_SPDIF_CHANNELS * 3 * kPlayBufferFrames * kNumBuffers)
195 #define K1212_ADAT_BUF_SIZE (K1212_ADAT_CHANNELS * 2 * kPlayBufferFrames * kNumBuffers)
196 #define K1212_MAX_BUF_SIZE (K1212_ANALOG_BUF_SIZE + K1212_ADAT_BUF_SIZE)
198 #define k1212MinADCSens 0x00
199 #define k1212MaxADCSens 0x7f
200 #define k1212MaxVolume 0x7fff
201 #define k1212MaxWaveVolume 0xffff
202 #define k1212MinVolume 0x0000
203 #define k1212MaxVolInverted 0x8000
205 // -----------------------------------------------------------------
206 // the following bits are used for controlling interrupts in the
207 // interrupt control/status reg
208 // -----------------------------------------------------------------
209 #define PCI_INT_ENABLE_BIT 0x00000100
210 #define PCI_DOORBELL_INT_ENABLE_BIT 0x00000200
211 #define LOCAL_INT_ENABLE_BIT 0x00010000
212 #define LOCAL_DOORBELL_INT_ENABLE_BIT 0x00020000
213 #define LOCAL_DMA1_INT_ENABLE_BIT 0x00080000
215 // -----------------------------------------------------------------
216 // the following bits are defined for the PCI command register
217 // -----------------------------------------------------------------
218 #define PCI_CMD_MEM_SPACE_ENABLE_BIT 0x0002
219 #define PCI_CMD_IO_SPACE_ENABLE_BIT 0x0001
220 #define PCI_CMD_BUS_MASTER_ENABLE_BIT 0x0004
222 // -----------------------------------------------------------------
223 // the following bits are defined for the PCI status register
224 // -----------------------------------------------------------------
225 #define PCI_STAT_PARITY_ERROR_BIT 0x8000
226 #define PCI_STAT_SYSTEM_ERROR_BIT 0x4000
227 #define PCI_STAT_MASTER_ABORT_RCVD_BIT 0x2000
228 #define PCI_STAT_TARGET_ABORT_RCVD_BIT 0x1000
229 #define PCI_STAT_TARGET_ABORT_SENT_BIT 0x0800
231 // ------------------------------------------------------------------------
232 // the following constants are used in setting the 1212 I/O card's input
234 // ------------------------------------------------------------------------
235 #define SET_SENS_LOCALINIT_BITPOS 15
236 #define SET_SENS_DATA_BITPOS 10
237 #define SET_SENS_CLOCK_BITPOS 8
238 #define SET_SENS_LOADSHIFT_BITPOS 0
240 #define SET_SENS_LEFTCHANID 0x00
241 #define SET_SENS_RIGHTCHANID 0x01
243 #define K1212SENSUPDATE_DELAY_IN_MS 50
245 // --------------------------------------------------------------------------
248 // This function waits the specified number of real time clock ticks.
249 // According to the DDK, each tick is ~0.8 microseconds.
250 // The defines following the function declaration can be used for the
251 // numTicksToWait parameter.
252 // --------------------------------------------------------------------------
253 #define ONE_RTC_TICK 1
254 #define SENSCLKPULSE_WIDTH 4
255 #define LOADSHIFT_DELAY 4
256 #define INTERCOMMAND_DELAY 40
257 #define STOPCARD_DELAY 300 // max # RTC ticks for the card to stop once we write
258 // the command register. (could be up to 180 us)
259 #define COMMAND_ACK_DELAY 13 // number of RTC ticks to wait for an acknowledgement
260 // from the card after sending a command.
262 enum ClockSourceIndex
{
263 K1212_CLKIDX_AdatAt44_1K
= 0, // selects source as ADAT at 44.1 kHz
264 K1212_CLKIDX_AdatAt48K
, // selects source as ADAT at 48 kHz
265 K1212_CLKIDX_WordAt44_1K
, // selects source as S/PDIF at 44.1 kHz
266 K1212_CLKIDX_WordAt48K
, // selects source as S/PDIF at 48 kHz
267 K1212_CLKIDX_LocalAt44_1K
, // selects source as local clock at 44.1 kHz
268 K1212_CLKIDX_LocalAt48K
, // selects source as local clock at 48 kHz
269 K1212_CLKIDX_Invalid
// used to check validity of the index
272 enum ClockSourceType
{
273 K1212_CLKIDX_Adat
= 0, // selects source as ADAT
274 K1212_CLKIDX_Word
, // selects source as S/PDIF
275 K1212_CLKIDX_Local
// selects source as local clock
278 struct KorgAudioFrame
{
279 u16 frameData16
[k16BitChannels
]; /* channels 0-9 use 16 bit samples */
280 u32 frameData32
[k32BitChannels
]; /* channels 10-11 use 32 bits - only 20 are sent across S/PDIF */
281 u32 timeCodeVal
; /* holds the ADAT timecode value */
284 struct KorgAudioBuffer
{
285 struct KorgAudioFrame bufferData
[kPlayBufferFrames
]; /* buffer definition */
288 struct KorgSharedBuffer
{
289 #ifdef K1212_LARGEALLOC
290 struct KorgAudioBuffer playDataBufs
[kNumBuffers
];
291 struct KorgAudioBuffer recordDataBufs
[kNumBuffers
];
293 short volumeData
[kAudioChannels
];
295 u16 routeData
[kAudioChannels
];
296 u32 AdatTimeCode
; // ADAT timecode value
302 unsigned int leftChanVal
:8;
303 unsigned int leftChanId
:8;
309 unsigned int rightChanVal
:8;
310 unsigned int rightChanId
:8;
316 struct snd_korg1212
{
317 struct snd_card
*card
;
323 struct mutex open_mutex
;
325 struct timer_list timer
; /* timer callback for checking ack of stop request */
326 int stop_pending_cnt
; /* counter for stop pending check */
328 wait_queue_head_t wait
;
331 unsigned long ioport
;
332 unsigned long iomem2
;
333 unsigned long irqcount
;
335 void __iomem
*iobase
;
337 struct snd_dma_buffer dma_dsp
;
338 struct snd_dma_buffer dma_play
;
339 struct snd_dma_buffer dma_rec
;
340 struct snd_dma_buffer dma_shared
;
344 struct KorgAudioBuffer
* playDataBufsPtr
;
345 struct KorgAudioBuffer
* recordDataBufsPtr
;
347 struct KorgSharedBuffer
* sharedBufferPtr
;
351 unsigned long sharedBufferPhy
;
356 u32 __iomem
* statusRegPtr
; // address of the interrupt status/control register
357 u32 __iomem
* outDoorbellPtr
; // address of the host->card doorbell register
358 u32 __iomem
* inDoorbellPtr
; // address of the card->host doorbell register
359 u32 __iomem
* mailbox0Ptr
; // address of mailbox 0 on the card
360 u32 __iomem
* mailbox1Ptr
; // address of mailbox 1 on the card
361 u32 __iomem
* mailbox2Ptr
; // address of mailbox 2 on the card
362 u32 __iomem
* mailbox3Ptr
; // address of mailbox 3 on the card
363 u32 __iomem
* controlRegPtr
; // address of the EEPROM, PCI, I/O, Init ctrl reg
364 u16 __iomem
* sensRegPtr
; // address of the sensitivity setting register
365 u32 __iomem
* idRegPtr
; // address of the device and vendor ID registers
371 struct snd_pcm_substream
*playback_substream
;
372 struct snd_pcm_substream
*capture_substream
;
377 enum CardState cardState
;
379 int idleMonitorOn
; // indicates whether the card is in idle monitor mode.
380 u32 cmdRetryCount
; // tracks how many times we have retried sending to the card.
382 enum ClockSourceIndex clkSrcRate
; // sample rate and clock source
384 enum ClockSourceType clkSource
; // clock source
385 int clkRate
; // clock rate
387 int volumePhase
[kAudioChannels
];
389 u16 leftADCInSens
; // ADC left channel input sensitivity
390 u16 rightADCInSens
; // ADC right channel input sensitivity
392 int opencnt
; // Open/Close count
393 int setcnt
; // SetupForPlay count
394 int playcnt
; // TriggerPlay count
395 int errorcnt
; // Error Count
396 unsigned long totalerrorcnt
; // Total Error Count
399 int dsp_stop_is_processed
;
403 MODULE_DESCRIPTION("korg1212");
404 MODULE_LICENSE("GPL");
405 MODULE_SUPPORTED_DEVICE("{{KORG,korg1212}}");
406 MODULE_FIRMWARE("korg/k1212.dsp");
408 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-MAX */
409 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
410 static bool enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE
; /* Enable this card */
412 module_param_array(index
, int, NULL
, 0444);
413 MODULE_PARM_DESC(index
, "Index value for Korg 1212 soundcard.");
414 module_param_array(id
, charp
, NULL
, 0444);
415 MODULE_PARM_DESC(id
, "ID string for Korg 1212 soundcard.");
416 module_param_array(enable
, bool, NULL
, 0444);
417 MODULE_PARM_DESC(enable
, "Enable Korg 1212 soundcard.");
418 MODULE_AUTHOR("Haroldo Gamal <gamal@alternex.com.br>");
420 static const struct pci_device_id snd_korg1212_ids
[] = {
424 .subvendor
= PCI_ANY_ID
,
425 .subdevice
= PCI_ANY_ID
,
430 MODULE_DEVICE_TABLE(pci
, snd_korg1212_ids
);
432 static char *stateName
[] = {
435 "DSP download in process",
436 "DSP download complete",
446 static const char * const clockSourceTypeName
[] = { "ADAT", "S/PDIF", "local" };
448 static const char * const clockSourceName
[] = {
451 "S/PDIF at 44.1 kHz",
453 "local clock at 44.1 kHz",
454 "local clock at 48 kHz"
457 static const char * const channelName
[] = {
472 static u16 ClockSourceSelector
[] = {
473 0x8000, // selects source as ADAT at 44.1 kHz
474 0x0000, // selects source as ADAT at 48 kHz
475 0x8001, // selects source as S/PDIF at 44.1 kHz
476 0x0001, // selects source as S/PDIF at 48 kHz
477 0x8002, // selects source as local clock at 44.1 kHz
478 0x0002 // selects source as local clock at 48 kHz
481 union swap_u32
{ unsigned char c
[4]; u32 i
; };
483 #ifdef SNDRV_BIG_ENDIAN
484 static u32
LowerWordSwap(u32 swappee
)
486 static u32
UpperWordSwap(u32 swappee
)
489 union swap_u32 retVal
, swapper
;
492 retVal
.c
[2] = swapper
.c
[3];
493 retVal
.c
[3] = swapper
.c
[2];
494 retVal
.c
[1] = swapper
.c
[1];
495 retVal
.c
[0] = swapper
.c
[0];
500 #ifdef SNDRV_BIG_ENDIAN
501 static u32
UpperWordSwap(u32 swappee
)
503 static u32
LowerWordSwap(u32 swappee
)
506 union swap_u32 retVal
, swapper
;
509 retVal
.c
[2] = swapper
.c
[2];
510 retVal
.c
[3] = swapper
.c
[3];
511 retVal
.c
[1] = swapper
.c
[0];
512 retVal
.c
[0] = swapper
.c
[1];
517 #define SetBitInWord(theWord,bitPosition) (*theWord) |= (0x0001 << bitPosition)
518 #define SetBitInDWord(theWord,bitPosition) (*theWord) |= (0x00000001 << bitPosition)
519 #define ClearBitInWord(theWord,bitPosition) (*theWord) &= ~(0x0001 << bitPosition)
520 #define ClearBitInDWord(theWord,bitPosition) (*theWord) &= ~(0x00000001 << bitPosition)
522 static int snd_korg1212_Send1212Command(struct snd_korg1212
*korg1212
,
523 enum korg1212_dbcnst doorbellVal
,
524 u32 mailBox0Val
, u32 mailBox1Val
,
525 u32 mailBox2Val
, u32 mailBox3Val
)
529 int rc
= K1212_CMDRET_Success
;
531 if (!korg1212
->outDoorbellPtr
) {
532 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: CardUninitialized\n");
533 return K1212_CMDRET_CardUninitialized
;
536 K1212_DEBUG_PRINTK("K1212_DEBUG: Card <- 0x%08x 0x%08x [%s]\n",
537 doorbellVal
, mailBox0Val
, stateName
[korg1212
->cardState
]);
538 for (retryCount
= 0; retryCount
< MAX_COMMAND_RETRIES
; retryCount
++) {
539 writel(mailBox3Val
, korg1212
->mailbox3Ptr
);
540 writel(mailBox2Val
, korg1212
->mailbox2Ptr
);
541 writel(mailBox1Val
, korg1212
->mailbox1Ptr
);
542 writel(mailBox0Val
, korg1212
->mailbox0Ptr
);
543 writel(doorbellVal
, korg1212
->outDoorbellPtr
); // interrupt the card
545 // --------------------------------------------------------------
546 // the reboot command will not give an acknowledgement.
547 // --------------------------------------------------------------
548 if ( doorbellVal
== K1212_DB_RebootCard
||
549 doorbellVal
== K1212_DB_BootFromDSPPage4
||
550 doorbellVal
== K1212_DB_StartDSPDownload
) {
551 rc
= K1212_CMDRET_Success
;
555 // --------------------------------------------------------------
556 // See if the card acknowledged the command. Wait a bit, then
557 // read in the low word of mailbox3. If the MSB is set and the
558 // low byte is equal to the doorbell value, then it ack'd.
559 // --------------------------------------------------------------
560 udelay(COMMAND_ACK_DELAY
);
561 mailBox3Lo
= readl(korg1212
->mailbox3Ptr
);
562 if (mailBox3Lo
& COMMAND_ACK_MASK
) {
563 if ((mailBox3Lo
& DOORBELL_VAL_MASK
) == (doorbellVal
& DOORBELL_VAL_MASK
)) {
564 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: Card <- Success\n");
565 rc
= K1212_CMDRET_Success
;
570 korg1212
->cmdRetryCount
+= retryCount
;
572 if (retryCount
>= MAX_COMMAND_RETRIES
) {
573 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: Card <- NoAckFromCard\n");
574 rc
= K1212_CMDRET_NoAckFromCard
;
580 /* spinlock already held */
581 static void snd_korg1212_SendStop(struct snd_korg1212
*korg1212
)
583 if (! korg1212
->stop_pending_cnt
) {
584 korg1212
->sharedBufferPtr
->cardCommand
= 0xffffffff;
585 /* program the timer */
586 korg1212
->stop_pending_cnt
= HZ
;
587 mod_timer(&korg1212
->timer
, jiffies
+ 1);
591 static void snd_korg1212_SendStopAndWait(struct snd_korg1212
*korg1212
)
594 spin_lock_irqsave(&korg1212
->lock
, flags
);
595 korg1212
->dsp_stop_is_processed
= 0;
596 snd_korg1212_SendStop(korg1212
);
597 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
598 wait_event_timeout(korg1212
->wait
, korg1212
->dsp_stop_is_processed
, (HZ
* 3) / 2);
601 /* timer callback for checking the ack of stop request */
602 static void snd_korg1212_timer_func(unsigned long data
)
604 struct snd_korg1212
*korg1212
= (struct snd_korg1212
*) data
;
607 spin_lock_irqsave(&korg1212
->lock
, flags
);
608 if (korg1212
->sharedBufferPtr
->cardCommand
== 0) {
610 korg1212
->stop_pending_cnt
= 0;
611 korg1212
->dsp_stop_is_processed
= 1;
612 wake_up(&korg1212
->wait
);
613 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: Stop ack'ed [%s]\n",
614 stateName
[korg1212
->cardState
]);
616 if (--korg1212
->stop_pending_cnt
> 0) {
617 /* reprogram timer */
618 mod_timer(&korg1212
->timer
, jiffies
+ 1);
620 snd_printd("korg1212_timer_func timeout\n");
621 korg1212
->sharedBufferPtr
->cardCommand
= 0;
622 korg1212
->dsp_stop_is_processed
= 1;
623 wake_up(&korg1212
->wait
);
624 K1212_DEBUG_PRINTK("K1212_DEBUG: Stop timeout [%s]\n",
625 stateName
[korg1212
->cardState
]);
628 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
631 static int snd_korg1212_TurnOnIdleMonitor(struct snd_korg1212
*korg1212
)
636 udelay(INTERCOMMAND_DELAY
);
637 spin_lock_irqsave(&korg1212
->lock
, flags
);
638 korg1212
->idleMonitorOn
= 1;
639 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_SelectPlayMode
,
640 K1212_MODE_MonitorOn
, 0, 0, 0);
641 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
645 static void snd_korg1212_TurnOffIdleMonitor(struct snd_korg1212
*korg1212
)
647 if (korg1212
->idleMonitorOn
) {
648 snd_korg1212_SendStopAndWait(korg1212
);
649 korg1212
->idleMonitorOn
= 0;
653 static inline void snd_korg1212_setCardState(struct snd_korg1212
* korg1212
, enum CardState csState
)
655 korg1212
->cardState
= csState
;
658 static int snd_korg1212_OpenCard(struct snd_korg1212
* korg1212
)
660 K1212_DEBUG_PRINTK("K1212_DEBUG: OpenCard [%s] %d\n",
661 stateName
[korg1212
->cardState
], korg1212
->opencnt
);
662 mutex_lock(&korg1212
->open_mutex
);
663 if (korg1212
->opencnt
++ == 0) {
664 snd_korg1212_TurnOffIdleMonitor(korg1212
);
665 snd_korg1212_setCardState(korg1212
, K1212_STATE_OPEN
);
668 mutex_unlock(&korg1212
->open_mutex
);
672 static int snd_korg1212_CloseCard(struct snd_korg1212
* korg1212
)
674 K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard [%s] %d\n",
675 stateName
[korg1212
->cardState
], korg1212
->opencnt
);
677 mutex_lock(&korg1212
->open_mutex
);
678 if (--(korg1212
->opencnt
)) {
679 mutex_unlock(&korg1212
->open_mutex
);
683 if (korg1212
->cardState
== K1212_STATE_SETUP
) {
684 int rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_SelectPlayMode
,
685 K1212_MODE_StopPlay
, 0, 0, 0);
687 K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard - RC = %d [%s]\n",
688 rc
, stateName
[korg1212
->cardState
]);
689 if (rc
!= K1212_CMDRET_Success
) {
690 mutex_unlock(&korg1212
->open_mutex
);
693 } else if (korg1212
->cardState
> K1212_STATE_SETUP
) {
694 snd_korg1212_SendStopAndWait(korg1212
);
697 if (korg1212
->cardState
> K1212_STATE_READY
) {
698 snd_korg1212_TurnOnIdleMonitor(korg1212
);
699 snd_korg1212_setCardState(korg1212
, K1212_STATE_READY
);
702 mutex_unlock(&korg1212
->open_mutex
);
706 /* spinlock already held */
707 static int snd_korg1212_SetupForPlay(struct snd_korg1212
* korg1212
)
711 K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay [%s] %d\n",
712 stateName
[korg1212
->cardState
], korg1212
->setcnt
);
714 if (korg1212
->setcnt
++)
717 snd_korg1212_setCardState(korg1212
, K1212_STATE_SETUP
);
718 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_SelectPlayMode
,
719 K1212_MODE_SetupPlay
, 0, 0, 0);
721 K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay - RC = %d [%s]\n",
722 rc
, stateName
[korg1212
->cardState
]);
723 if (rc
!= K1212_CMDRET_Success
) {
729 /* spinlock already held */
730 static int snd_korg1212_TriggerPlay(struct snd_korg1212
* korg1212
)
734 K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay [%s] %d\n",
735 stateName
[korg1212
->cardState
], korg1212
->playcnt
);
737 if (korg1212
->playcnt
++)
740 snd_korg1212_setCardState(korg1212
, K1212_STATE_PLAYING
);
741 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_TriggerPlay
, 0, 0, 0, 0);
743 K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay - RC = %d [%s]\n",
744 rc
, stateName
[korg1212
->cardState
]);
745 if (rc
!= K1212_CMDRET_Success
) {
751 /* spinlock already held */
752 static int snd_korg1212_StopPlay(struct snd_korg1212
* korg1212
)
754 K1212_DEBUG_PRINTK("K1212_DEBUG: StopPlay [%s] %d\n",
755 stateName
[korg1212
->cardState
], korg1212
->playcnt
);
757 if (--(korg1212
->playcnt
))
760 korg1212
->setcnt
= 0;
762 if (korg1212
->cardState
!= K1212_STATE_ERRORSTOP
)
763 snd_korg1212_SendStop(korg1212
);
765 snd_korg1212_setCardState(korg1212
, K1212_STATE_OPEN
);
769 static void snd_korg1212_EnableCardInterrupts(struct snd_korg1212
* korg1212
)
771 writel(PCI_INT_ENABLE_BIT
|
772 PCI_DOORBELL_INT_ENABLE_BIT
|
773 LOCAL_INT_ENABLE_BIT
|
774 LOCAL_DOORBELL_INT_ENABLE_BIT
|
775 LOCAL_DMA1_INT_ENABLE_BIT
,
776 korg1212
->statusRegPtr
);
781 static int snd_korg1212_SetMonitorMode(struct snd_korg1212
*korg1212
,
782 enum MonitorModeSelector mode
)
784 K1212_DEBUG_PRINTK("K1212_DEBUG: SetMonitorMode [%s]\n",
785 stateName
[korg1212
->cardState
]);
788 case K1212_MONMODE_Off
:
789 if (korg1212
->cardState
!= K1212_STATE_MONITOR
)
792 snd_korg1212_SendStopAndWait(korg1212
);
793 snd_korg1212_setCardState(korg1212
, K1212_STATE_OPEN
);
797 case K1212_MONMODE_On
:
798 if (korg1212
->cardState
!= K1212_STATE_OPEN
)
802 snd_korg1212_setCardState(korg1212
, K1212_STATE_MONITOR
);
803 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_SelectPlayMode
,
804 K1212_MODE_MonitorOn
, 0, 0, 0);
805 if (rc
!= K1212_CMDRET_Success
)
817 #endif /* not used */
819 static inline int snd_korg1212_use_is_exclusive(struct snd_korg1212
*korg1212
)
821 if (korg1212
->playback_pid
!= korg1212
->capture_pid
&&
822 korg1212
->playback_pid
>= 0 && korg1212
->capture_pid
>= 0)
828 static int snd_korg1212_SetRate(struct snd_korg1212
*korg1212
, int rate
)
830 static enum ClockSourceIndex s44
[] = {
831 K1212_CLKIDX_AdatAt44_1K
,
832 K1212_CLKIDX_WordAt44_1K
,
833 K1212_CLKIDX_LocalAt44_1K
835 static enum ClockSourceIndex s48
[] = {
836 K1212_CLKIDX_AdatAt48K
,
837 K1212_CLKIDX_WordAt48K
,
838 K1212_CLKIDX_LocalAt48K
842 if (!snd_korg1212_use_is_exclusive (korg1212
))
847 parm
= s44
[korg1212
->clkSource
];
851 parm
= s48
[korg1212
->clkSource
];
858 korg1212
->clkSrcRate
= parm
;
859 korg1212
->clkRate
= rate
;
861 udelay(INTERCOMMAND_DELAY
);
862 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_SetClockSourceRate
,
863 ClockSourceSelector
[korg1212
->clkSrcRate
],
866 K1212_DEBUG_PRINTK("K1212_DEBUG: Set Clock Source Selector - RC = %d [%s]\n",
867 rc
, stateName
[korg1212
->cardState
]);
872 static int snd_korg1212_SetClockSource(struct snd_korg1212
*korg1212
, int source
)
875 if (source
< 0 || source
> 2)
878 korg1212
->clkSource
= source
;
880 snd_korg1212_SetRate(korg1212
, korg1212
->clkRate
);
885 static void snd_korg1212_DisableCardInterrupts(struct snd_korg1212
*korg1212
)
887 writel(0, korg1212
->statusRegPtr
);
890 static int snd_korg1212_WriteADCSensitivity(struct snd_korg1212
*korg1212
)
892 struct SensBits sensVals
;
897 u16 controlValue
; // this keeps the current value to be written to
898 // the card's eeprom control register.
902 K1212_DEBUG_PRINTK("K1212_DEBUG: WriteADCSensivity [%s]\n",
903 stateName
[korg1212
->cardState
]);
905 // ----------------------------------------------------------------------------
906 // initialize things. The local init bit is always set when writing to the
907 // card's control register.
908 // ----------------------------------------------------------------------------
910 SetBitInWord(&controlValue
, SET_SENS_LOCALINIT_BITPOS
); // init the control value
912 // ----------------------------------------------------------------------------
913 // make sure the card is not in monitor mode when we do this update.
914 // ----------------------------------------------------------------------------
915 if (korg1212
->cardState
== K1212_STATE_MONITOR
|| korg1212
->idleMonitorOn
) {
917 snd_korg1212_SendStopAndWait(korg1212
);
921 spin_lock_irqsave(&korg1212
->lock
, flags
);
923 // ----------------------------------------------------------------------------
924 // we are about to send new values to the card, so clear the new values queued
925 // flag. Also, clear out mailbox 3, so we don't lockup.
926 // ----------------------------------------------------------------------------
927 writel(0, korg1212
->mailbox3Ptr
);
928 udelay(LOADSHIFT_DELAY
);
930 // ----------------------------------------------------------------------------
931 // determine whether we are running a 48K or 44.1K clock. This info is used
932 // later when setting the SPDIF FF after the volume has been shifted in.
933 // ----------------------------------------------------------------------------
934 switch (korg1212
->clkSrcRate
) {
935 case K1212_CLKIDX_AdatAt44_1K
:
936 case K1212_CLKIDX_WordAt44_1K
:
937 case K1212_CLKIDX_LocalAt44_1K
:
941 case K1212_CLKIDX_WordAt48K
:
942 case K1212_CLKIDX_AdatAt48K
:
943 case K1212_CLKIDX_LocalAt48K
:
949 // ----------------------------------------------------------------------------
950 // start the update. Setup the bit structure and then shift the bits.
951 // ----------------------------------------------------------------------------
952 sensVals
.l
.v
.leftChanId
= SET_SENS_LEFTCHANID
;
953 sensVals
.r
.v
.rightChanId
= SET_SENS_RIGHTCHANID
;
954 sensVals
.l
.v
.leftChanVal
= korg1212
->leftADCInSens
;
955 sensVals
.r
.v
.rightChanVal
= korg1212
->rightADCInSens
;
957 // ----------------------------------------------------------------------------
958 // now start shifting the bits in. Start with the left channel then the right.
959 // ----------------------------------------------------------------------------
960 for (channel
= 0; channel
< 2; channel
++) {
962 // ----------------------------------------------------------------------------
963 // Bring the load/shift line low, then wait - the spec says >150ns from load/
964 // shift low to the first rising edge of the clock.
965 // ----------------------------------------------------------------------------
966 ClearBitInWord(&controlValue
, SET_SENS_LOADSHIFT_BITPOS
);
967 ClearBitInWord(&controlValue
, SET_SENS_DATA_BITPOS
);
968 writew(controlValue
, korg1212
->sensRegPtr
); // load/shift goes low
969 udelay(LOADSHIFT_DELAY
);
971 for (bitPosition
= 15; bitPosition
>= 0; bitPosition
--) { // for all the bits
973 if (sensVals
.l
.leftSensBits
& (0x0001 << bitPosition
))
974 SetBitInWord(&controlValue
, SET_SENS_DATA_BITPOS
); // data bit set high
976 ClearBitInWord(&controlValue
, SET_SENS_DATA_BITPOS
); // data bit set low
978 if (sensVals
.r
.rightSensBits
& (0x0001 << bitPosition
))
979 SetBitInWord(&controlValue
, SET_SENS_DATA_BITPOS
); // data bit set high
981 ClearBitInWord(&controlValue
, SET_SENS_DATA_BITPOS
); // data bit set low
984 ClearBitInWord(&controlValue
, SET_SENS_CLOCK_BITPOS
);
985 writew(controlValue
, korg1212
->sensRegPtr
); // clock goes low
986 udelay(SENSCLKPULSE_WIDTH
);
987 SetBitInWord(&controlValue
, SET_SENS_CLOCK_BITPOS
);
988 writew(controlValue
, korg1212
->sensRegPtr
); // clock goes high
989 udelay(SENSCLKPULSE_WIDTH
);
992 // ----------------------------------------------------------------------------
993 // finish up SPDIF for left. Bring the load/shift line high, then write a one
994 // bit if the clock rate is 48K otherwise write 0.
995 // ----------------------------------------------------------------------------
996 ClearBitInWord(&controlValue
, SET_SENS_DATA_BITPOS
);
997 ClearBitInWord(&controlValue
, SET_SENS_CLOCK_BITPOS
);
998 SetBitInWord(&controlValue
, SET_SENS_LOADSHIFT_BITPOS
);
999 writew(controlValue
, korg1212
->sensRegPtr
); // load shift goes high - clk low
1000 udelay(SENSCLKPULSE_WIDTH
);
1003 SetBitInWord(&controlValue
, SET_SENS_DATA_BITPOS
);
1005 writew(controlValue
, korg1212
->sensRegPtr
); // set/clear data bit
1006 udelay(ONE_RTC_TICK
);
1007 SetBitInWord(&controlValue
, SET_SENS_CLOCK_BITPOS
);
1008 writew(controlValue
, korg1212
->sensRegPtr
); // clock goes high
1009 udelay(SENSCLKPULSE_WIDTH
);
1010 ClearBitInWord(&controlValue
, SET_SENS_CLOCK_BITPOS
);
1011 writew(controlValue
, korg1212
->sensRegPtr
); // clock goes low
1012 udelay(SENSCLKPULSE_WIDTH
);
1015 // ----------------------------------------------------------------------------
1016 // The update is complete. Set a timeout. This is the inter-update delay.
1017 // Also, if the card was in monitor mode, restore it.
1018 // ----------------------------------------------------------------------------
1019 for (count
= 0; count
< 10; count
++)
1020 udelay(SENSCLKPULSE_WIDTH
);
1023 int rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_SelectPlayMode
,
1024 K1212_MODE_MonitorOn
, 0, 0, 0);
1026 K1212_DEBUG_PRINTK("K1212_DEBUG: WriteADCSensivity - RC = %d [%s]\n",
1027 rc
, stateName
[korg1212
->cardState
]);
1030 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1035 static void snd_korg1212_OnDSPDownloadComplete(struct snd_korg1212
*korg1212
)
1039 K1212_DEBUG_PRINTK("K1212_DEBUG: DSP download is complete. [%s]\n",
1040 stateName
[korg1212
->cardState
]);
1042 // ----------------------------------------------------
1043 // tell the card to boot
1044 // ----------------------------------------------------
1045 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_BootFromDSPPage4
, 0, 0, 0, 0);
1048 K1212_DEBUG_PRINTK("K1212_DEBUG: Boot from Page 4 - RC = %d [%s]\n",
1049 rc
, stateName
[korg1212
->cardState
]);
1050 msleep(DSP_BOOT_DELAY_IN_MS
);
1052 // --------------------------------------------------------------------------------
1053 // Let the card know where all the buffers are.
1054 // --------------------------------------------------------------------------------
1055 rc
= snd_korg1212_Send1212Command(korg1212
,
1056 K1212_DB_ConfigureBufferMemory
,
1057 LowerWordSwap(korg1212
->PlayDataPhy
),
1058 LowerWordSwap(korg1212
->RecDataPhy
),
1059 ((kNumBuffers
* kPlayBufferFrames
) / 2), // size given to the card
1060 // is based on 2 buffers
1065 K1212_DEBUG_PRINTK("K1212_DEBUG: Configure Buffer Memory - RC = %d [%s]\n",
1066 rc
, stateName
[korg1212
->cardState
]);
1068 udelay(INTERCOMMAND_DELAY
);
1070 rc
= snd_korg1212_Send1212Command(korg1212
,
1071 K1212_DB_ConfigureMiscMemory
,
1072 LowerWordSwap(korg1212
->VolumeTablePhy
),
1073 LowerWordSwap(korg1212
->RoutingTablePhy
),
1074 LowerWordSwap(korg1212
->AdatTimeCodePhy
),
1079 K1212_DEBUG_PRINTK("K1212_DEBUG: Configure Misc Memory - RC = %d [%s]\n",
1080 rc
, stateName
[korg1212
->cardState
]);
1082 // --------------------------------------------------------------------------------
1083 // Initialize the routing and volume tables, then update the card's state.
1084 // --------------------------------------------------------------------------------
1085 udelay(INTERCOMMAND_DELAY
);
1087 for (channel
= 0; channel
< kAudioChannels
; channel
++) {
1088 korg1212
->sharedBufferPtr
->volumeData
[channel
] = k1212MaxVolume
;
1089 //korg1212->sharedBufferPtr->routeData[channel] = channel;
1090 korg1212
->sharedBufferPtr
->routeData
[channel
] = 8 + (channel
& 1);
1093 snd_korg1212_WriteADCSensitivity(korg1212
);
1095 udelay(INTERCOMMAND_DELAY
);
1096 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_SetClockSourceRate
,
1097 ClockSourceSelector
[korg1212
->clkSrcRate
],
1100 K1212_DEBUG_PRINTK("K1212_DEBUG: Set Clock Source Selector - RC = %d [%s]\n",
1101 rc
, stateName
[korg1212
->cardState
]);
1103 rc
= snd_korg1212_TurnOnIdleMonitor(korg1212
);
1104 snd_korg1212_setCardState(korg1212
, K1212_STATE_READY
);
1107 K1212_DEBUG_PRINTK("K1212_DEBUG: Set Monitor On - RC = %d [%s]\n",
1108 rc
, stateName
[korg1212
->cardState
]);
1110 snd_korg1212_setCardState(korg1212
, K1212_STATE_DSP_COMPLETE
);
1113 static irqreturn_t
snd_korg1212_interrupt(int irq
, void *dev_id
)
1116 struct snd_korg1212
*korg1212
= dev_id
;
1118 doorbellValue
= readl(korg1212
->inDoorbellPtr
);
1123 spin_lock(&korg1212
->lock
);
1125 writel(doorbellValue
, korg1212
->inDoorbellPtr
);
1127 korg1212
->irqcount
++;
1131 switch (doorbellValue
) {
1132 case K1212_DB_DSPDownloadDone
:
1133 K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ DNLD count - %ld, %x, [%s].\n",
1134 korg1212
->irqcount
, doorbellValue
,
1135 stateName
[korg1212
->cardState
]);
1136 if (korg1212
->cardState
== K1212_STATE_DSP_IN_PROCESS
) {
1137 korg1212
->dsp_is_loaded
= 1;
1138 wake_up(&korg1212
->wait
);
1142 // ------------------------------------------------------------------------
1143 // an error occurred - stop the card
1144 // ------------------------------------------------------------------------
1145 case K1212_DB_DMAERROR
:
1146 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: IRQ DMAE count - %ld, %x, [%s].\n",
1147 korg1212
->irqcount
, doorbellValue
,
1148 stateName
[korg1212
->cardState
]);
1149 snd_printk(KERN_ERR
"korg1212: DMA Error\n");
1150 korg1212
->errorcnt
++;
1151 korg1212
->totalerrorcnt
++;
1152 korg1212
->sharedBufferPtr
->cardCommand
= 0;
1153 snd_korg1212_setCardState(korg1212
, K1212_STATE_ERRORSTOP
);
1156 // ------------------------------------------------------------------------
1157 // the card has stopped by our request. Clear the command word and signal
1158 // the semaphore in case someone is waiting for this.
1159 // ------------------------------------------------------------------------
1160 case K1212_DB_CARDSTOPPED
:
1161 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: IRQ CSTP count - %ld, %x, [%s].\n",
1162 korg1212
->irqcount
, doorbellValue
,
1163 stateName
[korg1212
->cardState
]);
1164 korg1212
->sharedBufferPtr
->cardCommand
= 0;
1168 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: IRQ DFLT count - %ld, %x, cpos=%d [%s].\n",
1169 korg1212
->irqcount
, doorbellValue
,
1170 korg1212
->currentBuffer
, stateName
[korg1212
->cardState
]);
1171 if ((korg1212
->cardState
> K1212_STATE_SETUP
) || korg1212
->idleMonitorOn
) {
1172 korg1212
->currentBuffer
++;
1174 if (korg1212
->currentBuffer
>= kNumBuffers
)
1175 korg1212
->currentBuffer
= 0;
1177 if (!korg1212
->running
)
1180 if (korg1212
->capture_substream
) {
1181 spin_unlock(&korg1212
->lock
);
1182 snd_pcm_period_elapsed(korg1212
->capture_substream
);
1183 spin_lock(&korg1212
->lock
);
1186 if (korg1212
->playback_substream
) {
1187 spin_unlock(&korg1212
->lock
);
1188 snd_pcm_period_elapsed(korg1212
->playback_substream
);
1189 spin_lock(&korg1212
->lock
);
1197 spin_unlock(&korg1212
->lock
);
1202 static int snd_korg1212_downloadDSPCode(struct snd_korg1212
*korg1212
)
1206 K1212_DEBUG_PRINTK("K1212_DEBUG: DSP download is starting... [%s]\n",
1207 stateName
[korg1212
->cardState
]);
1209 // ---------------------------------------------------------------
1210 // verify the state of the card before proceeding.
1211 // ---------------------------------------------------------------
1212 if (korg1212
->cardState
>= K1212_STATE_DSP_IN_PROCESS
)
1215 snd_korg1212_setCardState(korg1212
, K1212_STATE_DSP_IN_PROCESS
);
1217 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_StartDSPDownload
,
1218 UpperWordSwap(korg1212
->dma_dsp
.addr
),
1221 K1212_DEBUG_PRINTK("K1212_DEBUG: Start DSP Download RC = %d [%s]\n",
1222 rc
, stateName
[korg1212
->cardState
]);
1224 korg1212
->dsp_is_loaded
= 0;
1225 wait_event_timeout(korg1212
->wait
, korg1212
->dsp_is_loaded
, HZ
* CARD_BOOT_TIMEOUT
);
1226 if (! korg1212
->dsp_is_loaded
)
1227 return -EBUSY
; /* timeout */
1229 snd_korg1212_OnDSPDownloadComplete(korg1212
);
1234 static struct snd_pcm_hardware snd_korg1212_playback_info
=
1236 .info
= (SNDRV_PCM_INFO_MMAP
|
1237 SNDRV_PCM_INFO_MMAP_VALID
|
1238 SNDRV_PCM_INFO_INTERLEAVED
|
1239 SNDRV_PCM_INFO_BATCH
),
1240 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
1241 .rates
= (SNDRV_PCM_RATE_44100
|
1242 SNDRV_PCM_RATE_48000
),
1245 .channels_min
= K1212_MIN_CHANNELS
,
1246 .channels_max
= K1212_MAX_CHANNELS
,
1247 .buffer_bytes_max
= K1212_MAX_BUF_SIZE
,
1248 .period_bytes_min
= K1212_MIN_CHANNELS
* 2 * kPlayBufferFrames
,
1249 .period_bytes_max
= K1212_MAX_CHANNELS
* 2 * kPlayBufferFrames
,
1250 .periods_min
= K1212_PERIODS
,
1251 .periods_max
= K1212_PERIODS
,
1255 static struct snd_pcm_hardware snd_korg1212_capture_info
=
1257 .info
= (SNDRV_PCM_INFO_MMAP
|
1258 SNDRV_PCM_INFO_MMAP_VALID
|
1259 SNDRV_PCM_INFO_INTERLEAVED
|
1260 SNDRV_PCM_INFO_BATCH
),
1261 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
1262 .rates
= (SNDRV_PCM_RATE_44100
|
1263 SNDRV_PCM_RATE_48000
),
1266 .channels_min
= K1212_MIN_CHANNELS
,
1267 .channels_max
= K1212_MAX_CHANNELS
,
1268 .buffer_bytes_max
= K1212_MAX_BUF_SIZE
,
1269 .period_bytes_min
= K1212_MIN_CHANNELS
* 2 * kPlayBufferFrames
,
1270 .period_bytes_max
= K1212_MAX_CHANNELS
* 2 * kPlayBufferFrames
,
1271 .periods_min
= K1212_PERIODS
,
1272 .periods_max
= K1212_PERIODS
,
1276 static int snd_korg1212_silence(struct snd_korg1212
*korg1212
, int pos
, int count
, int offset
, int size
)
1278 struct KorgAudioFrame
* dst
= korg1212
->playDataBufsPtr
[0].bufferData
+ pos
;
1281 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_silence pos=%d offset=%d size=%d count=%d\n",
1282 pos
, offset
, size
, count
);
1283 if (snd_BUG_ON(pos
+ count
> K1212_MAX_SAMPLES
))
1286 for (i
=0; i
< count
; i
++) {
1287 #if K1212_DEBUG_LEVEL > 0
1288 if ( (void *) dst
< (void *) korg1212
->playDataBufsPtr
||
1289 (void *) dst
> (void *) korg1212
->playDataBufsPtr
[8].bufferData
) {
1290 printk(KERN_DEBUG
"K1212_DEBUG: snd_korg1212_silence KERNEL EFAULT dst=%p iter=%d\n",
1295 memset((void*) dst
+ offset
, 0, size
);
1302 static int snd_korg1212_copy_to(struct snd_korg1212
*korg1212
, void __user
*dst
, int pos
, int count
, int offset
, int size
)
1304 struct KorgAudioFrame
* src
= korg1212
->recordDataBufsPtr
[0].bufferData
+ pos
;
1307 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_copy_to pos=%d offset=%d size=%d\n",
1309 if (snd_BUG_ON(pos
+ count
> K1212_MAX_SAMPLES
))
1312 for (i
=0; i
< count
; i
++) {
1313 #if K1212_DEBUG_LEVEL > 0
1314 if ( (void *) src
< (void *) korg1212
->recordDataBufsPtr
||
1315 (void *) src
> (void *) korg1212
->recordDataBufsPtr
[8].bufferData
) {
1316 printk(KERN_DEBUG
"K1212_DEBUG: snd_korg1212_copy_to KERNEL EFAULT, src=%p dst=%p iter=%d\n", src
, dst
, i
);
1320 rc
= copy_to_user(dst
+ offset
, src
, size
);
1322 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_to USER EFAULT src=%p dst=%p iter=%d\n", src
, dst
, i
);
1332 static int snd_korg1212_copy_from(struct snd_korg1212
*korg1212
, void __user
*src
, int pos
, int count
, int offset
, int size
)
1334 struct KorgAudioFrame
* dst
= korg1212
->playDataBufsPtr
[0].bufferData
+ pos
;
1337 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_copy_from pos=%d offset=%d size=%d count=%d\n",
1338 pos
, offset
, size
, count
);
1340 if (snd_BUG_ON(pos
+ count
> K1212_MAX_SAMPLES
))
1343 for (i
=0; i
< count
; i
++) {
1344 #if K1212_DEBUG_LEVEL > 0
1345 if ( (void *) dst
< (void *) korg1212
->playDataBufsPtr
||
1346 (void *) dst
> (void *) korg1212
->playDataBufsPtr
[8].bufferData
) {
1347 printk(KERN_DEBUG
"K1212_DEBUG: snd_korg1212_copy_from KERNEL EFAULT, src=%p dst=%p iter=%d\n", src
, dst
, i
);
1351 rc
= copy_from_user((void*) dst
+ offset
, src
, size
);
1353 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_from USER EFAULT src=%p dst=%p iter=%d\n", src
, dst
, i
);
1363 static void snd_korg1212_free_pcm(struct snd_pcm
*pcm
)
1365 struct snd_korg1212
*korg1212
= pcm
->private_data
;
1367 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_free_pcm [%s]\n",
1368 stateName
[korg1212
->cardState
]);
1370 korg1212
->pcm
= NULL
;
1373 static int snd_korg1212_playback_open(struct snd_pcm_substream
*substream
)
1375 unsigned long flags
;
1376 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1377 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1379 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_open [%s]\n",
1380 stateName
[korg1212
->cardState
]);
1382 snd_korg1212_OpenCard(korg1212
);
1384 runtime
->hw
= snd_korg1212_playback_info
;
1385 snd_pcm_set_runtime_buffer(substream
, &korg1212
->dma_play
);
1387 spin_lock_irqsave(&korg1212
->lock
, flags
);
1389 korg1212
->playback_substream
= substream
;
1390 korg1212
->playback_pid
= current
->pid
;
1391 korg1212
->periodsize
= K1212_PERIODS
;
1392 korg1212
->channels
= K1212_CHANNELS
;
1393 korg1212
->errorcnt
= 0;
1395 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1397 snd_pcm_hw_constraint_minmax(runtime
, SNDRV_PCM_HW_PARAM_PERIOD_SIZE
, kPlayBufferFrames
, kPlayBufferFrames
);
1402 static int snd_korg1212_capture_open(struct snd_pcm_substream
*substream
)
1404 unsigned long flags
;
1405 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1406 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1408 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_open [%s]\n",
1409 stateName
[korg1212
->cardState
]);
1411 snd_korg1212_OpenCard(korg1212
);
1413 runtime
->hw
= snd_korg1212_capture_info
;
1414 snd_pcm_set_runtime_buffer(substream
, &korg1212
->dma_rec
);
1416 spin_lock_irqsave(&korg1212
->lock
, flags
);
1418 korg1212
->capture_substream
= substream
;
1419 korg1212
->capture_pid
= current
->pid
;
1420 korg1212
->periodsize
= K1212_PERIODS
;
1421 korg1212
->channels
= K1212_CHANNELS
;
1423 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1425 snd_pcm_hw_constraint_minmax(runtime
, SNDRV_PCM_HW_PARAM_PERIOD_SIZE
,
1426 kPlayBufferFrames
, kPlayBufferFrames
);
1430 static int snd_korg1212_playback_close(struct snd_pcm_substream
*substream
)
1432 unsigned long flags
;
1433 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1435 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_close [%s]\n",
1436 stateName
[korg1212
->cardState
]);
1438 snd_korg1212_silence(korg1212
, 0, K1212_MAX_SAMPLES
, 0, korg1212
->channels
* 2);
1440 spin_lock_irqsave(&korg1212
->lock
, flags
);
1442 korg1212
->playback_pid
= -1;
1443 korg1212
->playback_substream
= NULL
;
1444 korg1212
->periodsize
= 0;
1446 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1448 snd_korg1212_CloseCard(korg1212
);
1452 static int snd_korg1212_capture_close(struct snd_pcm_substream
*substream
)
1454 unsigned long flags
;
1455 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1457 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_close [%s]\n",
1458 stateName
[korg1212
->cardState
]);
1460 spin_lock_irqsave(&korg1212
->lock
, flags
);
1462 korg1212
->capture_pid
= -1;
1463 korg1212
->capture_substream
= NULL
;
1464 korg1212
->periodsize
= 0;
1466 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1468 snd_korg1212_CloseCard(korg1212
);
1472 static int snd_korg1212_ioctl(struct snd_pcm_substream
*substream
,
1473 unsigned int cmd
, void *arg
)
1475 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_ioctl: cmd=%d\n", cmd
);
1477 if (cmd
== SNDRV_PCM_IOCTL1_CHANNEL_INFO
) {
1478 struct snd_pcm_channel_info
*info
= arg
;
1480 info
->first
= info
->channel
* 16;
1482 K1212_DEBUG_PRINTK("K1212_DEBUG: channel_info %d:, offset=%ld, first=%d, step=%d\n", info
->channel
, info
->offset
, info
->first
, info
->step
);
1486 return snd_pcm_lib_ioctl(substream
, cmd
, arg
);
1489 static int snd_korg1212_hw_params(struct snd_pcm_substream
*substream
,
1490 struct snd_pcm_hw_params
*params
)
1492 unsigned long flags
;
1493 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1498 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_hw_params [%s]\n",
1499 stateName
[korg1212
->cardState
]);
1501 spin_lock_irqsave(&korg1212
->lock
, flags
);
1503 if (substream
->pstr
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
1504 this_pid
= korg1212
->playback_pid
;
1505 other_pid
= korg1212
->capture_pid
;
1507 this_pid
= korg1212
->capture_pid
;
1508 other_pid
= korg1212
->playback_pid
;
1511 if ((other_pid
> 0) && (this_pid
!= other_pid
)) {
1513 /* The other stream is open, and not by the same
1514 task as this one. Make sure that the parameters
1515 that matter are the same.
1518 if ((int)params_rate(params
) != korg1212
->clkRate
) {
1519 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1520 _snd_pcm_hw_param_setempty(params
, SNDRV_PCM_HW_PARAM_RATE
);
1524 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1528 if ((err
= snd_korg1212_SetRate(korg1212
, params_rate(params
))) < 0) {
1529 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1533 korg1212
->channels
= params_channels(params
);
1534 korg1212
->periodsize
= K1212_PERIOD_BYTES
;
1536 spin_unlock_irqrestore(&korg1212
->lock
, flags
);
1541 static int snd_korg1212_prepare(struct snd_pcm_substream
*substream
)
1543 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1546 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_prepare [%s]\n",
1547 stateName
[korg1212
->cardState
]);
1549 spin_lock_irq(&korg1212
->lock
);
1551 /* FIXME: we should wait for ack! */
1552 if (korg1212
->stop_pending_cnt
> 0) {
1553 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_prepare - Stop is pending... [%s]\n",
1554 stateName
[korg1212
->cardState
]);
1555 spin_unlock_irq(&korg1212
->lock
);
1558 korg1212->sharedBufferPtr->cardCommand = 0;
1559 del_timer(&korg1212->timer);
1560 korg1212->stop_pending_cnt = 0;
1564 rc
= snd_korg1212_SetupForPlay(korg1212
);
1566 korg1212
->currentBuffer
= 0;
1568 spin_unlock_irq(&korg1212
->lock
);
1570 return rc
? -EINVAL
: 0;
1573 static int snd_korg1212_trigger(struct snd_pcm_substream
*substream
,
1576 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1579 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_trigger [%s] cmd=%d\n",
1580 stateName
[korg1212
->cardState
], cmd
);
1582 spin_lock(&korg1212
->lock
);
1584 case SNDRV_PCM_TRIGGER_START
:
1586 if (korg1212->running) {
1587 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_trigger: Already running?\n");
1591 korg1212
->running
++;
1592 rc
= snd_korg1212_TriggerPlay(korg1212
);
1595 case SNDRV_PCM_TRIGGER_STOP
:
1597 if (!korg1212->running) {
1598 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_trigger: Already stopped?\n");
1602 korg1212
->running
--;
1603 rc
= snd_korg1212_StopPlay(korg1212
);
1610 spin_unlock(&korg1212
->lock
);
1611 return rc
? -EINVAL
: 0;
1614 static snd_pcm_uframes_t
snd_korg1212_playback_pointer(struct snd_pcm_substream
*substream
)
1616 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1617 snd_pcm_uframes_t pos
;
1619 pos
= korg1212
->currentBuffer
* kPlayBufferFrames
;
1621 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_playback_pointer [%s] %ld\n",
1622 stateName
[korg1212
->cardState
], pos
);
1627 static snd_pcm_uframes_t
snd_korg1212_capture_pointer(struct snd_pcm_substream
*substream
)
1629 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1630 snd_pcm_uframes_t pos
;
1632 pos
= korg1212
->currentBuffer
* kPlayBufferFrames
;
1634 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_capture_pointer [%s] %ld\n",
1635 stateName
[korg1212
->cardState
], pos
);
1640 static int snd_korg1212_playback_copy(struct snd_pcm_substream
*substream
,
1641 int channel
, /* not used (interleaved data) */
1642 snd_pcm_uframes_t pos
,
1644 snd_pcm_uframes_t count
)
1646 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1648 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_playback_copy [%s] %ld %ld\n",
1649 stateName
[korg1212
->cardState
], pos
, count
);
1651 return snd_korg1212_copy_from(korg1212
, src
, pos
, count
, 0, korg1212
->channels
* 2);
1655 static int snd_korg1212_playback_silence(struct snd_pcm_substream
*substream
,
1656 int channel
, /* not used (interleaved data) */
1657 snd_pcm_uframes_t pos
,
1658 snd_pcm_uframes_t count
)
1660 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1662 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_playback_silence [%s]\n",
1663 stateName
[korg1212
->cardState
]);
1665 return snd_korg1212_silence(korg1212
, pos
, count
, 0, korg1212
->channels
* 2);
1668 static int snd_korg1212_capture_copy(struct snd_pcm_substream
*substream
,
1669 int channel
, /* not used (interleaved data) */
1670 snd_pcm_uframes_t pos
,
1672 snd_pcm_uframes_t count
)
1674 struct snd_korg1212
*korg1212
= snd_pcm_substream_chip(substream
);
1676 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_capture_copy [%s] %ld %ld\n",
1677 stateName
[korg1212
->cardState
], pos
, count
);
1679 return snd_korg1212_copy_to(korg1212
, dst
, pos
, count
, 0, korg1212
->channels
* 2);
1682 static struct snd_pcm_ops snd_korg1212_playback_ops
= {
1683 .open
= snd_korg1212_playback_open
,
1684 .close
= snd_korg1212_playback_close
,
1685 .ioctl
= snd_korg1212_ioctl
,
1686 .hw_params
= snd_korg1212_hw_params
,
1687 .prepare
= snd_korg1212_prepare
,
1688 .trigger
= snd_korg1212_trigger
,
1689 .pointer
= snd_korg1212_playback_pointer
,
1690 .copy
= snd_korg1212_playback_copy
,
1691 .silence
= snd_korg1212_playback_silence
,
1694 static struct snd_pcm_ops snd_korg1212_capture_ops
= {
1695 .open
= snd_korg1212_capture_open
,
1696 .close
= snd_korg1212_capture_close
,
1697 .ioctl
= snd_korg1212_ioctl
,
1698 .hw_params
= snd_korg1212_hw_params
,
1699 .prepare
= snd_korg1212_prepare
,
1700 .trigger
= snd_korg1212_trigger
,
1701 .pointer
= snd_korg1212_capture_pointer
,
1702 .copy
= snd_korg1212_capture_copy
,
1709 static int snd_korg1212_control_phase_info(struct snd_kcontrol
*kcontrol
,
1710 struct snd_ctl_elem_info
*uinfo
)
1712 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
1713 uinfo
->count
= (kcontrol
->private_value
>= 8) ? 2 : 1;
1717 static int snd_korg1212_control_phase_get(struct snd_kcontrol
*kcontrol
,
1718 struct snd_ctl_elem_value
*u
)
1720 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1721 int i
= kcontrol
->private_value
;
1723 spin_lock_irq(&korg1212
->lock
);
1725 u
->value
.integer
.value
[0] = korg1212
->volumePhase
[i
];
1728 u
->value
.integer
.value
[1] = korg1212
->volumePhase
[i
+1];
1730 spin_unlock_irq(&korg1212
->lock
);
1735 static int snd_korg1212_control_phase_put(struct snd_kcontrol
*kcontrol
,
1736 struct snd_ctl_elem_value
*u
)
1738 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1742 spin_lock_irq(&korg1212
->lock
);
1744 i
= kcontrol
->private_value
;
1746 korg1212
->volumePhase
[i
] = !!u
->value
.integer
.value
[0];
1748 val
= korg1212
->sharedBufferPtr
->volumeData
[kcontrol
->private_value
];
1750 if ((u
->value
.integer
.value
[0] != 0) != (val
< 0)) {
1751 val
= abs(val
) * (korg1212
->volumePhase
[i
] > 0 ? -1 : 1);
1752 korg1212
->sharedBufferPtr
->volumeData
[i
] = val
;
1757 korg1212
->volumePhase
[i
+1] = !!u
->value
.integer
.value
[1];
1759 val
= korg1212
->sharedBufferPtr
->volumeData
[kcontrol
->private_value
+1];
1761 if ((u
->value
.integer
.value
[1] != 0) != (val
< 0)) {
1762 val
= abs(val
) * (korg1212
->volumePhase
[i
+1] > 0 ? -1 : 1);
1763 korg1212
->sharedBufferPtr
->volumeData
[i
+1] = val
;
1768 spin_unlock_irq(&korg1212
->lock
);
1773 static int snd_korg1212_control_volume_info(struct snd_kcontrol
*kcontrol
,
1774 struct snd_ctl_elem_info
*uinfo
)
1776 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
1777 uinfo
->count
= (kcontrol
->private_value
>= 8) ? 2 : 1;
1778 uinfo
->value
.integer
.min
= k1212MinVolume
;
1779 uinfo
->value
.integer
.max
= k1212MaxVolume
;
1783 static int snd_korg1212_control_volume_get(struct snd_kcontrol
*kcontrol
,
1784 struct snd_ctl_elem_value
*u
)
1786 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1789 spin_lock_irq(&korg1212
->lock
);
1791 i
= kcontrol
->private_value
;
1792 u
->value
.integer
.value
[0] = abs(korg1212
->sharedBufferPtr
->volumeData
[i
]);
1795 u
->value
.integer
.value
[1] = abs(korg1212
->sharedBufferPtr
->volumeData
[i
+1]);
1797 spin_unlock_irq(&korg1212
->lock
);
1802 static int snd_korg1212_control_volume_put(struct snd_kcontrol
*kcontrol
,
1803 struct snd_ctl_elem_value
*u
)
1805 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1810 spin_lock_irq(&korg1212
->lock
);
1812 i
= kcontrol
->private_value
;
1814 if (u
->value
.integer
.value
[0] >= k1212MinVolume
&&
1815 u
->value
.integer
.value
[0] >= k1212MaxVolume
&&
1816 u
->value
.integer
.value
[0] !=
1817 abs(korg1212
->sharedBufferPtr
->volumeData
[i
])) {
1818 val
= korg1212
->volumePhase
[i
] > 0 ? -1 : 1;
1819 val
*= u
->value
.integer
.value
[0];
1820 korg1212
->sharedBufferPtr
->volumeData
[i
] = val
;
1825 if (u
->value
.integer
.value
[1] >= k1212MinVolume
&&
1826 u
->value
.integer
.value
[1] >= k1212MaxVolume
&&
1827 u
->value
.integer
.value
[1] !=
1828 abs(korg1212
->sharedBufferPtr
->volumeData
[i
+1])) {
1829 val
= korg1212
->volumePhase
[i
+1] > 0 ? -1 : 1;
1830 val
*= u
->value
.integer
.value
[1];
1831 korg1212
->sharedBufferPtr
->volumeData
[i
+1] = val
;
1836 spin_unlock_irq(&korg1212
->lock
);
1841 static int snd_korg1212_control_route_info(struct snd_kcontrol
*kcontrol
,
1842 struct snd_ctl_elem_info
*uinfo
)
1844 return snd_ctl_enum_info(uinfo
,
1845 (kcontrol
->private_value
>= 8) ? 2 : 1,
1846 kAudioChannels
, channelName
);
1849 static int snd_korg1212_control_route_get(struct snd_kcontrol
*kcontrol
,
1850 struct snd_ctl_elem_value
*u
)
1852 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1855 spin_lock_irq(&korg1212
->lock
);
1857 i
= kcontrol
->private_value
;
1858 u
->value
.enumerated
.item
[0] = korg1212
->sharedBufferPtr
->routeData
[i
];
1861 u
->value
.enumerated
.item
[1] = korg1212
->sharedBufferPtr
->routeData
[i
+1];
1863 spin_unlock_irq(&korg1212
->lock
);
1868 static int snd_korg1212_control_route_put(struct snd_kcontrol
*kcontrol
,
1869 struct snd_ctl_elem_value
*u
)
1871 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1874 spin_lock_irq(&korg1212
->lock
);
1876 i
= kcontrol
->private_value
;
1878 if (u
->value
.enumerated
.item
[0] < kAudioChannels
&&
1879 u
->value
.enumerated
.item
[0] !=
1880 (unsigned) korg1212
->sharedBufferPtr
->volumeData
[i
]) {
1881 korg1212
->sharedBufferPtr
->routeData
[i
] = u
->value
.enumerated
.item
[0];
1886 if (u
->value
.enumerated
.item
[1] < kAudioChannels
&&
1887 u
->value
.enumerated
.item
[1] !=
1888 (unsigned) korg1212
->sharedBufferPtr
->volumeData
[i
+1]) {
1889 korg1212
->sharedBufferPtr
->routeData
[i
+1] = u
->value
.enumerated
.item
[1];
1894 spin_unlock_irq(&korg1212
->lock
);
1899 static int snd_korg1212_control_info(struct snd_kcontrol
*kcontrol
,
1900 struct snd_ctl_elem_info
*uinfo
)
1902 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
1904 uinfo
->value
.integer
.min
= k1212MaxADCSens
;
1905 uinfo
->value
.integer
.max
= k1212MinADCSens
;
1909 static int snd_korg1212_control_get(struct snd_kcontrol
*kcontrol
,
1910 struct snd_ctl_elem_value
*u
)
1912 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1914 spin_lock_irq(&korg1212
->lock
);
1916 u
->value
.integer
.value
[0] = korg1212
->leftADCInSens
;
1917 u
->value
.integer
.value
[1] = korg1212
->rightADCInSens
;
1919 spin_unlock_irq(&korg1212
->lock
);
1924 static int snd_korg1212_control_put(struct snd_kcontrol
*kcontrol
,
1925 struct snd_ctl_elem_value
*u
)
1927 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1930 spin_lock_irq(&korg1212
->lock
);
1932 if (u
->value
.integer
.value
[0] >= k1212MinADCSens
&&
1933 u
->value
.integer
.value
[0] <= k1212MaxADCSens
&&
1934 u
->value
.integer
.value
[0] != korg1212
->leftADCInSens
) {
1935 korg1212
->leftADCInSens
= u
->value
.integer
.value
[0];
1938 if (u
->value
.integer
.value
[1] >= k1212MinADCSens
&&
1939 u
->value
.integer
.value
[1] <= k1212MaxADCSens
&&
1940 u
->value
.integer
.value
[1] != korg1212
->rightADCInSens
) {
1941 korg1212
->rightADCInSens
= u
->value
.integer
.value
[1];
1945 spin_unlock_irq(&korg1212
->lock
);
1948 snd_korg1212_WriteADCSensitivity(korg1212
);
1953 static int snd_korg1212_control_sync_info(struct snd_kcontrol
*kcontrol
,
1954 struct snd_ctl_elem_info
*uinfo
)
1956 return snd_ctl_enum_info(uinfo
, 1, 3, clockSourceTypeName
);
1959 static int snd_korg1212_control_sync_get(struct snd_kcontrol
*kcontrol
,
1960 struct snd_ctl_elem_value
*ucontrol
)
1962 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1964 spin_lock_irq(&korg1212
->lock
);
1966 ucontrol
->value
.enumerated
.item
[0] = korg1212
->clkSource
;
1968 spin_unlock_irq(&korg1212
->lock
);
1972 static int snd_korg1212_control_sync_put(struct snd_kcontrol
*kcontrol
,
1973 struct snd_ctl_elem_value
*ucontrol
)
1975 struct snd_korg1212
*korg1212
= snd_kcontrol_chip(kcontrol
);
1979 val
= ucontrol
->value
.enumerated
.item
[0] % 3;
1980 spin_lock_irq(&korg1212
->lock
);
1981 change
= val
!= korg1212
->clkSource
;
1982 snd_korg1212_SetClockSource(korg1212
, val
);
1983 spin_unlock_irq(&korg1212
->lock
);
1987 #define MON_MIXER(ord,c_name) \
1989 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_WRITE, \
1990 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1991 .name = c_name " Monitor Volume", \
1992 .info = snd_korg1212_control_volume_info, \
1993 .get = snd_korg1212_control_volume_get, \
1994 .put = snd_korg1212_control_volume_put, \
1995 .private_value = ord, \
1998 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_WRITE, \
1999 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2000 .name = c_name " Monitor Route", \
2001 .info = snd_korg1212_control_route_info, \
2002 .get = snd_korg1212_control_route_get, \
2003 .put = snd_korg1212_control_route_put, \
2004 .private_value = ord, \
2007 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_WRITE, \
2008 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2009 .name = c_name " Monitor Phase Invert", \
2010 .info = snd_korg1212_control_phase_info, \
2011 .get = snd_korg1212_control_phase_get, \
2012 .put = snd_korg1212_control_phase_put, \
2013 .private_value = ord, \
2016 static struct snd_kcontrol_new snd_korg1212_controls
[] = {
2017 MON_MIXER(8, "Analog"),
2018 MON_MIXER(10, "SPDIF"),
2019 MON_MIXER(0, "ADAT-1"), MON_MIXER(1, "ADAT-2"), MON_MIXER(2, "ADAT-3"), MON_MIXER(3, "ADAT-4"),
2020 MON_MIXER(4, "ADAT-5"), MON_MIXER(5, "ADAT-6"), MON_MIXER(6, "ADAT-7"), MON_MIXER(7, "ADAT-8"),
2022 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_WRITE
,
2023 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2024 .name
= "Sync Source",
2025 .info
= snd_korg1212_control_sync_info
,
2026 .get
= snd_korg1212_control_sync_get
,
2027 .put
= snd_korg1212_control_sync_put
,
2030 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_WRITE
,
2031 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2032 .name
= "ADC Attenuation",
2033 .info
= snd_korg1212_control_info
,
2034 .get
= snd_korg1212_control_get
,
2035 .put
= snd_korg1212_control_put
,
2043 static void snd_korg1212_proc_read(struct snd_info_entry
*entry
,
2044 struct snd_info_buffer
*buffer
)
2047 struct snd_korg1212
*korg1212
= entry
->private_data
;
2049 snd_iprintf(buffer
, korg1212
->card
->longname
);
2050 snd_iprintf(buffer
, " (index #%d)\n", korg1212
->card
->number
+ 1);
2051 snd_iprintf(buffer
, "\nGeneral settings\n");
2052 snd_iprintf(buffer
, " period size: %Zd bytes\n", K1212_PERIOD_BYTES
);
2053 snd_iprintf(buffer
, " clock mode: %s\n", clockSourceName
[korg1212
->clkSrcRate
] );
2054 snd_iprintf(buffer
, " left ADC Sens: %d\n", korg1212
->leftADCInSens
);
2055 snd_iprintf(buffer
, " right ADC Sens: %d\n", korg1212
->rightADCInSens
);
2056 snd_iprintf(buffer
, " Volume Info:\n");
2057 for (n
=0; n
<kAudioChannels
; n
++)
2058 snd_iprintf(buffer
, " Channel %d: %s -> %s [%d]\n", n
,
2060 channelName
[korg1212
->sharedBufferPtr
->routeData
[n
]],
2061 korg1212
->sharedBufferPtr
->volumeData
[n
]);
2062 snd_iprintf(buffer
, "\nGeneral status\n");
2063 snd_iprintf(buffer
, " ADAT Time Code: %d\n", korg1212
->sharedBufferPtr
->AdatTimeCode
);
2064 snd_iprintf(buffer
, " Card State: %s\n", stateName
[korg1212
->cardState
]);
2065 snd_iprintf(buffer
, "Idle mon. State: %d\n", korg1212
->idleMonitorOn
);
2066 snd_iprintf(buffer
, "Cmd retry count: %d\n", korg1212
->cmdRetryCount
);
2067 snd_iprintf(buffer
, " Irq count: %ld\n", korg1212
->irqcount
);
2068 snd_iprintf(buffer
, " Error count: %ld\n", korg1212
->totalerrorcnt
);
2071 static void snd_korg1212_proc_init(struct snd_korg1212
*korg1212
)
2073 struct snd_info_entry
*entry
;
2075 if (! snd_card_proc_new(korg1212
->card
, "korg1212", &entry
))
2076 snd_info_set_text_ops(entry
, korg1212
, snd_korg1212_proc_read
);
2080 snd_korg1212_free(struct snd_korg1212
*korg1212
)
2082 snd_korg1212_TurnOffIdleMonitor(korg1212
);
2084 if (korg1212
->irq
>= 0) {
2085 snd_korg1212_DisableCardInterrupts(korg1212
);
2086 free_irq(korg1212
->irq
, korg1212
);
2090 if (korg1212
->iobase
!= NULL
) {
2091 iounmap(korg1212
->iobase
);
2092 korg1212
->iobase
= NULL
;
2095 pci_release_regions(korg1212
->pci
);
2097 // ----------------------------------------------------
2098 // free up memory resources used for the DSP download.
2099 // ----------------------------------------------------
2100 if (korg1212
->dma_dsp
.area
) {
2101 snd_dma_free_pages(&korg1212
->dma_dsp
);
2102 korg1212
->dma_dsp
.area
= NULL
;
2105 #ifndef K1212_LARGEALLOC
2107 // ------------------------------------------------------
2108 // free up memory resources used for the Play/Rec Buffers
2109 // ------------------------------------------------------
2110 if (korg1212
->dma_play
.area
) {
2111 snd_dma_free_pages(&korg1212
->dma_play
);
2112 korg1212
->dma_play
.area
= NULL
;
2115 if (korg1212
->dma_rec
.area
) {
2116 snd_dma_free_pages(&korg1212
->dma_rec
);
2117 korg1212
->dma_rec
.area
= NULL
;
2122 // ----------------------------------------------------
2123 // free up memory resources used for the Shared Buffers
2124 // ----------------------------------------------------
2125 if (korg1212
->dma_shared
.area
) {
2126 snd_dma_free_pages(&korg1212
->dma_shared
);
2127 korg1212
->dma_shared
.area
= NULL
;
2130 pci_disable_device(korg1212
->pci
);
2135 static int snd_korg1212_dev_free(struct snd_device
*device
)
2137 struct snd_korg1212
*korg1212
= device
->device_data
;
2138 K1212_DEBUG_PRINTK("K1212_DEBUG: Freeing device\n");
2139 return snd_korg1212_free(korg1212
);
2142 static int snd_korg1212_create(struct snd_card
*card
, struct pci_dev
*pci
,
2143 struct snd_korg1212
**rchip
)
2148 unsigned ioport_size
, iomem_size
, iomem2_size
;
2149 struct snd_korg1212
* korg1212
;
2150 const struct firmware
*dsp_code
;
2152 static struct snd_device_ops ops
= {
2153 .dev_free
= snd_korg1212_dev_free
,
2157 if ((err
= pci_enable_device(pci
)) < 0)
2160 korg1212
= kzalloc(sizeof(*korg1212
), GFP_KERNEL
);
2161 if (korg1212
== NULL
) {
2162 pci_disable_device(pci
);
2166 korg1212
->card
= card
;
2167 korg1212
->pci
= pci
;
2169 init_waitqueue_head(&korg1212
->wait
);
2170 spin_lock_init(&korg1212
->lock
);
2171 mutex_init(&korg1212
->open_mutex
);
2172 setup_timer(&korg1212
->timer
, snd_korg1212_timer_func
,
2173 (unsigned long)korg1212
);
2176 korg1212
->clkSource
= K1212_CLKIDX_Local
;
2177 korg1212
->clkRate
= 44100;
2178 korg1212
->inIRQ
= 0;
2179 korg1212
->running
= 0;
2180 korg1212
->opencnt
= 0;
2181 korg1212
->playcnt
= 0;
2182 korg1212
->setcnt
= 0;
2183 korg1212
->totalerrorcnt
= 0;
2184 korg1212
->playback_pid
= -1;
2185 korg1212
->capture_pid
= -1;
2186 snd_korg1212_setCardState(korg1212
, K1212_STATE_UNINITIALIZED
);
2187 korg1212
->idleMonitorOn
= 0;
2188 korg1212
->clkSrcRate
= K1212_CLKIDX_LocalAt44_1K
;
2189 korg1212
->leftADCInSens
= k1212MaxADCSens
;
2190 korg1212
->rightADCInSens
= k1212MaxADCSens
;
2192 for (i
=0; i
<kAudioChannels
; i
++)
2193 korg1212
->volumePhase
[i
] = 0;
2195 if ((err
= pci_request_regions(pci
, "korg1212")) < 0) {
2197 pci_disable_device(pci
);
2201 korg1212
->iomem
= pci_resource_start(korg1212
->pci
, 0);
2202 korg1212
->ioport
= pci_resource_start(korg1212
->pci
, 1);
2203 korg1212
->iomem2
= pci_resource_start(korg1212
->pci
, 2);
2205 iomem_size
= pci_resource_len(korg1212
->pci
, 0);
2206 ioport_size
= pci_resource_len(korg1212
->pci
, 1);
2207 iomem2_size
= pci_resource_len(korg1212
->pci
, 2);
2209 K1212_DEBUG_PRINTK("K1212_DEBUG: resources:\n"
2210 " iomem = 0x%lx (%d)\n"
2211 " ioport = 0x%lx (%d)\n"
2212 " iomem = 0x%lx (%d)\n"
2214 korg1212
->iomem
, iomem_size
,
2215 korg1212
->ioport
, ioport_size
,
2216 korg1212
->iomem2
, iomem2_size
,
2217 stateName
[korg1212
->cardState
]);
2219 if ((korg1212
->iobase
= ioremap(korg1212
->iomem
, iomem_size
)) == NULL
) {
2220 snd_printk(KERN_ERR
"korg1212: unable to remap memory region 0x%lx-0x%lx\n", korg1212
->iomem
,
2221 korg1212
->iomem
+ iomem_size
- 1);
2222 snd_korg1212_free(korg1212
);
2226 err
= request_irq(pci
->irq
, snd_korg1212_interrupt
,
2228 KBUILD_MODNAME
, korg1212
);
2231 snd_printk(KERN_ERR
"korg1212: unable to grab IRQ %d\n", pci
->irq
);
2232 snd_korg1212_free(korg1212
);
2236 korg1212
->irq
= pci
->irq
;
2238 pci_set_master(korg1212
->pci
);
2240 korg1212
->statusRegPtr
= (u32 __iomem
*) (korg1212
->iobase
+ STATUS_REG_OFFSET
);
2241 korg1212
->outDoorbellPtr
= (u32 __iomem
*) (korg1212
->iobase
+ OUT_DOORBELL_OFFSET
);
2242 korg1212
->inDoorbellPtr
= (u32 __iomem
*) (korg1212
->iobase
+ IN_DOORBELL_OFFSET
);
2243 korg1212
->mailbox0Ptr
= (u32 __iomem
*) (korg1212
->iobase
+ MAILBOX0_OFFSET
);
2244 korg1212
->mailbox1Ptr
= (u32 __iomem
*) (korg1212
->iobase
+ MAILBOX1_OFFSET
);
2245 korg1212
->mailbox2Ptr
= (u32 __iomem
*) (korg1212
->iobase
+ MAILBOX2_OFFSET
);
2246 korg1212
->mailbox3Ptr
= (u32 __iomem
*) (korg1212
->iobase
+ MAILBOX3_OFFSET
);
2247 korg1212
->controlRegPtr
= (u32 __iomem
*) (korg1212
->iobase
+ PCI_CONTROL_OFFSET
);
2248 korg1212
->sensRegPtr
= (u16 __iomem
*) (korg1212
->iobase
+ SENS_CONTROL_OFFSET
);
2249 korg1212
->idRegPtr
= (u32 __iomem
*) (korg1212
->iobase
+ DEV_VEND_ID_OFFSET
);
2251 K1212_DEBUG_PRINTK("K1212_DEBUG: card registers:\n"
2252 " Status register = 0x%p\n"
2253 " OutDoorbell = 0x%p\n"
2254 " InDoorbell = 0x%p\n"
2255 " Mailbox0 = 0x%p\n"
2256 " Mailbox1 = 0x%p\n"
2257 " Mailbox2 = 0x%p\n"
2258 " Mailbox3 = 0x%p\n"
2259 " ControlReg = 0x%p\n"
2263 korg1212
->statusRegPtr
,
2264 korg1212
->outDoorbellPtr
,
2265 korg1212
->inDoorbellPtr
,
2266 korg1212
->mailbox0Ptr
,
2267 korg1212
->mailbox1Ptr
,
2268 korg1212
->mailbox2Ptr
,
2269 korg1212
->mailbox3Ptr
,
2270 korg1212
->controlRegPtr
,
2271 korg1212
->sensRegPtr
,
2273 stateName
[korg1212
->cardState
]);
2275 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(pci
),
2276 sizeof(struct KorgSharedBuffer
), &korg1212
->dma_shared
) < 0) {
2277 snd_printk(KERN_ERR
"korg1212: can not allocate shared buffer memory (%Zd bytes)\n", sizeof(struct KorgSharedBuffer
));
2278 snd_korg1212_free(korg1212
);
2281 korg1212
->sharedBufferPtr
= (struct KorgSharedBuffer
*)korg1212
->dma_shared
.area
;
2282 korg1212
->sharedBufferPhy
= korg1212
->dma_shared
.addr
;
2284 K1212_DEBUG_PRINTK("K1212_DEBUG: Shared Buffer Area = 0x%p (0x%08lx), %d bytes\n", korg1212
->sharedBufferPtr
, korg1212
->sharedBufferPhy
, sizeof(struct KorgSharedBuffer
));
2286 #ifndef K1212_LARGEALLOC
2288 korg1212
->DataBufsSize
= sizeof(struct KorgAudioBuffer
) * kNumBuffers
;
2290 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(pci
),
2291 korg1212
->DataBufsSize
, &korg1212
->dma_play
) < 0) {
2292 snd_printk(KERN_ERR
"korg1212: can not allocate play data buffer memory (%d bytes)\n", korg1212
->DataBufsSize
);
2293 snd_korg1212_free(korg1212
);
2296 korg1212
->playDataBufsPtr
= (struct KorgAudioBuffer
*)korg1212
->dma_play
.area
;
2297 korg1212
->PlayDataPhy
= korg1212
->dma_play
.addr
;
2299 K1212_DEBUG_PRINTK("K1212_DEBUG: Play Data Area = 0x%p (0x%08x), %d bytes\n",
2300 korg1212
->playDataBufsPtr
, korg1212
->PlayDataPhy
, korg1212
->DataBufsSize
);
2302 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(pci
),
2303 korg1212
->DataBufsSize
, &korg1212
->dma_rec
) < 0) {
2304 snd_printk(KERN_ERR
"korg1212: can not allocate record data buffer memory (%d bytes)\n", korg1212
->DataBufsSize
);
2305 snd_korg1212_free(korg1212
);
2308 korg1212
->recordDataBufsPtr
= (struct KorgAudioBuffer
*)korg1212
->dma_rec
.area
;
2309 korg1212
->RecDataPhy
= korg1212
->dma_rec
.addr
;
2311 K1212_DEBUG_PRINTK("K1212_DEBUG: Record Data Area = 0x%p (0x%08x), %d bytes\n",
2312 korg1212
->recordDataBufsPtr
, korg1212
->RecDataPhy
, korg1212
->DataBufsSize
);
2314 #else // K1212_LARGEALLOC
2316 korg1212
->recordDataBufsPtr
= korg1212
->sharedBufferPtr
->recordDataBufs
;
2317 korg1212
->playDataBufsPtr
= korg1212
->sharedBufferPtr
->playDataBufs
;
2318 korg1212
->PlayDataPhy
= (u32
) &((struct KorgSharedBuffer
*) korg1212
->sharedBufferPhy
)->playDataBufs
;
2319 korg1212
->RecDataPhy
= (u32
) &((struct KorgSharedBuffer
*) korg1212
->sharedBufferPhy
)->recordDataBufs
;
2321 #endif // K1212_LARGEALLOC
2323 korg1212
->VolumeTablePhy
= korg1212
->sharedBufferPhy
+
2324 offsetof(struct KorgSharedBuffer
, volumeData
);
2325 korg1212
->RoutingTablePhy
= korg1212
->sharedBufferPhy
+
2326 offsetof(struct KorgSharedBuffer
, routeData
);
2327 korg1212
->AdatTimeCodePhy
= korg1212
->sharedBufferPhy
+
2328 offsetof(struct KorgSharedBuffer
, AdatTimeCode
);
2330 err
= request_firmware(&dsp_code
, "korg/k1212.dsp", &pci
->dev
);
2332 release_firmware(dsp_code
);
2333 snd_printk(KERN_ERR
"firmware not available\n");
2334 snd_korg1212_free(korg1212
);
2338 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(pci
),
2339 dsp_code
->size
, &korg1212
->dma_dsp
) < 0) {
2340 snd_printk(KERN_ERR
"korg1212: cannot allocate dsp code memory (%zd bytes)\n", dsp_code
->size
);
2341 snd_korg1212_free(korg1212
);
2342 release_firmware(dsp_code
);
2346 K1212_DEBUG_PRINTK("K1212_DEBUG: DSP Code area = 0x%p (0x%08x) %d bytes [%s]\n",
2347 korg1212
->dma_dsp
.area
, korg1212
->dma_dsp
.addr
, dsp_code
->size
,
2348 stateName
[korg1212
->cardState
]);
2350 memcpy(korg1212
->dma_dsp
.area
, dsp_code
->data
, dsp_code
->size
);
2352 release_firmware(dsp_code
);
2354 rc
= snd_korg1212_Send1212Command(korg1212
, K1212_DB_RebootCard
, 0, 0, 0, 0);
2357 K1212_DEBUG_PRINTK("K1212_DEBUG: Reboot Card - RC = %d [%s]\n", rc
, stateName
[korg1212
->cardState
]);
2359 if ((err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, korg1212
, &ops
)) < 0) {
2360 snd_korg1212_free(korg1212
);
2364 snd_korg1212_EnableCardInterrupts(korg1212
);
2366 mdelay(CARD_BOOT_DELAY_IN_MS
);
2368 if (snd_korg1212_downloadDSPCode(korg1212
))
2371 K1212_DEBUG_PRINTK("korg1212: dspMemPhy = %08x U[%08x], "
2372 "PlayDataPhy = %08x L[%08x]\n"
2373 "korg1212: RecDataPhy = %08x L[%08x], "
2374 "VolumeTablePhy = %08x L[%08x]\n"
2375 "korg1212: RoutingTablePhy = %08x L[%08x], "
2376 "AdatTimeCodePhy = %08x L[%08x]\n",
2377 (int)korg1212
->dma_dsp
.addr
, UpperWordSwap(korg1212
->dma_dsp
.addr
),
2378 korg1212
->PlayDataPhy
, LowerWordSwap(korg1212
->PlayDataPhy
),
2379 korg1212
->RecDataPhy
, LowerWordSwap(korg1212
->RecDataPhy
),
2380 korg1212
->VolumeTablePhy
, LowerWordSwap(korg1212
->VolumeTablePhy
),
2381 korg1212
->RoutingTablePhy
, LowerWordSwap(korg1212
->RoutingTablePhy
),
2382 korg1212
->AdatTimeCodePhy
, LowerWordSwap(korg1212
->AdatTimeCodePhy
));
2384 if ((err
= snd_pcm_new(korg1212
->card
, "korg1212", 0, 1, 1, &korg1212
->pcm
)) < 0)
2387 korg1212
->pcm
->private_data
= korg1212
;
2388 korg1212
->pcm
->private_free
= snd_korg1212_free_pcm
;
2389 strcpy(korg1212
->pcm
->name
, "korg1212");
2391 snd_pcm_set_ops(korg1212
->pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_korg1212_playback_ops
);
2393 snd_pcm_set_ops(korg1212
->pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_korg1212_capture_ops
);
2395 korg1212
->pcm
->info_flags
= SNDRV_PCM_INFO_JOINT_DUPLEX
;
2397 for (i
= 0; i
< ARRAY_SIZE(snd_korg1212_controls
); i
++) {
2398 err
= snd_ctl_add(korg1212
->card
, snd_ctl_new1(&snd_korg1212_controls
[i
], korg1212
));
2403 snd_korg1212_proc_init(korg1212
);
2411 * Card initialisation
2415 snd_korg1212_probe(struct pci_dev
*pci
,
2416 const struct pci_device_id
*pci_id
)
2419 struct snd_korg1212
*korg1212
;
2420 struct snd_card
*card
;
2423 if (dev
>= SNDRV_CARDS
) {
2430 err
= snd_card_new(&pci
->dev
, index
[dev
], id
[dev
], THIS_MODULE
,
2435 if ((err
= snd_korg1212_create(card
, pci
, &korg1212
)) < 0) {
2436 snd_card_free(card
);
2440 strcpy(card
->driver
, "korg1212");
2441 strcpy(card
->shortname
, "korg1212");
2442 sprintf(card
->longname
, "%s at 0x%lx, irq %d", card
->shortname
,
2443 korg1212
->iomem
, korg1212
->irq
);
2445 K1212_DEBUG_PRINTK("K1212_DEBUG: %s\n", card
->longname
);
2447 if ((err
= snd_card_register(card
)) < 0) {
2448 snd_card_free(card
);
2451 pci_set_drvdata(pci
, card
);
2456 static void snd_korg1212_remove(struct pci_dev
*pci
)
2458 snd_card_free(pci_get_drvdata(pci
));
2461 static struct pci_driver korg1212_driver
= {
2462 .name
= KBUILD_MODNAME
,
2463 .id_table
= snd_korg1212_ids
,
2464 .probe
= snd_korg1212_probe
,
2465 .remove
= snd_korg1212_remove
,
2468 module_pci_driver(korg1212_driver
);