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

[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

Re: [alsa-devel] 2.6.28-rc5 broke ALSA headphone output for my Toughbooks.
by Takashi Iwai 01 Jan '09

01 Jan '09

At Tue, 23 Dec 2008 10:44:50 -0500, Kyler Laird wrote: > > My Panasonic CF-74 Toughbooks do not play audio through the headphone > jack starting with 2.6.28-rc5. The patch below is only to illustrate > what changes I made to restore headphone jack functionality. I do not > suggest using this patch as part of the mainline kernel because it > reverts some code that I'm sure is important to other users. > > Output of the ALSA script aadebug follows the patch. > > I'm continuing to investigate but I wanted to get this out in case the > solution is obvious to someone else. It would be great to have a fix in > 2.6.28. (2.6.28 is the first series to support all of the hardware in > the Toughbook.) Please run alsa-info.sh with --no-upload option and attach the generated files on both the headphone plugged and unplugged. Also, run preferably on both (old) working and non-working kernels to compare. thanks, Takashi

1 0

Re: [alsa-devel] [PATCH 11/13] sound/usb: use USB API functions rather than constants
by Takashi Iwai 01 Jan '09

01 Jan '09

At Mon, 29 Dec 2008 11:23:02 +0100 (CET), Julia Lawall wrote: > > From: Julia Lawall <julia(a)diku.dk> > > This set of patches introduces calls to the following set of functions: > > usb_endpoint_dir_in(epd) > usb_endpoint_dir_out(epd) > usb_endpoint_is_bulk_in(epd) > usb_endpoint_is_bulk_out(epd) > usb_endpoint_is_int_in(epd) > usb_endpoint_is_int_out(epd) > usb_endpoint_num(epd) > usb_endpoint_type(epd) > usb_endpoint_xfer_bulk(epd) > usb_endpoint_xfer_control(epd) > usb_endpoint_xfer_int(epd) > usb_endpoint_xfer_isoc(epd) > > In some cases, introducing one of these functions is not possible, and it > just replaces an explicit integer value by one of the following constants: > > USB_ENDPOINT_XFER_BULK > USB_ENDPOINT_XFER_CONTROL > USB_ENDPOINT_XFER_INT > USB_ENDPOINT_XFER_ISOC > > An extract of the semantic patch that makes these changes is as follows: > (http://www.emn.fr/x-info/coccinelle/) > > // <smpl> > @r1@ struct usb_endpoint_descriptor *epd; @@ > > - ((epd->bmAttributes & \(USB_ENDPOINT_XFERTYPE_MASK\|3\)) == > - \(USB_ENDPOINT_XFER_CONTROL\|0\)) > + usb_endpoint_xfer_control(epd) > > @r5@ struct usb_endpoint_descriptor *epd; @@ > > - ((epd->bEndpointAddress & \(USB_ENDPOINT_DIR_MASK\|0x80\)) == > - \(USB_DIR_IN\|0x80\)) > + usb_endpoint_dir_in(epd) > > @inc@ > @@ > > #include <linux/usb.h> > > @depends on !inc && (r1||r5)@ > @@ > > + #include <linux/usb.h> > #include <linux/usb/...> > // </smpl> > > Signed-off-by: Julia Lawall <julia(a)diku.dk> Applied now. Thanks. Takashi

1 0

[alsa-devel] [PATCH] hda - fix name for ALC1200
by Wu Fengguang 01 Jan '09

01 Jan '09

On Thu, Dec 25, 2008 at 03:13:58PM +0200, Thomas Schneider wrote: > Hi, > > here is the output from alsa-info.sh > > http://www.alsa-project.org/db/?f=8282910dc807e1f141896886cd5f8fd574117000 > > I found another small mistake. In the Mixer my Soundcard is shown as "Realtek ALC888". > When i switch this to lines in patch_realtek.c then it is shown as "Realtek ALC1200". > > > static struct hda_codec_preset snd_hda_preset_realtek[] = { > ...... > > { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 }, > { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200", > .patch = patch_alc883 }, > > ..... Good catch! Reversing the order should fix the name. Thanks, Fengguang --- hda - fix name for ALC1200 Move the more specific preset for ALC1200 above the general one for ALC888, so that it will have the chance to get matched and selected. Reported-by: Thomas Schneider <nailstudio(a)gmx.net> Signed-off-by: Wu Fengguang <fengguang.wu(a)intel.com> --- sound/pci/hda/patch_realtek.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) --- sound-2.6.orig/sound/pci/hda/patch_realtek.c +++ sound-2.6/sound/pci/hda/patch_realtek.c @@ -16638,9 +16638,9 @@ static struct hda_codec_preset snd_hda_p .patch = patch_alc882 }, /* should be patch_alc883() in future */ { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 }, { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 }, - { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 }, { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200", .patch = patch_alc883 }, + { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 }, { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 }, {} /* terminator */ };

2 1

[alsa-devel] [PATCH] ALSA: hda - Add HP Acacia detection
by Chris Bagwell 01 Jan '09

01 Jan '09

Add automatic mapping of HP Acacia motherboards to 3stack-hp. Allows for greater then 2 channel audio by enabling Channel Mode option in mixer. Motherboard specs: http://h10025.www1.hp.com/ewfrf/wc/document?docname=c01321559&lc=en&dlc=en&… Signed-off-by: Chris Bagwell <chris at cnpbagwell dot com> diff --git a/pci/hda/patch_realtek.c b/pci/hda/patch_realtek.c index 4afa0c9..410be84 100644 --- a/pci/hda/patch_realtek.c +++ b/pci/hda/patch_realtek.c @@ -8444,6 +8444,7 @@ static struct snd_pci_quirk alc883_cfg_tbl[] = { SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP), SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP), SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG), + SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP), SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V), SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG), SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),

2 1