3 * ALSA driver for the digigram lx6464es interface
6 * Copyright (c) 2009 Tim Blechmann <tim@klingt.org>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; see the file COPYING. If not, write to
20 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 * Boston, MA 02111-1307, USA.
25 /* #define RMH_DEBUG 1 */
27 #include <linux/module.h>
28 #include <linux/pci.h>
29 #include <linux/delay.h>
34 /* low-level register access */
36 static const unsigned long dsp_port_offsets
[] = {
69 static void __iomem
*lx_dsp_register(struct lx6464es
*chip
, int port
)
71 void __iomem
*base_address
= chip
->port_dsp_bar
;
72 return base_address
+ dsp_port_offsets
[port
]*4;
75 unsigned long lx_dsp_reg_read(struct lx6464es
*chip
, int port
)
77 void __iomem
*address
= lx_dsp_register(chip
, port
);
78 return ioread32(address
);
81 void lx_dsp_reg_readbuf(struct lx6464es
*chip
, int port
, u32
*data
, u32 len
)
83 void __iomem
*address
= lx_dsp_register(chip
, port
);
84 memcpy_fromio(data
, address
, len
*sizeof(u32
));
88 void lx_dsp_reg_write(struct lx6464es
*chip
, int port
, unsigned data
)
90 void __iomem
*address
= lx_dsp_register(chip
, port
);
91 iowrite32(data
, address
);
94 void lx_dsp_reg_writebuf(struct lx6464es
*chip
, int port
, const u32
*data
,
97 void __iomem
*address
= lx_dsp_register(chip
, port
);
98 memcpy_toio(address
, data
, len
*sizeof(u32
));
102 static const unsigned long plx_port_offsets
[] = {
117 static void __iomem
*lx_plx_register(struct lx6464es
*chip
, int port
)
119 void __iomem
*base_address
= chip
->port_plx_remapped
;
120 return base_address
+ plx_port_offsets
[port
];
123 unsigned long lx_plx_reg_read(struct lx6464es
*chip
, int port
)
125 void __iomem
*address
= lx_plx_register(chip
, port
);
126 return ioread32(address
);
129 void lx_plx_reg_write(struct lx6464es
*chip
, int port
, u32 data
)
131 void __iomem
*address
= lx_plx_register(chip
, port
);
132 iowrite32(data
, address
);
135 u32
lx_plx_mbox_read(struct lx6464es
*chip
, int mbox_nr
)
141 index
= ePLX_MBOX1
; break;
143 index
= ePLX_MBOX2
; break;
145 index
= ePLX_MBOX3
; break;
147 index
= ePLX_MBOX4
; break;
149 index
= ePLX_MBOX5
; break;
151 index
= ePLX_MBOX6
; break;
153 index
= ePLX_MBOX7
; break;
154 case 0: /* reserved for HF flags */
160 return lx_plx_reg_read(chip
, index
);
163 int lx_plx_mbox_write(struct lx6464es
*chip
, int mbox_nr
, u32 value
)
169 index
= ePLX_MBOX1
; break;
171 index
= ePLX_MBOX3
; break;
173 index
= ePLX_MBOX4
; break;
175 index
= ePLX_MBOX5
; break;
177 index
= ePLX_MBOX6
; break;
179 index
= ePLX_MBOX7
; break;
180 case 0: /* reserved for HF flags */
181 case 2: /* reserved for Pipe States
182 * the DSP keeps an image of it */
187 lx_plx_reg_write(chip
, index
, value
);
194 #ifdef CONFIG_SND_DEBUG
195 #define CMD_NAME(a) a
197 #define CMD_NAME(a) NULL
200 #define Reg_CSM_MR 0x00000002
201 #define Reg_CSM_MC 0x00000001
203 struct dsp_cmd_info
{
204 u32 dcCodeOp
; /* Op Code of the command (usually 1st 24-bits
206 u16 dcCmdLength
; /* Command length in words of 24 bits.*/
207 u16 dcStatusType
; /* Status type: 0 for fixed length, 1 for
209 u16 dcStatusLength
; /* Status length (if fixed).*/
214 Initialization and control data for the Microblaze interface
216 the opcode field of the command set at the proper offset
218 the number of command words
220 offset in the status registers: 0 means that the return value may be
221 different from 0, and must be read
223 the number of status words (in addition to the return value)
226 static struct dsp_cmd_info dsp_commands
[] =
228 { (CMD_00_INFO_DEBUG
<< OPCODE_OFFSET
) , 1 /*custom*/
229 , 1 , 0 /**/ , CMD_NAME("INFO_DEBUG") },
230 { (CMD_01_GET_SYS_CFG
<< OPCODE_OFFSET
) , 1 /**/
231 , 1 , 2 /**/ , CMD_NAME("GET_SYS_CFG") },
232 { (CMD_02_SET_GRANULARITY
<< OPCODE_OFFSET
) , 1 /**/
233 , 1 , 0 /**/ , CMD_NAME("SET_GRANULARITY") },
234 { (CMD_03_SET_TIMER_IRQ
<< OPCODE_OFFSET
) , 1 /**/
235 , 1 , 0 /**/ , CMD_NAME("SET_TIMER_IRQ") },
236 { (CMD_04_GET_EVENT
<< OPCODE_OFFSET
) , 1 /**/
237 , 1 , 0 /*up to 10*/ , CMD_NAME("GET_EVENT") },
238 { (CMD_05_GET_PIPES
<< OPCODE_OFFSET
) , 1 /**/
239 , 1 , 2 /*up to 4*/ , CMD_NAME("GET_PIPES") },
240 { (CMD_06_ALLOCATE_PIPE
<< OPCODE_OFFSET
) , 1 /**/
241 , 0 , 0 /**/ , CMD_NAME("ALLOCATE_PIPE") },
242 { (CMD_07_RELEASE_PIPE
<< OPCODE_OFFSET
) , 1 /**/
243 , 0 , 0 /**/ , CMD_NAME("RELEASE_PIPE") },
244 { (CMD_08_ASK_BUFFERS
<< OPCODE_OFFSET
) , 1 /**/
245 , 1 , MAX_STREAM_BUFFER
, CMD_NAME("ASK_BUFFERS") },
246 { (CMD_09_STOP_PIPE
<< OPCODE_OFFSET
) , 1 /**/
247 , 0 , 0 /*up to 2*/ , CMD_NAME("STOP_PIPE") },
248 { (CMD_0A_GET_PIPE_SPL_COUNT
<< OPCODE_OFFSET
) , 1 /**/
249 , 1 , 1 /*up to 2*/ , CMD_NAME("GET_PIPE_SPL_COUNT") },
250 { (CMD_0B_TOGGLE_PIPE_STATE
<< OPCODE_OFFSET
) , 1 /*up to 5*/
251 , 1 , 0 /**/ , CMD_NAME("TOGGLE_PIPE_STATE") },
252 { (CMD_0C_DEF_STREAM
<< OPCODE_OFFSET
) , 1 /*up to 4*/
253 , 1 , 0 /**/ , CMD_NAME("DEF_STREAM") },
254 { (CMD_0D_SET_MUTE
<< OPCODE_OFFSET
) , 3 /**/
255 , 1 , 0 /**/ , CMD_NAME("SET_MUTE") },
256 { (CMD_0E_GET_STREAM_SPL_COUNT
<< OPCODE_OFFSET
) , 1/**/
257 , 1 , 2 /**/ , CMD_NAME("GET_STREAM_SPL_COUNT") },
258 { (CMD_0F_UPDATE_BUFFER
<< OPCODE_OFFSET
) , 3 /*up to 4*/
259 , 0 , 1 /**/ , CMD_NAME("UPDATE_BUFFER") },
260 { (CMD_10_GET_BUFFER
<< OPCODE_OFFSET
) , 1 /**/
261 , 1 , 4 /**/ , CMD_NAME("GET_BUFFER") },
262 { (CMD_11_CANCEL_BUFFER
<< OPCODE_OFFSET
) , 1 /**/
263 , 1 , 1 /*up to 4*/ , CMD_NAME("CANCEL_BUFFER") },
264 { (CMD_12_GET_PEAK
<< OPCODE_OFFSET
) , 1 /**/
265 , 1 , 1 /**/ , CMD_NAME("GET_PEAK") },
266 { (CMD_13_SET_STREAM_STATE
<< OPCODE_OFFSET
) , 1 /**/
267 , 1 , 0 /**/ , CMD_NAME("SET_STREAM_STATE") },
270 static void lx_message_init(struct lx_rmh
*rmh
, enum cmd_mb_opcodes cmd
)
272 snd_BUG_ON(cmd
>= CMD_14_INVALID
);
274 rmh
->cmd
[0] = dsp_commands
[cmd
].dcCodeOp
;
275 rmh
->cmd_len
= dsp_commands
[cmd
].dcCmdLength
;
276 rmh
->stat_len
= dsp_commands
[cmd
].dcStatusLength
;
277 rmh
->dsp_stat
= dsp_commands
[cmd
].dcStatusType
;
279 memset(&rmh
->cmd
[1], 0, (REG_CRM_NUMBER
- 1) * sizeof(u32
));
281 #ifdef CONFIG_SND_DEBUG
282 memset(rmh
->stat
, 0, REG_CRM_NUMBER
* sizeof(u32
));
290 #define LXRMH "lx6464es rmh: "
291 static void lx_message_dump(struct lx_rmh
*rmh
)
293 u8 idx
= rmh
->cmd_idx
;
296 snd_printk(LXRMH
"command %s\n", dsp_commands
[idx
].dcOpName
);
298 for (i
= 0; i
!= rmh
->cmd_len
; ++i
)
299 snd_printk(LXRMH
"\tcmd[%d] %08x\n", i
, rmh
->cmd
[i
]);
301 for (i
= 0; i
!= rmh
->stat_len
; ++i
)
302 snd_printk(LXRMH
"\tstat[%d]: %08x\n", i
, rmh
->stat
[i
]);
306 static inline void lx_message_dump(struct lx_rmh
*rmh
)
312 /* sleep 500 - 100 = 400 times 100us -> the timeout is >= 40 ms */
313 #define XILINX_TIMEOUT_MS 40
314 #define XILINX_POLL_NO_SLEEP 100
315 #define XILINX_POLL_ITERATIONS 150
317 static int lx_message_send(struct lx6464es
*chip
, struct lx_rmh
*rmh
)
319 u32 reg
= ED_DSP_TIMED_OUT
;
323 if (lx_dsp_reg_read(chip
, eReg_CSM
) & (Reg_CSM_MC
| Reg_CSM_MR
)) {
324 snd_printk(KERN_ERR LXP
"PIOSendMessage eReg_CSM %x\n", reg
);
329 lx_dsp_reg_writebuf(chip
, eReg_CRM1
, rmh
->cmd
, rmh
->cmd_len
);
331 snd_BUG_ON(atomic_read(&chip
->send_message_locked
) != 0);
332 atomic_set(&chip
->send_message_locked
, 1);
334 /* MicoBlaze gogogo */
335 lx_dsp_reg_write(chip
, eReg_CSM
, Reg_CSM_MC
);
337 /* wait for interrupt to answer */
338 for (dwloop
= 0; dwloop
!= XILINX_TIMEOUT_MS
; ++dwloop
) {
339 answer_received
= atomic_read(&chip
->send_message_locked
);
340 if (answer_received
== 0)
345 if (answer_received
== 0) {
346 /* in Debug mode verify Reg_CSM_MR */
347 snd_BUG_ON(!(lx_dsp_reg_read(chip
, eReg_CSM
) & Reg_CSM_MR
));
349 /* command finished, read status */
350 if (rmh
->dsp_stat
== 0)
351 reg
= lx_dsp_reg_read(chip
, eReg_CRM1
);
356 snd_printk(KERN_WARNING LXP
"TIMEOUT lx_message_send! "
357 "Interrupts disabled?\n");
359 /* attente bit Reg_CSM_MR */
360 for (i
= 0; i
!= XILINX_POLL_ITERATIONS
; i
++) {
361 if ((lx_dsp_reg_read(chip
, eReg_CSM
) & Reg_CSM_MR
)) {
362 if (rmh
->dsp_stat
== 0)
363 reg
= lx_dsp_reg_read(chip
, eReg_CRM1
);
366 goto polling_successful
;
369 if (i
> XILINX_POLL_NO_SLEEP
)
372 snd_printk(KERN_WARNING LXP
"TIMEOUT lx_message_send! "
376 atomic_set(&chip
->send_message_locked
, 0);
379 if ((reg
& ERROR_VALUE
) == 0) {
382 snd_BUG_ON(rmh
->stat_len
>= (REG_CRM_NUMBER
-1));
384 lx_dsp_reg_readbuf(chip
, eReg_CRM2
, rmh
->stat
,
388 snd_printk(KERN_WARNING LXP
"lx_message_send: error_value %x\n",
391 /* clear Reg_CSM_MR */
392 lx_dsp_reg_write(chip
, eReg_CSM
, 0);
395 case ED_DSP_TIMED_OUT
:
396 snd_printk(KERN_WARNING LXP
"lx_message_send: dsp timeout\n");
400 snd_printk(KERN_WARNING LXP
"lx_message_send: dsp crashed\n");
404 lx_message_dump(rmh
);
408 static int lx_message_send_atomic(struct lx6464es
*chip
, struct lx_rmh
*rmh
)
410 u32 reg
= ED_DSP_TIMED_OUT
;
413 if (lx_dsp_reg_read(chip
, eReg_CSM
) & (Reg_CSM_MC
| Reg_CSM_MR
)) {
414 snd_printk(KERN_ERR LXP
"PIOSendMessage eReg_CSM %x\n", reg
);
419 lx_dsp_reg_writebuf(chip
, eReg_CRM1
, rmh
->cmd
, rmh
->cmd_len
);
421 /* MicoBlaze gogogo */
422 lx_dsp_reg_write(chip
, eReg_CSM
, Reg_CSM_MC
);
424 /* wait for interrupt to answer */
425 for (dwloop
= 0; dwloop
!= XILINX_TIMEOUT_MS
* 1000; ++dwloop
) {
426 if (lx_dsp_reg_read(chip
, eReg_CSM
) & Reg_CSM_MR
) {
427 if (rmh
->dsp_stat
== 0)
428 reg
= lx_dsp_reg_read(chip
, eReg_CRM1
);
431 goto polling_successful
;
435 snd_printk(KERN_WARNING LXP
"TIMEOUT lx_message_send_atomic! "
439 if ((reg
& ERROR_VALUE
) == 0) {
442 snd_BUG_ON(rmh
->stat_len
>= (REG_CRM_NUMBER
-1));
443 lx_dsp_reg_readbuf(chip
, eReg_CRM2
, rmh
->stat
,
447 snd_printk(LXP
"rmh error: %08x\n", reg
);
449 /* clear Reg_CSM_MR */
450 lx_dsp_reg_write(chip
, eReg_CSM
, 0);
453 case ED_DSP_TIMED_OUT
:
454 snd_printk(KERN_WARNING LXP
"lx_message_send: dsp timeout\n");
458 snd_printk(KERN_WARNING LXP
"lx_message_send: dsp crashed\n");
462 lx_message_dump(rmh
);
468 /* low-level dsp access */
469 int __devinit
lx_dsp_get_version(struct lx6464es
*chip
, u32
*rdsp_version
)
474 spin_lock_irqsave(&chip
->msg_lock
, flags
);
476 lx_message_init(&chip
->rmh
, CMD_01_GET_SYS_CFG
);
477 ret
= lx_message_send_atomic(chip
, &chip
->rmh
);
479 *rdsp_version
= chip
->rmh
.stat
[1];
480 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
484 int lx_dsp_get_clock_frequency(struct lx6464es
*chip
, u32
*rfreq
)
492 spin_lock_irqsave(&chip
->msg_lock
, flags
);
494 lx_message_init(&chip
->rmh
, CMD_01_GET_SYS_CFG
);
495 ret
= lx_message_send_atomic(chip
, &chip
->rmh
);
498 freq_raw
= chip
->rmh
.stat
[0] >> FREQ_FIELD_OFFSET
;
499 freq
= freq_raw
& XES_FREQ_COUNT8_MASK
;
501 if ((freq
< XES_FREQ_COUNT8_48_MAX
) ||
502 (freq
> XES_FREQ_COUNT8_44_MIN
))
503 frequency
= 0; /* unknown */
504 else if (freq
>= XES_FREQ_COUNT8_44_MAX
)
510 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
512 *rfreq
= frequency
* chip
->freq_ratio
;
517 int lx_dsp_get_mac(struct lx6464es
*chip
, u8
*mac_address
)
521 macmsb
= lx_dsp_reg_read(chip
, eReg_ADMACESMSB
) & 0x00FFFFFF;
522 maclsb
= lx_dsp_reg_read(chip
, eReg_ADMACESLSB
) & 0x00FFFFFF;
524 /* todo: endianess handling */
525 mac_address
[5] = ((u8
*)(&maclsb
))[0];
526 mac_address
[4] = ((u8
*)(&maclsb
))[1];
527 mac_address
[3] = ((u8
*)(&maclsb
))[2];
528 mac_address
[2] = ((u8
*)(&macmsb
))[0];
529 mac_address
[1] = ((u8
*)(&macmsb
))[1];
530 mac_address
[0] = ((u8
*)(&macmsb
))[2];
536 int lx_dsp_set_granularity(struct lx6464es
*chip
, u32 gran
)
541 spin_lock_irqsave(&chip
->msg_lock
, flags
);
543 lx_message_init(&chip
->rmh
, CMD_02_SET_GRANULARITY
);
544 chip
->rmh
.cmd
[0] |= gran
;
546 ret
= lx_message_send_atomic(chip
, &chip
->rmh
);
547 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
551 int lx_dsp_read_async_events(struct lx6464es
*chip
, u32
*data
)
556 spin_lock_irqsave(&chip
->msg_lock
, flags
);
558 lx_message_init(&chip
->rmh
, CMD_04_GET_EVENT
);
559 chip
->rmh
.stat_len
= 9; /* we don't necessarily need the full length */
561 ret
= lx_message_send_atomic(chip
, &chip
->rmh
);
564 memcpy(data
, chip
->rmh
.stat
, chip
->rmh
.stat_len
* sizeof(u32
));
566 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
570 #define CSES_TIMEOUT 100 /* microseconds */
571 #define CSES_CE 0x0001
572 #define CSES_BROADCAST 0x0002
573 #define CSES_UPDATE_LDSV 0x0004
575 int lx_dsp_es_check_pipeline(struct lx6464es
*chip
)
579 for (i
= 0; i
!= CSES_TIMEOUT
; ++i
) {
581 * le bit CSES_UPDATE_LDSV est à1 dés que le macprog
582 * est pret. il re-passe à0 lorsque le premier read a
583 * été fait. pour l'instant on retire le test car ce bit
584 * passe a 1 environ 200 à400 ms aprés que le registre
585 * confES àété écrit (kick du xilinx ES).
587 * On ne teste que le bit CE.
590 u32 cses
= lx_dsp_reg_read(chip
, eReg_CSES
);
592 if ((cses
& CSES_CE
) == 0)
602 #define PIPE_INFO_TO_CMD(capture, pipe) \
603 ((u32)((u32)(pipe) | ((capture) ? ID_IS_CAPTURE : 0L)) << ID_OFFSET)
607 /* low-level pipe handling */
608 int lx_pipe_allocate(struct lx6464es
*chip
, u32 pipe
, int is_capture
,
614 u32 pipe_cmd
= PIPE_INFO_TO_CMD(is_capture
, pipe
);
616 spin_lock_irqsave(&chip
->msg_lock
, flags
);
617 lx_message_init(&chip
->rmh
, CMD_06_ALLOCATE_PIPE
);
619 chip
->rmh
.cmd
[0] |= pipe_cmd
;
620 chip
->rmh
.cmd
[0] |= channels
;
622 err
= lx_message_send_atomic(chip
, &chip
->rmh
);
623 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
626 snd_printk(KERN_ERR
"lx6464es: could not allocate pipe\n");
631 int lx_pipe_release(struct lx6464es
*chip
, u32 pipe
, int is_capture
)
636 u32 pipe_cmd
= PIPE_INFO_TO_CMD(is_capture
, pipe
);
638 spin_lock_irqsave(&chip
->msg_lock
, flags
);
639 lx_message_init(&chip
->rmh
, CMD_07_RELEASE_PIPE
);
641 chip
->rmh
.cmd
[0] |= pipe_cmd
;
643 err
= lx_message_send_atomic(chip
, &chip
->rmh
);
644 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
649 int lx_buffer_ask(struct lx6464es
*chip
, u32 pipe
, int is_capture
,
650 u32
*r_needed
, u32
*r_freed
, u32
*size_array
)
655 u32 pipe_cmd
= PIPE_INFO_TO_CMD(is_capture
, pipe
);
657 #ifdef CONFIG_SND_DEBUG
659 memset(size_array
, 0, sizeof(u32
)*MAX_STREAM_BUFFER
);
665 spin_lock_irqsave(&chip
->msg_lock
, flags
);
666 lx_message_init(&chip
->rmh
, CMD_08_ASK_BUFFERS
);
668 chip
->rmh
.cmd
[0] |= pipe_cmd
;
670 err
= lx_message_send_atomic(chip
, &chip
->rmh
);
674 for (i
= 0; i
< MAX_STREAM_BUFFER
; ++i
) {
675 u32 stat
= chip
->rmh
.stat
[i
];
676 if (stat
& (BF_EOB
<< BUFF_FLAGS_OFFSET
)) {
680 size_array
[i
] = stat
& MASK_DATA_SIZE
;
681 } else if ((stat
& (BF_VALID
<< BUFF_FLAGS_OFFSET
))
688 snd_printdd(LXP
"CMD_08_ASK_BUFFERS: needed %d, freed %d\n",
689 *r_needed
, *r_freed
);
690 for (i
= 0; i
< MAX_STREAM_BUFFER
; ++i
) {
691 for (i
= 0; i
!= chip
->rmh
.stat_len
; ++i
)
692 snd_printdd(" stat[%d]: %x, %x\n", i
,
694 chip
->rmh
.stat
[i
] & MASK_DATA_SIZE
);
699 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
704 int lx_pipe_stop(struct lx6464es
*chip
, u32 pipe
, int is_capture
)
709 u32 pipe_cmd
= PIPE_INFO_TO_CMD(is_capture
, pipe
);
711 spin_lock_irqsave(&chip
->msg_lock
, flags
);
712 lx_message_init(&chip
->rmh
, CMD_09_STOP_PIPE
);
714 chip
->rmh
.cmd
[0] |= pipe_cmd
;
716 err
= lx_message_send_atomic(chip
, &chip
->rmh
);
718 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
722 static int lx_pipe_toggle_state(struct lx6464es
*chip
, u32 pipe
, int is_capture
)
727 u32 pipe_cmd
= PIPE_INFO_TO_CMD(is_capture
, pipe
);
729 spin_lock_irqsave(&chip
->msg_lock
, flags
);
730 lx_message_init(&chip
->rmh
, CMD_0B_TOGGLE_PIPE_STATE
);
732 chip
->rmh
.cmd
[0] |= pipe_cmd
;
734 err
= lx_message_send_atomic(chip
, &chip
->rmh
);
736 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
741 int lx_pipe_start(struct lx6464es
*chip
, u32 pipe
, int is_capture
)
745 err
= lx_pipe_wait_for_idle(chip
, pipe
, is_capture
);
749 err
= lx_pipe_toggle_state(chip
, pipe
, is_capture
);
754 int lx_pipe_pause(struct lx6464es
*chip
, u32 pipe
, int is_capture
)
758 err
= lx_pipe_wait_for_start(chip
, pipe
, is_capture
);
762 err
= lx_pipe_toggle_state(chip
, pipe
, is_capture
);
768 int lx_pipe_sample_count(struct lx6464es
*chip
, u32 pipe
, int is_capture
,
774 u32 pipe_cmd
= PIPE_INFO_TO_CMD(is_capture
, pipe
);
776 spin_lock_irqsave(&chip
->msg_lock
, flags
);
777 lx_message_init(&chip
->rmh
, CMD_0A_GET_PIPE_SPL_COUNT
);
779 chip
->rmh
.cmd
[0] |= pipe_cmd
;
780 chip
->rmh
.stat_len
= 2; /* need all words here! */
782 err
= lx_message_send_atomic(chip
, &chip
->rmh
); /* don't sleep! */
786 "lx6464es: could not query pipe's sample count\n");
788 *rsample_count
= ((u64
)(chip
->rmh
.stat
[0] & MASK_SPL_COUNT_HI
)
790 + chip
->rmh
.stat
[1]; /* lo part */
793 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
797 int lx_pipe_state(struct lx6464es
*chip
, u32 pipe
, int is_capture
, u16
*rstate
)
802 u32 pipe_cmd
= PIPE_INFO_TO_CMD(is_capture
, pipe
);
804 spin_lock_irqsave(&chip
->msg_lock
, flags
);
805 lx_message_init(&chip
->rmh
, CMD_0A_GET_PIPE_SPL_COUNT
);
807 chip
->rmh
.cmd
[0] |= pipe_cmd
;
809 err
= lx_message_send_atomic(chip
, &chip
->rmh
);
812 snd_printk(KERN_ERR
"lx6464es: could not query pipe's state\n");
814 *rstate
= (chip
->rmh
.stat
[0] >> PSTATE_OFFSET
) & 0x0F;
816 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
820 static int lx_pipe_wait_for_state(struct lx6464es
*chip
, u32 pipe
,
821 int is_capture
, u16 state
)
825 /* max 2*PCMOnlyGranularity = 2*1024 at 44100 = < 50 ms:
827 for (i
= 0; i
!= 50; ++i
) {
829 int err
= lx_pipe_state(chip
, pipe
, is_capture
, ¤t_state
);
834 if (current_state
== state
)
843 int lx_pipe_wait_for_start(struct lx6464es
*chip
, u32 pipe
, int is_capture
)
845 return lx_pipe_wait_for_state(chip
, pipe
, is_capture
, PSTATE_RUN
);
848 int lx_pipe_wait_for_idle(struct lx6464es
*chip
, u32 pipe
, int is_capture
)
850 return lx_pipe_wait_for_state(chip
, pipe
, is_capture
, PSTATE_IDLE
);
853 /* low-level stream handling */
854 int lx_stream_set_state(struct lx6464es
*chip
, u32 pipe
,
855 int is_capture
, enum stream_state_t state
)
860 u32 pipe_cmd
= PIPE_INFO_TO_CMD(is_capture
, pipe
);
862 spin_lock_irqsave(&chip
->msg_lock
, flags
);
863 lx_message_init(&chip
->rmh
, CMD_13_SET_STREAM_STATE
);
865 chip
->rmh
.cmd
[0] |= pipe_cmd
;
866 chip
->rmh
.cmd
[0] |= state
;
868 err
= lx_message_send_atomic(chip
, &chip
->rmh
);
869 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
874 int lx_stream_set_format(struct lx6464es
*chip
, struct snd_pcm_runtime
*runtime
,
875 u32 pipe
, int is_capture
)
880 u32 pipe_cmd
= PIPE_INFO_TO_CMD(is_capture
, pipe
);
882 u32 channels
= runtime
->channels
;
884 if (runtime
->channels
!= channels
)
885 snd_printk(KERN_ERR LXP
"channel count mismatch: %d vs %d",
886 runtime
->channels
, channels
);
888 spin_lock_irqsave(&chip
->msg_lock
, flags
);
889 lx_message_init(&chip
->rmh
, CMD_0C_DEF_STREAM
);
891 chip
->rmh
.cmd
[0] |= pipe_cmd
;
893 if (runtime
->sample_bits
== 16)
895 chip
->rmh
.cmd
[0] |= (STREAM_FMT_16b
<< STREAM_FMT_OFFSET
);
897 if (snd_pcm_format_little_endian(runtime
->format
))
898 /* little endian/intel format */
899 chip
->rmh
.cmd
[0] |= (STREAM_FMT_intel
<< STREAM_FMT_OFFSET
);
901 chip
->rmh
.cmd
[0] |= channels
-1;
903 err
= lx_message_send_atomic(chip
, &chip
->rmh
);
904 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
909 int lx_stream_state(struct lx6464es
*chip
, u32 pipe
, int is_capture
,
915 u32 pipe_cmd
= PIPE_INFO_TO_CMD(is_capture
, pipe
);
917 spin_lock_irqsave(&chip
->msg_lock
, flags
);
918 lx_message_init(&chip
->rmh
, CMD_0E_GET_STREAM_SPL_COUNT
);
920 chip
->rmh
.cmd
[0] |= pipe_cmd
;
922 err
= lx_message_send_atomic(chip
, &chip
->rmh
);
924 *rstate
= (chip
->rmh
.stat
[0] & SF_START
) ? START_STATE
: PAUSE_STATE
;
926 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
930 int lx_stream_sample_position(struct lx6464es
*chip
, u32 pipe
, int is_capture
,
936 u32 pipe_cmd
= PIPE_INFO_TO_CMD(is_capture
, pipe
);
938 spin_lock_irqsave(&chip
->msg_lock
, flags
);
939 lx_message_init(&chip
->rmh
, CMD_0E_GET_STREAM_SPL_COUNT
);
941 chip
->rmh
.cmd
[0] |= pipe_cmd
;
943 err
= lx_message_send_atomic(chip
, &chip
->rmh
);
945 *r_bytepos
= ((u64
) (chip
->rmh
.stat
[0] & MASK_SPL_COUNT_HI
)
947 + chip
->rmh
.stat
[1]; /* lo part */
949 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
953 /* low-level buffer handling */
954 int lx_buffer_give(struct lx6464es
*chip
, u32 pipe
, int is_capture
,
955 u32 buffer_size
, u32 buf_address_lo
, u32 buf_address_hi
,
961 u32 pipe_cmd
= PIPE_INFO_TO_CMD(is_capture
, pipe
);
963 spin_lock_irqsave(&chip
->msg_lock
, flags
);
964 lx_message_init(&chip
->rmh
, CMD_0F_UPDATE_BUFFER
);
966 chip
->rmh
.cmd
[0] |= pipe_cmd
;
967 chip
->rmh
.cmd
[0] |= BF_NOTIFY_EOB
; /* request interrupt notification */
969 /* todo: pause request, circular buffer */
971 chip
->rmh
.cmd
[1] = buffer_size
& MASK_DATA_SIZE
;
972 chip
->rmh
.cmd
[2] = buf_address_lo
;
974 if (buf_address_hi
) {
975 chip
->rmh
.cmd_len
= 4;
976 chip
->rmh
.cmd
[3] = buf_address_hi
;
977 chip
->rmh
.cmd
[0] |= BF_64BITS_ADR
;
980 err
= lx_message_send_atomic(chip
, &chip
->rmh
);
983 *r_buffer_index
= chip
->rmh
.stat
[0];
987 if (err
== EB_RBUFFERS_TABLE_OVERFLOW
)
988 snd_printk(LXP
"lx_buffer_give EB_RBUFFERS_TABLE_OVERFLOW\n");
990 if (err
== EB_INVALID_STREAM
)
991 snd_printk(LXP
"lx_buffer_give EB_INVALID_STREAM\n");
993 if (err
== EB_CMD_REFUSED
)
994 snd_printk(LXP
"lx_buffer_give EB_CMD_REFUSED\n");
997 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
1001 int lx_buffer_free(struct lx6464es
*chip
, u32 pipe
, int is_capture
,
1005 unsigned long flags
;
1007 u32 pipe_cmd
= PIPE_INFO_TO_CMD(is_capture
, pipe
);
1009 spin_lock_irqsave(&chip
->msg_lock
, flags
);
1010 lx_message_init(&chip
->rmh
, CMD_11_CANCEL_BUFFER
);
1012 chip
->rmh
.cmd
[0] |= pipe_cmd
;
1013 chip
->rmh
.cmd
[0] |= MASK_BUFFER_ID
; /* ask for the current buffer: the
1014 * microblaze will seek for it */
1016 err
= lx_message_send_atomic(chip
, &chip
->rmh
);
1019 *r_buffer_size
= chip
->rmh
.stat
[0] & MASK_DATA_SIZE
;
1021 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
1025 int lx_buffer_cancel(struct lx6464es
*chip
, u32 pipe
, int is_capture
,
1029 unsigned long flags
;
1031 u32 pipe_cmd
= PIPE_INFO_TO_CMD(is_capture
, pipe
);
1033 spin_lock_irqsave(&chip
->msg_lock
, flags
);
1034 lx_message_init(&chip
->rmh
, CMD_11_CANCEL_BUFFER
);
1036 chip
->rmh
.cmd
[0] |= pipe_cmd
;
1037 chip
->rmh
.cmd
[0] |= buffer_index
;
1039 err
= lx_message_send_atomic(chip
, &chip
->rmh
);
1041 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
1046 /* low-level gain/peak handling
1048 * \todo: can we unmute capture/playback channels independently?
1051 int lx_level_unmute(struct lx6464es
*chip
, int is_capture
, int unmute
)
1054 unsigned long flags
;
1056 /* bit set to 1: channel muted */
1057 u64 mute_mask
= unmute
? 0 : 0xFFFFFFFFFFFFFFFFLLU
;
1059 spin_lock_irqsave(&chip
->msg_lock
, flags
);
1060 lx_message_init(&chip
->rmh
, CMD_0D_SET_MUTE
);
1062 chip
->rmh
.cmd
[0] |= PIPE_INFO_TO_CMD(is_capture
, 0);
1064 chip
->rmh
.cmd
[1] = (u32
)(mute_mask
>> (u64
)32); /* hi part */
1065 chip
->rmh
.cmd
[2] = (u32
)(mute_mask
& (u64
)0xFFFFFFFF); /* lo part */
1067 snd_printk("mute %x %x %x\n", chip
->rmh
.cmd
[0], chip
->rmh
.cmd
[1],
1070 err
= lx_message_send_atomic(chip
, &chip
->rmh
);
1072 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
1076 static u32 peak_map
[] = {
1077 0x00000109, /* -90.308dB */
1078 0x0000083B, /* -72.247dB */
1079 0x000020C4, /* -60.205dB */
1080 0x00008273, /* -48.030dB */
1081 0x00020756, /* -36.005dB */
1082 0x00040C37, /* -30.001dB */
1083 0x00081385, /* -24.002dB */
1084 0x00101D3F, /* -18.000dB */
1085 0x0016C310, /* -15.000dB */
1086 0x002026F2, /* -12.001dB */
1087 0x002D6A86, /* -9.000dB */
1088 0x004026E6, /* -6.004dB */
1089 0x005A9DF6, /* -3.000dB */
1090 0x0065AC8B, /* -2.000dB */
1091 0x00721481, /* -1.000dB */
1092 0x007FFFFF, /* FS */
1095 int lx_level_peaks(struct lx6464es
*chip
, int is_capture
, int channels
,
1099 unsigned long flags
;
1101 spin_lock_irqsave(&chip
->msg_lock
, flags
);
1103 for (i
= 0; i
< channels
; i
+= 4) {
1106 lx_message_init(&chip
->rmh
, CMD_12_GET_PEAK
);
1107 chip
->rmh
.cmd
[0] |= PIPE_INFO_TO_CMD(is_capture
, i
);
1109 err
= lx_message_send_atomic(chip
, &chip
->rmh
);
1112 s0
= peak_map
[chip
->rmh
.stat
[0] & 0x0F];
1113 s1
= peak_map
[(chip
->rmh
.stat
[0] >> 4) & 0xf];
1114 s2
= peak_map
[(chip
->rmh
.stat
[0] >> 8) & 0xf];
1115 s3
= peak_map
[(chip
->rmh
.stat
[0] >> 12) & 0xf];
1117 s0
= s1
= s2
= s3
= 0;
1127 spin_unlock_irqrestore(&chip
->msg_lock
, flags
);
1131 /* interrupt handling */
1132 #define PCX_IRQ_NONE 0
1133 #define IRQCS_ACTIVE_PCIDB 0x00002000L /* Bit nÃ\83¸ 13 */
1134 #define IRQCS_ENABLE_PCIIRQ 0x00000100L /* Bit nÃ\83¸ 08 */
1135 #define IRQCS_ENABLE_PCIDB 0x00000200L /* Bit nÃ\83¸ 09 */
1137 static u32
lx_interrupt_test_ack(struct lx6464es
*chip
)
1139 u32 irqcs
= lx_plx_reg_read(chip
, ePLX_IRQCS
);
1141 /* Test if PCI Doorbell interrupt is active */
1142 if (irqcs
& IRQCS_ACTIVE_PCIDB
) {
1144 irqcs
= PCX_IRQ_NONE
;
1146 while ((temp
= lx_plx_reg_read(chip
, ePLX_L2PCIDB
))) {
1149 lx_plx_reg_write(chip
, ePLX_L2PCIDB
, temp
);
1154 return PCX_IRQ_NONE
;
1157 static int lx_interrupt_ack(struct lx6464es
*chip
, u32
*r_irqsrc
,
1158 int *r_async_pending
, int *r_async_escmd
)
1161 u32 irqsrc
= lx_interrupt_test_ack(chip
);
1163 if (irqsrc
== PCX_IRQ_NONE
)
1168 irq_async
= irqsrc
& MASK_SYS_ASYNC_EVENTS
; /* + EtherSound response
1169 * (set by xilinx) + EOB */
1171 if (irq_async
& MASK_SYS_STATUS_ESA
) {
1172 irq_async
&= ~MASK_SYS_STATUS_ESA
;
1176 if (irqsrc
& MASK_SYS_STATUS_CMD_DONE
)
1177 /* xilinx command notification */
1178 atomic_set(&chip
->send_message_locked
, 0);
1181 /* snd_printd("interrupt: async event pending\n"); */
1182 *r_async_pending
= 1;
1188 static int lx_interrupt_handle_async_events(struct lx6464es
*chip
, u32 irqsrc
,
1189 int *r_freq_changed
,
1190 u64
*r_notified_in_pipe_mask
,
1191 u64
*r_notified_out_pipe_mask
)
1194 u32 stat
[9]; /* answer from CMD_04_GET_EVENT */
1196 /* On peut optimiser pour ne pas lire les evenements vides
1197 * les mots de rÃ\83©ponse sont dans l'ordre suivant :
1198 * Stat[0] mot de status gÃ\83©nÃ\83©ral
1199 * Stat[1] fin de buffer OUT pF
1200 * Stat[2] fin de buffer OUT pf
1201 * Stat[3] fin de buffer IN pF
1202 * Stat[4] fin de buffer IN pf
1203 * Stat[5] underrun poid fort
1204 * Stat[6] underrun poid faible
1205 * Stat[7] overrun poid fort
1206 * Stat[8] overrun poid faible
1212 int has_underrun
= (irqsrc
& MASK_SYS_STATUS_URUN
) ? 1 : 0;
1213 int has_overrun
= (irqsrc
& MASK_SYS_STATUS_ORUN
) ? 1 : 0;
1215 int eb_pending_out
= (irqsrc
& MASK_SYS_STATUS_EOBO
) ? 1 : 0;
1216 int eb_pending_in
= (irqsrc
& MASK_SYS_STATUS_EOBI
) ? 1 : 0;
1218 *r_freq_changed
= (irqsrc
& MASK_SYS_STATUS_FREQ
) ? 1 : 0;
1220 err
= lx_dsp_read_async_events(chip
, stat
);
1224 if (eb_pending_in
) {
1225 *r_notified_in_pipe_mask
= ((u64
)stat
[3] << 32)
1227 snd_printdd(LXP
"interrupt: EOBI pending %llx\n",
1228 *r_notified_in_pipe_mask
);
1230 if (eb_pending_out
) {
1231 *r_notified_out_pipe_mask
= ((u64
)stat
[1] << 32)
1233 snd_printdd(LXP
"interrupt: EOBO pending %llx\n",
1234 *r_notified_out_pipe_mask
);
1237 orun_mask
= ((u64
)stat
[7] << 32) + stat
[8];
1238 urun_mask
= ((u64
)stat
[5] << 32) + stat
[6];
1240 /* todo: handle xrun notification */
1245 static int lx_interrupt_request_new_buffer(struct lx6464es
*chip
,
1246 struct lx_stream
*lx_stream
)
1248 struct snd_pcm_substream
*substream
= lx_stream
->stream
;
1249 int is_capture
= lx_stream
->is_capture
;
1251 unsigned long flags
;
1253 const u32 channels
= substream
->runtime
->channels
;
1254 const u32 bytes_per_frame
= channels
* 3;
1255 const u32 period_size
= substream
->runtime
->period_size
;
1256 const u32 period_bytes
= period_size
* bytes_per_frame
;
1257 const u32 pos
= lx_stream
->frame_pos
;
1258 const u32 next_pos
= ((pos
+1) == substream
->runtime
->periods
) ?
1261 dma_addr_t buf
= substream
->dma_buffer
.addr
+ pos
* period_bytes
;
1264 u32 buffer_index
= 0;
1267 u32 size_array
[MAX_STREAM_BUFFER
];
1269 snd_printdd("->lx_interrupt_request_new_buffer\n");
1271 spin_lock_irqsave(&chip
->lock
, flags
);
1273 err
= lx_buffer_ask(chip
, 0, is_capture
, &needed
, &freed
, size_array
);
1274 snd_printdd(LXP
"interrupt: needed %d, freed %d\n", needed
, freed
);
1276 unpack_pointer(buf
, &buf_lo
, &buf_hi
);
1277 err
= lx_buffer_give(chip
, 0, is_capture
, period_bytes
, buf_lo
, buf_hi
,
1279 snd_printdd(LXP
"interrupt: gave buffer index %x on %p (%d bytes)\n",
1280 buffer_index
, (void *)buf
, period_bytes
);
1282 lx_stream
->frame_pos
= next_pos
;
1283 spin_unlock_irqrestore(&chip
->lock
, flags
);
1288 void lx_tasklet_playback(unsigned long data
)
1290 struct lx6464es
*chip
= (struct lx6464es
*)data
;
1291 struct lx_stream
*lx_stream
= &chip
->playback_stream
;
1294 snd_printdd("->lx_tasklet_playback\n");
1296 err
= lx_interrupt_request_new_buffer(chip
, lx_stream
);
1298 snd_printk(KERN_ERR LXP
1299 "cannot request new buffer for playback\n");
1301 snd_pcm_period_elapsed(lx_stream
->stream
);
1304 void lx_tasklet_capture(unsigned long data
)
1306 struct lx6464es
*chip
= (struct lx6464es
*)data
;
1307 struct lx_stream
*lx_stream
= &chip
->capture_stream
;
1310 snd_printdd("->lx_tasklet_capture\n");
1311 err
= lx_interrupt_request_new_buffer(chip
, lx_stream
);
1313 snd_printk(KERN_ERR LXP
1314 "cannot request new buffer for capture\n");
1316 snd_pcm_period_elapsed(lx_stream
->stream
);
1321 static int lx_interrupt_handle_audio_transfer(struct lx6464es
*chip
,
1322 u64 notified_in_pipe_mask
,
1323 u64 notified_out_pipe_mask
)
1327 if (notified_in_pipe_mask
) {
1328 snd_printdd(LXP
"requesting audio transfer for capture\n");
1329 tasklet_hi_schedule(&chip
->tasklet_capture
);
1332 if (notified_out_pipe_mask
) {
1333 snd_printdd(LXP
"requesting audio transfer for playback\n");
1334 tasklet_hi_schedule(&chip
->tasklet_playback
);
1341 irqreturn_t
lx_interrupt(int irq
, void *dev_id
)
1343 struct lx6464es
*chip
= dev_id
;
1344 int async_pending
, async_escmd
;
1347 spin_lock(&chip
->lock
);
1349 snd_printdd("**************************************************\n");
1351 if (!lx_interrupt_ack(chip
, &irqsrc
, &async_pending
, &async_escmd
)) {
1352 spin_unlock(&chip
->lock
);
1353 snd_printdd("IRQ_NONE\n");
1354 return IRQ_NONE
; /* this device did not cause the interrupt */
1357 if (irqsrc
& MASK_SYS_STATUS_CMD_DONE
)
1361 if (irqsrc
& MASK_SYS_STATUS_EOBI
)
1362 snd_printdd(LXP
"interrupt: EOBI\n");
1364 if (irqsrc
& MASK_SYS_STATUS_EOBO
)
1365 snd_printdd(LXP
"interrupt: EOBO\n");
1367 if (irqsrc
& MASK_SYS_STATUS_URUN
)
1368 snd_printdd(LXP
"interrupt: URUN\n");
1370 if (irqsrc
& MASK_SYS_STATUS_ORUN
)
1371 snd_printdd(LXP
"interrupt: ORUN\n");
1374 if (async_pending
) {
1375 u64 notified_in_pipe_mask
= 0;
1376 u64 notified_out_pipe_mask
= 0;
1380 /* handle async events */
1381 err
= lx_interrupt_handle_async_events(chip
, irqsrc
,
1383 ¬ified_in_pipe_mask
,
1384 ¬ified_out_pipe_mask
);
1386 snd_printk(KERN_ERR LXP
1387 "error handling async events\n");
1389 err
= lx_interrupt_handle_audio_transfer(chip
,
1390 notified_in_pipe_mask
,
1391 notified_out_pipe_mask
1394 snd_printk(KERN_ERR LXP
1395 "error during audio transfer\n");
1400 /* backdoor for ethersound commands
1402 * for now, we do not need this
1406 snd_printdd("lx6464es: interrupt requests escmd handling\n");
1411 spin_unlock(&chip
->lock
);
1412 return IRQ_HANDLED
; /* this device caused the interrupt */
1416 static void lx_irq_set(struct lx6464es
*chip
, int enable
)
1418 u32 reg
= lx_plx_reg_read(chip
, ePLX_IRQCS
);
1420 /* enable/disable interrupts
1422 * Set the Doorbell and PCI interrupt enable bits
1426 reg
|= (IRQCS_ENABLE_PCIIRQ
| IRQCS_ENABLE_PCIDB
);
1428 reg
&= ~(IRQCS_ENABLE_PCIIRQ
| IRQCS_ENABLE_PCIDB
);
1429 lx_plx_reg_write(chip
, ePLX_IRQCS
, reg
);
1432 void lx_irq_enable(struct lx6464es
*chip
)
1434 snd_printdd("->lx_irq_enable\n");
1435 lx_irq_set(chip
, 1);
1438 void lx_irq_disable(struct lx6464es
*chip
)
1440 snd_printdd("->lx_irq_disable\n");
1441 lx_irq_set(chip
, 0);