ALSA: asihpi - DSP code loader API now independent of OS

The loader API has been revised so that OS specific data is kept
local to hpidspcd.c, and the public API is unchanged across OSes.

Signed-off-by: Eliot Blennerhassett <eblennerhassett@audioscience.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>

1 files changed, 54 insertions, 81 deletions

diff --git a/sound/pci/asihpi/hpidspcd.c b/sound/pci/asihpi/hpidspcd.c
index 5c6ea113d219..987538819b24 100644
--- a/sound/pci/asihpi/hpidspcd.c
+++ b/sound/pci/asihpi/hpidspcd.c
@@ -1,8 +1,8 @@
 /***********************************************************************/
-/*!
+/**
 
     AudioScience HPI driver
-    Copyright (C) 1997-2010  AudioScience Inc. <support@audioscience.com>
+    Copyright (C) 1997-2011  AudioScience Inc. <support@audioscience.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of version 2 of the GNU General Public License as
@@ -18,90 +18,60 @@
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 \file
-Functions for reading DSP code to load into DSP
-
-(Linux only:) If DSPCODE_FIRMWARE_LOADER is defined, code is read using
+Functions for reading DSP code using
 hotplug firmware loader from individual dsp code files
-
-If neither of the above is defined, code is read from linked arrays.
-DSPCODE_ARRAY is defined.
-
-HPI_INCLUDE_**** must be defined
-and the appropriate hzz?????.c or hex?????.c linked in
-
- */
+*/
 /***********************************************************************/
 #define SOURCEFILE_NAME "hpidspcd.c"
 #include "hpidspcd.h"
 #include "hpidebug.h"
 
-/**
- Header structure for binary dsp code file (see asidsp.doc)
- This structure must match that used in s2bin.c for generation of asidsp.bin
- */
-
-#ifndef DISABLE_PRAGMA_PACK1
-#pragma pack(push, 1)
-#endif
-
-struct code_header {
-        u32 size;
-        char type[4];
-        u32 adapter;
-        u32 version;
-        u32 crc;
+struct dsp_code_private {
+        /**  Firmware descriptor */
+        const struct firmware *firmware;
+        struct pci_dev *dev;
 };
 
-#ifndef DISABLE_PRAGMA_PACK1
-#pragma pack(pop)
-#endif
-
 #define HPI_VER_DECIMAL ((int)(HPI_VER_MAJOR(HPI_VER) * 10000 + \
             HPI_VER_MINOR(HPI_VER) * 100 + HPI_VER_RELEASE(HPI_VER)))
 
-/***********************************************************************/
 #include <linux/pci.h>
 /*-------------------------------------------------------------------*/
-short hpi_dsp_code_open(u32 adapter, struct dsp_code *ps_dsp_code,
-        u32 *pos_error_code)
+short hpi_dsp_code_open(u32 adapter, void *os_data, struct dsp_code *dsp_code,
+        u32 *os_error_code)
 {
-        const struct firmware *ps_firmware = ps_dsp_code->ps_firmware;
+        const struct firmware *firmware;
+        struct pci_dev *dev = os_data;
         struct code_header header;
         char fw_name[20];
         int err;
 
         sprintf(fw_name, "asihpi/dsp%04x.bin", adapter);
 
-        err = request_firmware(&ps_firmware, fw_name,
-                &ps_dsp_code->ps_dev->dev);
+        err = request_firmware(&firmware, fw_name, &dev->dev);
 
-        if (err != 0) {
-                dev_printk(KERN_ERR, &ps_dsp_code->ps_dev->dev,
+        if (err || !firmware) {
+                dev_printk(KERN_ERR, &dev->dev,
                         "%d, request_firmware failed for  %s\n", err,
                         fw_name);
                 goto error1;
         }
-        if (ps_firmware->size < sizeof(header)) {
-                dev_printk(KERN_ERR, &ps_dsp_code->ps_dev->dev,
-                        "Header size too small %s\n", fw_name);
-                goto error2;
-        }
-        memcpy(&header, ps_firmware->data, sizeof(header));
-        if (header.adapter != adapter) {
-                dev_printk(KERN_ERR, &ps_dsp_code->ps_dev->dev,
-                        "Adapter type incorrect %4x != %4x\n", header.adapter,
-                        adapter);
+        if (firmware->size < sizeof(header)) {
+                dev_printk(KERN_ERR, &dev->dev, "Header size too small %s\n",
+                        fw_name);
                 goto error2;
         }
-        if (header.size != ps_firmware->size) {
-                dev_printk(KERN_ERR, &ps_dsp_code->ps_dev->dev,
-                        "Code size wrong  %d != %ld\n", header.size,
-                        (unsigned long)ps_firmware->size);
+        memcpy(&header, firmware->data, sizeof(header));
+
+        if ((header.type != 0x45444F43) ||      /* "CODE" */
+                (header.adapter != adapter)
+                || (header.size != firmware->size)) {
+                dev_printk(KERN_ERR, &dev->dev, "Invalid firmware file\n");
                 goto error2;
         }
 
-        if (header.version / 100 != HPI_VER_DECIMAL / 100) {
-                dev_printk(KERN_ERR, &ps_dsp_code->ps_dev->dev,
+        if ((header.version / 100 & ~1) != (HPI_VER_DECIMAL / 100 & ~1)) {
+                dev_printk(KERN_ERR, &dev->dev,
                         "Incompatible firmware version "
                         "DSP image %d != Driver %d\n", header.version,
                         HPI_VER_DECIMAL);
@@ -109,67 +79,70 @@ short hpi_dsp_code_open(u32 adapter, struct dsp_code *ps_dsp_code,
         }
 
         if (header.version != HPI_VER_DECIMAL) {
-                dev_printk(KERN_WARNING, &ps_dsp_code->ps_dev->dev,
+                dev_printk(KERN_WARNING, &dev->dev,
                         "Firmware: release version mismatch  DSP image %d != Driver %d\n",
                         header.version, HPI_VER_DECIMAL);
         }
 
         HPI_DEBUG_LOG(DEBUG, "dsp code %s opened\n", fw_name);
-        ps_dsp_code->ps_firmware = ps_firmware;
-        ps_dsp_code->block_length = header.size / sizeof(u32);
-        ps_dsp_code->word_count = sizeof(header) / sizeof(u32);
-        ps_dsp_code->version = header.version;
-        ps_dsp_code->crc = header.crc;
+        dsp_code->pvt = kmalloc(sizeof(*dsp_code->pvt), GFP_KERNEL);
+        if (!dsp_code->pvt)
+                return HPI_ERROR_MEMORY_ALLOC;
+
+        dsp_code->pvt->dev = dev;
+        dsp_code->pvt->firmware = firmware;
+        dsp_code->header = header;
+        dsp_code->block_length = header.size / sizeof(u32);
+        dsp_code->word_count = sizeof(header) / sizeof(u32);
         return 0;
 
 error2:
-        release_firmware(ps_firmware);
+        release_firmware(firmware);
 error1:
-        ps_dsp_code->ps_firmware = NULL;
-        ps_dsp_code->block_length = 0;
+        dsp_code->block_length = 0;
         return HPI_ERROR_DSP_FILE_NOT_FOUND;
 }
 
 /*-------------------------------------------------------------------*/
-void hpi_dsp_code_close(struct dsp_code *ps_dsp_code)
+void hpi_dsp_code_close(struct dsp_code *dsp_code)
 {
-        if (ps_dsp_code->ps_firmware != NULL) {
+        if (dsp_code->pvt->firmware) {
                 HPI_DEBUG_LOG(DEBUG, "dsp code closed\n");
-                release_firmware(ps_dsp_code->ps_firmware);
-                ps_dsp_code->ps_firmware = NULL;
+                release_firmware(dsp_code->pvt->firmware);
+                dsp_code->pvt->firmware = NULL;
         }
+        kfree(dsp_code->pvt);
 }
 
 /*-------------------------------------------------------------------*/
-void hpi_dsp_code_rewind(struct dsp_code *ps_dsp_code)
+void hpi_dsp_code_rewind(struct dsp_code *dsp_code)
 {
         /* Go back to start of  data, after header */
-        ps_dsp_code->word_count = sizeof(struct code_header) / sizeof(u32);
+        dsp_code->word_count = sizeof(struct code_header) / sizeof(u32);
 }
 
 /*-------------------------------------------------------------------*/
-short hpi_dsp_code_read_word(struct dsp_code *ps_dsp_code, u32 *pword)
+short hpi_dsp_code_read_word(struct dsp_code *dsp_code, u32 *pword)
 {
-        if (ps_dsp_code->word_count + 1 > ps_dsp_code->block_length)
+        if (dsp_code->word_count + 1 > dsp_code->block_length)
                 return HPI_ERROR_DSP_FILE_FORMAT;
 
-        *pword = ((u32 *)(ps_dsp_code->ps_firmware->data))[ps_dsp_code->
+        *pword = ((u32 *)(dsp_code->pvt->firmware->data))[dsp_code->
                 word_count];
-        ps_dsp_code->word_count++;
+        dsp_code->word_count++;
         return 0;
 }
 
 /*-------------------------------------------------------------------*/
 short hpi_dsp_code_read_block(size_t words_requested,
-        struct dsp_code *ps_dsp_code, u32 **ppblock)
+        struct dsp_code *dsp_code, u32 **ppblock)
 {
-        if (ps_dsp_code->word_count + words_requested >
-                ps_dsp_code->block_length)
+        if (dsp_code->word_count + words_requested > dsp_code->block_length)
                 return HPI_ERROR_DSP_FILE_FORMAT;
 
         *ppblock =
-                ((u32 *)(ps_dsp_code->ps_firmware->data)) +
-                ps_dsp_code->word_count;
-        ps_dsp_code->word_count += words_requested;
+                ((u32 *)(dsp_code->pvt->firmware->data)) +
+                dsp_code->word_count;
+        dsp_code->word_count += words_requested;
         return 0;
 }