blob: 43b4228d9afe41812a25d4d9ea81e2b028016410 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Driver for the Korg 1212 IO PCI card
3 *
4 * Copyright (c) 2001 Haroldo Gamal <gamal@alternex.com.br>
5 *
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.
10 *
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.
15 *
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
19 *
20 */
21
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#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>
Paul Gortmaker65a77212011-07-15 13:13:37 -040028#include <linux/module.h>
Ingo Molnar62932df2006-01-16 16:34:20 +010029#include <linux/mutex.h>
Clemens Ladisch2493a6d2006-11-06 09:24:29 +010030#include <linux/firmware.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
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>
38
39#include <asm/io.h>
40
41// ----------------------------------------------------------------------------
42// Debug Stuff
43// ----------------------------------------------------------------------------
44#define K1212_DEBUG_LEVEL 0
Takashi Iwai9fd91562005-11-17 10:45:48 +010045#if K1212_DEBUG_LEVEL > 0
46#define K1212_DEBUG_PRINTK(fmt,args...) printk(KERN_DEBUG fmt,##args)
47#else
48#define K1212_DEBUG_PRINTK(fmt,...)
49#endif
50#if K1212_DEBUG_LEVEL > 1
51#define K1212_DEBUG_PRINTK_VERBOSE(fmt,args...) printk(KERN_DEBUG fmt,##args)
52#else
53#define K1212_DEBUG_PRINTK_VERBOSE(fmt,...)
54#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
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
61
62// ----------------------------------------------------------------------------
63// Valid states of the Korg 1212 I/O card.
64// ----------------------------------------------------------------------------
Takashi Iwaifcfd3332005-11-17 15:00:46 +010065enum CardState {
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 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
Takashi Iwaifcfd3332005-11-17 15:00:46 +010081};
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
83// ----------------------------------------------------------------------------
84// The following enumeration defines the constants written to the card's
85// host-to-card doorbell to initiate a command.
86// ----------------------------------------------------------------------------
Takashi Iwaifcfd3332005-11-17 15:00:46 +010087enum korg1212_dbcnst {
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 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
96 // timecode value.
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
103 // completed.
104 K1212_DB_StartDSPDownload = 0xAF // tells the card to download its DSP firmware.
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100105};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
107
108// ----------------------------------------------------------------------------
109// The following enumeration defines return codes
110// to the Korg 1212 I/O driver.
111// ----------------------------------------------------------------------------
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100112enum snd_korg1212rc {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 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
119 // state)
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
127
128 K1212_CMDRET_BadDevice, // the specified wave device was out of range
129 K1212_CMDRET_BadFormat // the specified wave format is unsupported
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100130};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
132// ----------------------------------------------------------------------------
133// The following enumeration defines the constants used to select the play
134// mode for the card in the SelectPlayMode command.
135// ----------------------------------------------------------------------------
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100136enum PlayModeSelector {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 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
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100141};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142
143// ----------------------------------------------------------------------------
144// The following enumeration defines the constants used to select the monitor
145// mode for the card in the SetMonitorMode command.
146// ----------------------------------------------------------------------------
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100147enum MonitorModeSelector {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 K1212_MONMODE_Off = 0, // tells card to turn off monitor mode
149 K1212_MONMODE_On // tells card to turn on monitor mode
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100150};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
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
160 // register
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
164
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165#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
168 // the card.
169#define DOORBELL_VAL_MASK 0x00FF // the doorbell value is one byte
170
171#define CARD_BOOT_DELAY_IN_MS 10
172#define CARD_BOOT_TIMEOUT 10
173#define DSP_BOOT_DELAY_IN_MS 200
174
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
182
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
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100189#define K1212_FRAME_SIZE (sizeof(struct KorgAudioFrame))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190#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)
198
Takashi Iwaifbaf6a52012-08-30 07:57:38 -0700199#define k1212MinADCSens 0x00
200#define k1212MaxADCSens 0x7f
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201#define k1212MaxVolume 0x7fff
202#define k1212MaxWaveVolume 0xffff
203#define k1212MinVolume 0x0000
204#define k1212MaxVolInverted 0x8000
205
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
215
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
222
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
231
232// ------------------------------------------------------------------------
233// the following constants are used in setting the 1212 I/O card's input
234// sensitivity.
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
240
241#define SET_SENS_LEFTCHANID 0x00
242#define SET_SENS_RIGHTCHANID 0x01
243
244#define K1212SENSUPDATE_DELAY_IN_MS 50
245
246// --------------------------------------------------------------------------
247// WaitRTCTicks
248//
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.
262
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100263enum ClockSourceIndex {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 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
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100271};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100273enum ClockSourceType {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 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
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100277};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100279struct 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 */
283};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100285struct KorgAudioBuffer {
286 struct KorgAudioFrame bufferData[kPlayBufferFrames]; /* buffer definition */
287};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100289struct KorgSharedBuffer {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290#ifdef K1212_LARGEALLOC
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100291 struct KorgAudioBuffer playDataBufs[kNumBuffers];
292 struct KorgAudioBuffer recordDataBufs[kNumBuffers];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293#endif
294 short volumeData[kAudioChannels];
295 u32 cardCommand;
296 u16 routeData [kAudioChannels];
297 u32 AdatTimeCode; // ADAT timecode value
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100298};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100300struct SensBits {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 union {
302 struct {
303 unsigned int leftChanVal:8;
304 unsigned int leftChanId:8;
305 } v;
306 u16 leftSensBits;
307 } l;
308 union {
309 struct {
310 unsigned int rightChanVal:8;
311 unsigned int rightChanId:8;
312 } v;
313 u16 rightSensBits;
314 } r;
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100315};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100317struct snd_korg1212 {
318 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 struct pci_dev *pci;
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100320 struct snd_pcm *pcm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 int irq;
322
323 spinlock_t lock;
Ingo Molnar62932df2006-01-16 16:34:20 +0100324 struct mutex open_mutex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
326 struct timer_list timer; /* timer callback for checking ack of stop request */
327 int stop_pending_cnt; /* counter for stop pending check */
328
329 wait_queue_head_t wait;
330
331 unsigned long iomem;
332 unsigned long ioport;
333 unsigned long iomem2;
334 unsigned long irqcount;
335 unsigned long inIRQ;
336 void __iomem *iobase;
337
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;
342
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 u32 DataBufsSize;
344
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100345 struct KorgAudioBuffer * playDataBufsPtr;
346 struct KorgAudioBuffer * recordDataBufsPtr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100348 struct KorgSharedBuffer * sharedBufferPtr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
350 u32 RecDataPhy;
351 u32 PlayDataPhy;
352 unsigned long sharedBufferPhy;
353 u32 VolumeTablePhy;
354 u32 RoutingTablePhy;
355 u32 AdatTimeCodePhy;
356
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
367
368 size_t periodsize;
369 int channels;
370 int currentBuffer;
371
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100372 struct snd_pcm_substream *playback_substream;
373 struct snd_pcm_substream *capture_substream;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374
375 pid_t capture_pid;
376 pid_t playback_pid;
377
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100378 enum CardState cardState;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 int running;
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.
382
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100383 enum ClockSourceIndex clkSrcRate; // sample rate and clock source
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100385 enum ClockSourceType clkSource; // clock source
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 int clkRate; // clock rate
387
388 int volumePhase[kAudioChannels];
389
390 u16 leftADCInSens; // ADC left channel input sensitivity
391 u16 rightADCInSens; // ADC right channel input sensitivity
392
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
398
399 int dsp_is_loaded;
400 int dsp_stop_is_processed;
401
402};
403
404MODULE_DESCRIPTION("korg1212");
405MODULE_LICENSE("GPL");
406MODULE_SUPPORTED_DEVICE("{{KORG,korg1212}}");
Clemens Ladisch7e0af292007-05-03 17:59:54 +0200407MODULE_FIRMWARE("korg/k1212.dsp");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
409static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
410static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
Rusty Russella67ff6a2011-12-15 13:49:36 +1030411static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE; /* Enable this card */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
413module_param_array(index, int, NULL, 0444);
414MODULE_PARM_DESC(index, "Index value for Korg 1212 soundcard.");
415module_param_array(id, charp, NULL, 0444);
416MODULE_PARM_DESC(id, "ID string for Korg 1212 soundcard.");
417module_param_array(enable, bool, NULL, 0444);
418MODULE_PARM_DESC(enable, "Enable Korg 1212 soundcard.");
419MODULE_AUTHOR("Haroldo Gamal <gamal@alternex.com.br>");
420
Alexey Dobriyancebe41d2010-02-06 00:21:03 +0200421static DEFINE_PCI_DEVICE_TABLE(snd_korg1212_ids) = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 {
423 .vendor = 0x10b5,
424 .device = 0x906d,
425 .subvendor = PCI_ANY_ID,
426 .subdevice = PCI_ANY_ID,
427 },
428 { 0, },
429};
430
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100431MODULE_DEVICE_TABLE(pci, snd_korg1212_ids);
432
Takashi Iwai9fd91562005-11-17 10:45:48 +0100433static char *stateName[] = {
434 "Non-existent",
435 "Uninitialized",
436 "DSP download in process",
437 "DSP download complete",
438 "Ready",
439 "Open",
440 "Setup for play",
441 "Playing",
442 "Monitor mode on",
443 "Calibrating",
444 "Invalid"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445};
446
Takashi Iwai9fd91562005-11-17 10:45:48 +0100447static char *clockSourceTypeName[] = { "ADAT", "S/PDIF", "local" };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448
Takashi Iwai9fd91562005-11-17 10:45:48 +0100449static char *clockSourceName[] = {
450 "ADAT at 44.1 kHz",
451 "ADAT at 48 kHz",
452 "S/PDIF at 44.1 kHz",
453 "S/PDIF at 48 kHz",
454 "local clock at 44.1 kHz",
455 "local clock at 48 kHz"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456};
457
Takashi Iwai9fd91562005-11-17 10:45:48 +0100458static char *channelName[] = {
459 "ADAT-1",
460 "ADAT-2",
461 "ADAT-3",
462 "ADAT-4",
463 "ADAT-5",
464 "ADAT-6",
465 "ADAT-7",
466 "ADAT-8",
467 "Analog-L",
468 "Analog-R",
469 "SPDIF-L",
470 "SPDIF-R",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471};
472
Takashi Iwai9fd91562005-11-17 10:45:48 +0100473static 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
480};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100482union swap_u32 { unsigned char c[4]; u32 i; };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
484#ifdef SNDRV_BIG_ENDIAN
485static u32 LowerWordSwap(u32 swappee)
486#else
487static u32 UpperWordSwap(u32 swappee)
488#endif
489{
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100490 union swap_u32 retVal, swapper;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
492 swapper.i = swappee;
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];
497
498 return retVal.i;
499}
500
501#ifdef SNDRV_BIG_ENDIAN
502static u32 UpperWordSwap(u32 swappee)
503#else
504static u32 LowerWordSwap(u32 swappee)
505#endif
506{
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100507 union swap_u32 retVal, swapper;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
509 swapper.i = swappee;
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];
514
515 return retVal.i;
516}
517
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518#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)
522
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100523static int snd_korg1212_Send1212Command(struct snd_korg1212 *korg1212,
524 enum korg1212_dbcnst doorbellVal,
525 u32 mailBox0Val, u32 mailBox1Val,
526 u32 mailBox2Val, u32 mailBox3Val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527{
528 u32 retryCount;
529 u16 mailBox3Lo;
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100530 int rc = K1212_CMDRET_Success;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
532 if (!korg1212->outDoorbellPtr) {
Takashi Iwai9fd91562005-11-17 10:45:48 +0100533 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: CardUninitialized\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 return K1212_CMDRET_CardUninitialized;
535 }
536
Takashi Iwai9fd91562005-11-17 10:45:48 +0100537 K1212_DEBUG_PRINTK("K1212_DEBUG: Card <- 0x%08x 0x%08x [%s]\n",
538 doorbellVal, mailBox0Val, stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 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
545
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;
553 break;
554 }
555
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)) {
Takashi Iwai9fd91562005-11-17 10:45:48 +0100565 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: Card <- Success\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 rc = K1212_CMDRET_Success;
567 break;
568 }
569 }
570 }
571 korg1212->cmdRetryCount += retryCount;
572
573 if (retryCount >= MAX_COMMAND_RETRIES) {
Takashi Iwai9fd91562005-11-17 10:45:48 +0100574 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: Card <- NoAckFromCard\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 rc = K1212_CMDRET_NoAckFromCard;
576 }
577
578 return rc;
579}
580
581/* spinlock already held */
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100582static void snd_korg1212_SendStop(struct snd_korg1212 *korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583{
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);
590 }
591}
592
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100593static void snd_korg1212_SendStopAndWait(struct snd_korg1212 *korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594{
595 unsigned long flags;
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);
601}
602
603/* timer callback for checking the ack of stop request */
604static void snd_korg1212_timer_func(unsigned long data)
605{
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100606 struct snd_korg1212 *korg1212 = (struct snd_korg1212 *) data;
Takashi Iwaib32425a2005-11-18 18:52:14 +0100607 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608
Takashi Iwaib32425a2005-11-18 18:52:14 +0100609 spin_lock_irqsave(&korg1212->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 if (korg1212->sharedBufferPtr->cardCommand == 0) {
611 /* ack'ed */
612 korg1212->stop_pending_cnt = 0;
613 korg1212->dsp_stop_is_processed = 1;
614 wake_up(&korg1212->wait);
Takashi Iwai9fd91562005-11-17 10:45:48 +0100615 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: Stop ack'ed [%s]\n",
616 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 } else {
618 if (--korg1212->stop_pending_cnt > 0) {
619 /* reprogram timer */
620 korg1212->timer.expires = jiffies + 1;
621 add_timer(&korg1212->timer);
622 } else {
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);
Takashi Iwai9fd91562005-11-17 10:45:48 +0100627 K1212_DEBUG_PRINTK("K1212_DEBUG: Stop timeout [%s]\n",
628 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 }
630 }
Takashi Iwaib32425a2005-11-18 18:52:14 +0100631 spin_unlock_irqrestore(&korg1212->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632}
633
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100634static int snd_korg1212_TurnOnIdleMonitor(struct snd_korg1212 *korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635{
636 unsigned long flags;
Takashi Iwai9fd91562005-11-17 10:45:48 +0100637 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638
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);
Takashi Iwai9fd91562005-11-17 10:45:48 +0100645 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646}
647
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100648static void snd_korg1212_TurnOffIdleMonitor(struct snd_korg1212 *korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649{
650 if (korg1212->idleMonitorOn) {
651 snd_korg1212_SendStopAndWait(korg1212);
652 korg1212->idleMonitorOn = 0;
653 }
654}
655
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100656static inline void snd_korg1212_setCardState(struct snd_korg1212 * korg1212, enum CardState csState)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657{
658 korg1212->cardState = csState;
659}
660
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100661static int snd_korg1212_OpenCard(struct snd_korg1212 * korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662{
Takashi Iwai9fd91562005-11-17 10:45:48 +0100663 K1212_DEBUG_PRINTK("K1212_DEBUG: OpenCard [%s] %d\n",
664 stateName[korg1212->cardState], korg1212->opencnt);
Ingo Molnar62932df2006-01-16 16:34:20 +0100665 mutex_lock(&korg1212->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 if (korg1212->opencnt++ == 0) {
667 snd_korg1212_TurnOffIdleMonitor(korg1212);
668 snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
669 }
670
Ingo Molnar62932df2006-01-16 16:34:20 +0100671 mutex_unlock(&korg1212->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 return 1;
673}
674
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100675static int snd_korg1212_CloseCard(struct snd_korg1212 * korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676{
Takashi Iwai9fd91562005-11-17 10:45:48 +0100677 K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard [%s] %d\n",
678 stateName[korg1212->cardState], korg1212->opencnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
Ingo Molnar62932df2006-01-16 16:34:20 +0100680 mutex_lock(&korg1212->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 if (--(korg1212->opencnt)) {
Ingo Molnar62932df2006-01-16 16:34:20 +0100682 mutex_unlock(&korg1212->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 return 0;
684 }
685
686 if (korg1212->cardState == K1212_STATE_SETUP) {
Takashi Iwai9fd91562005-11-17 10:45:48 +0100687 int rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 K1212_MODE_StopPlay, 0, 0, 0);
Takashi Iwai9fd91562005-11-17 10:45:48 +0100689 if (rc)
690 K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard - RC = %d [%s]\n",
691 rc, stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 if (rc != K1212_CMDRET_Success) {
Ingo Molnar62932df2006-01-16 16:34:20 +0100693 mutex_unlock(&korg1212->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 return 0;
695 }
696 } else if (korg1212->cardState > K1212_STATE_SETUP) {
697 snd_korg1212_SendStopAndWait(korg1212);
698 }
699
700 if (korg1212->cardState > K1212_STATE_READY) {
701 snd_korg1212_TurnOnIdleMonitor(korg1212);
702 snd_korg1212_setCardState(korg1212, K1212_STATE_READY);
703 }
704
Ingo Molnar62932df2006-01-16 16:34:20 +0100705 mutex_unlock(&korg1212->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 return 0;
707}
708
709/* spinlock already held */
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100710static int snd_korg1212_SetupForPlay(struct snd_korg1212 * korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711{
Takashi Iwai9fd91562005-11-17 10:45:48 +0100712 int rc;
713
714 K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay [%s] %d\n",
715 stateName[korg1212->cardState], korg1212->setcnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716
717 if (korg1212->setcnt++)
718 return 0;
719
720 snd_korg1212_setCardState(korg1212, K1212_STATE_SETUP);
721 rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode,
722 K1212_MODE_SetupPlay, 0, 0, 0);
Takashi Iwai9fd91562005-11-17 10:45:48 +0100723 if (rc)
724 K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay - RC = %d [%s]\n",
725 rc, stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 if (rc != K1212_CMDRET_Success) {
727 return 1;
728 }
729 return 0;
730}
731
732/* spinlock already held */
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100733static int snd_korg1212_TriggerPlay(struct snd_korg1212 * korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734{
Takashi Iwai9fd91562005-11-17 10:45:48 +0100735 int rc;
736
737 K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay [%s] %d\n",
738 stateName[korg1212->cardState], korg1212->playcnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
740 if (korg1212->playcnt++)
741 return 0;
742
743 snd_korg1212_setCardState(korg1212, K1212_STATE_PLAYING);
744 rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_TriggerPlay, 0, 0, 0, 0);
Takashi Iwai9fd91562005-11-17 10:45:48 +0100745 if (rc)
746 K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay - RC = %d [%s]\n",
747 rc, stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 if (rc != K1212_CMDRET_Success) {
749 return 1;
750 }
751 return 0;
752}
753
754/* spinlock already held */
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100755static int snd_korg1212_StopPlay(struct snd_korg1212 * korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756{
Takashi Iwai9fd91562005-11-17 10:45:48 +0100757 K1212_DEBUG_PRINTK("K1212_DEBUG: StopPlay [%s] %d\n",
758 stateName[korg1212->cardState], korg1212->playcnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
760 if (--(korg1212->playcnt))
761 return 0;
762
763 korg1212->setcnt = 0;
764
765 if (korg1212->cardState != K1212_STATE_ERRORSTOP)
766 snd_korg1212_SendStop(korg1212);
767
768 snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
769 return 0;
770}
771
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100772static void snd_korg1212_EnableCardInterrupts(struct snd_korg1212 * korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773{
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);
780}
781
782#if 0 /* not used */
783
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100784static int snd_korg1212_SetMonitorMode(struct snd_korg1212 *korg1212,
785 enum MonitorModeSelector mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786{
Takashi Iwai9fd91562005-11-17 10:45:48 +0100787 K1212_DEBUG_PRINTK("K1212_DEBUG: SetMonitorMode [%s]\n",
788 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789
790 switch (mode) {
Takashi Iwai9fd91562005-11-17 10:45:48 +0100791 case K1212_MONMODE_Off:
792 if (korg1212->cardState != K1212_STATE_MONITOR)
793 return 0;
794 else {
795 snd_korg1212_SendStopAndWait(korg1212);
796 snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
797 }
798 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799
Takashi Iwai9fd91562005-11-17 10:45:48 +0100800 case K1212_MONMODE_On:
801 if (korg1212->cardState != K1212_STATE_OPEN)
802 return 0;
803 else {
804 int rc;
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)
809 return 0;
810 }
811 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812
Takashi Iwai9fd91562005-11-17 10:45:48 +0100813 default:
814 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 }
816
817 return 1;
818}
819
820#endif /* not used */
821
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100822static inline int snd_korg1212_use_is_exclusive(struct snd_korg1212 *korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823{
Takashi Iwai9fd91562005-11-17 10:45:48 +0100824 if (korg1212->playback_pid != korg1212->capture_pid &&
825 korg1212->playback_pid >= 0 && korg1212->capture_pid >= 0)
826 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
Takashi Iwai9fd91562005-11-17 10:45:48 +0100828 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829}
830
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100831static int snd_korg1212_SetRate(struct snd_korg1212 *korg1212, int rate)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832{
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100833 static enum ClockSourceIndex s44[] = {
Takashi Iwai9fd91562005-11-17 10:45:48 +0100834 K1212_CLKIDX_AdatAt44_1K,
835 K1212_CLKIDX_WordAt44_1K,
836 K1212_CLKIDX_LocalAt44_1K
837 };
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100838 static enum ClockSourceIndex s48[] = {
Takashi Iwai9fd91562005-11-17 10:45:48 +0100839 K1212_CLKIDX_AdatAt48K,
840 K1212_CLKIDX_WordAt48K,
841 K1212_CLKIDX_LocalAt48K
842 };
843 int parm, rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844
Takashi Iwai9fd91562005-11-17 10:45:48 +0100845 if (!snd_korg1212_use_is_exclusive (korg1212))
846 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100848 switch (rate) {
Takashi Iwai9fd91562005-11-17 10:45:48 +0100849 case 44100:
850 parm = s44[korg1212->clkSource];
851 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
Takashi Iwai9fd91562005-11-17 10:45:48 +0100853 case 48000:
854 parm = s48[korg1212->clkSource];
855 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856
Takashi Iwai9fd91562005-11-17 10:45:48 +0100857 default:
858 return -EINVAL;
859 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860
861 korg1212->clkSrcRate = parm;
862 korg1212->clkRate = rate;
863
864 udelay(INTERCOMMAND_DELAY);
865 rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SetClockSourceRate,
866 ClockSourceSelector[korg1212->clkSrcRate],
867 0, 0, 0);
Takashi Iwai9fd91562005-11-17 10:45:48 +0100868 if (rc)
869 K1212_DEBUG_PRINTK("K1212_DEBUG: Set Clock Source Selector - RC = %d [%s]\n",
870 rc, stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
872 return 0;
873}
874
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100875static int snd_korg1212_SetClockSource(struct snd_korg1212 *korg1212, int source)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876{
877
Takashi Iwai9fd91562005-11-17 10:45:48 +0100878 if (source < 0 || source > 2)
879 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880
881 korg1212->clkSource = source;
882
883 snd_korg1212_SetRate(korg1212, korg1212->clkRate);
884
885 return 0;
886}
887
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100888static void snd_korg1212_DisableCardInterrupts(struct snd_korg1212 *korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889{
890 writel(0, korg1212->statusRegPtr);
891}
892
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100893static int snd_korg1212_WriteADCSensitivity(struct snd_korg1212 *korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894{
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100895 struct SensBits sensVals;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 int bitPosition;
897 int channel;
898 int clkIs48K;
899 int monModeSet;
900 u16 controlValue; // this keeps the current value to be written to
901 // the card's eeprom control register.
902 u16 count;
903 unsigned long flags;
904
Takashi Iwai9fd91562005-11-17 10:45:48 +0100905 K1212_DEBUG_PRINTK("K1212_DEBUG: WriteADCSensivity [%s]\n",
906 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907
908 // ----------------------------------------------------------------------------
909 // initialize things. The local init bit is always set when writing to the
910 // card's control register.
911 // ----------------------------------------------------------------------------
912 controlValue = 0;
913 SetBitInWord(&controlValue, SET_SENS_LOCALINIT_BITPOS); // init the control value
914
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) {
919 monModeSet = 1;
920 snd_korg1212_SendStopAndWait(korg1212);
921 } else
922 monModeSet = 0;
923
924 spin_lock_irqsave(&korg1212->lock, flags);
925
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);
932
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:
941 clkIs48K = 0;
942 break;
943
944 case K1212_CLKIDX_WordAt48K:
945 case K1212_CLKIDX_AdatAt48K:
946 case K1212_CLKIDX_LocalAt48K:
947 default:
948 clkIs48K = 1;
949 break;
950 }
951
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;
959
960 // ----------------------------------------------------------------------------
961 // now start shifting the bits in. Start with the left channel then the right.
962 // ----------------------------------------------------------------------------
963 for (channel = 0; channel < 2; channel++) {
964
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);
973
974 for (bitPosition = 15; bitPosition >= 0; bitPosition--) { // for all the bits
Takashi Iwai9fd91562005-11-17 10:45:48 +0100975 if (channel == 0) {
976 if (sensVals.l.leftSensBits & (0x0001 << bitPosition))
Takashi Iwaifcfd3332005-11-17 15:00:46 +0100977 SetBitInWord(&controlValue, SET_SENS_DATA_BITPOS); // data bit set high
Takashi Iwai9fd91562005-11-17 10:45:48 +0100978 else
979 ClearBitInWord(&controlValue, SET_SENS_DATA_BITPOS); // data bit set low
980 } else {
981 if (sensVals.r.rightSensBits & (0x0001 << bitPosition))
982 SetBitInWord(&controlValue, SET_SENS_DATA_BITPOS); // data bit set high
983 else
984 ClearBitInWord(&controlValue, SET_SENS_DATA_BITPOS); // data bit set low
985 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986
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);
993 }
994
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);
1004
1005 if (clkIs48K)
1006 SetBitInWord(&controlValue, SET_SENS_DATA_BITPOS);
1007
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);
1016 }
1017
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);
1024
1025 if (monModeSet) {
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001026 int rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 K1212_MODE_MonitorOn, 0, 0, 0);
Takashi Iwai9fd91562005-11-17 10:45:48 +01001028 if (rc)
1029 K1212_DEBUG_PRINTK("K1212_DEBUG: WriteADCSensivity - RC = %d [%s]\n",
1030 rc, stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 }
1032
1033 spin_unlock_irqrestore(&korg1212->lock, flags);
1034
1035 return 1;
1036}
1037
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001038static void snd_korg1212_OnDSPDownloadComplete(struct snd_korg1212 *korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001040 int channel, rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041
Takashi Iwai9fd91562005-11-17 10:45:48 +01001042 K1212_DEBUG_PRINTK("K1212_DEBUG: DSP download is complete. [%s]\n",
1043 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044
1045 // ----------------------------------------------------
1046 // tell the card to boot
1047 // ----------------------------------------------------
1048 rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_BootFromDSPPage4, 0, 0, 0, 0);
1049
Takashi Iwai9fd91562005-11-17 10:45:48 +01001050 if (rc)
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);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054
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
1064 0
1065 );
1066
Takashi Iwai9fd91562005-11-17 10:45:48 +01001067 if (rc)
1068 K1212_DEBUG_PRINTK("K1212_DEBUG: Configure Buffer Memory - RC = %d [%s]\n",
1069 rc, stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070
1071 udelay(INTERCOMMAND_DELAY);
1072
1073 rc = snd_korg1212_Send1212Command(korg1212,
1074 K1212_DB_ConfigureMiscMemory,
1075 LowerWordSwap(korg1212->VolumeTablePhy),
1076 LowerWordSwap(korg1212->RoutingTablePhy),
1077 LowerWordSwap(korg1212->AdatTimeCodePhy),
1078 0
1079 );
1080
Takashi Iwai9fd91562005-11-17 10:45:48 +01001081 if (rc)
1082 K1212_DEBUG_PRINTK("K1212_DEBUG: Configure Misc Memory - RC = %d [%s]\n",
1083 rc, stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084
1085 // --------------------------------------------------------------------------------
1086 // Initialize the routing and volume tables, then update the card's state.
1087 // --------------------------------------------------------------------------------
1088 udelay(INTERCOMMAND_DELAY);
1089
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);
1094 }
1095
1096 snd_korg1212_WriteADCSensitivity(korg1212);
1097
1098 udelay(INTERCOMMAND_DELAY);
1099 rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SetClockSourceRate,
1100 ClockSourceSelector[korg1212->clkSrcRate],
1101 0, 0, 0);
Takashi Iwai9fd91562005-11-17 10:45:48 +01001102 if (rc)
1103 K1212_DEBUG_PRINTK("K1212_DEBUG: Set Clock Source Selector - RC = %d [%s]\n",
1104 rc, stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105
Takashi Iwai9fd91562005-11-17 10:45:48 +01001106 rc = snd_korg1212_TurnOnIdleMonitor(korg1212);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 snd_korg1212_setCardState(korg1212, K1212_STATE_READY);
1108
Takashi Iwai9fd91562005-11-17 10:45:48 +01001109 if (rc)
1110 K1212_DEBUG_PRINTK("K1212_DEBUG: Set Monitor On - RC = %d [%s]\n",
1111 rc, stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112
1113 snd_korg1212_setCardState(korg1212, K1212_STATE_DSP_COMPLETE);
1114}
1115
David Howells7d12e782006-10-05 14:55:46 +01001116static irqreturn_t snd_korg1212_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117{
1118 u32 doorbellValue;
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001119 struct snd_korg1212 *korg1212 = dev_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 doorbellValue = readl(korg1212->inDoorbellPtr);
1122
1123 if (!doorbellValue)
1124 return IRQ_NONE;
1125
1126 spin_lock(&korg1212->lock);
1127
1128 writel(doorbellValue, korg1212->inDoorbellPtr);
1129
1130 korg1212->irqcount++;
1131
1132 korg1212->inIRQ++;
1133
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 switch (doorbellValue) {
1135 case K1212_DB_DSPDownloadDone:
Takashi Iwai9fd91562005-11-17 10:45:48 +01001136 K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ DNLD count - %ld, %x, [%s].\n",
1137 korg1212->irqcount, doorbellValue,
1138 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 if (korg1212->cardState == K1212_STATE_DSP_IN_PROCESS) {
1140 korg1212->dsp_is_loaded = 1;
1141 wake_up(&korg1212->wait);
1142 }
1143 break;
1144
1145 // ------------------------------------------------------------------------
1146 // an error occurred - stop the card
1147 // ------------------------------------------------------------------------
1148 case K1212_DB_DMAERROR:
Takashi Iwai9fd91562005-11-17 10:45:48 +01001149 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");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 korg1212->errorcnt++;
1154 korg1212->totalerrorcnt++;
1155 korg1212->sharedBufferPtr->cardCommand = 0;
1156 snd_korg1212_setCardState(korg1212, K1212_STATE_ERRORSTOP);
1157 break;
1158
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:
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001164 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: IRQ CSTP count - %ld, %x, [%s].\n",
Takashi Iwai9fd91562005-11-17 10:45:48 +01001165 korg1212->irqcount, doorbellValue,
1166 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 korg1212->sharedBufferPtr->cardCommand = 0;
1168 break;
1169
1170 default:
Takashi Iwai9fd91562005-11-17 10:45:48 +01001171 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: IRQ DFLT count - %ld, %x, cpos=%d [%s].\n",
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001172 korg1212->irqcount, doorbellValue,
1173 korg1212->currentBuffer, stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 if ((korg1212->cardState > K1212_STATE_SETUP) || korg1212->idleMonitorOn) {
1175 korg1212->currentBuffer++;
1176
1177 if (korg1212->currentBuffer >= kNumBuffers)
1178 korg1212->currentBuffer = 0;
1179
1180 if (!korg1212->running)
1181 break;
1182
1183 if (korg1212->capture_substream) {
1184 spin_unlock(&korg1212->lock);
1185 snd_pcm_period_elapsed(korg1212->capture_substream);
1186 spin_lock(&korg1212->lock);
1187 }
1188
1189 if (korg1212->playback_substream) {
1190 spin_unlock(&korg1212->lock);
1191 snd_pcm_period_elapsed(korg1212->playback_substream);
1192 spin_lock(&korg1212->lock);
1193 }
1194 }
1195 break;
1196 }
1197
1198 korg1212->inIRQ--;
1199
1200 spin_unlock(&korg1212->lock);
1201
1202 return IRQ_HANDLED;
1203}
1204
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001205static int snd_korg1212_downloadDSPCode(struct snd_korg1212 *korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001207 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208
Takashi Iwai9fd91562005-11-17 10:45:48 +01001209 K1212_DEBUG_PRINTK("K1212_DEBUG: DSP download is starting... [%s]\n",
1210 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211
1212 // ---------------------------------------------------------------
1213 // verify the state of the card before proceeding.
1214 // ---------------------------------------------------------------
Takashi Iwai9fd91562005-11-17 10:45:48 +01001215 if (korg1212->cardState >= K1212_STATE_DSP_IN_PROCESS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217
1218 snd_korg1212_setCardState(korg1212, K1212_STATE_DSP_IN_PROCESS);
1219
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_StartDSPDownload,
1221 UpperWordSwap(korg1212->dma_dsp.addr),
1222 0, 0, 0);
Takashi Iwai9fd91562005-11-17 10:45:48 +01001223 if (rc)
1224 K1212_DEBUG_PRINTK("K1212_DEBUG: Start DSP Download RC = %d [%s]\n",
1225 rc, stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226
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 */
1231
1232 snd_korg1212_OnDSPDownloadComplete(korg1212);
1233
1234 return 0;
1235}
1236
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001237static struct snd_pcm_hardware snd_korg1212_playback_info =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238{
1239 .info = (SNDRV_PCM_INFO_MMAP |
1240 SNDRV_PCM_INFO_MMAP_VALID |
Takashi Iwai2008f132009-04-28 12:25:59 +02001241 SNDRV_PCM_INFO_INTERLEAVED |
1242 SNDRV_PCM_INFO_BATCH),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1244 .rates = (SNDRV_PCM_RATE_44100 |
1245 SNDRV_PCM_RATE_48000),
1246 .rate_min = 44100,
1247 .rate_max = 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,
1255 .fifo_size = 0,
1256};
1257
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001258static struct snd_pcm_hardware snd_korg1212_capture_info =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259{
1260 .info = (SNDRV_PCM_INFO_MMAP |
1261 SNDRV_PCM_INFO_MMAP_VALID |
Takashi Iwai2008f132009-04-28 12:25:59 +02001262 SNDRV_PCM_INFO_INTERLEAVED |
1263 SNDRV_PCM_INFO_BATCH),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1265 .rates = (SNDRV_PCM_RATE_44100 |
1266 SNDRV_PCM_RATE_48000),
1267 .rate_min = 44100,
1268 .rate_max = 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,
1276 .fifo_size = 0,
1277};
1278
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001279static int snd_korg1212_silence(struct snd_korg1212 *korg1212, int pos, int count, int offset, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001281 struct KorgAudioFrame * dst = korg1212->playDataBufsPtr[0].bufferData + pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 int i;
1283
Takashi Iwai9fd91562005-11-17 10:45:48 +01001284 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_silence pos=%d offset=%d size=%d count=%d\n",
1285 pos, offset, size, count);
Takashi Iwaida3cec32008-08-08 17:12:14 +02001286 if (snd_BUG_ON(pos + count > K1212_MAX_SAMPLES))
1287 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288
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 ) {
Takashi Iwai9fd91562005-11-17 10:45:48 +01001293 printk(KERN_DEBUG "K1212_DEBUG: snd_korg1212_silence KERNEL EFAULT dst=%p iter=%d\n",
1294 dst, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 return -EFAULT;
1296 }
1297#endif
1298 memset((void*) dst + offset, 0, size);
1299 dst++;
1300 }
1301
1302 return 0;
1303}
1304
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001305static int snd_korg1212_copy_to(struct snd_korg1212 *korg1212, void __user *dst, int pos, int count, int offset, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001307 struct KorgAudioFrame * src = korg1212->recordDataBufsPtr[0].bufferData + pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 int i, rc;
1309
Takashi Iwai9fd91562005-11-17 10:45:48 +01001310 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_copy_to pos=%d offset=%d size=%d\n",
1311 pos, offset, size);
Takashi Iwaida3cec32008-08-08 17:12:14 +02001312 if (snd_BUG_ON(pos + count > K1212_MAX_SAMPLES))
1313 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314
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 ) {
Takashi Iwai9fd91562005-11-17 10:45:48 +01001319 printk(KERN_DEBUG "K1212_DEBUG: snd_korg1212_copy_to KERNEL EFAULT, src=%p dst=%p iter=%d\n", src, dst, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 return -EFAULT;
1321 }
1322#endif
1323 rc = copy_to_user(dst + offset, src, size);
1324 if (rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_to USER EFAULT src=%p dst=%p iter=%d\n", src, dst, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 return -EFAULT;
1327 }
1328 src++;
1329 dst += size;
1330 }
1331
1332 return 0;
1333}
1334
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001335static int snd_korg1212_copy_from(struct snd_korg1212 *korg1212, void __user *src, int pos, int count, int offset, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001337 struct KorgAudioFrame * dst = korg1212->playDataBufsPtr[0].bufferData + pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 int i, rc;
1339
Takashi Iwai9fd91562005-11-17 10:45:48 +01001340 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_copy_from pos=%d offset=%d size=%d count=%d\n",
1341 pos, offset, size, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342
Takashi Iwaida3cec32008-08-08 17:12:14 +02001343 if (snd_BUG_ON(pos + count > K1212_MAX_SAMPLES))
1344 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345
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 ) {
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001350 printk(KERN_DEBUG "K1212_DEBUG: snd_korg1212_copy_from KERNEL EFAULT, src=%p dst=%p iter=%d\n", src, dst, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 return -EFAULT;
1352 }
1353#endif
1354 rc = copy_from_user((void*) dst + offset, src, size);
1355 if (rc) {
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001356 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_from USER EFAULT src=%p dst=%p iter=%d\n", src, dst, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 return -EFAULT;
1358 }
1359 dst++;
1360 src += size;
1361 }
1362
1363 return 0;
1364}
1365
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001366static void snd_korg1212_free_pcm(struct snd_pcm *pcm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001368 struct snd_korg1212 *korg1212 = pcm->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369
Takashi Iwai9fd91562005-11-17 10:45:48 +01001370 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_free_pcm [%s]\n",
1371 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372
1373 korg1212->pcm = NULL;
1374}
1375
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001376static int snd_korg1212_playback_open(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377{
1378 unsigned long flags;
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001379 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);
1380 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381
Takashi Iwai9fd91562005-11-17 10:45:48 +01001382 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_open [%s]\n",
1383 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 snd_korg1212_OpenCard(korg1212);
1386
1387 runtime->hw = snd_korg1212_playback_info;
1388 snd_pcm_set_runtime_buffer(substream, &korg1212->dma_play);
1389
1390 spin_lock_irqsave(&korg1212->lock, flags);
1391
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;
1397
1398 spin_unlock_irqrestore(&korg1212->lock, flags);
1399
1400 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, kPlayBufferFrames, kPlayBufferFrames);
1401 return 0;
1402}
1403
1404
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001405static int snd_korg1212_capture_open(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406{
1407 unsigned long flags;
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001408 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);
1409 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410
Takashi Iwai9fd91562005-11-17 10:45:48 +01001411 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_open [%s]\n",
1412 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 snd_korg1212_OpenCard(korg1212);
1415
1416 runtime->hw = snd_korg1212_capture_info;
1417 snd_pcm_set_runtime_buffer(substream, &korg1212->dma_rec);
1418
1419 spin_lock_irqsave(&korg1212->lock, flags);
1420
1421 korg1212->capture_substream = substream;
1422 korg1212->capture_pid = current->pid;
1423 korg1212->periodsize = K1212_PERIODS;
1424 korg1212->channels = K1212_CHANNELS;
1425
1426 spin_unlock_irqrestore(&korg1212->lock, flags);
1427
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001428 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1429 kPlayBufferFrames, kPlayBufferFrames);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 return 0;
1431}
1432
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001433static int snd_korg1212_playback_close(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434{
1435 unsigned long flags;
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001436 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437
Takashi Iwai9fd91562005-11-17 10:45:48 +01001438 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_close [%s]\n",
1439 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440
1441 snd_korg1212_silence(korg1212, 0, K1212_MAX_SAMPLES, 0, korg1212->channels * 2);
1442
1443 spin_lock_irqsave(&korg1212->lock, flags);
1444
1445 korg1212->playback_pid = -1;
1446 korg1212->playback_substream = NULL;
1447 korg1212->periodsize = 0;
1448
1449 spin_unlock_irqrestore(&korg1212->lock, flags);
1450
1451 snd_korg1212_CloseCard(korg1212);
1452 return 0;
1453}
1454
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001455static int snd_korg1212_capture_close(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456{
1457 unsigned long flags;
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001458 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459
Takashi Iwai9fd91562005-11-17 10:45:48 +01001460 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_close [%s]\n",
1461 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462
1463 spin_lock_irqsave(&korg1212->lock, flags);
1464
1465 korg1212->capture_pid = -1;
1466 korg1212->capture_substream = NULL;
1467 korg1212->periodsize = 0;
1468
1469 spin_unlock_irqrestore(&korg1212->lock, flags);
1470
1471 snd_korg1212_CloseCard(korg1212);
1472 return 0;
1473}
1474
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001475static int snd_korg1212_ioctl(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 unsigned int cmd, void *arg)
1477{
Takashi Iwai9fd91562005-11-17 10:45:48 +01001478 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_ioctl: cmd=%d\n", cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479
1480 if (cmd == SNDRV_PCM_IOCTL1_CHANNEL_INFO ) {
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001481 struct snd_pcm_channel_info *info = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 info->offset = 0;
1483 info->first = info->channel * 16;
1484 info->step = 256;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 K1212_DEBUG_PRINTK("K1212_DEBUG: channel_info %d:, offset=%ld, first=%d, step=%d\n", info->channel, info->offset, info->first, info->step);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 return 0;
1487 }
1488
1489 return snd_pcm_lib_ioctl(substream, cmd, arg);
1490}
1491
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001492static int snd_korg1212_hw_params(struct snd_pcm_substream *substream,
1493 struct snd_pcm_hw_params *params)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494{
1495 unsigned long flags;
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001496 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 int err;
1498 pid_t this_pid;
1499 pid_t other_pid;
1500
Takashi Iwai9fd91562005-11-17 10:45:48 +01001501 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_hw_params [%s]\n",
1502 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503
1504 spin_lock_irqsave(&korg1212->lock, flags);
1505
1506 if (substream->pstr->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1507 this_pid = korg1212->playback_pid;
1508 other_pid = korg1212->capture_pid;
1509 } else {
1510 this_pid = korg1212->capture_pid;
1511 other_pid = korg1212->playback_pid;
1512 }
1513
1514 if ((other_pid > 0) && (this_pid != other_pid)) {
1515
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.
1519 */
1520
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);
1524 return -EBUSY;
1525 }
1526
1527 spin_unlock_irqrestore(&korg1212->lock, flags);
1528 return 0;
1529 }
1530
1531 if ((err = snd_korg1212_SetRate(korg1212, params_rate(params))) < 0) {
1532 spin_unlock_irqrestore(&korg1212->lock, flags);
1533 return err;
1534 }
1535
1536 korg1212->channels = params_channels(params);
1537 korg1212->periodsize = K1212_PERIOD_BYTES;
1538
1539 spin_unlock_irqrestore(&korg1212->lock, flags);
1540
1541 return 0;
1542}
1543
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001544static int snd_korg1212_prepare(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001546 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 int rc;
1548
Takashi Iwai9fd91562005-11-17 10:45:48 +01001549 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_prepare [%s]\n",
1550 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551
1552 spin_lock_irq(&korg1212->lock);
1553
1554 /* FIXME: we should wait for ack! */
1555 if (korg1212->stop_pending_cnt > 0) {
Takashi Iwai9fd91562005-11-17 10:45:48 +01001556 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_prepare - Stop is pending... [%s]\n",
1557 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 spin_unlock_irq(&korg1212->lock);
1559 return -EAGAIN;
1560 /*
1561 korg1212->sharedBufferPtr->cardCommand = 0;
1562 del_timer(&korg1212->timer);
1563 korg1212->stop_pending_cnt = 0;
1564 */
1565 }
1566
1567 rc = snd_korg1212_SetupForPlay(korg1212);
1568
1569 korg1212->currentBuffer = 0;
1570
1571 spin_unlock_irq(&korg1212->lock);
1572
1573 return rc ? -EINVAL : 0;
1574}
1575
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001576static int snd_korg1212_trigger(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 int cmd)
1578{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001579 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 int rc;
1581
Takashi Iwai9fd91562005-11-17 10:45:48 +01001582 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_trigger [%s] cmd=%d\n",
1583 stateName[korg1212->cardState], cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584
1585 spin_lock(&korg1212->lock);
1586 switch (cmd) {
1587 case SNDRV_PCM_TRIGGER_START:
1588/*
1589 if (korg1212->running) {
Takashi Iwai9fd91562005-11-17 10:45:48 +01001590 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_trigger: Already running?\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 break;
1592 }
1593*/
1594 korg1212->running++;
1595 rc = snd_korg1212_TriggerPlay(korg1212);
1596 break;
1597
1598 case SNDRV_PCM_TRIGGER_STOP:
1599/*
1600 if (!korg1212->running) {
Takashi Iwai9fd91562005-11-17 10:45:48 +01001601 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_trigger: Already stopped?\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 break;
1603 }
1604*/
1605 korg1212->running--;
1606 rc = snd_korg1212_StopPlay(korg1212);
1607 break;
1608
1609 default:
1610 rc = 1;
1611 break;
1612 }
1613 spin_unlock(&korg1212->lock);
1614 return rc ? -EINVAL : 0;
1615}
1616
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001617static snd_pcm_uframes_t snd_korg1212_playback_pointer(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001619 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 snd_pcm_uframes_t pos;
1621
1622 pos = korg1212->currentBuffer * kPlayBufferFrames;
1623
Takashi Iwai9fd91562005-11-17 10:45:48 +01001624 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_playback_pointer [%s] %ld\n",
1625 stateName[korg1212->cardState], pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626
1627 return pos;
1628}
1629
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001630static snd_pcm_uframes_t snd_korg1212_capture_pointer(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001632 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 snd_pcm_uframes_t pos;
1634
1635 pos = korg1212->currentBuffer * kPlayBufferFrames;
1636
Takashi Iwai9fd91562005-11-17 10:45:48 +01001637 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_capture_pointer [%s] %ld\n",
1638 stateName[korg1212->cardState], pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639
1640 return pos;
1641}
1642
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001643static int snd_korg1212_playback_copy(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 int channel, /* not used (interleaved data) */
1645 snd_pcm_uframes_t pos,
1646 void __user *src,
1647 snd_pcm_uframes_t count)
1648{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001649 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650
Takashi Iwai9fd91562005-11-17 10:45:48 +01001651 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_playback_copy [%s] %ld %ld\n",
1652 stateName[korg1212->cardState], pos, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
1654 return snd_korg1212_copy_from(korg1212, src, pos, count, 0, korg1212->channels * 2);
1655
1656}
1657
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001658static int snd_korg1212_playback_silence(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 int channel, /* not used (interleaved data) */
1660 snd_pcm_uframes_t pos,
1661 snd_pcm_uframes_t count)
1662{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001663 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664
Takashi Iwai9fd91562005-11-17 10:45:48 +01001665 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_playback_silence [%s]\n",
1666 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667
1668 return snd_korg1212_silence(korg1212, pos, count, 0, korg1212->channels * 2);
1669}
1670
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001671static int snd_korg1212_capture_copy(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 int channel, /* not used (interleaved data) */
1673 snd_pcm_uframes_t pos,
1674 void __user *dst,
1675 snd_pcm_uframes_t count)
1676{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001677 struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678
Takashi Iwai9fd91562005-11-17 10:45:48 +01001679 K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_capture_copy [%s] %ld %ld\n",
1680 stateName[korg1212->cardState], pos, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681
1682 return snd_korg1212_copy_to(korg1212, dst, pos, count, 0, korg1212->channels * 2);
1683}
1684
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001685static struct snd_pcm_ops snd_korg1212_playback_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 .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,
1695};
1696
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001697static struct snd_pcm_ops snd_korg1212_capture_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 .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,
1706};
1707
1708/*
1709 * Control Interface
1710 */
1711
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001712static int snd_korg1212_control_phase_info(struct snd_kcontrol *kcontrol,
1713 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714{
1715 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1716 uinfo->count = (kcontrol->private_value >= 8) ? 2 : 1;
1717 return 0;
1718}
1719
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001720static int snd_korg1212_control_phase_get(struct snd_kcontrol *kcontrol,
1721 struct snd_ctl_elem_value *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001723 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 int i = kcontrol->private_value;
1725
1726 spin_lock_irq(&korg1212->lock);
1727
1728 u->value.integer.value[0] = korg1212->volumePhase[i];
1729
1730 if (i >= 8)
1731 u->value.integer.value[1] = korg1212->volumePhase[i+1];
1732
1733 spin_unlock_irq(&korg1212->lock);
1734
1735 return 0;
1736}
1737
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001738static int snd_korg1212_control_phase_put(struct snd_kcontrol *kcontrol,
1739 struct snd_ctl_elem_value *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001741 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 int change = 0;
1743 int i, val;
1744
1745 spin_lock_irq(&korg1212->lock);
1746
1747 i = kcontrol->private_value;
1748
Takashi Iwai4e98d6a2007-11-15 15:58:13 +01001749 korg1212->volumePhase[i] = !!u->value.integer.value[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750
1751 val = korg1212->sharedBufferPtr->volumeData[kcontrol->private_value];
1752
Takashi Iwai4e98d6a2007-11-15 15:58:13 +01001753 if ((u->value.integer.value[0] != 0) != (val < 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 val = abs(val) * (korg1212->volumePhase[i] > 0 ? -1 : 1);
1755 korg1212->sharedBufferPtr->volumeData[i] = val;
1756 change = 1;
1757 }
1758
1759 if (i >= 8) {
Takashi Iwai4e98d6a2007-11-15 15:58:13 +01001760 korg1212->volumePhase[i+1] = !!u->value.integer.value[1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761
1762 val = korg1212->sharedBufferPtr->volumeData[kcontrol->private_value+1];
1763
Takashi Iwai4e98d6a2007-11-15 15:58:13 +01001764 if ((u->value.integer.value[1] != 0) != (val < 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 val = abs(val) * (korg1212->volumePhase[i+1] > 0 ? -1 : 1);
1766 korg1212->sharedBufferPtr->volumeData[i+1] = val;
1767 change = 1;
1768 }
1769 }
1770
1771 spin_unlock_irq(&korg1212->lock);
1772
1773 return change;
1774}
1775
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001776static int snd_korg1212_control_volume_info(struct snd_kcontrol *kcontrol,
1777 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778{
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;
1783 return 0;
1784}
1785
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001786static int snd_korg1212_control_volume_get(struct snd_kcontrol *kcontrol,
1787 struct snd_ctl_elem_value *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001789 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 int i;
1791
1792 spin_lock_irq(&korg1212->lock);
1793
1794 i = kcontrol->private_value;
1795 u->value.integer.value[0] = abs(korg1212->sharedBufferPtr->volumeData[i]);
1796
1797 if (i >= 8)
1798 u->value.integer.value[1] = abs(korg1212->sharedBufferPtr->volumeData[i+1]);
1799
1800 spin_unlock_irq(&korg1212->lock);
1801
1802 return 0;
1803}
1804
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001805static int snd_korg1212_control_volume_put(struct snd_kcontrol *kcontrol,
1806 struct snd_ctl_elem_value *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001808 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809 int change = 0;
1810 int i;
1811 int val;
1812
1813 spin_lock_irq(&korg1212->lock);
1814
1815 i = kcontrol->private_value;
1816
Takashi Iwai4e98d6a2007-11-15 15:58:13 +01001817 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])) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 val = korg1212->volumePhase[i] > 0 ? -1 : 1;
1822 val *= u->value.integer.value[0];
1823 korg1212->sharedBufferPtr->volumeData[i] = val;
1824 change = 1;
1825 }
1826
1827 if (i >= 8) {
Takashi Iwai4e98d6a2007-11-15 15:58:13 +01001828 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])) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 val = korg1212->volumePhase[i+1] > 0 ? -1 : 1;
1833 val *= u->value.integer.value[1];
1834 korg1212->sharedBufferPtr->volumeData[i+1] = val;
1835 change = 1;
1836 }
1837 }
1838
1839 spin_unlock_irq(&korg1212->lock);
1840
1841 return change;
1842}
1843
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001844static int snd_korg1212_control_route_info(struct snd_kcontrol *kcontrol,
1845 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846{
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;
1852 }
1853 strcpy(uinfo->value.enumerated.name, channelName[uinfo->value.enumerated.item]);
1854 return 0;
1855}
1856
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001857static int snd_korg1212_control_route_get(struct snd_kcontrol *kcontrol,
1858 struct snd_ctl_elem_value *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001860 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 int i;
1862
1863 spin_lock_irq(&korg1212->lock);
1864
1865 i = kcontrol->private_value;
1866 u->value.enumerated.item[0] = korg1212->sharedBufferPtr->routeData[i];
1867
1868 if (i >= 8)
1869 u->value.enumerated.item[1] = korg1212->sharedBufferPtr->routeData[i+1];
1870
1871 spin_unlock_irq(&korg1212->lock);
1872
1873 return 0;
1874}
1875
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001876static int snd_korg1212_control_route_put(struct snd_kcontrol *kcontrol,
1877 struct snd_ctl_elem_value *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001879 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 int change = 0, i;
1881
1882 spin_lock_irq(&korg1212->lock);
1883
1884 i = kcontrol->private_value;
1885
Takashi Iwai4e98d6a2007-11-15 15:58:13 +01001886 if (u->value.enumerated.item[0] < kAudioChannels &&
1887 u->value.enumerated.item[0] !=
1888 (unsigned) korg1212->sharedBufferPtr->volumeData[i]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 korg1212->sharedBufferPtr->routeData[i] = u->value.enumerated.item[0];
1890 change = 1;
1891 }
1892
1893 if (i >= 8) {
Takashi Iwai4e98d6a2007-11-15 15:58:13 +01001894 if (u->value.enumerated.item[1] < kAudioChannels &&
1895 u->value.enumerated.item[1] !=
1896 (unsigned) korg1212->sharedBufferPtr->volumeData[i+1]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 korg1212->sharedBufferPtr->routeData[i+1] = u->value.enumerated.item[1];
1898 change = 1;
1899 }
1900 }
1901
1902 spin_unlock_irq(&korg1212->lock);
1903
1904 return change;
1905}
1906
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001907static int snd_korg1212_control_info(struct snd_kcontrol *kcontrol,
1908 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909{
1910 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1911 uinfo->count = 2;
1912 uinfo->value.integer.min = k1212MaxADCSens;
1913 uinfo->value.integer.max = k1212MinADCSens;
1914 return 0;
1915}
1916
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001917static int snd_korg1212_control_get(struct snd_kcontrol *kcontrol,
1918 struct snd_ctl_elem_value *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001920 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921
1922 spin_lock_irq(&korg1212->lock);
1923
1924 u->value.integer.value[0] = korg1212->leftADCInSens;
1925 u->value.integer.value[1] = korg1212->rightADCInSens;
1926
1927 spin_unlock_irq(&korg1212->lock);
1928
1929 return 0;
1930}
1931
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001932static int snd_korg1212_control_put(struct snd_kcontrol *kcontrol,
1933 struct snd_ctl_elem_value *u)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001935 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 int change = 0;
1937
1938 spin_lock_irq(&korg1212->lock);
1939
Takashi Iwai4e98d6a2007-11-15 15:58:13 +01001940 if (u->value.integer.value[0] >= k1212MinADCSens &&
1941 u->value.integer.value[0] <= k1212MaxADCSens &&
1942 u->value.integer.value[0] != korg1212->leftADCInSens) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 korg1212->leftADCInSens = u->value.integer.value[0];
1944 change = 1;
1945 }
Takashi Iwai4e98d6a2007-11-15 15:58:13 +01001946 if (u->value.integer.value[1] >= k1212MinADCSens &&
1947 u->value.integer.value[1] <= k1212MaxADCSens &&
1948 u->value.integer.value[1] != korg1212->rightADCInSens) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 korg1212->rightADCInSens = u->value.integer.value[1];
1950 change = 1;
1951 }
1952
1953 spin_unlock_irq(&korg1212->lock);
1954
1955 if (change)
1956 snd_korg1212_WriteADCSensitivity(korg1212);
1957
1958 return change;
1959}
1960
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001961static int snd_korg1212_control_sync_info(struct snd_kcontrol *kcontrol,
1962 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963{
1964 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1965 uinfo->count = 1;
1966 uinfo->value.enumerated.items = 3;
1967 if (uinfo->value.enumerated.item > 2) {
1968 uinfo->value.enumerated.item = 2;
1969 }
1970 strcpy(uinfo->value.enumerated.name, clockSourceTypeName[uinfo->value.enumerated.item]);
1971 return 0;
1972}
1973
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001974static int snd_korg1212_control_sync_get(struct snd_kcontrol *kcontrol,
1975 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001977 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978
1979 spin_lock_irq(&korg1212->lock);
1980
1981 ucontrol->value.enumerated.item[0] = korg1212->clkSource;
1982
1983 spin_unlock_irq(&korg1212->lock);
1984 return 0;
1985}
1986
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001987static int snd_korg1212_control_sync_put(struct snd_kcontrol *kcontrol,
1988 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01001990 struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 unsigned int val;
1992 int change;
1993
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);
1999 return change;
2000}
2001
2002#define MON_MIXER(ord,c_name) \
2003 { \
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, \
2011 }, \
2012 { \
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, \
2020 }, \
2021 { \
2022 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_WRITE, \
Clemens Ladisch67ed4162005-07-29 15:32:58 +02002023 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 .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, \
2029 }
2030
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002031static struct snd_kcontrol_new snd_korg1212_controls[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032 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"),
2036 {
2037 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_WRITE,
Clemens Ladisch67ed4162005-07-29 15:32:58 +02002038 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 .name = "Sync Source",
2040 .info = snd_korg1212_control_sync_info,
2041 .get = snd_korg1212_control_sync_get,
2042 .put = snd_korg1212_control_sync_put,
2043 },
2044 {
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,
2051 }
2052};
2053
2054/*
2055 * proc interface
2056 */
2057
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002058static void snd_korg1212_proc_read(struct snd_info_entry *entry,
2059 struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060{
2061 int n;
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002062 struct snd_korg1212 *korg1212 = entry->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063
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,
2074 channelName[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);
2084}
2085
Bill Pembertone23e7a12012-12-06 12:35:10 -05002086static void snd_korg1212_proc_init(struct snd_korg1212 *korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002088 struct snd_info_entry *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089
2090 if (! snd_card_proc_new(korg1212->card, "korg1212", &entry))
Takashi Iwaibf850202006-04-28 15:13:41 +02002091 snd_info_set_text_ops(entry, korg1212, snd_korg1212_proc_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092}
2093
2094static int
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002095snd_korg1212_free(struct snd_korg1212 *korg1212)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096{
2097 snd_korg1212_TurnOffIdleMonitor(korg1212);
2098
2099 if (korg1212->irq >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100 snd_korg1212_DisableCardInterrupts(korg1212);
Takashi Iwai9fd91562005-11-17 10:45:48 +01002101 free_irq(korg1212->irq, korg1212);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102 korg1212->irq = -1;
2103 }
2104
2105 if (korg1212->iobase != NULL) {
2106 iounmap(korg1212->iobase);
2107 korg1212->iobase = NULL;
2108 }
2109
2110 pci_release_regions(korg1212->pci);
2111
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;
2118 }
2119
2120#ifndef K1212_LARGEALLOC
2121
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;
2128 }
2129
2130 if (korg1212->dma_rec.area) {
2131 snd_dma_free_pages(&korg1212->dma_rec);
2132 korg1212->dma_rec.area = NULL;
2133 }
2134
2135#endif
2136
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;
2143 }
2144
2145 pci_disable_device(korg1212->pci);
2146 kfree(korg1212);
2147 return 0;
2148}
2149
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002150static int snd_korg1212_dev_free(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151{
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002152 struct snd_korg1212 *korg1212 = device->device_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153 K1212_DEBUG_PRINTK("K1212_DEBUG: Freeing device\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154 return snd_korg1212_free(korg1212);
2155}
2156
Bill Pembertone23e7a12012-12-06 12:35:10 -05002157static int snd_korg1212_create(struct snd_card *card, struct pci_dev *pci,
2158 struct snd_korg1212 **rchip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159
2160{
Takashi Iwai9fd91562005-11-17 10:45:48 +01002161 int err, rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162 unsigned int i;
2163 unsigned ioport_size, iomem_size, iomem2_size;
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002164 struct snd_korg1212 * korg1212;
Clemens Ladisch2493a6d2006-11-06 09:24:29 +01002165 const struct firmware *dsp_code;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002167 static struct snd_device_ops ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 .dev_free = snd_korg1212_dev_free,
2169 };
2170
2171 * rchip = NULL;
2172 if ((err = pci_enable_device(pci)) < 0)
2173 return err;
2174
Takashi Iwaie560d8d2005-09-09 14:21:46 +02002175 korg1212 = kzalloc(sizeof(*korg1212), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176 if (korg1212 == NULL) {
2177 pci_disable_device(pci);
2178 return -ENOMEM;
2179 }
2180
2181 korg1212->card = card;
2182 korg1212->pci = pci;
2183
2184 init_waitqueue_head(&korg1212->wait);
2185 spin_lock_init(&korg1212->lock);
Ingo Molnar62932df2006-01-16 16:34:20 +01002186 mutex_init(&korg1212->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187 init_timer(&korg1212->timer);
2188 korg1212->timer.function = snd_korg1212_timer_func;
2189 korg1212->timer.data = (unsigned long)korg1212;
2190
2191 korg1212->irq = -1;
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;
2207
2208 for (i=0; i<kAudioChannels; i++)
2209 korg1212->volumePhase[i] = 0;
2210
2211 if ((err = pci_request_regions(pci, "korg1212")) < 0) {
2212 kfree(korg1212);
2213 pci_disable_device(pci);
2214 return err;
2215 }
2216
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);
2220
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);
2224
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 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"
2229 " [%s]\n",
2230 korg1212->iomem, iomem_size,
2231 korg1212->ioport, ioport_size,
2232 korg1212->iomem2, iomem2_size,
2233 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234
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);
2239 return -EBUSY;
2240 }
2241
2242 err = request_irq(pci->irq, snd_korg1212_interrupt,
Takashi Iwai437a5a42006-11-21 12:14:23 +01002243 IRQF_SHARED,
Takashi Iwai934c2b62011-06-10 16:36:37 +02002244 KBUILD_MODNAME, korg1212);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245
2246 if (err) {
2247 snd_printk(KERN_ERR "korg1212: unable to grab IRQ %d\n", pci->irq);
2248 snd_korg1212_free(korg1212);
2249 return -EBUSY;
2250 }
2251
2252 korg1212->irq = pci->irq;
2253
2254 pci_set_master(korg1212->pci);
2255
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);
2266
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267 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"
2276 " SensReg = 0x%p\n"
2277 " IDReg = 0x%p\n"
2278 " [%s]\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,
2288 korg1212->idRegPtr,
2289 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290
2291 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002292 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));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 snd_korg1212_free(korg1212);
2295 return -ENOMEM;
2296 }
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002297 korg1212->sharedBufferPtr = (struct KorgSharedBuffer *)korg1212->dma_shared.area;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298 korg1212->sharedBufferPhy = korg1212->dma_shared.addr;
2299
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002300 K1212_DEBUG_PRINTK("K1212_DEBUG: Shared Buffer Area = 0x%p (0x%08lx), %d bytes\n", korg1212->sharedBufferPtr, korg1212->sharedBufferPhy, sizeof(struct KorgSharedBuffer));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301
2302#ifndef K1212_LARGEALLOC
2303
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002304 korg1212->DataBufsSize = sizeof(struct KorgAudioBuffer) * kNumBuffers;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305
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);
2310 return -ENOMEM;
2311 }
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002312 korg1212->playDataBufsPtr = (struct KorgAudioBuffer *)korg1212->dma_play.area;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313 korg1212->PlayDataPhy = korg1212->dma_play.addr;
2314
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315 K1212_DEBUG_PRINTK("K1212_DEBUG: Play Data Area = 0x%p (0x%08x), %d bytes\n",
2316 korg1212->playDataBufsPtr, korg1212->PlayDataPhy, korg1212->DataBufsSize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317
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);
2322 return -ENOMEM;
2323 }
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002324 korg1212->recordDataBufsPtr = (struct KorgAudioBuffer *)korg1212->dma_rec.area;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325 korg1212->RecDataPhy = korg1212->dma_rec.addr;
2326
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327 K1212_DEBUG_PRINTK("K1212_DEBUG: Record Data Area = 0x%p (0x%08x), %d bytes\n",
2328 korg1212->recordDataBufsPtr, korg1212->RecDataPhy, korg1212->DataBufsSize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329
2330#else // K1212_LARGEALLOC
2331
2332 korg1212->recordDataBufsPtr = korg1212->sharedBufferPtr->recordDataBufs;
2333 korg1212->playDataBufsPtr = korg1212->sharedBufferPtr->playDataBufs;
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002334 korg1212->PlayDataPhy = (u32) &((struct KorgSharedBuffer *) korg1212->sharedBufferPhy)->playDataBufs;
2335 korg1212->RecDataPhy = (u32) &((struct KorgSharedBuffer *) korg1212->sharedBufferPhy)->recordDataBufs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336
2337#endif // K1212_LARGEALLOC
2338
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339 korg1212->VolumeTablePhy = korg1212->sharedBufferPhy +
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002340 offsetof(struct KorgSharedBuffer, volumeData);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341 korg1212->RoutingTablePhy = korg1212->sharedBufferPhy +
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002342 offsetof(struct KorgSharedBuffer, routeData);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343 korg1212->AdatTimeCodePhy = korg1212->sharedBufferPhy +
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002344 offsetof(struct KorgSharedBuffer, AdatTimeCode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345
Clemens Ladisch2493a6d2006-11-06 09:24:29 +01002346 err = request_firmware(&dsp_code, "korg/k1212.dsp", &pci->dev);
2347 if (err < 0) {
2348 release_firmware(dsp_code);
Clemens Ladisch2493a6d2006-11-06 09:24:29 +01002349 snd_printk(KERN_ERR "firmware not available\n");
2350 snd_korg1212_free(korg1212);
2351 return err;
Clemens Ladisch2493a6d2006-11-06 09:24:29 +01002352 }
2353
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
Clemens Ladisch2493a6d2006-11-06 09:24:29 +01002355 dsp_code->size, &korg1212->dma_dsp) < 0) {
Randy Dunlap9fb62c92006-11-21 19:01:51 +01002356 snd_printk(KERN_ERR "korg1212: cannot allocate dsp code memory (%zd bytes)\n", dsp_code->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357 snd_korg1212_free(korg1212);
Takashi Iwaib7dd2b32007-04-26 14:13:44 +02002358 release_firmware(dsp_code);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359 return -ENOMEM;
2360 }
2361
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362 K1212_DEBUG_PRINTK("K1212_DEBUG: DSP Code area = 0x%p (0x%08x) %d bytes [%s]\n",
Clemens Ladisch2493a6d2006-11-06 09:24:29 +01002363 korg1212->dma_dsp.area, korg1212->dma_dsp.addr, dsp_code->size,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364 stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365
Clemens Ladisch2493a6d2006-11-06 09:24:29 +01002366 memcpy(korg1212->dma_dsp.area, dsp_code->data, dsp_code->size);
2367
Takashi Iwaib7dd2b32007-04-26 14:13:44 +02002368 release_firmware(dsp_code);
Clemens Ladisch2493a6d2006-11-06 09:24:29 +01002369
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370 rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_RebootCard, 0, 0, 0, 0);
2371
Takashi Iwai9fd91562005-11-17 10:45:48 +01002372 if (rc)
2373 K1212_DEBUG_PRINTK("K1212_DEBUG: Reboot Card - RC = %d [%s]\n", rc, stateName[korg1212->cardState]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374
2375 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, korg1212, &ops)) < 0) {
2376 snd_korg1212_free(korg1212);
2377 return err;
2378 }
2379
2380 snd_korg1212_EnableCardInterrupts(korg1212);
2381
2382 mdelay(CARD_BOOT_DELAY_IN_MS);
2383
2384 if (snd_korg1212_downloadDSPCode(korg1212))
2385 return -EBUSY;
2386
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002387 K1212_DEBUG_PRINTK("korg1212: dspMemPhy = %08x U[%08x], "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002388 "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));
2399
2400 if ((err = snd_pcm_new(korg1212->card, "korg1212", 0, 1, 1, &korg1212->pcm)) < 0)
2401 return err;
2402
2403 korg1212->pcm->private_data = korg1212;
2404 korg1212->pcm->private_free = snd_korg1212_free_pcm;
2405 strcpy(korg1212->pcm->name, "korg1212");
2406
2407 snd_pcm_set_ops(korg1212->pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_korg1212_playback_ops);
2408
2409 snd_pcm_set_ops(korg1212->pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_korg1212_capture_ops);
2410
2411 korg1212->pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
2412
Linus Torvalds1da177e2005-04-16 15:20:36 -07002413 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));
2415 if (err < 0)
2416 return err;
2417 }
2418
2419 snd_korg1212_proc_init(korg1212);
2420
2421 snd_card_set_dev(card, &pci->dev);
2422
2423 * rchip = korg1212;
2424 return 0;
2425
2426}
2427
2428/*
2429 * Card initialisation
2430 */
2431
Bill Pembertone23e7a12012-12-06 12:35:10 -05002432static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433snd_korg1212_probe(struct pci_dev *pci,
2434 const struct pci_device_id *pci_id)
2435{
2436 static int dev;
Takashi Iwaifcfd3332005-11-17 15:00:46 +01002437 struct snd_korg1212 *korg1212;
2438 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002439 int err;
2440
2441 if (dev >= SNDRV_CARDS) {
2442 return -ENODEV;
2443 }
2444 if (!enable[dev]) {
2445 dev++;
2446 return -ENOENT;
2447 }
Takashi Iwaie58de7b2008-12-28 16:44:30 +01002448 err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
2449 if (err < 0)
2450 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002451
2452 if ((err = snd_korg1212_create(card, pci, &korg1212)) < 0) {
2453 snd_card_free(card);
2454 return err;
2455 }
2456
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);
2461
Linus Torvalds1da177e2005-04-16 15:20:36 -07002462 K1212_DEBUG_PRINTK("K1212_DEBUG: %s\n", card->longname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002463
2464 if ((err = snd_card_register(card)) < 0) {
2465 snd_card_free(card);
2466 return err;
2467 }
2468 pci_set_drvdata(pci, card);
2469 dev++;
2470 return 0;
2471}
2472
Bill Pembertone23e7a12012-12-06 12:35:10 -05002473static void snd_korg1212_remove(struct pci_dev *pci)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474{
2475 snd_card_free(pci_get_drvdata(pci));
2476 pci_set_drvdata(pci, NULL);
2477}
2478
Takashi Iwaie9f66d92012-04-24 12:25:00 +02002479static struct pci_driver korg1212_driver = {
Takashi Iwai3733e422011-06-10 16:20:20 +02002480 .name = KBUILD_MODNAME,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002481 .id_table = snd_korg1212_ids,
2482 .probe = snd_korg1212_probe,
Bill Pembertone23e7a12012-12-06 12:35:10 -05002483 .remove = snd_korg1212_remove,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484};
2485
Takashi Iwaie9f66d92012-04-24 12:25:00 +02002486module_pci_driver(korg1212_driver);