- Alsa-devel - mailman.alsa-project.org

[alsa-devel] [PATCH] ALSA: Add support for video out to the jack reporting API
by Jani Nikula 05 Jan '09

05 Jan '09

Add support for reporting new jack types SND_JACK_VIDEOOUT and SND_JACK_AVOUT (a combination of LINEOUT and VIDEOOUT) to the jack reporting API. Also add the corresponding SW_VIDEOOUT_INSERT switch to the input system header. Signed-off-by: Jani Nikula <ext-jani.1.nikula(a)nokia.com> --- include/linux/input.h | 1 + include/sound/jack.h | 2 ++ sound/core/jack.c | 6 ++++++ 3 files changed, 9 insertions(+), 0 deletions(-) diff --git a/include/linux/input.h b/include/linux/input.h index 9a6355f..adc1332 100644 --- a/include/linux/input.h +++ b/include/linux/input.h @@ -661,6 +661,7 @@ struct input_absinfo { #define SW_DOCK 0x05 /* set = plugged into dock */ #define SW_LINEOUT_INSERT 0x06 /* set = inserted */ #define SW_JACK_PHYSICAL_INSERT 0x07 /* set = mechanical switch set */ +#define SW_VIDEOOUT_INSERT 0x08 /* set = inserted */ #define SW_MAX 0x0f #define SW_CNT (SW_MAX+1) diff --git a/include/sound/jack.h b/include/sound/jack.h index 2e0315c..283c975 100644 --- a/include/sound/jack.h +++ b/include/sound/jack.h @@ -37,6 +37,8 @@ enum snd_jack_types { SND_JACK_HEADSET = SND_JACK_HEADPHONE | SND_JACK_MICROPHONE, SND_JACK_LINEOUT = 0x0004, SND_JACK_MECHANICAL = 0x0008, /* If detected separately */ + SND_JACK_VIDEOOUT = 0x0010, + SND_JACK_AVOUT = SND_JACK_LINEOUT | SND_JACK_VIDEOOUT, }; struct snd_jack { diff --git a/sound/core/jack.c b/sound/core/jack.c index dd4a12d..e1de195 100644 --- a/sound/core/jack.c +++ b/sound/core/jack.c @@ -106,6 +106,9 @@ int snd_jack_new(struct snd_card *card, const char *id, int type, if (type & SND_JACK_LINEOUT) input_set_capability(jack->input_dev, EV_SW, SW_LINEOUT_INSERT); + if (type & SND_JACK_VIDEOOUT) + input_set_capability(jack->input_dev, EV_SW, + SW_VIDEOOUT_INSERT); if (type & SND_JACK_MICROPHONE) input_set_capability(jack->input_dev, EV_SW, SW_MICROPHONE_INSERT); @@ -163,6 +166,9 @@ void snd_jack_report(struct snd_jack *jack, int status) if (jack->type & SND_JACK_LINEOUT) input_report_switch(jack->input_dev, SW_LINEOUT_INSERT, status & SND_JACK_LINEOUT); + if (jack->type & SND_JACK_VIDEOOUT) + input_report_switch(jack->input_dev, SW_VIDEOOUT_INSERT, + status & SND_JACK_VIDEOOUT); if (jack->type & SND_JACK_MICROPHONE) input_report_switch(jack->input_dev, SW_MICROPHONE_INSERT, status & SND_JACK_MICROPHONE); -- 1.6.0.4

2 1

[alsa-devel] Crackling instead of Audio
by Calad Sigilon 05 Jan '09

05 Jan '09

Got a bit of an interesting problem that #alsa wasn't able to help me solve - though gnubien did get me through a rigorous amount of debugging! No audio output - just crackling. Using position_fix=1 seemed to work for one boot, but then never worked again. Tried position_fix=1, position_fix=2, mode=vaio, no mode=vaio. No effect. Tried pci=nolapic, pci=noacpi, pci=irqpoll, pci=routeirq on the grub boot line. No effect. Firewire is the only other thing on interrupt 21, and I don't use it. Tried blacklisting all modules so HDA Intel was the only thing on interrupt 21 - no effect. It is filed as Bug #4311, which has the alsa-info attached (https://bugtrack.alsa-project.org/alsa-bug/file_download.php?file_id=2818&t…) -- CaladSigilon

1 0

[alsa-devel] added support for remote in Toshiba SB0500
by Andrea Borgia 05 Jan '09

05 Jan '09

Hello. I have a Toshiba SB-0500 (041e:3048), which is basically a USB hub plus ethernet card plus sound card with remote. As of alsa 1.0.18a / linux 2.6.28 this beast is only partially supported by snd-usb-audio and, most importantly for me, the remote does not work (hub and ethernet are ok). Considering the similarities with the SB 24 Live External and with the Audigy, I tried patching usbmixer.c and usbmixer_maps.c until I got it working with lirc's alsa_usb module. Please note that I didn't test mixer functionality and I have not much interest in that part for my use. What should I do to get my patches reviewed and possibly incorporated into the next version? The changes are rather trivial imho but still this is my first serious attempt at kernel hacking. Thanks for your help, Andrea.

1 0

Re: [alsa-devel] [PATCH 2/2] sound/usb: Use negated usb_endpoint_xfer_control, etc
by Takashi Iwai 04 Jan '09

04 Jan '09

At Sat, 3 Jan 2009 17:54:53 +0100 (CET), Julia Lawall wrote: > > From: Julia Lawall <julia(a)diku.dk> > > This patch extends 42a6e66f1e40a930d093c33ba0bb9d8d8e4555ed by using > usb_endpoint_xfer_control, usb_endpoint_xfer_isoc, usb_endpoint_xfer_bulk, > and usb_endpoint_xfer_int in the negated case as well. > > This patch also rewrites some calls to usb_endpoint_dir_in as negated calls > to !usb_endpoint_dir_out, and vice versa, to better correspond to the > intent of the original code. > > The semantic patch that makes this change is as follows: > (http://www.emn.fr/x-info/coccinelle/) > > // <smpl> > @@ struct usb_endpoint_descriptor *epd; @@ > > - (usb_endpoint_type(epd) != \(USB_ENDPOINT_XFER_CONTROL\|0\)) > + !usb_endpoint_xfer_control(epd) > > @@ struct usb_endpoint_descriptor *epd; @@ > > - (usb_endpoint_type(epd) != \(USB_ENDPOINT_XFER_ISOC\|1\)) > + !usb_endpoint_xfer_isoc(epd) > > @@ struct usb_endpoint_descriptor *epd; @@ > > - (usb_endpoint_type(epd) != \(USB_ENDPOINT_XFER_BULK\|2\)) > + !usb_endpoint_xfer_bulk(epd) > > @@ struct usb_endpoint_descriptor *epd; @@ > > - (usb_endpoint_type(epd) != \(USB_ENDPOINT_XFER_INT\|3\)) > + !usb_endpoint_xfer_int(epd) > // </smpl> > > Signed-off-by: Julia Lawall <julia(a)diku.dk> Applied now. Thanks. Takashi

1 0

[alsa-devel] [PATCH 2/2] New Control Plugin - arcam-av
by Peter Stokes 03 Jan '09

03 Jan '09

Signed-off-by: Peter Stokes <linux(a)dadeos.co.uk> diff -Nrup alsa-plugins-1.0.18-orig/arcam-av/arcam_av.c alsa-plugins-1.0.18/arcam-av/arcam_av.c --- alsa-plugins-1.0.18-orig/arcam-av/arcam_av.c 1970-01-01 01:00:00.000000000 +0100 +++ alsa-plugins-1.0.18/arcam-av/arcam_av.c 2009-01-02 22:30:55.000000000 +0000 @@ -0,0 +1,638 @@ +/* + * ALSA -> Arcam AV control plugin + * + * Copyright (c) 2009 by Peter Stokes <linux(a)dadeos.co.uk> + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include "arcam_av.h" + +#include <errno.h> +#include <fcntl.h> +#include <semaphore.h> +#include <signal.h> +#include <stddef.h> +#include <stdio.h> +#include <termios.h> +#include <unistd.h> + +#include <sys/ipc.h> +#include <sys/shm.h> +#include <sys/stat.h> +#include <sys/stat.h> +#include <sys/socket.h> +#include <sys/un.h> + +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +#define MAX(a, b) ((a) > (b) ? (a) : (b)) + + +int arcam_av_connect(const char* port) +{ + int fd = open(port, O_RDWR | O_NOCTTY); + if (fd < 0) + return -errno; + + struct termios portsettings; + bzero(&portsettings, sizeof(portsettings)); + portsettings.c_cflag = B38400 | CS8 | CLOCAL | CREAD; + portsettings.c_iflag = IGNPAR; + portsettings.c_oflag = 0; + portsettings.c_lflag = 0; + portsettings.c_cc[VTIME] = 0; + portsettings.c_cc[VMIN] = 5; + tcflush(fd, TCIFLUSH); + tcsetattr(fd, TCSANOW, &portsettings); + + return fd; +} + + +int arcam_av_send(int fd, arcam_av_cc_t command, unsigned char param1, unsigned char param2) +{ + char buffer[7] = {'P', 'C', '_', command, param1, param2, 0x0D}; + + tcdrain(fd); + ssize_t bytes = write(fd, buffer, 7); + + if (bytes == 7) + return 0; + else if (bytes >= 0) + return -1; + else + return -errno; +} + + +static int arcam_av_receive(int fd, arcam_av_cc_t* command, unsigned char* param1, unsigned char* param2) +{ + static int index = 0; + static arcam_av_cc_t received_command; + static unsigned char received_param1; + static unsigned char received_param2; + + do { + static char buffer[8]; + ssize_t bytes = read(fd, buffer, sizeof buffer - index); + + if (bytes <= 0) + return -errno; + + char* cursor = buffer; + + while(bytes > 0) { + switch(index++) { + case 0: + if (*cursor != 'A') + index = 0; + break; + + case 1: + if (*cursor != 'V') { + index = 0; + continue; + } + break; + + case 2: + if (*cursor != '_') { + index = 0; + continue; + } + break; + + case 3: + received_command = *cursor; + break; + + case 4: + if (*cursor != ARCAM_AV_OK) { + index = 0; + continue; + } + break; + + case 5: + received_param1 = *cursor; + break; + + case 6: + received_param2 = *cursor; + break; + + case 7: + if (*cursor != 0x0D) { + index = 0; + continue; + } + break; + } + + ++cursor; + --bytes; + } + } while (index < 8); + + index = 0; + *command = received_command; + *param1 = received_param1; + *param2 = received_param2; + + return 0; +} + + +static int arcam_av_update(arcam_av_state_t* state, int fd) +{ + int result = -1; + + arcam_av_cc_t command = 0; + unsigned char param1 = 0; + unsigned char param2 = 0; + + while (!arcam_av_receive(fd, &command, &param1, &param2)) { + switch(command) { + case ARCAM_AV_POWER: + switch(param1) { + case ARCAM_AV_ZONE1: + state->zone1.power = param2; + result = 0; + break; + + case ARCAM_AV_ZONE2: + state->zone2.power = param2; + result = 0; + break; + + default: + break; + } + break; + + case ARCAM_AV_VOLUME_CHANGE: + case ARCAM_AV_VOLUME_SET: + switch(param1) { + case ARCAM_AV_ZONE1: + state->zone1.volume = param2; + result = 0; + break; + + case ARCAM_AV_ZONE2: + state->zone2.volume = param2; + result = 0; + break; + + default: + break; + } + break; + + case ARCAM_AV_MUTE: + switch(param1) { + case ARCAM_AV_ZONE1: + state->zone1.mute = param2; + result = 0; + break; + + case ARCAM_AV_ZONE2: + state->zone2.mute = param2; + result = 0; + break; + + default: + break; + } + break; + + case ARCAM_AV_DIRECT: + switch(param1) { + case ARCAM_AV_ZONE1: + state->zone1.direct = param2; + result = 0; + break; + + default: + break; + } + break; + + case ARCAM_AV_SOURCE: + switch(param1) { + case ARCAM_AV_ZONE1: + state->zone1.source = param2; + result = 0; + break; + + case ARCAM_AV_ZONE2: + state->zone2.source = param2; + result = 0; + break; + + default: + break; + } + break; + + case ARCAM_AV_SOURCE_TYPE: + switch(param1) { + case ARCAM_AV_ZONE1: + state->zone1.source_type = param2; + result = 0; + break; + + default: + break; + } + break; + + case ARCAM_AV_STEREO_DECODE: + switch(param1) { + case ARCAM_AV_ZONE1: + state->zone1.stereo_decode = param2; + result = 0; + break; + + default: + break; + } + break; + + case ARCAM_AV_STEREO_EFFECT: + switch(param1) { + case ARCAM_AV_ZONE1: + state->zone1.stereo_effect = param2; + result = 0; + break; + + default: + break; + } + break; + + case ARCAM_AV_MULTI_DECODE: + switch(param1) { + case ARCAM_AV_ZONE1: + state->zone1.multi_decode = param2; + result = 0; + break; + + default: + break; + } + break; + + default: + break; + } + } + + return result; +} + + +static void arcam_av_state_query(int fd) +{ + arcam_av_send(fd, ARCAM_AV_POWER, ARCAM_AV_ZONE1, ARCAM_AV_POWER_REQUEST); + arcam_av_send(fd, ARCAM_AV_VOLUME_CHANGE, ARCAM_AV_ZONE1, ARCAM_AV_VOLUME_REQUEST); + arcam_av_send(fd, ARCAM_AV_MUTE, ARCAM_AV_ZONE1, ARCAM_AV_MUTE_REQUEST); + arcam_av_send(fd, ARCAM_AV_DIRECT, ARCAM_AV_ZONE1, ARCAM_AV_DIRECT_REQUEST); + arcam_av_send(fd, ARCAM_AV_SOURCE, ARCAM_AV_ZONE1, ARCAM_AV_SOURCE_REQUEST); + arcam_av_send(fd, ARCAM_AV_SOURCE_TYPE, ARCAM_AV_ZONE1, ARCAM_AV_SOURCE_TYPE_REQUEST); + arcam_av_send(fd, ARCAM_AV_STEREO_DECODE, ARCAM_AV_ZONE1, ARCAM_AV_STEREO_DECODE_REQUEST); + arcam_av_send(fd, ARCAM_AV_MULTI_DECODE, ARCAM_AV_ZONE1, ARCAM_AV_MULTI_DECODE_REQUEST); + arcam_av_send(fd, ARCAM_AV_STEREO_EFFECT, ARCAM_AV_ZONE1, ARCAM_AV_STEREO_EFFECT_REQUEST); + + arcam_av_send(fd, ARCAM_AV_POWER, ARCAM_AV_ZONE2, ARCAM_AV_POWER_REQUEST); + arcam_av_send(fd, ARCAM_AV_VOLUME_CHANGE, ARCAM_AV_ZONE2, ARCAM_AV_VOLUME_REQUEST); + arcam_av_send(fd, ARCAM_AV_MUTE, ARCAM_AV_ZONE2, ARCAM_AV_MUTE_REQUEST); + arcam_av_send(fd, ARCAM_AV_SOURCE, ARCAM_AV_ZONE2, ARCAM_AV_SOURCE_REQUEST); +} + + +static int arcam_av_state_shm_id = -1; + +arcam_av_state_t* arcam_av_state_attach(const char* port) +{ + if (arcam_av_state_shm_id < 0) { + struct stat port_stat; + if (stat(port, &port_stat)) + return NULL; + + key_t ipc_key = ftok(port, 'A'); + if (ipc_key < 0) + return NULL; + + int shmflg = IPC_CREAT | (port_stat.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO)); + arcam_av_state_shm_id = shmget(ipc_key, sizeof(arcam_av_state_t), shmflg); + if (arcam_av_state_shm_id < 0) + return NULL; + + struct shmid_ds shm_stat; + if (shmctl(arcam_av_state_shm_id, IPC_STAT, &shm_stat)) + return NULL; + + shm_stat.shm_perm.uid = port_stat.st_uid; + shm_stat.shm_perm.gid = port_stat.st_gid; + shmctl(arcam_av_state_shm_id, IPC_SET, &shm_stat); + } + + arcam_av_state_t* state = shmat(arcam_av_state_shm_id, NULL, 0); + + return (state == (void*)-1) ? NULL : state; +} + + +int arcam_av_state_detach(arcam_av_state_t* state) +{ + if (shmdt(state)) + return -1; + + struct shmid_ds shm_stat; + if (shmctl(arcam_av_state_shm_id, IPC_STAT, &shm_stat)) + return -1; + + if (!shm_stat.shm_nattch) { + shmctl(arcam_av_state_shm_id, IPC_RMID, NULL); + arcam_av_state_shm_id = -1; + } + + return 0; +} + + +static void arcam_av_server_broadcast(fd_set* fds, int fd_max, void* buffer, int bytes) +{ + int fd; + for (fd = 0; fd <= fd_max; ++fd) { + if (FD_ISSET(fd, fds)) { + send(fd, buffer, bytes, 0); + } + } +} + + +static int arcam_av_server_master(int server_fd) +{ + int result = 0; + + struct sockaddr_un server_address; + socklen_t server_address_length = sizeof(server_address) - 1; + if (getsockname(server_fd, (struct sockaddr*) &server_address, &server_address_length)) + return -errno; + + server_address.sun_path[server_address_length - offsetof(struct sockaddr_un, sun_path)] = '\0'; + + const char* port = server_address.sun_path + 1; + + int arcam_fd = arcam_av_connect(port); + + arcam_av_state_t* state = arcam_av_state_attach(port); + if (!state) { + close(arcam_fd); + return -errno; + } + + arcam_av_state_query(arcam_fd); + + fcntl(arcam_fd, F_SETFL, O_NONBLOCK); + + fd_set all_fds, client_fds, read_fds; + + FD_ZERO(&all_fds); + FD_ZERO(&client_fds); + FD_SET(arcam_fd, &all_fds); + FD_SET(server_fd, &all_fds); + int fd, fd_max = MAX(arcam_fd, server_fd); + + for(;;) { + read_fds = all_fds; + + if (select(fd_max + 1, &read_fds, NULL, NULL, NULL) < 0) { + perror("arcam_av_server_master(): select"); + result = -errno; + break; + } + + for(fd = fd_max; fd; --fd) { + if (FD_ISSET(fd, &read_fds)) { + if (fd == arcam_fd) { + if (arcam_av_update(state, arcam_fd)) + continue; + + arcam_av_server_broadcast(&client_fds, fd_max, "", 1); + } else if (fd == server_fd) { + struct sockaddr_un client_address; + socklen_t client_address_length = sizeof(client_address); + int client_fd = accept(server_fd, (struct sockaddr*) &client_address, &client_address_length); + + if (client_fd >= 0) { + FD_SET(client_fd, &all_fds); + FD_SET(client_fd, &client_fds); + fd_max = MAX(fd_max, client_fd); + } else { + perror("arcam_av_server_master(): accept"); + result = -errno; + goto exit; + } + } else { + pthread_t thread; + int bytes = recv(fd, &thread, sizeof(pthread_t), 0); + + if (bytes > 0) { + if (bytes == sizeof(pthread_t)) { + if (thread == pthread_self()) + goto exit; + + arcam_av_server_broadcast(&client_fds, fd_max, &thread, sizeof(pthread_t)); + } + } else { + close(fd); + FD_CLR(fd, &all_fds); + FD_CLR(fd, &client_fds); + fd_max -= (fd_max == fd); + } + } + } + } + } + +exit: + + for (fd = 0; fd <= fd_max; ++fd) { + if (fd != server_fd && FD_ISSET(fd, &all_fds)) { + close(fd); + } + } + + if (state) + arcam_av_state_detach(state); + + return result; +} + + +static int arcam_av_server_slave(int server_fd) +{ + for (;;) { + pthread_t thread; + int bytes = recv(server_fd, &thread, sizeof(pthread_t), 0); + + if (bytes > 0) { + if (bytes == sizeof(pthread_t)) + if (thread == pthread_self()) + return 0; + } else { + break; + } + } + + return -1; +} + + +static void* arcam_av_server_thread(void* context) +{ + sem_t* semaphore = context; + const char* port = *(const char**)(semaphore + 1); + + struct sockaddr_un address; + address.sun_family = AF_FILE; + address.sun_path[0] = '\0'; + strncpy(&address.sun_path[1], port, sizeof(address.sun_path) - 1); + int size = offsetof(struct sockaddr_un, sun_path) + + MIN(strlen(port) + 1, sizeof(address.sun_path)); + + signal(SIGPIPE, SIG_IGN); + + int quit = 0; + + while (!quit) { + int server_fd = socket(PF_UNIX, SOCK_STREAM, 0); + if (server_fd < 0) { + perror("arcam_av_server_thread(): socket"); + break; + } + + if (!bind(server_fd, (struct sockaddr*) &address, size)) { + if (!listen(server_fd, 10)) { + if (semaphore) { + sem_post(semaphore); + semaphore = NULL; + } + arcam_av_server_master(server_fd); + } else { + perror("arcam_av_server_master(): listen"); + } + quit = 1; + } else if (errno != EADDRINUSE) { + perror("arcam_av_server_thread(): bind"); + quit = 1; + } else if (!connect(server_fd, (struct sockaddr*) &address, size)) { + if (semaphore) { + sem_post(semaphore); + semaphore = NULL; + } + quit = !arcam_av_server_slave(server_fd); + } else { + perror("arcam_av_server_thread(): connect"); + quit = 1; + } + + close(server_fd); + } + + if (semaphore) + sem_post(semaphore); + + return NULL; +} + + +int arcam_av_server_start(pthread_t* thread, const char* port) +{ + struct { + sem_t semaphore; + const char* port; + } context; + + int result = 0; + + if (sem_init(&context.semaphore, 0, 0)) + return -1; + + context.port = port; + + if (pthread_create(thread, NULL, arcam_av_server_thread, &context)) + result = -1; + else + sem_wait(&context.semaphore); + + sem_destroy(&context.semaphore); + + return result; +} + + +int arcam_av_server_stop(pthread_t thread, const char* port) +{ + int client_fd = arcam_av_client(port); + if (client_fd < 0) + return -1; + + if (send(client_fd, &thread, sizeof(pthread_t), 0) > 0) + pthread_join(thread, NULL); + + close(client_fd); + return 0; +} + + +int arcam_av_client(const char* port) +{ + int client_fd = socket(PF_UNIX, SOCK_STREAM, 0); + if (client_fd < 0) + return -1; + + struct sockaddr_un address; + address.sun_family = AF_FILE; + address.sun_path[0] = '\0'; + strncpy(&address.sun_path[1], port, sizeof(address.sun_path) - 1); + int size = offsetof(struct sockaddr_un, sun_path) + + MIN(strlen(port) + 1, sizeof(address.sun_path)); + + const int max_retries = 5; + int retries = max_retries; + + do { + if (!connect(client_fd, (struct sockaddr*) &address, size)) + return client_fd; + + if (!retries--) + break; + + struct timeval sleep = {0, 10 * (max_retries - retries)}; + + select(0, NULL, NULL, NULL, &sleep); + + } while (errno == ECONNREFUSED); + + perror("arcam_av_client(): connect"); + + close(client_fd); + return -1; +} + diff -Nrup alsa-plugins-1.0.18-orig/arcam-av/arcam_av.h alsa-plugins-1.0.18/arcam-av/arcam_av.h --- alsa-plugins-1.0.18-orig/arcam-av/arcam_av.h 1970-01-01 01:00:00.000000000 +0100 +++ alsa-plugins-1.0.18/arcam-av/arcam_av.h 2009-01-02 22:30:58.000000000 +0000 @@ -0,0 +1,161 @@ +/* + * ALSA -> Arcam AV control plugin + * + * Copyright (c) 2009 by Peter Stokes <linux(a)dadeos.co.uk> + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include <pthread.h> + +typedef enum { + ARCAM_AV_ZONE1 = '1', + ARCAM_AV_ZONE2 = '2' +} arcam_av_zone_t; + + +typedef enum { + ARCAM_AV_POWER = '*', + ARCAM_AV_VOLUME_CHANGE = '/', + ARCAM_AV_VOLUME_SET = '0', + ARCAM_AV_MUTE = '.', + ARCAM_AV_SOURCE = '1', + ARCAM_AV_SOURCE_TYPE = '7', + ARCAM_AV_DIRECT = '3', + ARCAM_AV_STEREO_DECODE = '4', + ARCAM_AV_MULTI_DECODE = '5', + ARCAM_AV_STEREO_EFFECT = '6' +} arcam_av_cc_t; + + +typedef enum { + ARCAM_AV_OK = 'P', + ARCAM_AV_ERROR = 'R' +} arcam_av_rc_t; + + +typedef enum { + ARCAM_AV_POWER_STAND_BY = '0', + ARCAM_AV_POWER_ON = '1', + ARCAM_AV_POWER_REQUEST = '9' +} arcam_av_power_t; + + +typedef enum { + ARCAM_AV_VOLUME_MIN = '0', + ARCAM_AV_VOLUME_REQUEST = '9' +} arcam_av_volume_t; + + +typedef enum { + ARCAM_AV_MUTE_ON = '0', + ARCAM_AV_MUTE_OFF = '1', + ARCAM_AV_MUTE_REQUEST = '9' +} arcam_av_mute_t; + + +typedef enum { + ARCAM_AV_DIRECT_DISABLE = '0', + ARCAM_AV_DIRECT_ENABLE = '1', + ARCAM_AV_DIRECT_REQUEST = '9' +} arcam_av_direct_t; + + +typedef enum { + ARCAM_AV_SOURCE_DVD = '0', + ARCAM_AV_SOURCE_SAT = '1', + ARCAM_AV_SOURCE_AV = '2', + ARCAM_AV_SOURCE_PVR = '3', + ARCAM_AV_SOURCE_VCR = '4', + ARCAM_AV_SOURCE_CD = '5', + ARCAM_AV_SOURCE_FM = '6', + ARCAM_AV_SOURCE_AM = '7', + ARCAM_AV_SOURCE_DVDA = '8', + ARCAM_AV_SOURCE_REQUEST = '9' +} arcam_av_source_t; + + +typedef enum { + ARCAM_AV_SOURCE_TYPE_ANALOGUE = '0', + ARCAM_AV_SOURCE_TYPE_DIGITAL = '1', + ARCAM_AV_SOURCE_TYPE_REQUEST = '9' +} arcam_av_source_type_t; + + +typedef enum { + ARCAM_AV_STEREO_DECODE_MONO = '.', + ARCAM_AV_STEREO_DECODE_STEREO = '/', + ARCAM_AV_STEREO_DECODE_PLII_MOVIE = '0', + ARCAM_AV_STEREO_DECODE_PLII_MUSIC = '1', + ARCAM_AV_STEREO_DECODE_PLIIx_MOVIE = '3', + ARCAM_AV_STEREO_DECODE_PLIIx_MUSIC = '4', + ARCAM_AV_STEREO_DECODE_DOLBY_PL = '6', + ARCAM_AV_STEREO_DECODE_NEO6_CINEMA = '7', + ARCAM_AV_STEREO_DECODE_NEO6_MUSIC = '8', + ARCAM_AV_STEREO_DECODE_REQUEST = '9' +} arcam_av_stereo_decode_t; + + +typedef enum { + ARCAM_AV_MULTI_DECODE_MONO = '.', + ARCAM_AV_MULTI_DECODE_STEREO = '/', + ARCAM_AV_MULTI_DECODE_MULTI_CHANNEL = '0', + ARCAM_AV_MULTI_DECODE_PLIIx = '2', + ARCAM_AV_MULTI_DECODE_REQUEST = '9' +} arcam_av_multi_decode_t; + + +typedef enum { + ARCAM_AV_STEREO_EFFECT_NONE = '0', + ARCAM_AV_STEREO_EFFECT_MUSIC = '1', + ARCAM_AV_STEREO_EFFECT_PARTY = '2', + ARCAM_AV_STEREO_EFFECT_CLUB = '3', + ARCAM_AV_STEREO_EFFECT_HALL = '4', + ARCAM_AV_STEREO_EFFECT_SPORTS = '5', + ARCAM_AV_STEREO_EFFECT_CHURCH = '6', + ARCAM_AV_STEREO_EFFECT_REQUEST = '9' +} arcam_av_stereo_effect_t; + +int arcam_av_connect(const char* port); +int arcam_av_send(int fd, arcam_av_cc_t command, unsigned char param1, unsigned char param2); + + +typedef struct arcam_av_state { + struct { + arcam_av_power_t power; + unsigned char volume; + arcam_av_mute_t mute; + arcam_av_direct_t direct; + arcam_av_source_t source; + arcam_av_source_type_t source_type; + arcam_av_stereo_decode_t stereo_decode; + arcam_av_stereo_effect_t stereo_effect; + arcam_av_multi_decode_t multi_decode; + } zone1; + struct { + arcam_av_power_t power; + unsigned char volume; + arcam_av_mute_t mute; + arcam_av_source_t source; + } zone2; +} arcam_av_state_t; + +arcam_av_state_t* arcam_av_state_attach(const char* port); +int arcam_av_state_detach(arcam_av_state_t* state); + +int arcam_av_server_start(pthread_t* thread, const char* port); +int arcam_av_server_stop(pthread_t thread, const char* port); + +int arcam_av_client(const char* port); diff -Nrup alsa-plugins-1.0.18-orig/arcam-av/ctl_arcam_av.c alsa-plugins-1.0.18/arcam-av/ctl_arcam_av.c --- alsa-plugins-1.0.18-orig/arcam-av/ctl_arcam_av.c 1970-01-01 01:00:00.000000000 +0100 +++ alsa-plugins-1.0.18/arcam-av/ctl_arcam_av.c 2009-01-02 22:30:55.000000000 +0000 @@ -0,0 +1,1024 @@ +/* + * ALSA -> Arcam AV control plugin + * + * Copyright (c) 2009 by Peter Stokes <linux(a)dadeos.co.uk> + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include <sys/socket.h> +#include <alsa/asoundlib.h> +#include <alsa/control_external.h> + +#include "arcam_av.h" + + +#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +#define MID(a, b, c) ((a) < (b) ? ((b) < (c) ? (b) : ((a) < (c) ? (c) : (a))) \ + : ((b) > (c) ? (b) : ((a) > (c) ? (c) : (a)))) + + +static const char* arcam_av_name = "Arcam AV"; +static const char* arcam_av_power_name = "Power Switch"; +static const char* arcam_av_volume_name = "Master Playback Volume"; +static const char* arcam_av_mute_name = "Master Playback Switch"; +static const char* arcam_av_direct_name = "Direct Playback Switch"; +static const char* arcam_av_source_name = "Source Playback Route"; +static const char* arcam_av_source_type_name = "Source Type Playback Route"; +static const char* arcam_av_stereo_decode_name = "Stereo Decode Playback Route"; +static const char* arcam_av_multi_decode_name = "Multi-Channel Decode Playback Route"; +static const char* arcam_av_stereo_effect_name = "Stereo Effect Playback Route"; + +static const struct { + arcam_av_source_t code; + const char* name; +} arcam_av_sources[] = { + {ARCAM_AV_SOURCE_DVD, "DVD" }, + {ARCAM_AV_SOURCE_SAT, "SAT" }, + {ARCAM_AV_SOURCE_AV, "AV" }, + {ARCAM_AV_SOURCE_PVR, "PVR" }, + {ARCAM_AV_SOURCE_VCR, "VCR" }, + {ARCAM_AV_SOURCE_CD, "CD" }, + {ARCAM_AV_SOURCE_FM, "FM" }, + {ARCAM_AV_SOURCE_AM, "AM" }, + {ARCAM_AV_SOURCE_DVDA, "DVDA" } +}; + +static const struct { + arcam_av_source_type_t code; + const char* name; +} arcam_av_source_types[] = { + {ARCAM_AV_SOURCE_TYPE_ANALOGUE, "Analogue" }, + {ARCAM_AV_SOURCE_TYPE_DIGITAL, "Digital" } +}; + +static const struct { + arcam_av_direct_t code; + const char* name; +} arcam_av_direct[] = { + {ARCAM_AV_DIRECT_DISABLE, "Disable" }, + {ARCAM_AV_DIRECT_ENABLE, "Enable" } +}; + +static const struct { + arcam_av_stereo_decode_t code; + const char* name; +} arcam_av_stereo_decode_modes[] = { + {ARCAM_AV_STEREO_DECODE_MONO, "Mono" }, + {ARCAM_AV_STEREO_DECODE_STEREO, "Stereo" }, + {ARCAM_AV_STEREO_DECODE_PLII_MOVIE, "Pro Logic II Movie" }, + {ARCAM_AV_STEREO_DECODE_PLII_MUSIC, "Pro Logic II Music" }, + {ARCAM_AV_STEREO_DECODE_PLIIx_MOVIE, "Pro Logic IIx Movie" }, + {ARCAM_AV_STEREO_DECODE_PLIIx_MUSIC, "Pro Logic IIx Music" }, + {ARCAM_AV_STEREO_DECODE_DOLBY_PL, "Dolby Pro Logic" }, + {ARCAM_AV_STEREO_DECODE_NEO6_CINEMA, "Neo:6 Cinema" }, + {ARCAM_AV_STEREO_DECODE_NEO6_MUSIC, "Neo:6 Music" } +}; + +static const struct { + arcam_av_multi_decode_t code; + const char* name; +} arcam_av_multi_decode_modes[] = { + {ARCAM_AV_MULTI_DECODE_MONO, "Mono down-mix" }, + {ARCAM_AV_MULTI_DECODE_STEREO, "Stereo down-mix" }, + {ARCAM_AV_MULTI_DECODE_MULTI_CHANNEL, "Multi-channel" }, + {ARCAM_AV_MULTI_DECODE_PLIIx, "Pro Logic IIx" } +}; + +static const struct { + arcam_av_stereo_effect_t code; + const char* name; +} arcam_av_stereo_effects[] = { + {ARCAM_AV_STEREO_EFFECT_NONE, "None" }, + {ARCAM_AV_STEREO_EFFECT_MUSIC, "Music" }, + {ARCAM_AV_STEREO_EFFECT_PARTY, "Party" }, + {ARCAM_AV_STEREO_EFFECT_CLUB, "Club" }, + {ARCAM_AV_STEREO_EFFECT_HALL, "Hall" }, + {ARCAM_AV_STEREO_EFFECT_SPORTS, "Sports" }, + {ARCAM_AV_STEREO_EFFECT_CHURCH, "Church" } +}; + + +typedef struct snd_ctl_arcam_av { + snd_ctl_ext_t ext; + int port_fd; + int shm_id; + const char* port; + arcam_av_zone_t zone; + arcam_av_state_t local; + arcam_av_state_t* global; + pthread_t server; +} snd_ctl_arcam_av_t; + +static void arcam_av_close(snd_ctl_ext_t *ext) +{ + snd_ctl_arcam_av_t *arcam_av = ext->private_data; + + if (arcam_av->port_fd >= 0) + close(arcam_av->port_fd); + + if (arcam_av->global) + arcam_av_state_detach(arcam_av->global); + + if (arcam_av->ext.poll_fd >= 0) { + close(arcam_av->ext.poll_fd); + arcam_av_server_stop(arcam_av->server, arcam_av->port); + } + + free(arcam_av); +} + +static int arcam_av_elem_count(snd_ctl_ext_t *ext) +{ + snd_ctl_arcam_av_t *arcam_av = ext->private_data; + + return arcam_av->zone == ARCAM_AV_ZONE1 ? 9 : 4; +} + +static int arcam_av_elem_list(snd_ctl_ext_t *ext, unsigned int offset, snd_ctl_elem_id_t *id) +{ + snd_ctl_arcam_av_t *arcam_av = ext->private_data; + + snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER); + + if (arcam_av->zone == ARCAM_AV_ZONE1) { + switch(offset) { + case 0: + snd_ctl_elem_id_set_name(id, arcam_av_power_name); + break; + + case 1: + snd_ctl_elem_id_set_name(id, arcam_av_volume_name); + break; + + case 2: + snd_ctl_elem_id_set_name(id, arcam_av_mute_name); + break; + + case 3: + snd_ctl_elem_id_set_name(id, arcam_av_direct_name); + break; + + case 4: + snd_ctl_elem_id_set_name(id, arcam_av_source_name); + break; + + case 5: + snd_ctl_elem_id_set_name(id, arcam_av_source_type_name); + break; + + case 6: + snd_ctl_elem_id_set_name(id, arcam_av_stereo_decode_name); + break; + + case 7: + snd_ctl_elem_id_set_name(id, arcam_av_multi_decode_name); + break; + + case 8: + snd_ctl_elem_id_set_name(id, arcam_av_stereo_effect_name); + break; + } + } else { + switch(offset) { + case 0: + snd_ctl_elem_id_set_name(id, arcam_av_power_name); + break; + + case 1: + snd_ctl_elem_id_set_name(id, arcam_av_volume_name); + break; + + case 2: + snd_ctl_elem_id_set_name(id, arcam_av_mute_name); + break; + + case 3: + snd_ctl_elem_id_set_name(id, arcam_av_source_name); + break; + } + } + + return 0; +} + +static snd_ctl_ext_key_t arcam_av_find_elem(snd_ctl_ext_t *ext ATTRIBUTE_UNUSED, + const snd_ctl_elem_id_t *id) +{ + const char *name; + + name = snd_ctl_elem_id_get_name(id); + if (!strcmp(name, arcam_av_power_name)) { + return ARCAM_AV_POWER; + } else if (!strcmp(name, arcam_av_volume_name)) { + return ARCAM_AV_VOLUME_SET; + } else if (!strcmp(name, arcam_av_mute_name)) { + return ARCAM_AV_MUTE; + } else if (!strcmp(name, arcam_av_direct_name)) { + return ARCAM_AV_DIRECT; + } else if (!strcmp(name, arcam_av_source_name)) { + return ARCAM_AV_SOURCE; + } else if (!strcmp(name, arcam_av_source_type_name)) { + return ARCAM_AV_SOURCE_TYPE; + } else if (!strcmp(name, arcam_av_stereo_decode_name)) { + return ARCAM_AV_STEREO_DECODE; + } else if (!strcmp(name, arcam_av_multi_decode_name)) { + return ARCAM_AV_MULTI_DECODE; + } else if (!strcmp(name, arcam_av_stereo_effect_name)) { + return ARCAM_AV_STEREO_EFFECT; + } + + return SND_CTL_EXT_KEY_NOT_FOUND; +} + +static int arcam_av_get_attribute(snd_ctl_ext_t *ext ATTRIBUTE_UNUSED, + snd_ctl_ext_key_t key, int *type, + unsigned int *acc, unsigned int *count) +{ + switch(key) { + case ARCAM_AV_POWER: + *type = SND_CTL_ELEM_TYPE_BOOLEAN; + *acc = SND_CTL_EXT_ACCESS_READWRITE; + *count = 1; + break; + + case ARCAM_AV_VOLUME_SET: + *type = SND_CTL_ELEM_TYPE_INTEGER; + *acc = SND_CTL_EXT_ACCESS_READWRITE; + *count = 1; + break; + + case ARCAM_AV_MUTE: + *type = SND_CTL_ELEM_TYPE_BOOLEAN; + *acc = SND_CTL_EXT_ACCESS_READWRITE; + *count = 1; + break; + + case ARCAM_AV_DIRECT: + *type = SND_CTL_ELEM_TYPE_ENUMERATED; + *acc = SND_CTL_EXT_ACCESS_READWRITE; + *count = 1; + break; + + case ARCAM_AV_SOURCE: + *type = SND_CTL_ELEM_TYPE_ENUMERATED; + *acc = SND_CTL_EXT_ACCESS_READWRITE; + *count = 1; + break; + + case ARCAM_AV_SOURCE_TYPE: + *type = SND_CTL_ELEM_TYPE_ENUMERATED; + *acc = SND_CTL_EXT_ACCESS_READWRITE; + *count = 1; + break; + + case ARCAM_AV_STEREO_DECODE: + *type = SND_CTL_ELEM_TYPE_ENUMERATED; + *acc = SND_CTL_EXT_ACCESS_READWRITE; + *count = 1; + break; + + case ARCAM_AV_MULTI_DECODE: + *type = SND_CTL_ELEM_TYPE_ENUMERATED; + *acc = SND_CTL_EXT_ACCESS_READWRITE; + *count = 1; + break; + + case ARCAM_AV_STEREO_EFFECT: + *type = SND_CTL_ELEM_TYPE_ENUMERATED; + *acc = SND_CTL_EXT_ACCESS_READWRITE; + *count = 1; + break; + + default: + return -EINVAL; + } + + return 0; +} + +static int arcam_av_get_integer_info(snd_ctl_ext_t *ext, + snd_ctl_ext_key_t key, + long *imin, long *imax, long *istep) +{ + snd_ctl_arcam_av_t *arcam_av = ext->private_data; + + switch(key) { + case ARCAM_AV_VOLUME_SET: + *istep = 1; + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + *imin = 0; + *imax = 100; + break; + + case ARCAM_AV_ZONE2: + *imin = 20; + *imax = 83; + break; + } + break; + + default: + return -EINVAL; + } + + return 0; +} + +static int arcam_av_get_enumerated_info(snd_ctl_ext_t *ext ATTRIBUTE_UNUSED, + snd_ctl_ext_key_t key, + unsigned int *items) +{ + switch(key) { + case ARCAM_AV_SOURCE: + *items = ARRAY_SIZE(arcam_av_sources); + break; + + case ARCAM_AV_SOURCE_TYPE: + *items = ARRAY_SIZE(arcam_av_source_types); + break; + + case ARCAM_AV_DIRECT: + *items = ARRAY_SIZE(arcam_av_direct); + break; + + case ARCAM_AV_STEREO_DECODE: + *items = ARRAY_SIZE(arcam_av_stereo_decode_modes); + break; + + case ARCAM_AV_MULTI_DECODE: + *items = ARRAY_SIZE(arcam_av_multi_decode_modes); + break; + + case ARCAM_AV_STEREO_EFFECT: + *items = ARRAY_SIZE(arcam_av_stereo_effects); + break; + + default: + return -EINVAL; + } + + return 0; +} + +static int arcam_av_get_enumerated_name(snd_ctl_ext_t *ext ATTRIBUTE_UNUSED, + snd_ctl_ext_key_t key, + unsigned int item, char *name, + size_t name_max_len) +{ + const char* label; + + switch(key) { + case ARCAM_AV_SOURCE: + if (item >= ARRAY_SIZE(arcam_av_sources)) + return -EINVAL; + + label = arcam_av_sources[item].name; + break; + + case ARCAM_AV_SOURCE_TYPE: + if (item >= ARRAY_SIZE(arcam_av_source_types)) + return -EINVAL; + + label = arcam_av_source_types[item].name; + break; + + case ARCAM_AV_DIRECT: + if (item >= ARRAY_SIZE(arcam_av_direct)) + return -EINVAL; + + label = arcam_av_direct[item].name; + break; + + case ARCAM_AV_STEREO_DECODE: + if (item >= ARRAY_SIZE(arcam_av_stereo_decode_modes)) + return -EINVAL; + + label = arcam_av_stereo_decode_modes[item].name; + break; + + case ARCAM_AV_MULTI_DECODE: + if (item >= ARRAY_SIZE(arcam_av_multi_decode_modes)) + return -EINVAL; + + label = arcam_av_multi_decode_modes[item].name; + break; + + case ARCAM_AV_STEREO_EFFECT: + if (item >= ARRAY_SIZE(arcam_av_stereo_effects)) + return -EINVAL; + + label = arcam_av_stereo_effects[item].name; + break; + + default: + return -EINVAL; + } + + strncpy(name, label, name_max_len - 1); + name[name_max_len - 1] = '\0'; + + return 0; +} + +static int arcam_av_read_integer(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, long *value) +{ + snd_ctl_arcam_av_t *arcam_av = ext->private_data; + + switch(key) { + case ARCAM_AV_POWER: + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.power = arcam_av->global->zone1.power; + *value = !(arcam_av->local.zone1.power == ARCAM_AV_POWER_STAND_BY); + break; + + case ARCAM_AV_ZONE2: + arcam_av->local.zone2.power = arcam_av->global->zone2.power; + *value = !(arcam_av->local.zone2.power == ARCAM_AV_POWER_STAND_BY); + break; + } + break; + + case ARCAM_AV_VOLUME_SET: + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.volume = arcam_av->global->zone1.volume; + *value = MID(0, arcam_av->local.zone1.volume - ARCAM_AV_VOLUME_MIN, 100); + break; + + case ARCAM_AV_ZONE2: + arcam_av->local.zone2.volume = arcam_av->global->zone2.volume; + *value = MID(20, arcam_av->local.zone2.volume - ARCAM_AV_VOLUME_MIN, 83); + break; + } + break; + + case ARCAM_AV_MUTE: + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.mute = arcam_av->global->zone1.mute; + *value = !(arcam_av->local.zone1.mute == ARCAM_AV_MUTE_ON); + break; + + case ARCAM_AV_ZONE2: + arcam_av->local.zone2.mute = arcam_av->global->zone2.mute; + *value = !(arcam_av->local.zone2.mute == ARCAM_AV_MUTE_ON); + break; + } + break; + + default: + return -EINVAL; + } + + return 0; +} + +static int arcam_av_read_enumerated(snd_ctl_ext_t *ext, + snd_ctl_ext_key_t key, + unsigned int *item) +{ + snd_ctl_arcam_av_t *arcam_av = ext->private_data; + unsigned int i; + + switch(key) { + case ARCAM_AV_SOURCE: + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.source = arcam_av->global->zone1.source; + for (i = 0; i < ARRAY_SIZE(arcam_av_sources); ++i) { + if (arcam_av_sources[i].code == arcam_av->local.zone1.source) { + *item = i; + break; + } + } + break; + + case ARCAM_AV_ZONE2: + arcam_av->local.zone2.source = arcam_av->global->zone2.source; + for (i = 0; i < ARRAY_SIZE(arcam_av_sources); ++i) { + if (arcam_av_sources[i].code == arcam_av->local.zone2.source) { + *item = i; + break; + } + } + break; + } + break; + + case ARCAM_AV_SOURCE_TYPE: + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.source_type = arcam_av->global->zone1.source_type; + for (i = 0; i < ARRAY_SIZE(arcam_av_source_types); ++i) { + if (arcam_av_source_types[i].code == arcam_av->local.zone1.source_type) { + *item = i; + break; + } + } + break; + + case ARCAM_AV_ZONE2: + return -EINVAL; + } + break; + + case ARCAM_AV_DIRECT: + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.direct = arcam_av->global->zone1.direct; + for (i = 0; i < ARRAY_SIZE(arcam_av_direct); ++i) { + if (arcam_av_direct[i].code == arcam_av->local.zone1.direct) { + *item = i; + break; + } + } + break; + + case ARCAM_AV_ZONE2: + return -EINVAL; + } + break; + + case ARCAM_AV_STEREO_DECODE: + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.stereo_decode = arcam_av->global->zone1.stereo_decode; + for (i = 0; i < ARRAY_SIZE(arcam_av_stereo_decode_modes); ++i) { + if (arcam_av_stereo_decode_modes[i].code == arcam_av->local.zone1.stereo_decode) { + *item = i; + break; + } + } + break; + + case ARCAM_AV_ZONE2: + return -EINVAL; + } + break; + + case ARCAM_AV_STEREO_EFFECT: + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.stereo_effect = arcam_av->global->zone1.stereo_effect; + for (i = 0; i < ARRAY_SIZE(arcam_av_stereo_effects); ++i) { + if (arcam_av_stereo_effects[i].code == arcam_av->local.zone1.stereo_effect) { + *item = i; + break; + } + } + break; + + case ARCAM_AV_ZONE2: + return -EINVAL; + } + break; + + case ARCAM_AV_MULTI_DECODE: + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.multi_decode = arcam_av->global->zone1.multi_decode; + for (i = 0; i < ARRAY_SIZE(arcam_av_multi_decode_modes); ++i) { + if (arcam_av_multi_decode_modes[i].code == arcam_av->local.zone1.multi_decode) { + *item = i; + break; + } + } + break; + + case ARCAM_AV_ZONE2: + return -EINVAL; + } + break; + + default: + return -EINVAL; + } + + return 0; +} + +static int arcam_av_write_integer(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, long *value) +{ + snd_ctl_arcam_av_t *arcam_av = ext->private_data; + unsigned char volume = ARCAM_AV_VOLUME_MIN; + + switch(key) { + case ARCAM_AV_POWER: + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.power = ARCAM_AV_POWER_STAND_BY + *value; + if (arcam_av->global->zone1.power == arcam_av->local.zone1.power) + return 0; + break; + + case ARCAM_AV_ZONE2: + arcam_av->local.zone2.power = ARCAM_AV_POWER_STAND_BY + *value; + if (arcam_av->global->zone2.power == arcam_av->local.zone2.power) + return 0; + break; + } + break; + + case ARCAM_AV_VOLUME_SET: + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.volume = ARCAM_AV_VOLUME_MIN + *value; + if (arcam_av->global->zone1.volume == arcam_av->local.zone1.volume) + return 0; + + if (arcam_av->global->zone1.mute == ARCAM_AV_MUTE_ON) { + arcam_av->global->zone1.volume = arcam_av->local.zone1.volume; + return 1; + } + break; + + case ARCAM_AV_ZONE2: + arcam_av->local.zone2.volume = ARCAM_AV_VOLUME_MIN + *value; + if (arcam_av->global->zone2.volume == arcam_av->local.zone2.volume) + return 0; + + if (arcam_av->global->zone2.mute == ARCAM_AV_MUTE_ON) { + arcam_av->global->zone2.volume = arcam_av->local.zone2.volume; + return 1; + } + break; + } + break; + + case ARCAM_AV_MUTE: + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.mute = ARCAM_AV_MUTE_ON + *value; + if (arcam_av->global->zone1.mute == arcam_av->local.zone1.mute) + return 0; + + volume = arcam_av->global->zone1.volume; + break; + + case ARCAM_AV_ZONE2: + arcam_av->local.zone2.mute = ARCAM_AV_MUTE_ON + *value; + if (arcam_av->global->zone2.mute == arcam_av->local.zone2.mute) + return 0; + + volume = arcam_av->global->zone2.volume; + break; + } + + if (*value) + arcam_av_send(arcam_av->port_fd, ARCAM_AV_VOLUME_SET, arcam_av->zone, volume); + break; + + default: + return -EINVAL; + } + + if (!arcam_av_send(arcam_av->port_fd, key, arcam_av->zone, '0' + *value)) + return 1; + else + return -1; +} + +static int arcam_av_write_enumerated(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, unsigned int *item) +{ + snd_ctl_arcam_av_t *arcam_av = ext->private_data; + + char code; + + switch(key) { + case ARCAM_AV_SOURCE: + if (*item >= ARRAY_SIZE(arcam_av_sources)) + return -EINVAL; + + code = arcam_av_sources[*item].code; + + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.source = code; + if (arcam_av->global->zone1.source == code) + return 0; + break; + + case ARCAM_AV_ZONE2: + arcam_av->local.zone2.source = code; + if (arcam_av->global->zone2.source == code) + return 0; + break; + } + break; + + case ARCAM_AV_SOURCE_TYPE: + if (*item >= ARRAY_SIZE(arcam_av_source_types)) + return -EINVAL; + + code = arcam_av_source_types[*item].code; + + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.source_type = code; + if (arcam_av->global->zone1.source_type == code) + return 0; + break; + + case ARCAM_AV_ZONE2: + return -EINVAL; + } + break; + + case ARCAM_AV_DIRECT: + if (*item >= ARRAY_SIZE(arcam_av_direct)) + return -EINVAL; + + code = arcam_av_direct[*item].code; + + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.direct = code; + if (arcam_av->global->zone1.direct == code) + return 0; + break; + + case ARCAM_AV_ZONE2: + return -EINVAL; + } + break; + + case ARCAM_AV_STEREO_DECODE: + if (*item >= ARRAY_SIZE(arcam_av_stereo_decode_modes)) + return -EINVAL; + + code = arcam_av_stereo_decode_modes[*item].code; + + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.stereo_decode = code; + if (arcam_av->global->zone1.stereo_decode == code) + return 0; + break; + + case ARCAM_AV_ZONE2: + return -EINVAL; + } + break; + + case ARCAM_AV_STEREO_EFFECT: + if (*item >= ARRAY_SIZE(arcam_av_stereo_effects)) + return -EINVAL; + + code = arcam_av_stereo_effects[*item].code; + + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.stereo_effect = code; + if (arcam_av->global->zone1.stereo_effect == code) + return 0; + break; + + case ARCAM_AV_ZONE2: + return -EINVAL; + } + break; + + case ARCAM_AV_MULTI_DECODE: + if (*item >= ARRAY_SIZE(arcam_av_multi_decode_modes)) + return -EINVAL; + + code = arcam_av_multi_decode_modes[*item].code; + + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + arcam_av->local.zone1.multi_decode = code; + if (arcam_av->global->zone1.multi_decode == code) + return 0; + break; + + case ARCAM_AV_ZONE2: + return -EINVAL; + } + break; + + default: + return -EINVAL; + } + + if (!arcam_av_send(arcam_av->port_fd, key, arcam_av->zone, code)) + return 1; + else + return -1; +} + + +static int arcam_av_read_event(snd_ctl_ext_t *ext, snd_ctl_elem_id_t *id, unsigned int *event_mask) +{ + snd_ctl_arcam_av_t *arcam_av = ext->private_data; + + switch(arcam_av->zone) { + case ARCAM_AV_ZONE1: + if (arcam_av->local.zone1.power != arcam_av->global->zone1.power) { + snd_ctl_elem_id_set_name(id, arcam_av_power_name); + arcam_av->local.zone1.power = arcam_av->global->zone1.power; + } else if (arcam_av->local.zone1.volume != arcam_av->global->zone1.volume) { + snd_ctl_elem_id_set_name(id, arcam_av_volume_name); + arcam_av->local.zone1.volume = arcam_av->global->zone1.volume; + } else if (arcam_av->local.zone1.mute != arcam_av->global->zone1.mute) { + snd_ctl_elem_id_set_name(id, arcam_av_mute_name); + arcam_av->local.zone1.mute = arcam_av->global->zone1.mute; + } else if (arcam_av->local.zone1.direct != arcam_av->global->zone1.direct) { + snd_ctl_elem_id_set_name(id, arcam_av_direct_name); + arcam_av->local.zone1.direct = arcam_av->global->zone1.direct; + } else if (arcam_av->local.zone1.source != arcam_av->global->zone1.source) { + snd_ctl_elem_id_set_name(id, arcam_av_source_name); + arcam_av->local.zone1.source = arcam_av->global->zone1.source; + } else if (arcam_av->local.zone1.source_type != arcam_av->global->zone1.source_type) { + snd_ctl_elem_id_set_name(id, arcam_av_source_type_name); + arcam_av->local.zone1.source_type = arcam_av->global->zone1.source_type; + } else if (arcam_av->local.zone1.stereo_decode != arcam_av->global->zone1.stereo_decode) { + snd_ctl_elem_id_set_name(id, arcam_av_stereo_decode_name); + arcam_av->local.zone1.stereo_decode = arcam_av->global->zone1.stereo_decode; + } else if (arcam_av->local.zone1.stereo_effect != arcam_av->global->zone1.stereo_effect) { + snd_ctl_elem_id_set_name(id, arcam_av_stereo_effect_name); + arcam_av->local.zone1.stereo_effect = arcam_av->global->zone1.stereo_effect; + } else if (arcam_av->local.zone1.multi_decode != arcam_av->global->zone1.multi_decode) { + snd_ctl_elem_id_set_name(id, arcam_av_multi_decode_name); + arcam_av->local.zone1.multi_decode = arcam_av->global->zone1.multi_decode; + } else { + char buf[10]; + if (recv(arcam_av->ext.poll_fd, buf, sizeof(buf), 0) <= 0) { + close(arcam_av->ext.poll_fd); + arcam_av->ext.poll_fd = arcam_av_client(arcam_av->port); + if (arcam_av->ext.poll_fd > 0) + fcntl(arcam_av->ext.poll_fd, F_SETFL, O_NONBLOCK); + } + + return -EAGAIN; + } + break; + + case ARCAM_AV_ZONE2: + if (arcam_av->local.zone2.power != arcam_av->global->zone2.power) { + snd_ctl_elem_id_set_name(id, arcam_av_power_name); + arcam_av->local.zone2.power = arcam_av->global->zone2.power; + } else if (arcam_av->local.zone2.volume != arcam_av->global->zone2.volume) { + snd_ctl_elem_id_set_name(id, arcam_av_volume_name); + arcam_av->local.zone2.volume = arcam_av->global->zone2.volume; + } else if (arcam_av->local.zone2.mute != arcam_av->global->zone2.mute) { + snd_ctl_elem_id_set_name(id, arcam_av_mute_name); + arcam_av->local.zone2.mute = arcam_av->global->zone2.mute; + } else if (arcam_av->local.zone2.source != arcam_av->global->zone2.source) { + snd_ctl_elem_id_set_name(id, arcam_av_source_name); + arcam_av->local.zone2.source = arcam_av->global->zone2.source; + } else { + char buf[10]; + if (recv(arcam_av->ext.poll_fd, buf, sizeof(buf), 0) <= 0) { + close(arcam_av->ext.poll_fd); + arcam_av->ext.poll_fd = arcam_av_client(arcam_av->port); + if (arcam_av->ext.poll_fd > 0) + fcntl(arcam_av->ext.poll_fd, F_SETFL, O_NONBLOCK); + } + + return -EAGAIN; + } + break; + } + + snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER); + + *event_mask = SND_CTL_EVENT_MASK_VALUE; + + return 1; +} + + +static snd_ctl_ext_callback_t arcam_av_ext_callback = { + .close = arcam_av_close, + .elem_count = arcam_av_elem_count, + .elem_list = arcam_av_elem_list, + .find_elem = arcam_av_find_elem, + .get_attribute = arcam_av_get_attribute, + .get_integer_info = arcam_av_get_integer_info, + .get_enumerated_info = arcam_av_get_enumerated_info, + .get_enumerated_name = arcam_av_get_enumerated_name, + .read_integer = arcam_av_read_integer, + .read_enumerated = arcam_av_read_enumerated, + .write_integer = arcam_av_write_integer, + .write_enumerated = arcam_av_write_enumerated, + .read_event = arcam_av_read_event, +}; + + +SND_CTL_PLUGIN_DEFINE_FUNC(arcam_av) +{ + snd_config_iterator_t it, next; + const char *port = "/dev/ttyS0"; + long zone = 1; + int err; + snd_ctl_arcam_av_t *arcam_av = NULL; + + snd_config_for_each(it, next, conf) { + snd_config_t *n = snd_config_iterator_entry(it); + const char *id; + if (snd_config_get_id(n, &id) < 0) + continue; + if (strcmp(id, "comment") == 0 || strcmp(id, "type") == 0) + continue; + if (strcmp(id, "port") == 0) { + if (snd_config_get_string(n, &port) < 0) { + SNDERR("Invalid type for %s", id); + return -EINVAL; + } + continue; + } + if (strcmp(id, "zone") == 0) { + if (snd_config_get_integer(n, &zone) < 0) { + SNDERR("Invalid type for %s", id); + return -EINVAL; + } + if (zone < 1 || zone > 2) { + SNDERR("Invalid value for %s", id); + return -EINVAL; + } + continue; + } + SNDERR("Unknown field %s", id); + return -EINVAL; + } + + if (access(port, R_OK | W_OK) < 0) { + err = -errno; + goto error; + } + + arcam_av = calloc(1, sizeof(*arcam_av) + strlen(port) + 1); + + if (!arcam_av) + return -ENOMEM; + + arcam_av->ext.version = SND_CTL_EXT_VERSION; + arcam_av->ext.card_idx = 0; + strncpy(arcam_av->ext.id, arcam_av_name, sizeof(arcam_av->ext.id) - 1); + strncpy(arcam_av->ext.name, arcam_av_name, sizeof(arcam_av->ext.name) - 1); + strncpy(arcam_av->ext.longname, arcam_av_name, sizeof(arcam_av->ext.longname) - 1); + strncpy(arcam_av->ext.mixername, arcam_av_name, sizeof(arcam_av->ext.mixername) - 1); + arcam_av->ext.poll_fd = -1; + arcam_av->ext.callback = &arcam_av_ext_callback; + arcam_av->ext.private_data = arcam_av; + + arcam_av->shm_id= -1; + arcam_av->port_fd = -1; + arcam_av->port = strcpy((char*)(arcam_av + 1), port); + arcam_av->zone = zone != 2 ? ARCAM_AV_ZONE1 : ARCAM_AV_ZONE2; + + arcam_av->port_fd = arcam_av_connect(arcam_av->port); + if (arcam_av->port_fd < 0) { + err = -errno; + goto error; + } + + if (arcam_av_server_start(&arcam_av->server, arcam_av->port)) { + err = -errno; + goto error; + } + + arcam_av->ext.poll_fd = arcam_av_client(arcam_av->port); + if (arcam_av->ext.poll_fd < 0) { + err = -errno; + goto error; + } + + fcntl(arcam_av->ext.poll_fd, F_SETFL, O_NONBLOCK); + + arcam_av->global = arcam_av_state_attach(arcam_av->port); + if (!arcam_av->global) { + err = -errno; + goto error; + } + + err = snd_ctl_ext_create(&arcam_av->ext, name, mode); + if (err < 0) + goto error; + + *handlep = arcam_av->ext.handle; + return 0; + + error: + perror("arcam_av()"); + arcam_av_close(&arcam_av->ext); + return err; +} + +SND_CTL_PLUGIN_SYMBOL(arcam_av); diff -Nrup alsa-plugins-1.0.18-orig/configure.in alsa-plugins-1.0.18/configure.in --- alsa-plugins-1.0.18-orig/configure.in 2008-10-29 12:42:13.000000000 +0000 +++ alsa-plugins-1.0.18/configure.in 2009-01-02 22:25:12.000000000 +0000 @@ -140,6 +140,7 @@ AC_OUTPUT([ maemo/Makefile doc/Makefile usb_stream/Makefile + arcam-av/Makefile ]) dnl Show the build conditions diff -Nrup alsa-plugins-1.0.18-orig/doc/Makefile.am alsa-plugins-1.0.18/doc/Makefile.am --- alsa-plugins-1.0.18-orig/doc/Makefile.am 2008-10-29 12:42:13.000000000 +0000 +++ alsa-plugins-1.0.18/doc/Makefile.am 2009-01-02 23:19:19.000000000 +0000 @@ -1,3 +1,3 @@ EXTRA_DIST = README-pcm-oss README-jack README-pulse README-maemo \ upmix.txt vdownmix.txt samplerate.txt a52.txt lavcrate.txt \ - speexrate.txt + speexrate.txt README-arcam-av diff -Nrup alsa-plugins-1.0.18-orig/doc/Makefile.in alsa-plugins-1.0.18/doc/Makefile.in --- alsa-plugins-1.0.18-orig/doc/Makefile.in 2008-10-29 12:47:43.000000000 +0000 +++ alsa-plugins-1.0.18/doc/Makefile.in 2009-01-02 23:20:03.000000000 +0000 @@ -182,7 +182,7 @@ sysconfdir = @sysconfdir@ target_alias = @target_alias@ EXTRA_DIST = README-pcm-oss README-jack README-pulse README-maemo \ upmix.txt vdownmix.txt samplerate.txt a52.txt lavcrate.txt \ - speexrate.txt + speexrate.txt README-arcam-av all: all-am diff -Nrup alsa-plugins-1.0.18-orig/doc/README-arcam-av alsa-plugins-1.0.18/doc/README-arcam-av --- alsa-plugins-1.0.18-orig/doc/README-arcam-av 1970-01-01 01:00:00.000000000 +0100 +++ alsa-plugins-1.0.18/doc/README-arcam-av 2009-01-02 23:18:14.000000000 +0000 @@ -0,0 +1,29 @@ +Arcam AV Amplifier ALSA Control plugin +====================================== + +This plugin exposes the controls for an Arcam AV amplifier +(see: http://www.arcam.co.uk/) as an ALSA mixer device. + +To use this plugin you will need to connect the amplifier +to the PC using an RS-232 null-modem cable and use the +following ALSA configuration: + + ctl.arcam_av { + type arcam_av + port /dev/ttyS0 + } + +The "port" parameter is required and indicates the serial +port to be used to communicate with the amplifier. There is +an optional "zone" parameter, which accepts a value of +either "1" (default) or "2", that indicates which of the +amplifiers zones should be controlled. + +NB: You must ensure that any user accounts that are to use +this plugin have both read and write access rights for the +configured serial port. + +This plugin was developed and tested using an Arcam AVR 300 +amplifier. I believe most Arcam amplifiers use a sufficiently +similar control system to be compatible with this plugin but +your mileage may vary.

1 0

[alsa-devel] [PATCH 0/2] New Control Plugin - arcam-av
by Peter Stokes 03 Jan '09

03 Jan '09

Hi, I have developed a new ALSA control plugin that I would like to be considered for inclusion into the alsa-plugins package. The plugin is for exposing the controls of an Arcam AV amplifier attached to a PC via an RS-232 null-modem cable. These patches are against the release source for alsa-plugins-1.0.18. Best regards Peter Stokes

1 0

[alsa-devel] [PATCH - 1/2] ALSA: hda - add basic jack reporting functions to patch_conexant.c
by Ulrich Dangel 03 Jan '09

03 Jan '09

Added functions to report jack sense. As CXT5051_PORTB_EVENT has the same value as CONEXANT_MIC_EVENT two input devices for the microphone will be created if using CXT5051. Signed-off-by: Ulrich Dangel <uli(a)spamt.net> diff --git a/pci/hda/patch_conexant.c b/pci/hda/patch_conexant.c index 0760107..3cb640c 100644 --- a/pci/hda/patch_conexant.c +++ b/pci/hda/patch_conexant.c @@ -25,6 +25,8 @@ #include <linux/slab.h> #include <linux/pci.h> #include <sound/core.h> +#include <sound/jack.h> + #include "hda_codec.h" #include "hda_local.h" #include "hda_patch.h" @@ -38,8 +40,21 @@ #define CONEXANT_HP_EVENT 0x37 #define CONEXANT_MIC_EVENT 0x38 +/* Conexant 5051 specific */ + +#define CXT5051_SPDIF_OUT 0x1C +#define CXT5051_PORTB_EVENT 0x38 +#define CXT5051_PORTC_EVENT 0x39 +struct conexant_jack { + + hda_nid_t nid; + int type; + struct snd_jack *jack; + +}; + struct conexant_spec { struct snd_kcontrol_new *mixers[5]; @@ -84,6 +99,9 @@ struct conexant_spec { unsigned int spdif_route; + /* jack detection */ + struct snd_array jacks; + /* dynamic controls, init_verbs and input_mux */ struct auto_pin_cfg autocfg; struct hda_input_mux private_imux; @@ -330,6 +348,86 @@ static int conexant_mux_enum_put(struct snd_kcontrol *kcontrol, &spec->cur_mux[adc_idx]); } +static int conexant_add_jack(struct hda_codec *codec, + hda_nid_t nid, int type) +{ + struct conexant_spec *spec; + struct conexant_jack *jack; + const char *name; + + spec = codec->spec; + snd_array_init(&spec->jacks, sizeof(*jack), 32); + jack = snd_array_new(&spec->jacks); + name = (type == SND_JACK_HEADPHONE) ? "Headphone" : "Mic" ; + + if (!jack) + return -ENOMEM; + + jack->nid = nid; + jack->type = type; + + return snd_jack_new(codec->bus->card, name, type, &jack->jack); +} + +static void conexant_report_jack(struct hda_codec *codec, hda_nid_t nid) +{ + struct conexant_spec *spec = codec->spec; + struct conexant_jack *jacks = spec->jacks.list; + + if (jacks) { + int i; + for (i = 0; i < spec->jacks.used; i++) { + if (jacks->nid == nid) { + unsigned int present; + present = snd_hda_codec_read(codec, nid, 0, + AC_VERB_GET_PIN_SENSE, 0) & + AC_PINSENSE_PRESENCE; + + present = (present) ? jacks->type : 0 ; + + snd_jack_report(jacks->jack, + present); + } + jacks++; + } + } +} + +static int conexant_init_jacks(struct hda_codec *codec) +{ +#ifdef CONFIG_SND_JACK + struct conexant_spec *spec = codec->spec; + int i; + + for (i = 0; i < spec->num_init_verbs; i++) { + const struct hda_verb *hv; + + hv = spec->init_verbs[i]; + while (hv->nid) { + int err = 0; + switch (hv->param ^ AC_USRSP_EN) { + case CONEXANT_HP_EVENT: + err = conexant_add_jack(codec, hv->nid, + SND_JACK_HEADPHONE); + conexant_report_jack(codec, hv->nid); + break; + case CXT5051_PORTC_EVENT: + case CONEXANT_MIC_EVENT: + err = conexant_add_jack(codec, hv->nid, + SND_JACK_MICROPHONE); + conexant_report_jack(codec, hv->nid); + break; + } + if (err < 0) + return err; + ++hv; + } + } +#endif + return 0; + +} + static int conexant_init(struct hda_codec *codec) { struct conexant_spec *spec = codec->spec; @@ -342,6 +440,16 @@ static int conexant_init(struct hda_codec *codec) static void conexant_free(struct hda_codec *codec) { +#ifdef CONFIG_SND_JACK + struct conexant_spec *spec = codec->spec; + if (spec->jacks.list) { + struct conexant_jack *jacks = spec->jacks.list; + int i; + for (i = 0; i < spec->jacks.used; i++) + snd_device_free(codec->bus->card, &jacks[i].jack); + snd_array_free(&spec->jacks); + } +#endif kfree(codec->spec); } @@ -1527,9 +1635,6 @@ static int patch_cxt5047(struct hda_codec *codec) /* Conexant 5051 specific */ static hda_nid_t cxt5051_dac_nids[1] = { 0x10 }; static hda_nid_t cxt5051_adc_nids[2] = { 0x14, 0x15 }; -#define CXT5051_SPDIF_OUT 0x1C -#define CXT5051_PORTB_EVENT 0x38 -#define CXT5051_PORTC_EVENT 0x39 static struct hda_channel_mode cxt5051_modes[1] = { { 2, NULL }, -- 1.6.0.6

2 2

[alsa-devel] [PATCH 0/4] ASoC updates for next
by Mark Brown 02 Jan '09

02 Jan '09

The following changes since commit 6a94cb73064c952255336cc57731904174b2c58f: Linus Torvalds (1): Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs are available in the git repository at: git://git.kernel.org/pub/scm/linux/kernel/git/broonie/sound-2.6.git for-tiwai If merging these patches just now is going to cause hassle then let me know. Mark Brown (1): ASoC: Clean up kerneldoc warnings Peter Ujfalusi (2): ASoC: TWL4030: Make the enum filter generic for twl4030 ASoC: TWL4030: DAPM based capture implementation Stephen Ware (1): ASoC: Fix pxa2xx-pcm checks for invalid DMA channels sound/soc/codecs/twl4030.c | 377 ++++++++++++++++++++++---------------------- sound/soc/codecs/twl4030.h | 7 + sound/soc/pxa/pxa2xx-pcm.c | 4 +- sound/soc/soc-core.c | 46 +++--- sound/soc/soc-dapm.c | 10 +- 5 files changed, 227 insertions(+), 217 deletions(-)

2 5

[alsa-devel] Subject: [PATCH 1/1] set invalid dma channel to -1 (and properly check for it) since 0 is not an invalid channel but -1 is.
by sware 01 Jan '09

01 Jan '09

Set the invalid dma channel to -1 (and check properly for it) in pxa2xx_pcm_hw_free(). Was assuming 0 is an invalid channel number but 0 is a valid pxa dma channel num. Signed-off-by: stephen <stephen.ware(a)eqware.net> --- sound/soc/pxa/pxa2xx-pcm.c | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-) diff --git a/sound/soc/pxa/pxa2xx-pcm.c b/sound/soc/pxa/pxa2xx-pcm.c index c670d08..53b9fb1 100644 --- a/sound/soc/pxa/pxa2xx-pcm.c +++ b/sound/soc/pxa/pxa2xx-pcm.c @@ -61,9 +61,9 @@ static int pxa2xx_pcm_hw_free(struct snd_pcm_substream *substream) __pxa2xx_pcm_hw_free(substream); - if (prtd->dma_ch) { + if (prtd->dma_ch >= 0) { pxa_free_dma(prtd->dma_ch); - prtd->dma_ch = 0; + prtd->dma_ch = -1; } return 0; -- 1.5.4.3

2 2

[alsa-devel] Control interconnection information API?
by Eliot Blennerhassett 01 Jan '09

01 Jan '09

New Year's Greetings, something that seems to be lacking in the ALSA API, or at least the way of describing controls (by name only), is any concept of the connectivity between the various controls and the codecs and output terminals. One use for such information is to build a GUI that shows this connectivity (instead of the current bucket'o'controls approach). Now there are a couple of special cases: * HDA driver exports the codec widget information via a proc file, allowing the codecgraph tool to visualise the connections. Widgets have numeric IDs and list the IDs of widgets that connect to their inputs. * ASoC DAPM (which I (not being an ASoC developer or user) have mostly been skimming over in this list). Reading this http://www.mjmwired.net/kernel/Documentation/sound/alsa/soc/dapm.txt 3. Codec Widget Interconnections. I can see that there are lists of connections. I'm not sure if these are visible to userspace via any API? So: Can either of these schemes be generalised to all ALSA drivers? Is there some other way to reveal the information (Connections TLV, new API etc?) Does anybody else thing this is worth pursuing, or is it just me? regards -- Eliot Blennerhassett AudioScience Inc

2 1