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;
 }