[deliverable/linux.git] / sound / pci / asihpi / hpidspcd.c

/***********************************************************************/
/*!

    AudioScience HPI driver
    Copyright (C) 1997-2010  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
    published by the Free Software Foundation;

    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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    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
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;
};

#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)
{
	const struct firmware *ps_firmware = ps_dsp_code->ps_firmware;
	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);

	if (err != 0) {
		dev_printk(KERN_ERR, &ps_dsp_code->ps_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);
		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);
		goto error2;
	}

	if (header.version / 100 != HPI_VER_DECIMAL / 100) {
		dev_printk(KERN_ERR, &ps_dsp_code->ps_dev->dev,
			"Incompatible firmware version "
			"DSP image %d != Driver %d\n", header.version,
			HPI_VER_DECIMAL);
		goto error2;
	}

	if (header.version != HPI_VER_DECIMAL) {
		dev_printk(KERN_WARNING, &ps_dsp_code->ps_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;
	return 0;

error2:
	release_firmware(ps_firmware);
error1:
	ps_dsp_code->ps_firmware = NULL;
	ps_dsp_code->block_length = 0;
	return HPI_ERROR_DSP_FILE_NOT_FOUND;
}

/*-------------------------------------------------------------------*/
void hpi_dsp_code_close(struct dsp_code *ps_dsp_code)
{
	if (ps_dsp_code->ps_firmware != NULL) {
		HPI_DEBUG_LOG(DEBUG, "dsp code closed\n");
		release_firmware(ps_dsp_code->ps_firmware);
		ps_dsp_code->ps_firmware = NULL;
	}
}

/*-------------------------------------------------------------------*/
void hpi_dsp_code_rewind(struct dsp_code *ps_dsp_code)
{
	/* Go back to start of  data, after header */
	ps_dsp_code->word_count = sizeof(struct code_header) / sizeof(u32);
}

/*-------------------------------------------------------------------*/
short hpi_dsp_code_read_word(struct dsp_code *ps_dsp_code, u32 *pword)
{
	if (ps_dsp_code->word_count + 1 > ps_dsp_code->block_length)
		return HPI_ERROR_DSP_FILE_FORMAT;

	*pword = ((u32 *)(ps_dsp_code->ps_firmware->data))[ps_dsp_code->
		word_count];
	ps_dsp_code->word_count++;
	return 0;
}

/*-------------------------------------------------------------------*/
short hpi_dsp_code_read_block(size_t words_requested,
	struct dsp_code *ps_dsp_code, u32 **ppblock)
{
	if (ps_dsp_code->word_count + words_requested >
		ps_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;
	return 0;
}
Commit	Line	Data
719f82d3 EB	1	/***********************************************************************/
	2	/*!
	3
	4	AudioScience HPI driver
	5	Copyright (C) 1997-2010 AudioScience Inc. <support@audioscience.com>
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of version 2 of the GNU General Public License as
	9	published by the Free Software Foundation;
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19
	20	\file
	21	Functions for reading DSP code to load into DSP
	22
	23	(Linux only:) If DSPCODE_FIRMWARE_LOADER is defined, code is read using
	24	hotplug firmware loader from individual dsp code files
	25
	26	If neither of the above is defined, code is read from linked arrays.
	27	DSPCODE_ARRAY is defined.
	28
	29	HPI_INCLUDE_**** must be defined
	30	and the appropriate hzz?????.c or hex?????.c linked in
	31
	32	*/
	33	/***********************************************************************/
	34	#define SOURCEFILE_NAME "hpidspcd.c"
	35	#include "hpidspcd.h"
	36	#include "hpidebug.h"
	37
	38	/**
	39	Header structure for binary dsp code file (see asidsp.doc)
	40	This structure must match that used in s2bin.c for generation of asidsp.bin
	41	*/
	42
	43	#ifndef DISABLE_PRAGMA_PACK1
	44	#pragma pack(push, 1)
	45	#endif
	46
	47	struct code_header {
	48	u32 size;
	49	char type[4];
	50	u32 adapter;
	51	u32 version;
	52	u32 crc;
	53	};
	54
	55	#ifndef DISABLE_PRAGMA_PACK1
	56	#pragma pack(pop)
	57	#endif
	58
	59	#define HPI_VER_DECIMAL ((int)(HPI_VER_MAJOR(HPI_VER) * 10000 + \
	60	HPI_VER_MINOR(HPI_VER) * 100 + HPI_VER_RELEASE(HPI_VER)))
	61
	62	/***********************************************************************/
d50a2fb6	63	#include <linux/pci.h>
719f82d3 EB	64	/-------------------------------------------------------------------/
	65	short hpi_dsp_code_open(u32 adapter, struct dsp_code *ps_dsp_code,
	66	u32 *pos_error_code)
	67	{
	68	const struct firmware *ps_firmware = ps_dsp_code->ps_firmware;
	69	struct code_header header;
	70	char fw_name[20];
	71	int err;
	72
	73	sprintf(fw_name, "asihpi/dsp%04x.bin", adapter);
719f82d3 EB	74
	75	err = request_firmware(&ps_firmware, fw_name,
	76	&ps_dsp_code->ps_dev->dev);
5ed15daf	77
719f82d3	78	if (err != 0) {
5ed15daf EB	79	dev_printk(KERN_ERR, &ps_dsp_code->ps_dev->dev,
	80	"%d, request_firmware failed for %s\n", err,
	81	fw_name);
719f82d3 EB	82	goto error1;
	83	}
	84	if (ps_firmware->size < sizeof(header)) {
5ed15daf EB	85	dev_printk(KERN_ERR, &ps_dsp_code->ps_dev->dev,
5ed15daf EB	86	"Header size too small %s\n", fw_name);
719f82d3 EB	87	goto error2;
	88	}
	89	memcpy(&header, ps_firmware->data, sizeof(header));
	90	if (header.adapter != adapter) {
5ed15daf EB	91	dev_printk(KERN_ERR, &ps_dsp_code->ps_dev->dev,
	92	"Adapter type incorrect %4x != %4x\n", header.adapter,
	93	adapter);
719f82d3 EB	94	goto error2;
	95	}
	96	if (header.size != ps_firmware->size) {
5ed15daf EB	97	dev_printk(KERN_ERR, &ps_dsp_code->ps_dev->dev,
	98	"Code size wrong %d != %ld\n", header.size,
	99	(unsigned long)ps_firmware->size);
719f82d3 EB	100	goto error2;
	101	}
	102
7f41b61b	103	if (header.version / 100 != HPI_VER_DECIMAL / 100) {
5ed15daf	104	dev_printk(KERN_ERR, &ps_dsp_code->ps_dev->dev,
7f41b61b	105	"Incompatible firmware version "
5ed15daf	106	"DSP image %d != Driver %d\n", header.version,
719f82d3 EB	107	HPI_VER_DECIMAL);
	108	goto error2;
	109	}
	110
	111	if (header.version != HPI_VER_DECIMAL) {
5ed15daf	112	dev_printk(KERN_WARNING, &ps_dsp_code->ps_dev->dev,
7f41b61b	113	"Firmware: release version mismatch DSP image %d != Driver %d\n",
719f82d3	114	header.version, HPI_VER_DECIMAL);
719f82d3 EB	115	}
719f82d3 EB	116
5ed15daf	117	HPI_DEBUG_LOG(DEBUG, "dsp code %s opened\n", fw_name);
719f82d3 EB	118	ps_dsp_code->ps_firmware = ps_firmware;
	119	ps_dsp_code->block_length = header.size / sizeof(u32);
	120	ps_dsp_code->word_count = sizeof(header) / sizeof(u32);
	121	ps_dsp_code->version = header.version;
	122	ps_dsp_code->crc = header.crc;
	123	return 0;
	124
	125	error2:
	126	release_firmware(ps_firmware);
	127	error1:
	128	ps_dsp_code->ps_firmware = NULL;
	129	ps_dsp_code->block_length = 0;
	130	return HPI_ERROR_DSP_FILE_NOT_FOUND;
	131	}
	132
	133	/-------------------------------------------------------------------/
	134	void hpi_dsp_code_close(struct dsp_code *ps_dsp_code)
	135	{
	136	if (ps_dsp_code->ps_firmware != NULL) {
	137	HPI_DEBUG_LOG(DEBUG, "dsp code closed\n");
	138	release_firmware(ps_dsp_code->ps_firmware);
	139	ps_dsp_code->ps_firmware = NULL;
	140	}
	141	}
	142
	143	/-------------------------------------------------------------------/
	144	void hpi_dsp_code_rewind(struct dsp_code *ps_dsp_code)
	145	{
	146	/* Go back to start of data, after header */
	147	ps_dsp_code->word_count = sizeof(struct code_header) / sizeof(u32);
	148	}
	149
	150	/-------------------------------------------------------------------/
	151	short hpi_dsp_code_read_word(struct dsp_code ps_dsp_code, u32 pword)
	152	{
	153	if (ps_dsp_code->word_count + 1 > ps_dsp_code->block_length)
5ed15daf	154	return HPI_ERROR_DSP_FILE_FORMAT;
719f82d3 EB	155
	156	pword = ((u32 )(ps_dsp_code->ps_firmware->data))[ps_dsp_code->
	157	word_count];
	158	ps_dsp_code->word_count++;
	159	return 0;
	160	}
	161
	162	/-------------------------------------------------------------------/
	163	short hpi_dsp_code_read_block(size_t words_requested,
	164	struct dsp_code ps_dsp_code, u32 *ppblock)
	165	{
	166	if (ps_dsp_code->word_count + words_requested >
	167	ps_dsp_code->block_length)
	168	return HPI_ERROR_DSP_FILE_FORMAT;
	169
	170	*ppblock =
	171	((u32 *)(ps_dsp_code->ps_firmware->data)) +
	172	ps_dsp_code->word_count;
	173	ps_dsp_code->word_count += words_requested;
	174	return 0;
	175	}