summaryrefslogtreecommitdiff
path: root/drivers/dahdi/voicebus/GpakCust.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/dahdi/voicebus/GpakCust.c')
-rw-r--r--drivers/dahdi/voicebus/GpakCust.c682
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;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-29 06:48:26 +0000