voicebus: Move common vpmadt032 interface into voicebus module.

The voicebus library was previously linked into both the wcte12xp and wctdm24xxp
drivers.  It is now broken out into it's own module and the common parts of the
vpmadt032 interface are now located in that module to reduce duplication between
the wcte12xp and wctdm24xxp drivers.

git-svn-id: http://svn.asterisk.org/svn/dahdi/linux/trunk@6527 a0bf4364-ded3-4de4-8d8a-66a801d63aff

1 files changed, 682 insertions, 0 deletions

diff --git a/drivers/dahdi/voicebus/GpakCust.c b/drivers/dahdi/voicebus/GpakCust.c
new file mode 100644
index 0000000..386c916
--- /dev/null
+++ b/drivers/dahdi/voicebus/GpakCust.c
@@ -0,0 +1,682 @@
+/*
+ * Copyright (c) 2005, Adaptive Digital Technologies, Inc.
+ * Copyright (c) 2005-2009, Digium Incorporated
+ *
+ * File Name: GpakCust.c
+ *
+ * Description:
+ *   This file contains host system dependent functions to support generic
+ *   G.PAK API functions. The file is integrated into the host processor
+ *   connected to C55x G.PAK DSPs via a Host Port Interface.
+ *
+ *   Note: This file is supplied by Adaptive Digital Technologies and
+ *   modified by Digium in order to support the VPMADT032 modules.
+ *
+ * This program has been released under the terms of the GPL version 2 by
+ * permission of Adaptive Digital Technologies, Inc.
+ *
+ */
+
+/*
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2 as published by the
+ * Free Software Foundation. See the LICENSE file included with
+ * this program for more details.
+ */
+
+#include <linux/version.h>
+#include <linux/types.h>
+#include <linux/delay.h>
+#include <linux/pci.h>
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
+#include <linux/semaphore.h>
+#else
+#include <asm/semaphore.h>
+#endif
+
+#include <dahdi/kernel.h>
+#include <dahdi/user.h>
+
+#include "GpakCust.h"
+#include "GpakApi.h"
+
+#include "adt_lec.h"
+#include "voicebus.h"
+#include "vpmadtreg.h"
+
+static rwlock_t ifacelock;
+static struct vpmadt032 *ifaces[MAX_DSP_CORES];
+
+static inline struct vpmadt032 *find_iface(const unsigned short dspid)
+{
+	struct vpmadt032 *ret;
+
+	read_lock(&ifacelock);
+	if (ifaces[dspid]) {
+		ret = ifaces[dspid];
+	} else {
+		ret = NULL;
+	}
+	read_unlock(&ifacelock);
+	return ret;
+}
+
+static struct vpmadt032_cmd *vpmadt032_get_free_cmd(struct vpmadt032 *vpm)
+{
+	unsigned long flags;
+	struct vpmadt032_cmd *cmd;
+	might_sleep();
+	spin_lock_irqsave(&vpm->list_lock, flags);
+	if (list_empty(&vpm->free_cmds)) {
+		spin_unlock_irqrestore(&vpm->list_lock, flags);
+		cmd = kmalloc(sizeof(struct vpmadt032_cmd), GFP_KERNEL);
+		if (unlikely(!cmd))
+			return NULL;
+		memset(cmd, 0, sizeof(*cmd));
+	} else {
+		cmd = list_entry(vpm->free_cmds.next, struct vpmadt032_cmd, node);
+		list_del_init(&cmd->node);
+		spin_unlock_irqrestore(&vpm->list_lock, flags);
+	}
+	init_completion(&cmd->complete);
+	return cmd;
+}
+
+/* Wait for any outstanding commands to the VPMADT032 to complete */
+static inline int vpmadt032_io_wait(struct vpmadt032 *vpm)
+{
+	unsigned long flags;
+	int empty;
+	while (1) {
+		spin_lock_irqsave(&vpm->list_lock, flags);
+		empty = list_empty(&vpm->pending_cmds) && list_empty(&vpm->active_cmds);
+		spin_unlock_irqrestore(&vpm->list_lock, flags);
+		if (empty) {
+			break;
+		} else {
+			msleep(1);
+		}
+	}
+	return 0;
+}
+
+/* Issue a read command to a register on the VPMADT032. We'll get the results
+ * later. */
+static struct vpmadt032_cmd *vpmadt032_getreg_full_async(struct vpmadt032 *vpm, int pagechange,
+	unsigned short addr)
+{
+	unsigned long flags;
+	struct vpmadt032_cmd *cmd;
+	cmd = vpmadt032_get_free_cmd(vpm);
+	if (!cmd)
+		return NULL;
+	cmd->desc = (pagechange) ? __VPM150M_RWPAGE | __VPM150M_RD : __VPM150M_RD;
+	cmd->address = addr;
+	cmd->data = 0;
+	spin_lock_irqsave(&vpm->list_lock, flags);
+	list_add_tail(&cmd->node, &vpm->pending_cmds);
+	spin_unlock_irqrestore(&vpm->list_lock, flags);
+	return cmd;
+}
+
+/* Get the results from a previous call to vpmadt032_getreg_full_async. */
+int vpmadt032_getreg_full_return(struct vpmadt032 *vpm, int pagechange,
+	u16 addr, u16 *outbuf, struct vpmadt032_cmd *cmd)
+{
+	unsigned long flags;
+	int ret = -EIO;
+	BUG_ON(!cmd);
+	wait_for_completion(&cmd->complete);
+	if (cmd->desc & __VPM150M_FIN) {
+		*outbuf = cmd->data;
+		cmd->desc = 0;
+		ret = 0;
+	}
+
+	/* Just throw this command back on the ready list. */
+	spin_lock_irqsave(&vpm->list_lock, flags);
+	list_add_tail(&cmd->node, &vpm->free_cmds);
+	spin_unlock_irqrestore(&vpm->list_lock, flags);
+	return ret;
+}
+
+/* Read one of the registers on the VPMADT032 */
+static int vpmadt032_getreg_full(struct vpmadt032 *vpm, int pagechange, u16 addr, u16 *outbuf)
+{
+	struct vpmadt032_cmd *cmd;
+	cmd = vpmadt032_getreg_full_async(vpm, pagechange, addr);
+	if (unlikely(!cmd)) {
+		return -ENOMEM;
+	}
+	return vpmadt032_getreg_full_return(vpm, pagechange, addr, outbuf, cmd);
+}
+
+static int vpmadt032_setreg_full(struct vpmadt032 *vpm, int pagechange, unsigned int addr,
+                        u16 data)
+{
+	unsigned long flags;
+	struct vpmadt032_cmd *cmd;
+	cmd = vpmadt032_get_free_cmd(vpm);
+	if (!cmd)
+		return -ENOMEM;
+	cmd->desc = cpu_to_le16((pagechange) ? (__VPM150M_WR|__VPM150M_RWPAGE) : __VPM150M_WR);
+	cmd->address = cpu_to_le16(addr);
+	cmd->data = cpu_to_le16(data);
+	spin_lock_irqsave(&vpm->list_lock, flags);
+	list_add_tail(&cmd->node, &vpm->pending_cmds);
+	spin_unlock_irqrestore(&vpm->list_lock, flags);
+	return 0;
+}
+
+
+static int vpmadt032_setpage(struct vpmadt032 *vpm, u16 addr)
+{
+	addr &= 0xf;
+	/* We do not need to set the page if we're already on the page we're
+	 * interested in. */
+	if (vpm->curpage == addr)
+		return 0;
+	else
+		vpm->curpage = addr;
+
+	return vpmadt032_setreg_full(vpm, 1, 0, addr);
+}
+
+static unsigned char vpmadt032_getpage(struct vpmadt032 *vpm)
+{
+	unsigned short res;
+	const int pagechange = 1;
+	vpmadt032_getreg_full(vpm, pagechange, 0, &res);
+	return res;
+}
+
+static int vpmadt032_getreg(struct vpmadt032 *vpm, unsigned int addr, u16 *data)
+{
+	unsigned short res;
+	vpmadt032_setpage(vpm, addr >> 16);
+	res = vpmadt032_getreg_full(vpm, 0, addr & 0xffff, data);
+ 	return res;
+}
+
+static int vpmadt032_setreg(struct vpmadt032 *vpm, unsigned int addr, u16 data)
+{
+	int res;
+	vpmadt032_setpage(vpm, addr >> 16);
+	res = vpmadt032_setreg_full(vpm, 0, addr & 0xffff, data);
+	return res;
+}
+
+/**
+ * vpmadt032_bh - Changes the echocan parameters on the vpmadt032 module.
+ *
+ * This function is typically scheduled to run in the workqueue by the
+ * vpmadt032_echocan_with_params function.  This is because communicating with
+ * the hardware can take some time while messages are sent to the VPMADT032
+ * module and the driver waits for the responses.
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
+static void vpmadt032_bh(void *data)
+{
+	struct vpmadt032 *vpm = data;
+#else
+static void vpmadt032_bh(struct work_struct *data)
+{
+	struct vpmadt032 *vpm = container_of(data, struct vpmadt032, work);
+#endif
+	struct adt_lec_params *curstate, *desiredstate;
+	int channel;
+
+	/* Sweep through all the echo can channels on the VPMADT032 module,
+	 * looking for ones where the desired state does not match the current
+	 * state.
+	 */
+	for (channel = 0; channel < vpm->span->channels; channel++) {
+		GPAK_AlgControlStat_t pstatus;
+		int res = 1;
+		curstate = &vpm->curecstate[channel];
+		desiredstate = &vpm->desiredecstate[channel];
+
+		if ((desiredstate->nlp_type != curstate->nlp_type) ||
+		    (desiredstate->nlp_threshold != curstate->nlp_threshold) ||
+		    (desiredstate->nlp_max_suppress != curstate->nlp_max_suppress)) {
+
+			GPAK_ChannelConfigStat_t cstatus;
+			GPAK_TearDownChanStat_t tstatus;
+			GpakChannelConfig_t chanconfig;
+
+			if (vpm->options.debug & DEBUG_ECHOCAN)
+				printk(KERN_DEBUG "Reconfiguring chan %d for nlp %d, nlp_thresh %d, and max_supp %d\n", channel + 1, vpm->desiredecstate[channel].nlp_type,
+					desiredstate->nlp_threshold, desiredstate->nlp_max_suppress);
+
+			vpm->setchanconfig_from_state(vpm, channel, &chanconfig);
+
+			res = gpakTearDownChannel(vpm->dspid, channel, &tstatus);
+			if (res)
+				goto vpm_bh_out;
+
+			res = gpakConfigureChannel(vpm->dspid, channel, tdmToTdm, &chanconfig, &cstatus);
+			if (res)
+				goto vpm_bh_out;
+
+			if (!desiredstate->tap_length) {
+				res = gpakAlgControl(vpm->dspid, channel, BypassSwCompanding, &pstatus);
+				if (res)
+					printk("Unable to disable sw companding on echo cancellation channel %d (reason %d)\n", channel, res);
+				res = gpakAlgControl(vpm->dspid, channel, BypassEcanA, &pstatus);
+			}
+
+		} else if (desiredstate->tap_length != curstate->tap_length) {
+			if (desiredstate->tap_length) {
+				printk(KERN_DEBUG "Enabling ecan on channel: %d\n", channel);
+				res = gpakAlgControl(vpm->dspid, channel, EnableMuLawSwCompanding, &pstatus);
+				if (res)
+					printk("Unable to set SW Companding on channel %d (reason %d)\n", channel, res);
+				res = gpakAlgControl(vpm->dspid, channel, EnableEcanA, &pstatus);
+			} else {
+				printk(KERN_DEBUG "Disabling ecan on channel: %d\n", channel);
+				res = gpakAlgControl(vpm->dspid, channel, BypassSwCompanding, &pstatus);
+				if (res)
+					printk("Unable to disable sw companding on echo cancellation channel %d (reason %d)\n", channel, res);
+				res = gpakAlgControl(vpm->dspid, channel, BypassEcanA, &pstatus);
+			}
+		}
+vpm_bh_out:
+		if (!res)
+			*curstate = *desiredstate;
+	}
+	return;
+}
+#include "adt_lec.c"
+int vpmadt032_echocan_with_params(struct vpmadt032 *vpm, int channo,
+	struct dahdi_echocanparams *ecp, struct dahdi_echocanparam *p)
+{
+	int update;
+	unsigned int ret;
+
+	ret = adt_lec_parse_params(&vpm->desiredecstate[channo], ecp, p);
+	if (ret)
+		return ret;
+
+	/* The driver cannot control the number of taps on the VPMADT032
+	 * module. Instead, it uses tap_length to enable or disable the echo
+	 * cancellation. */
+	vpm->desiredecstate[channo].tap_length = (ecp->tap_length) ? 1 : 0;
+
+	/* Only update the parameters if the new state of the echo canceller
+	 * is different than the current state. */
+	update = memcmp(&vpm->curecstate[channo],
+			&vpm->desiredecstate[channo],
+			sizeof(vpm->curecstate[channo]));
+	if (update && test_bit(VPM150M_ACTIVE, &vpm->control)) {
+		/* Since updating the parameters can take a bit of time while
+		 * the driver sends messages to the VPMADT032 and waits for
+		 * their responses, we'll push the work of updating the
+		 * parameters to a work queue so the caller can continue to
+		 * proceed with setting up the call.
+		 */
+		schedule_work(&vpm->work);
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL(vpmadt032_echocan_with_params);
+
+struct vpmadt032 *vpmadt032_alloc(struct vpmadt032_options *options)
+{
+	struct vpmadt032 *vpm;
+	int i;
+	might_sleep();
+
+	vpm = kzalloc(sizeof(*vpm), GFP_KERNEL);
+	if (!vpm)
+		return NULL;
+
+	/* Init our vpmadt032 struct */
+	memcpy(&vpm->options, options, sizeof(*options));
+	spin_lock_init(&vpm->list_lock);
+	INIT_LIST_HEAD(&vpm->free_cmds);
+	INIT_LIST_HEAD(&vpm->pending_cmds);
+	INIT_LIST_HEAD(&vpm->active_cmds);
+	sema_init(&vpm->sem, 1);
+	vpm->curpage = 0x80;
+	vpm->dspid = -1;
+
+	/* Place this structure in the ifaces array so that the DspId from the
+	 * Gpak Library can be used to locate it. */
+	write_lock(&ifacelock);
+	for (i=0; i<MAX_DSP_CORES; ++i) {
+		if (NULL == ifaces[i]) {
+			ifaces[i] = vpm;
+			vpm->dspid = i;
+			break;
+		}
+	}
+	write_unlock(&ifacelock);
+
+	if (-1 == vpm->dspid) {
+		kfree(vpm);
+		printk(KERN_NOTICE "Unable to initialize another vpmadt032 modules\n");
+		vpm = NULL;
+	} else if (vpm->options.debug & DEBUG_ECHOCAN) {
+		printk(KERN_DEBUG "Setting VPMADT032 DSP ID to %d\n", vpm->dspid);
+	}
+
+	return vpm;
+}
+EXPORT_SYMBOL(vpmadt032_alloc);
+
+int
+vpmadt032_init(struct vpmadt032 *vpm, struct voicebus *vb)
+{
+	int i;
+	u16 reg;
+	int res = -EFAULT;
+	gpakPingDspStat_t pingstatus;
+
+	BUG_ON(!vpm->setchanconfig_from_state);
+	might_sleep();
+
+	if (vpm->options.debug & DEBUG_ECHOCAN)
+		printk(KERN_DEBUG "VPMADT032 Testing page access: ");
+
+	for (i = 0; i < 0xf; i++) {
+		int x;
+		for (x = 0; x < 3; x++) {
+			vpmadt032_setpage(vpm, i);
+			reg = vpmadt032_getpage(vpm);
+			if (reg != i) {
+				if (vpm->options.debug & DEBUG_ECHOCAN)
+					printk(KERN_DEBUG "Failed: Sent %x != %x VPMADT032 Failed HI page test\n", i, reg);
+				res = -ENODEV;
+				goto failed_exit;
+			}
+		}
+	}
+
+	if (vpm->options.debug & DEBUG_ECHOCAN)
+		printk(KERN_DEBUG "Passed\n");
+
+	set_bit(VPM150M_HPIRESET, &vpm->control);
+	msleep(2000);
+	while (test_bit(VPM150M_HPIRESET, &vpm->control))
+		msleep(1);
+
+	/* Set us up to page 0 */
+	vpmadt032_setpage(vpm, 0);
+	if (vpm->options.debug & DEBUG_ECHOCAN)
+		printk(KERN_DEBUG "VPMADT032 now doing address test: ");
+
+	for (i = 0; i < 16; i++) {
+		int x;
+		for (x = 0; x < 2; x++) {
+			vpmadt032_setreg(vpm, 0x1000, i);
+			vpmadt032_getreg(vpm, 0x1000, &reg);
+			if (reg != i) {
+				printk("VPMADT032 Failed address test\n");
+				goto failed_exit;
+			}
+
+		}
+	}
+
+	if (vpm->options.debug & DEBUG_ECHOCAN)
+		printk("Passed\n");
+
+	set_bit(VPM150M_HPIRESET, &vpm->control);
+	while (test_bit(VPM150M_HPIRESET, &vpm->control))
+		msleep(1);
+
+	res = vpmadtreg_loadfirmware(vb);
+	if (res) {
+		struct pci_dev *pdev = voicebus_get_pci_dev(vb);
+		dev_printk(KERN_INFO, &pdev->dev, "Failed to load the firmware.\n");
+		return res;
+	}
+	vpm->curpage = -1;
+	set_bit(VPM150M_SWRESET, &vpm->control);
+
+	while (test_bit(VPM150M_SWRESET, &vpm->control))
+		msleep(1);
+
+	pingstatus = gpakPingDsp(vpm->dspid, &vpm->version);
+
+	if (!pingstatus) {
+		if (vpm->options.debug & DEBUG_ECHOCAN)
+			printk(KERN_DEBUG "Version of DSP is %x\n", vpm->version);
+	} else {
+		printk(KERN_NOTICE "VPMADT032 Failed! Unable to ping the DSP (%d)!\n", pingstatus);
+		res = -1;
+		goto failed_exit;
+	}
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
+	INIT_WORK(&vpm->work, vpmadt032_bh, vpm);
+#else
+	INIT_WORK(&vpm->work, vpmadt032_bh);
+#endif
+
+	return 0;
+
+failed_exit:
+	return res;
+}
+EXPORT_SYMBOL(vpmadt032_init);
+
+
+void vpmadt032_free(struct vpmadt032 *vpm)
+{
+	unsigned long flags;
+	struct vpmadt032_cmd *cmd;
+	LIST_HEAD(local_list);
+
+	BUG_ON(!vpm);
+
+	/* Move all the commands onto the local list protected by the locks */
+	spin_lock_irqsave(&vpm->list_lock, flags);
+	list_splice(&vpm->pending_cmds, &local_list);
+	list_splice(&vpm->active_cmds, &local_list);
+	list_splice(&vpm->free_cmds, &local_list);
+	spin_unlock_irqrestore(&vpm->list_lock, flags);
+
+	while (!list_empty(&local_list)) {
+		cmd = list_entry(local_list.next, struct vpmadt032_cmd, node);
+		list_del(&cmd->node);
+		kfree(cmd);
+	}
+
+	BUG_ON(ifaces[vpm->dspid] != vpm);
+	write_lock(&ifacelock);
+	ifaces[vpm->dspid] = NULL;
+	write_unlock(&ifacelock);
+	kfree(vpm);
+}
+EXPORT_SYMBOL(vpmadt032_free);
+
+int vpmadt032_module_init(void)
+{
+	rwlock_init(&ifacelock);
+	memset(ifaces, 0, sizeof(ifaces));
+	return 0;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * gpakReadDspMemory - Read DSP memory.
+ *
+ * FUNCTION
+ *  This function reads a contiguous block of words from DSP memory starting at
+ *  the specified address.
+ *
+ * RETURNS
+ *  nothing
+ *
+ */
+void gpakReadDspMemory(
+    unsigned short int DspId,   /* DSP Identifier (0 to MAX_DSP_CORES-1) */
+    DSP_ADDRESS DspAddress,     /* DSP's memory address of first word */
+    unsigned int NumWords,      /* number of contiguous words to read */
+    DSP_WORD *pWordValues       /* pointer to array of word values variable */
+    )
+{
+	struct vpmadt032 *vpm = find_iface(DspId);
+	int i;
+	int ret;
+
+	vpmadt032_io_wait(vpm);
+	if ( NumWords < VPM150M_MAX_COMMANDS ) {
+		struct vpmadt032_cmd *cmds[VPM150M_MAX_COMMANDS] = {0};
+		vpmadt032_setpage(vpm, DspAddress >> 16);
+		DspAddress &= 0xffff;
+		for (i=0; i < NumWords; ++i) {
+			if (!(cmds[i] = vpmadt032_getreg_full_async(vpm,0,DspAddress+i))) {
+				return;
+			}
+		}
+		for (i=NumWords-1; i >=0; --i) {
+			ret = vpmadt032_getreg_full_return(vpm,0,DspAddress+i,&pWordValues[i],
+				cmds[i]);
+			if (0 != ret) {
+				return;
+			}
+		}
+	}
+	else {
+		for (i=0; i<NumWords; ++i) {
+			vpmadt032_getreg(vpm, DspAddress + i, &pWordValues[i]);
+		}
+	}
+	return;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * gpakWriteDspMemory - Write DSP memory.
+ *
+ * FUNCTION
+ *  This function writes a contiguous block of words to DSP memory starting at
+ *  the specified address.
+ *
+ * RETURNS
+ *  nothing
+ *
+ */
+void gpakWriteDspMemory(
+    unsigned short int DspId,   /* DSP Identifier (0 to MAX_DSP_CORES-1) */
+    DSP_ADDRESS DspAddress,     /* DSP's memory address of first word */
+    unsigned int NumWords,      /* number of contiguous words to write */
+    DSP_WORD *pWordValues       /* pointer to array of word values to write */
+    )
+{
+
+	struct vpmadt032 *vpm = find_iface(DspId);
+	int i;
+
+	//printk(KERN_DEBUG "Writing %d words to memory\n", NumWords);
+	if (vpm) {
+		for (i = 0; i < NumWords; ++i) {
+			vpmadt032_setreg(vpm, DspAddress + i, pWordValues[i]);
+		}
+#if 0
+		for (i = 0; i < NumWords; i++) {
+			if (wctdm_vpmadt032_getreg(wc, DspAddress + i) != pWordValues[i]) {
+				printk(KERN_NOTICE "Error in write.  Address %x is not %x\n", DspAddress + i, pWordValues[i]);
+			}
+		}
+#endif
+	}
+	return;
+
+}
+
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * gpakHostDelay - Delay for a fixed time interval.
+ *
+ * FUNCTION
+ *  This function delays for a fixed time interval before returning. The time
+ *  interval is the Host Port Interface sampling period when polling a DSP for
+ *  replies to command messages.
+ *
+ * RETURNS
+ *  nothing
+ *
+ */
+void gpakHostDelay(void)
+{
+}
+
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * gpakLockAccess - Lock access to the specified DSP.
+ *
+ * FUNCTION
+ *  This function aquires exclusive access to the specified DSP.
+ *
+ * RETURNS
+ *  nothing
+ *
+ */
+void gpakLockAccess(unsigned short DspId)
+{
+	struct vpmadt032 *vpm;
+
+	vpm = find_iface(DspId);
+
+	if (vpm) {
+		if (down_interruptible(&vpm->sem)) {
+			return;
+		}
+	}
+}
+
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * gpakUnlockAccess - Unlock access to the specified DSP.
+ *
+ * FUNCTION
+ *  This function releases exclusive access to the specified DSP.
+ *
+ * RETURNS
+ *  nothing
+ *
+ */
+void gpakUnlockAccess(unsigned short DspId)
+{
+	struct vpmadt032 *vpm;
+
+	vpm = find_iface(DspId);
+
+	if (vpm) {
+		up(&vpm->sem);
+	}
+}
+
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * gpakReadFile - Read a block of bytes from a G.PAK Download file.
+ *
+ * FUNCTION
+ *  This function reads a contiguous block of bytes from a G.PAK Download file
+ *  starting at the current file position.
+ *
+ * RETURNS
+ *  The number of bytes read from the file.
+ *   -1 indicates an error occurred.
+ *    0 indicates all bytes have been read (end of file)
+ *
+ */
+int gpakReadFile(
+    GPAK_FILE_ID FileId,        /* G.PAK Download File Identifier */
+    unsigned char *pBuffer,	/* pointer to buffer for storing bytes */
+    unsigned int NumBytes       /* number of bytes to read */
+    )
+{
+	/* The firmware is loaded into the part by a closed-source firmware
+	 * loader, and therefore this function should never be called. */
+	WARN_ON(1);
+	return -1;
+}