korg1212.c source code [linux/sound/pci/korg1212/korg1212.c]

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

source code of linux/sound/pci/korg1212/korg1212.c