From patchwork Sun Jan 25 11:34:32 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Takashi Sakamoto X-Patchwork-Id: 5701161 Return-Path: X-Original-To: patchwork-alsa-devel@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork1.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.136]) by patchwork1.web.kernel.org (Postfix) with ESMTP id 8790F9F2ED for ; Sun, 25 Jan 2015 11:40:21 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 0C1C1201FE for ; Sun, 25 Jan 2015 11:40:20 +0000 (UTC) Received: from alsa0.perex.cz (alsa0.perex.cz [77.48.224.243]) by mail.kernel.org (Postfix) with ESMTP id 4FC40201EC for ; Sun, 25 Jan 2015 11:40:18 +0000 (UTC) Received: by alsa0.perex.cz (Postfix, from userid 1000) id 894E72606BA; Sun, 25 Jan 2015 12:40:17 +0100 (CET) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,NO_DNS_FOR_FROM, UNPARSEABLE_RELAY autolearn=no version=3.3.1 Received: from alsa0.perex.cz (localhost [IPv6:::1]) by alsa0.perex.cz (Postfix) with ESMTP id C0AC92604C3; Sun, 25 Jan 2015 12:35:34 +0100 (CET) X-Original-To: alsa-devel@alsa-project.org Delivered-To: alsa-devel@alsa-project.org Received: by alsa0.perex.cz (Postfix, from userid 1000) id 61403260453; Sun, 25 Jan 2015 12:35:31 +0100 (CET) Received: from smtp302.phy.lolipop.jp (smtp302.phy.lolipop.jp [210.157.22.85]) by alsa0.perex.cz (Postfix) with ESMTP id 3B74326044E for ; Sun, 25 Jan 2015 12:35:04 +0100 (CET) Received: from smtp302.phy.lolipop.lan (HELO smtp302.phy.lolipop.jp) (172.17.1.85) (smtp-auth username m12129643-o-takashi, mechanism plain) by smtp302.phy.lolipop.jp (qpsmtpd/0.82) with ESMTPA; Sun, 25 Jan 2015 20:35:00 +0900 Received: from 127.0.0.1 (127.0.0.1) by smtp302.phy.lolipop.jp (LOLIPOP-Fsecure); Sun, 25 Jan 2015 20:34:35 +0900 (JST) X-Virus-Status: clean(LOLIPOP-Fsecure) From: Takashi Sakamoto To: clemens@ladisch.de, tiwai@suse.de, perex@perex.cz Date: Sun, 25 Jan 2015 20:34:32 +0900 Message-Id: <1422185674-16431-12-git-send-email-o-takashi@sakamocchi.jp> X-Mailer: git-send-email 2.1.0 In-Reply-To: <1422185674-16431-1-git-send-email-o-takashi@sakamocchi.jp> References: <1422185674-16431-1-git-send-email-o-takashi@sakamocchi.jp> Cc: alsa-devel@alsa-project.org, linux1394-devel@lists.sourceforge.net, ffado-devel@lists.sf.net Subject: [alsa-devel] [PATCH 11/13] libhinawa: add 'snd_efw' object as a helper for EFW transaction X-BeenThere: alsa-devel@alsa-project.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: "Alsa-devel mailing list for ALSA developers - http://www.alsa-project.org" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Errors-To: alsa-devel-bounces@alsa-project.org Sender: alsa-devel-bounces@alsa-project.org X-Virus-Scanned: ClamAV using ClamSMTP Fireworks is a board module which Echo Audio produces. This module can be controlled by Echo Fireworks Transaction (a.k.a. EFW transaction). The transaction has categories, commands and arguments. The transaction is transferred by two ways; one is vendor-dependent AV/C command and another is a pair of request/response transaction to certain addresses. ALSA Fireworks driver already supports the latter way because the former way is not avaibale in some Fireworks based devices. The driver gives a way for applications to execute this transaction via ALSA hwdep interface. This commit adds HINAWA_TYPE_SND_EFW object for this purpose. An application can transfer requests and wait responses by calling transact() method after calling listen() method. This object is an inheritance of HINAWA_TYPE_SND_UNIT, therefore some signals and properties, methods are also available. Signed-off-by: Takashi Sakamoto --- libhinawa/doc/reference/hinawa-docs.sgml | 1 + libhinawa/src/Makefile.am | 7 +- libhinawa/src/internal.h | 3 + libhinawa/src/snd_efw.c | 315 +++++++++++++++++++++++++++++++ libhinawa/src/snd_efw.h | 54 ++++++ libhinawa/src/snd_unit.c | 5 + 6 files changed, 383 insertions(+), 2 deletions(-) create mode 100644 libhinawa/src/snd_efw.c create mode 100644 libhinawa/src/snd_efw.h diff --git a/libhinawa/doc/reference/hinawa-docs.sgml b/libhinawa/doc/reference/hinawa-docs.sgml index 58c862a..731ae15 100644 --- a/libhinawa/doc/reference/hinawa-docs.sgml +++ b/libhinawa/doc/reference/hinawa-docs.sgml @@ -36,6 +36,7 @@ + diff --git a/libhinawa/src/Makefile.am b/libhinawa/src/Makefile.am index 696e567..b746bf1 100644 --- a/libhinawa/src/Makefile.am +++ b/libhinawa/src/Makefile.am @@ -36,7 +36,9 @@ libhinawa_la_SOURCES = \ snd_unit.h \ snd_unit.c \ snd_dice.h \ - snd_dice.c + snd_dice.c \ + snd_efw.h \ + snd_efw.c pkginclude_HEADERS = \ hinawa_sigs_marshal.h \ @@ -45,7 +47,8 @@ pkginclude_HEADERS = \ fw_req.h \ fw_fcp.h \ snd_unit.h \ - snd_dice.h + snd_dice.h \ + snd_efw.h hinawa_sigs_marshal.list: $(AM_V_GEN)( find | grep \.c$$ | xargs cat | \ diff --git a/libhinawa/src/internal.h b/libhinawa/src/internal.h index ddbb298..9ff8fe4 100644 --- a/libhinawa/src/internal.h +++ b/libhinawa/src/internal.h @@ -13,6 +13,7 @@ #include "fw_req.h" #include "snd_unit.h" #include "snd_dice.h" +#include "snd_efw.h" void hinawa_fw_unit_ioctl(HinawaFwUnit *self, int req, void *args, int *err); void hinawa_fw_resp_handle_request(HinawaFwResp *self, @@ -25,4 +26,6 @@ void hinawa_snd_unit_write(HinawaSndUnit *unit, GError **exception); void hinawa_snd_dice_handle_notification(HinawaSndDice *self, const void *buf, unsigned int len); +void hinawa_snd_efw_handle_response(HinawaSndEfw *self, + const void *buf, unsigned int len); #endif diff --git a/libhinawa/src/snd_efw.c b/libhinawa/src/snd_efw.c new file mode 100644 index 0000000..6e1882b --- /dev/null +++ b/libhinawa/src/snd_efw.c @@ -0,0 +1,315 @@ +#include +#include +#include +#include "snd_efw.h" +#include "internal.h" + +#ifdef HAVE_CONFIG_H +# include +#endif + +/** + * SECTION:snd_efw + * @Title: HinawaSndEfw + * @Short_description: A transaction executor for Fireworks models + * + * A #HinawaSndEfw is an application of Echo Fireworks Transaction (EFT). + * This inherits #HinawaSndUnit. + */ +#define MINIMUM_SUPPORTED_VERSION 1 +#define MAXIMUM_FRAME_BYTES 0x200U + +enum efw_status { + EFT_STATUS_OK = 0, + EFT_STATUS_BAD = 1, + EFT_STATUS_BAD_COMMAND = 2, + EFT_STATUS_COMM_ERR = 3, + EFT_STATUS_BAD_QUAD_COUNT = 4, + EFT_STATUS_UNSUPPORTED = 5, + EFT_STATUS_1394_TIMEOUT = 6, + EFT_STATUS_DSP_TIMEOUT = 7, + EFT_STATUS_BAD_RATE = 8, + EFT_STATUS_BAD_CLOCK = 9, + EFT_STATUS_BAD_CHANNEL = 10, + EFT_STATUS_BAD_PAN = 11, + EFT_STATUS_FLASH_BUSY = 12, + EFT_STATUS_BAD_MIRROR = 13, + EFT_STATUS_BAD_LED = 14, + EFT_STATUS_BAD_PARAMETER = 15, +}; +static const char *const efw_status_names[] = { + [EFT_STATUS_OK] = "OK", + [EFT_STATUS_BAD] = "bad", + [EFT_STATUS_BAD_COMMAND] = "bad command", + [EFT_STATUS_COMM_ERR] = "comm err", + [EFT_STATUS_BAD_QUAD_COUNT] = "bad quad count", + [EFT_STATUS_UNSUPPORTED] = "unsupported", + [EFT_STATUS_1394_TIMEOUT] = "1394 timeout", + [EFT_STATUS_DSP_TIMEOUT] = "DSP timeout", + [EFT_STATUS_BAD_RATE] = "bad rate", + [EFT_STATUS_BAD_CLOCK] = "bad clock", + [EFT_STATUS_BAD_CHANNEL] = "bad channel", + [EFT_STATUS_BAD_PAN] = "bad pan", + [EFT_STATUS_FLASH_BUSY] = "flash busy", + [EFT_STATUS_BAD_MIRROR] = "bad mirror", + [EFT_STATUS_BAD_LED] = "bad LED", + [EFT_STATUS_BAD_PARAMETER] = "bad parameter", +}; + +struct efw_transaction { + guint seqnum; + + struct snd_efw_transaction *frame; + + GCond cond; +}; + +struct _HinawaSndEfwPrivate { + guint seqnum; + + GList *transactions; + GMutex lock; +}; +G_DEFINE_TYPE_WITH_PRIVATE(HinawaSndEfw, hinawa_snd_efw, HINAWA_TYPE_SND_UNIT) +#define SND_EFW_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE((obj), \ + HINAWA_TYPE_SND_EFW, HinawaSndEfwPrivate)) + +static void snd_efw_dispose(GObject *obj) +{ + G_OBJECT_CLASS(hinawa_snd_efw_parent_class)->dispose(obj); +} + +static void snd_efw_finalize(GObject *gobject) +{ + G_OBJECT_CLASS(hinawa_snd_efw_parent_class)->finalize(gobject); +} + +static void hinawa_snd_efw_class_init(HinawaSndEfwClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS(klass); + + gobject_class->dispose = snd_efw_dispose; + gobject_class->finalize = snd_efw_finalize; +} + +static void hinawa_snd_efw_init(HinawaSndEfw *self) +{ + self->priv = hinawa_snd_efw_get_instance_private(self); +} + +/** + * hinawa_snd_efw_new: + * @path: A path to ALSA hwdep device for Fireworks models (i.e. hw:0) + * @exception: A #GError + * + * Returns: A #HinawaSndEfw + */ +void hinawa_snd_efw_open(HinawaSndEfw *self, gchar *path, GError **exception) +{ + HinawaSndEfwPrivate *priv; + int type; + + g_return_if_fail(HINAWA_IS_SND_EFW(self)); + priv = SND_EFW_GET_PRIVATE(self); + + hinawa_snd_unit_open(&self->parent_instance, path, exception); + if (*exception != NULL) { + g_clear_object(&self); + return; + } + + g_object_get(G_OBJECT(self), "type", &type, NULL); + if (type != SNDRV_FIREWIRE_TYPE_FIREWORKS) { + g_set_error(exception, g_quark_from_static_string(__func__), + EINVAL, "%s", strerror(EINVAL)); + g_clear_object(&self); + return; + } + + priv = SND_EFW_GET_PRIVATE(self); + priv->seqnum = 0; + priv->transactions = NULL; + g_mutex_init(&priv->lock); +} + +/** + * hinawa_snd_efw_transact: + * @self: A #HinawaSndEfw + * @category: one of category for the transact + * @command: one of commands for the transact + * @args: (nullable) (element-type guint32) (array) (in): arguments for the + * transaction + * @params: (element-type guint32) (array) (out caller-allocates): return params + * @exception: A #GError + */ +void hinawa_snd_efw_transact(HinawaSndEfw *self, guint category, guint command, + GArray *args, GArray *params, GError **exception) +{ + HinawaSndEfwPrivate *priv; + int type; + + struct efw_transaction trans; + __le32 *items; + + unsigned int quads; + unsigned int count; + unsigned int i; + + gint64 expiration; + + g_return_if_fail(HINAWA_IS_SND_EFW(self)); + priv = SND_EFW_GET_PRIVATE(self); + + /* Check unit type and function arguments . */ + g_object_get(G_OBJECT(self), "type", &type, NULL); + if ((type != SNDRV_FIREWIRE_TYPE_FIREWORKS) || + (args && g_array_get_element_size(args) != sizeof(guint32)) || + (params && g_array_get_element_size(params) != sizeof(guint32))) { + g_set_error(exception, g_quark_from_static_string(__func__), + EINVAL, "%s", strerror(EINVAL)); + return; + } + + trans.frame = g_malloc0(MAXIMUM_FRAME_BYTES); + if (trans.frame == NULL) { + g_set_error(exception, g_quark_from_static_string(__func__), + ENOMEM, "%s", strerror(ENOMEM)); + return; + } + + /* Increment the sequence number for next transaction. */ + trans.frame->seqnum = priv->seqnum; + priv->seqnum += 2; + if (priv->seqnum > SND_EFW_TRANSACTION_USER_SEQNUM_MAX) + priv->seqnum = 0; + + /* Fill transaction frame. */ + quads = sizeof(struct snd_efw_transaction) / 4; + if (args) + quads += args->len; + trans.frame->length = quads; + trans.frame->version = MINIMUM_SUPPORTED_VERSION; + trans.frame->category = category; + trans.frame->command = command; + trans.frame->status = 0xff; + if (args) + memcpy(trans.frame->params, + args->data, args->len * sizeof(guint32)); + + /* The transactions are aligned to big-endian. */ + items = (__le32 *)trans.frame; + for (i = 0; i < quads; i++) + items[i] = htobe32(items[i]); + + /* Insert this entry to list and enter critical section. */ + g_mutex_lock(&priv->lock); + priv->transactions = g_list_append(priv->transactions, &trans); + + /* NOTE: Timeout is 200 milli-seconds. */ + expiration = g_get_monotonic_time() + 200 * G_TIME_SPAN_MILLISECOND; + g_cond_init(&trans.cond); + + /* Send this request frame. */ + hinawa_snd_unit_write(&self->parent_instance, trans.frame, quads * 4, + exception); + if (*exception != NULL) + goto end; + + /* + * Wait corresponding response till timeout and temporarily leave the + * critical section. + */ + if (!g_cond_wait_until(&trans.cond, &priv->lock, expiration)) { + g_set_error(exception, g_quark_from_static_string(__func__), + ETIMEDOUT, "%s", strerror(ETIMEDOUT)); + goto end; + } + + quads = be32toh(trans.frame->length); + + /* The transactions are aligned to big-endian. */ + items = (__le32 *)trans.frame; + for (i = 0; i < quads; i++) + items[i] = be32toh(items[i]); + + /* Check transaction status. */ + if (trans.frame->status != EFT_STATUS_OK) { + g_set_error(exception, g_quark_from_static_string(__func__), + EPROTO, "%s", + efw_status_names[trans.frame->status]); + goto end; + } + + /* Check transaction headers. */ + if ((trans.frame->version < MINIMUM_SUPPORTED_VERSION) || + (trans.frame->category != category) || + (trans.frame->command != command)) { + g_set_error(exception, g_quark_from_static_string(__func__), + EIO, "%s", strerror(EIO)); + goto end; + } + + /* Check returned parameters. */ + count = quads - sizeof(struct snd_efw_transaction) / 4; + if (count > 0 && params == NULL) { + g_set_error(exception, g_quark_from_static_string(__func__), + EINVAL, "%s", strerror(EINVAL)); + goto end; + } + + /* Copy parameters. */ + g_array_insert_vals(params, 0, trans.frame->params, count); +end: + /* Remove thie entry from list and leave the critical section. */ + priv->transactions = + g_list_remove(priv->transactions, (gpointer *)&trans); + g_mutex_unlock(&priv->lock); + + g_free(trans.frame); +} + +void hinawa_snd_efw_handle_response(HinawaSndEfw *self, + const void *buf, unsigned int len) +{ + HinawaSndEfwPrivate *priv; + struct snd_firewire_event_efw_response *event = + (struct snd_firewire_event_efw_response *)buf; + guint *responses = event->response; + + struct snd_efw_transaction *resp_frame; + struct efw_transaction *trans; + + unsigned int quadlets; + GList *entry; + + g_return_if_fail(HINAWA_IS_SND_EFW(self)); + priv = SND_EFW_GET_PRIVATE(self); + + while (len > 0) { + resp_frame = (struct snd_efw_transaction *)responses; + + g_mutex_lock(&priv->lock); + + trans = NULL; + for (entry = priv->transactions; + entry != NULL; entry = entry->next) { + trans = (struct efw_transaction *)entry->data; + + if (be32toh(resp_frame->seqnum) == trans->seqnum) + break; + } + + g_mutex_unlock(&priv->lock); + + if (trans == NULL) + continue; + + quadlets = be32toh(resp_frame->length); + memcpy(trans->frame, resp_frame, quadlets * 4); + g_cond_signal(&trans->cond); + + responses += quadlets; + len -= quadlets * sizeof(guint); + } +} diff --git a/libhinawa/src/snd_efw.h b/libhinawa/src/snd_efw.h new file mode 100644 index 0000000..cdc514b --- /dev/null +++ b/libhinawa/src/snd_efw.h @@ -0,0 +1,54 @@ +#ifndef __ALSA_TOOLS_HINAWA_SND_EFW_H__ +#define __ALSA_TOOLS_HINAWA_SND_EFW_H__ + +#include +#include +#include "snd_unit.h" + +G_BEGIN_DECLS + +#define HINAWA_TYPE_SND_EFW (hinawa_snd_efw_get_type()) + +#define HINAWA_SND_EFW(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), \ + HINAWA_TYPE_SND_EFW, \ + HinawaSndEfw)) +#define HINAWA_IS_SND_EFW(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj), \ + HINAWA_TYPE_SND_EFW)) + +#define HINAWA_SND_EFW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), \ + HINAWA_TYPE_SND_EFW, \ + HinawaSndEfwClass)) +#define HINAWA_IS_SND_EFW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), \ + HINAWA_TYPE_SND_EFW)) +#define HINAWA_SND_EFW_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), \ + HINAWA_TYPE_SND_EFW, \ + HinawaSndEfwClass)) + +typedef struct _HinawaSndEfw HinawaSndEfw; +typedef struct _HinawaSndEfwClass HinawaSndEfwClass; +typedef struct _HinawaSndEfwPrivate HinawaSndEfwPrivate; + +struct _HinawaSndEfw { + HinawaSndUnit parent_instance; + + HinawaSndEfwPrivate *priv; +}; + +struct _HinawaSndEfwClass { + HinawaSndUnitClass parent_class; +}; + +GType hinawa_snd_efw_get_type(void) G_GNUC_CONST; + +void hinawa_snd_efw_open(HinawaSndEfw *self, gchar *path, GError **exception); + +void hinawa_snd_efw_transact(HinawaSndEfw *self, guint category, guint command, + GArray *args, GArray *params, + GError **exception); + +#endif diff --git a/libhinawa/src/snd_unit.c b/libhinawa/src/snd_unit.c index b7537a3..eea6bbe 100644 --- a/libhinawa/src/snd_unit.c +++ b/libhinawa/src/snd_unit.c @@ -7,6 +7,7 @@ #include "fw_req.h" #include "fw_fcp.h" #include "snd_dice.h" +#include "snd_efw.h" #include "internal.h" #ifdef HAVE_CONFIG_H @@ -412,6 +413,10 @@ static gboolean check_src(GSource *gsrc) common->type == SNDRV_FIREWIRE_EVENT_DICE_NOTIFICATION) hinawa_snd_dice_handle_notification(HINAWA_SND_DICE(unit), priv->buf, len); + else if (HINAWA_IS_SND_EFW(unit) && + common->type == SNDRV_FIREWIRE_EVENT_EFW_RESPONSE) + hinawa_snd_efw_handle_response(HINAWA_SND_EFW(unit), + priv->buf, len); end: /* Don't go to dispatch, then continue to process this source. */ return FALSE;