diff options
| -rw-r--r-- | drivers/staging/Kconfig | 2 | ||||
| -rw-r--r-- | drivers/staging/Makefile | 1 | ||||
| -rw-r--r-- | drivers/staging/ced1401/Kconfig | 6 | ||||
| -rw-r--r-- | drivers/staging/ced1401/Makefile | 3 | ||||
| -rw-r--r-- | drivers/staging/ced1401/TODO | 10 | ||||
| -rw-r--r-- | drivers/staging/ced1401/ced_ioc.c | 1613 | ||||
| -rw-r--r-- | drivers/staging/ced1401/ced_ioctl.h | 336 | ||||
| -rw-r--r-- | drivers/staging/ced1401/machine.h | 119 | ||||
| -rw-r--r-- | drivers/staging/ced1401/usb1401.c | 1767 | ||||
| -rw-r--r-- | drivers/staging/ced1401/usb1401.h | 260 | ||||
| -rw-r--r-- | drivers/staging/ced1401/use1401.h | 288 | ||||
| -rw-r--r-- | drivers/staging/ced1401/use14_ioc.h | 299 | ||||
| -rw-r--r-- | drivers/staging/ced1401/userspace/use1401.c | 3030 |
13 files changed, 0 insertions, 7734 deletions
diff --git a/drivers/staging/Kconfig b/drivers/staging/Kconfig index 12b092c..0a92dc6 100644 --- a/drivers/staging/Kconfig +++ b/drivers/staging/Kconfig @@ -106,8 +106,6 @@ source "drivers/staging/gdm724x/Kconfig" source "drivers/staging/silicom/Kconfig" -source "drivers/staging/ced1401/Kconfig" - source "drivers/staging/imx-drm/Kconfig" source "drivers/staging/fwserial/Kconfig" diff --git a/drivers/staging/Makefile b/drivers/staging/Makefile index 29fa5df..fe5e76c 100644 --- a/drivers/staging/Makefile +++ b/drivers/staging/Makefile @@ -46,7 +46,6 @@ obj-$(CONFIG_USB_WPAN_HCD) += ozwpan/ obj-$(CONFIG_WIMAX_GDM72XX) += gdm72xx/ obj-$(CONFIG_LTE_GDM724X) += gdm724x/ obj-$(CONFIG_NET_VENDOR_SILICOM) += silicom/ -obj-$(CONFIG_CED1401) += ced1401/ obj-$(CONFIG_DRM_IMX) += imx-drm/ obj-$(CONFIG_FIREWIRE_SERIAL) += fwserial/ obj-$(CONFIG_GOLDFISH) += goldfish/ diff --git a/drivers/staging/ced1401/Kconfig b/drivers/staging/ced1401/Kconfig deleted file mode 100644 index ae36d1b..0000000 --- a/drivers/staging/ced1401/Kconfig +++ /dev/null @@ -1,6 +0,0 @@ -config CED1401 - tristate "Cambridge Electronic Design 1401 USB support" - depends on USB - help - This driver supports the Cambridge Electronic Design 1401 USB device - (whatever that is.) diff --git a/drivers/staging/ced1401/Makefile b/drivers/staging/ced1401/Makefile deleted file mode 100644 index f0c114b..0000000 --- a/drivers/staging/ced1401/Makefile +++ /dev/null @@ -1,3 +0,0 @@ - -obj-$(CONFIG_CED1401) := cedusb.o -cedusb-objs := usb1401.o ced_ioc.o diff --git a/drivers/staging/ced1401/TODO b/drivers/staging/ced1401/TODO deleted file mode 100644 index 9fd5630..0000000 --- a/drivers/staging/ced1401/TODO +++ /dev/null @@ -1,10 +0,0 @@ -TODO: - - coding syle fixes - - build warning fixups - - ioctl auditing - - usb api auditing - - proper USB minor number (it's stomping on an existing one right now.) - -Please send patches to Greg Kroah-Hartman <gregkh@linuxfoundation.org> and Cc: -Alois Schlögl <alois.schloegl@ist.ac.at> - diff --git a/drivers/staging/ced1401/ced_ioc.c b/drivers/staging/ced1401/ced_ioc.c deleted file mode 100644 index 8cb6ea9..0000000 --- a/drivers/staging/ced1401/ced_ioc.c +++ /dev/null @@ -1,1613 +0,0 @@ -/* ced_ioc.c - ioctl part of the 1401 usb device driver for linux. - Copyright (C) 2010 Cambridge Electronic Design Ltd - Author Greg P Smith (greg@ced.co.uk) - - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License - as published by the Free Software Foundation; either version 2 - of the License, or (at your option) any later version. - - 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. -*/ -#include <linux/kernel.h> -#include <linux/errno.h> -#include <linux/slab.h> -#include <linux/module.h> -#include <linux/kref.h> -#include <linux/uaccess.h> -#include <linux/usb.h> -#include <linux/mutex.h> -#include <linux/page-flags.h> -#include <linux/pagemap.h> -#include <linux/jiffies.h> - -#include "usb1401.h" - -/**************************************************************************** -** ced_flush_out_buff -** -** Empties the Output buffer and sets int lines. Used from user level only -****************************************************************************/ -static void ced_flush_out_buff(struct ced_data *ced) -{ - dev_dbg(&ced->interface->dev, "%s: current_state=%d\n", - __func__, ced->current_state); - - /* Do nothing if hardware in trouble */ - if (ced->current_state == U14ERR_TIME) - return; - /* Kill off any pending I/O */ - /* CharSend_Cancel(ced); */ - spin_lock_irq(&ced->char_out_lock); - ced->num_output = 0; - ced->out_buff_get = 0; - ced->out_buff_put = 0; - spin_unlock_irq(&ced->char_out_lock); -} - -/**************************************************************************** -** -** ced_flush_in_buff -** -** Empties the input buffer and sets int lines -****************************************************************************/ -static void ced_flush_in_buff(struct ced_data *ced) -{ - dev_dbg(&ced->interface->dev, "%s: current_state=%d\n", - __func__, ced->current_state); - - if (ced->current_state == U14ERR_TIME) - return; /* Do nothing if hardware in trouble */ - - /* Kill off any pending I/O */ - /* CharRead_Cancel(pDevObject); */ - spin_lock_irq(&ced->char_in_lock); - ced->num_input = 0; - ced->in_buff_get = 0; - ced->in_buff_put = 0; - spin_unlock_irq(&ced->char_in_lock); -} - -/**************************************************************************** -** ced_put_chars -** -** Utility routine to copy chars into the output buffer and fire them off. -** called from user mode, holds char_out_lock. -****************************************************************************/ -static int ced_put_chars(struct ced_data *ced, const char *ch, - unsigned int count) -{ - int ret; - - spin_lock_irq(&ced->char_out_lock); /* get the output spin lock */ - if ((OUTBUF_SZ - ced->num_output) >= count) { - unsigned int u; - - for (u = 0; u < count; u++) { - ced->output_buffer[ced->out_buff_put++] = ch[u]; - if (ced->out_buff_put >= OUTBUF_SZ) - ced->out_buff_put = 0; - } - ced->num_output += count; - spin_unlock_irq(&ced->char_out_lock); - - /* ...give a chance to transmit data */ - ret = ced_send_chars(ced); - } else { - ret = U14ERR_NOOUT; /* no room at the out (ha-ha) */ - spin_unlock_irq(&ced->char_out_lock); - } - return ret; -} - -/***************************************************************************** -** Add the data in "data" local pointer of length n to the output buffer, and -** trigger an output transfer if this is appropriate. User mode. -** Holds the io_mutex -*****************************************************************************/ -int ced_send_string(struct ced_data *ced, const char __user *data, - unsigned int n) -{ - int ret = U14ERR_NOERROR; /* assume all will be well */ - char buffer[OUTBUF_SZ + 1]; /* space in our address space */ - /* for characters */ - if (n > OUTBUF_SZ) /* check space in local buffer... */ - return U14ERR_NOOUT; /* ...too many characters */ - if (copy_from_user(buffer, data, n)) - return -EFAULT; - buffer[n] = 0; /* terminate for debug purposes */ - - mutex_lock(&ced->io_mutex); /* Protect disconnect from new i/o */ - if (n > 0) { /* do nothing if nowt to do! */ - dev_dbg(&ced->interface->dev, "%s: n=%d>%s<\n", - __func__, n, buffer); - ret = ced_put_chars(ced, buffer, n); - } - - ced_allowi(ced); /* make sure we have input int */ - mutex_unlock(&ced->io_mutex); - - return ret; -} - -/**************************************************************************** -** ced_send_char -** -** Sends a single character to the 1401. User mode, holds io_mutex. -****************************************************************************/ -int ced_send_char(struct ced_data *ced, char c) -{ - int ret; - - mutex_lock(&ced->io_mutex); /* Protect disconnect from new i/o */ - ret = ced_put_chars(ced, &c, 1); - dev_dbg(&ced->interface->dev, "ced_send_char >%c< (0x%02x)\n", c, c); - ced_allowi(ced); /* Make sure char reads are running */ - mutex_unlock(&ced->io_mutex); - return ret; -} - -/*************************************************************************** -** -** ced_get_state -** -** Retrieves state information from the 1401, adjusts the 1401 state held -** in the device extension to indicate the current 1401 type. -** -** *state is updated with information about the 1401 state as returned by the -** 1401. The low byte is a code for what 1401 is doing: -** -** 0 normal 1401 operation -** 1 sending chars to host -** 2 sending block data to host -** 3 reading block data from host -** 4 sending an escape sequence to the host -** 0x80 1401 is executing self-test, in which case the upper word -** is the last error code seen (or zero for no new error). -** -** *error is updated with error information if a self-test error code -** is returned in the upper word of state. -** -** both state and error are set to -1 if there are comms problems, and -** to zero if there is a simple failure. -** -** return error code (U14ERR_NOERROR for OK) -*/ -int ced_get_state(struct ced_data *ced, __u32 *state, __u32 *error) -{ - int got; - - dev_dbg(&ced->interface->dev, "%s: entry\n", __func__); - - *state = 0xFFFFFFFF; /* Start off with invalid state */ - got = usb_control_msg(ced->udev, usb_rcvctrlpipe(ced->udev, 0), - GET_STATUS, (D_TO_H | VENDOR | DEVREQ), 0, 0, - ced->stat_buf, sizeof(ced->stat_buf), HZ); - if (got != sizeof(ced->stat_buf)) { - dev_err(&ced->interface->dev, - "%s: FAILED, return code %d\n", __func__, got); - /* Indicate that things are very wrong indeed */ - ced->current_state = U14ERR_TIME; - *state = 0; /* Force status values to a known state */ - *error = 0; - } else { - int device; - - dev_dbg(&ced->interface->dev, - "%s: Success, state: 0x%x, 0x%x\n", - __func__, ced->stat_buf[0], ced->stat_buf[1]); - - /* Return the state values to the calling code */ - *state = ced->stat_buf[0]; - - *error = ced->stat_buf[1]; - - /* 1401 type code value */ - device = ced->udev->descriptor.bcdDevice >> 8; - switch (device) { /* so we can clean up current state */ - case 0: - ced->current_state = U14ERR_U1401; - break; - - default: /* allow lots of device codes for future 1401s */ - if ((device >= 1) && (device <= 23)) - ced->current_state = (short)(device + 6); - else - ced->current_state = U14ERR_ILL; - break; - } - } - - return ced->current_state >= 0 ? U14ERR_NOERROR : ced->current_state; -} - -/**************************************************************************** -** ced_read_write_cancel -** -** Kills off staged read\write request from the USB if one is pending. -****************************************************************************/ -int ced_read_write_cancel(struct ced_data *ced) -{ - dev_dbg(&ced->interface->dev, "%s: entry %d\n", - __func__, ced->staged_urb_pending); -#ifdef NOT_WRITTEN_YET - int ntStatus = STATUS_SUCCESS; - bool bResult = false; - unsigned int i; - - /* We can fill this in when we know how we will implement the staged */ - /* transfer stuff */ - spin_lock_irq(&ced->staged_lock); - - if (ced->staged_urb_pending) {/* anything to be cancelled? */ - /* May need more... */ - dev_info(&ced->interface - dev, - "ced_read_write_cancel about to cancel Urb\n"); - /* Clear the staging done flag */ - /* KeClearEvent(&ced->StagingDoneEvent); */ - USB_ASSERT(ced->pStagedIrp != NULL); - - /* Release the spinlock first otherwise the completion */ - /* routine may hang on the spinlock while this function */ - /* hands waiting for the event. */ - spin_unlock_irq(&ced->staged_lock); - - /* Actually do the cancel */ - bResult = IoCancelIrp(ced->pStagedIrp); - if (bResult) { - LARGE_INTEGER timeout; - - /* Use a timeout of 1 second */ - timeout.QuadPart = -10000000; - dev_info(&ced->interface - dev, - "%s: about to wait till done\n", __func__); - ntStatus = - KeWaitForSingleObject(&ced->StagingDoneEvent, - Executive, KernelMode, FALSE, - &timeout); - } else { - dev_info(&ced->interface - dev, - "%s: cancellation failed\n", __func__); - ntStatus = U14ERR_FAIL; - } - USB_KdPrint(DBGLVL_DEFAULT, - ("ced_read_write_cancel ntStatus = 0x%x decimal %d\n", - ntStatus, ntStatus)); - } else - spin_unlock_irq(&ced->staged_lock); - - dev_info(&ced->interface - dev, "%s: done\n", __func__); - return ntStatus; -#else - return U14ERR_NOERROR; -#endif - -} - -/*************************************************************************** -** ced_in_self_test - utility to check in self test. Return 1 for ST, 0 for not -** or a -ve error code if we failed for some reason. -***************************************************************************/ -static int ced_in_self_test(struct ced_data *ced, unsigned int *stat) -{ - unsigned int state, error; - int ret = ced_get_state(ced, &state, &error); /* see if in self-test */ - - if (ret == U14ERR_NOERROR) /* if all still OK */ - ret = (state == (unsigned int)-1) || /* TX problem or... */ - ((state & 0xff) == 0x80); /* ...self test */ - *stat = state; /* return actual state */ - return ret; -} - -/*************************************************************************** -** ced_is_1401 - ALWAYS CALLED HOLDING THE io_mutex -** -** Tests for the current state of the 1401. Sets current_state: -** -** U14ERR_NOIF 1401 i/f card not installed (not done here) -** U14ERR_OFF 1401 apparently not switched on -** U14ERR_NC 1401 appears to be not connected -** U14ERR_ILL 1401 if it is there its not very well at all -** U14ERR_TIME 1401 appears OK, but doesn't communicate - very bad -** U14ERR_STD 1401 OK and ready for use -** U14ERR_PLUS 1401+ OK and ready for use -** U14ERR_U1401 Micro1401 OK and ready for use -** U14ERR_POWER Power1401 OK and ready for use -** U14ERR_U14012 Micro1401 mkII OK and ready for use -** -** Returns TRUE if a 1401 detected and OK, else FALSE -****************************************************************************/ -static bool ced_is_1401(struct ced_data *ced) -{ - int ret; - - dev_dbg(&ced->interface->dev, "%s\n", __func__); - - ced_draw_down(ced); /* wait for, then kill outstanding Urbs */ - ced_flush_in_buff(ced); /* Clear out input buffer & pipe */ - ced_flush_out_buff(ced); /* Clear output buffer & pipe */ - - /* The next call returns 0 if OK, but has returned 1 in the past, */ - /* meaning that usb_unlock_device() is needed... now it always is */ - ret = usb_lock_device_for_reset(ced->udev, ced->interface); - - /* release the io_mutex because if we don't, we will deadlock due to */ - /* system calls back into the driver. */ - mutex_unlock(&ced->io_mutex); /* locked, so we will not get */ - /* system calls */ - if (ret >= 0) { /* if we failed */ - ret = usb_reset_device(ced->udev); /* try to do the reset */ - usb_unlock_device(ced->udev); /* undo the lock */ - } - - mutex_lock(&ced->io_mutex); /* hold stuff off while we wait */ - ced->dma_flag = MODE_CHAR; /* Clear DMA mode flag regardless! */ - if (ret == 0) { /* if all is OK still */ - unsigned int state; - - ret = ced_in_self_test(ced, &state); /* see if likely in */ - /* self test */ - if (ret > 0) { /* do we need to wait for self-test? */ - /* when to give up */ - unsigned long timeout = jiffies + 30 * HZ; - - while ((ret > 0) && time_before(jiffies, timeout)) { - schedule(); /* let other stuff run */ - - /* see if done yet */ - ret = ced_in_self_test(ced, &state); - } - } - - if (ret == 0) /* if all is OK... */ - /* then success is that the state is 0 */ - ret = state == 0; - } else - ret = 0; /* we failed */ - ced->force_reset = false; /* Clear forced reset flag now */ - - return ret > 0; -} - -/**************************************************************************** -** ced_quick_check - ALWAYS CALLED HOLDING THE io_mutex -** This is used to test for a 1401. It will try to do a quick check if all is -** OK, that is the 1401 was OK the last time it was asked, and there is no DMA -** in progress, and if the bTestBuff flag is set, the character buffers must be -** empty too. If the quick check shows that the state is still the same, then -** all is OK. -** -** If any of the above conditions are not met, or if the state or type of the -** 1401 has changed since the previous test, the full ced_is_1401 test is done, -** but only if can_reset is also TRUE. -** -** The return value is TRUE if a useable 1401 is found, FALSE if not -*/ -static bool ced_quick_check(struct ced_data *ced, bool test_buff, - bool can_reset) -{ - bool ret = false; /* assume it will fail and we will reset */ - bool short_test; - - short_test = ((ced->dma_flag == MODE_CHAR) && /* no DMA running */ - (!ced->force_reset) && /* Not had a real reset forced */ - /* No 1401 errors stored */ - (ced->current_state >= U14ERR_STD)); - - dev_dbg(&ced->interface->dev, - "%s: DMAFlag:%d, state:%d, force:%d, testBuff:%d, short:%d\n", - __func__, ced->dma_flag, ced->current_state, ced->force_reset, - test_buff, short_test); - - if ((test_buff) && /* Buffer check requested, and... */ - (ced->num_input || ced->num_output)) {/* ...characters were in */ - /* the buffer? */ - short_test = false; /* Then do the full test */ - dev_dbg(&ced->interface->dev, - "%s: will reset as buffers not empty\n", __func__); - } - - if (short_test || !can_reset) { /* Still OK to try the short test? */ - /* Always test if no reset - we */ - /* want state update */ - unsigned int state, error; - - dev_dbg(&ced->interface->dev, "%s: ced_get_state\n", __func__); - - /* Check on the 1401 state */ - if (ced_get_state(ced, &state, &error) == U14ERR_NOERROR) { - /* If call worked, check the status value */ - if ((state & 0xFF) == 0) - ret = true; /* If that was zero, all is OK, */ - /* no reset needed */ - } - } - - if (!ret && can_reset) { /* If all not OK, then */ - dev_info(&ced->interface->dev, "%s: ced_is_1401 %d %d %d %d\n", - __func__, short_test, ced->current_state, test_buff, - ced->force_reset); - ret = ced_is_1401(ced); /* do full test */ - } - - return ret; -} - -/**************************************************************************** -** ced_reset -** -** Resets the 1401 and empties the i/o buffers -*****************************************************************************/ -int ced_reset(struct ced_data *ced) -{ - mutex_lock(&ced->io_mutex); /* Protect disconnect from new i/o */ - dev_dbg(&ced->interface->dev, "%s: About to call ced_quick_check\n", - __func__); - ced_quick_check(ced, true, true); /* Check 1401, reset if not OK */ - mutex_unlock(&ced->io_mutex); - return U14ERR_NOERROR; -} - -/**************************************************************************** -** ced_get_char -** -** Gets a single character from the 1401 -****************************************************************************/ -int ced_get_char(struct ced_data *ced) -{ - int ret = U14ERR_NOIN; /* assume we will get nothing */ - - mutex_lock(&ced->io_mutex); /* Protect disconnect from new i/o */ - - dev_dbg(&ced->interface->dev, "%s\n", __func__); - - ced_allowi(ced); /* Make sure char reads are running */ - ced_send_chars(ced); /* and send any buffered chars */ - - spin_lock_irq(&ced->char_in_lock); - if (ced->num_input > 0) { /* worth looking */ - ret = ced->input_buffer[ced->in_buff_get++]; - if (ced->in_buff_get >= INBUF_SZ) - ced->in_buff_get = 0; - ced->num_input--; - } else - ret = U14ERR_NOIN; /* no input data to read */ - spin_unlock_irq(&ced->char_in_lock); - - ced_allowi(ced); /* Make sure char reads are running */ - - mutex_unlock(&ced->io_mutex); /* Protect disconnect from new i/o */ - return ret; -} - -/**************************************************************************** -** ced_get_string -** -** Gets a string from the 1401. Returns chars up to the next CR or when -** there are no more to read or nowhere to put them. CR is translated to -** 0 and counted as a character. If the string does not end in a 0, we will -** add one, if there is room, but it is not counted as a character. -** -** returns the count of characters (including the terminator, or 0 if none -** or a negative error code. -****************************************************************************/ -int ced_get_string(struct ced_data *ced, char __user *user, int n) -{ - int available; /* character in the buffer */ - int ret = U14ERR_NOIN; - - if (n <= 0) - return -ENOMEM; - - mutex_lock(&ced->io_mutex); /* Protect disconnect from new i/o */ - ced_allowi(ced); /* Make sure char reads are running */ - ced_send_chars(ced); /* and send any buffered chars */ - - spin_lock_irq(&ced->char_in_lock); - available = ced->num_input; /* characters available now */ - if (available > n) /* read max of space in user... */ - available = n; /* ...or input characters */ - - if (available > 0) { /* worth looking? */ - char buffer[INBUF_SZ + 1]; /* space for a linear copy of data */ - int got = 0; - int n_copy_to_user; /* number to copy to user */ - char data; - - do { - data = ced->input_buffer[ced->in_buff_get++]; - if (data == CR_CHAR) /* replace CR with zero */ - data = (char)0; - - if (ced->in_buff_get >= INBUF_SZ) - ced->in_buff_get = 0; /* wrap buffer pointer */ - - buffer[got++] = data; /* save the output */ - } while ((got < available) && data); - - n_copy_to_user = got; /* what to copy... */ - if (data) { /* do we need null */ - buffer[got] = (char)0; /* make it tidy */ - if (got < n) /* if space in user buffer... */ - ++n_copy_to_user; /* ...copy the 0 as well. */ - } - - ced->num_input -= got; - spin_unlock_irq(&ced->char_in_lock); - - dev_dbg(&ced->interface->dev, "%s: read %d characters >%s<\n", - __func__, got, buffer); - if (copy_to_user(user, buffer, n_copy_to_user)) - ret = -EFAULT; - else - ret = got; /* report characters read */ - } else - spin_unlock_irq(&ced->char_in_lock); - - ced_allowi(ced); /* Make sure char reads are running */ - mutex_unlock(&ced->io_mutex); /* Protect disconnect from new i/o */ - - return ret; -} - -/******************************************************************************* -** Get count of characters in the inout buffer. -*******************************************************************************/ -int ced_stat_1401(struct ced_data *ced) -{ - int ret; - - mutex_lock(&ced->io_mutex); /* Protect disconnect from new i/o */ - ced_allowi(ced); /* make sure we allow pending chars */ - ced_send_chars(ced); /* in both directions */ - ret = ced->num_input; /* no lock as single read */ - mutex_unlock(&ced->io_mutex); /* Protect disconnect from new i/o */ - return ret; -} - -/**************************************************************************** -** ced_line_count -** -** Returns the number of newline chars in the buffer. There is no need for -** any fancy interlocks as we only read the interrupt routine data, and the -** system is arranged so nothing can be destroyed. -****************************************************************************/ -int ced_line_count(struct ced_data *ced) -{ - int ret = 0; /* will be count of line ends */ - - mutex_lock(&ced->io_mutex); /* Protect disconnect from new i/o */ - ced_allowi(ced); /* Make sure char reads are running */ - ced_send_chars(ced); /* and send any buffered chars */ - spin_lock_irq(&ced->char_in_lock); /* Get protection */ - - if (ced->num_input > 0) { /* worth looking? */ - /* start at first available */ - unsigned int index = ced->in_buff_get; - /* Position for search end */ - unsigned int end = ced->in_buff_put; - - do { - if (ced->input_buffer[index++] == CR_CHAR) - ++ret; /* inc count if CR */ - - if (index >= INBUF_SZ) /* see if we fall off buff */ - index = 0; - } while (index != end); /* go to last available */ - } - - spin_unlock_irq(&ced->char_in_lock); - dev_dbg(&ced->interface->dev, "%s: returned %d\n", __func__, ret); - mutex_unlock(&ced->io_mutex); /* Protect disconnect from new i/o */ - return ret; -} - -/**************************************************************************** -** ced_get_out_buf_space -** -** Gets the space in the output buffer. Called from user code. -*****************************************************************************/ -int ced_get_out_buf_space(struct ced_data *ced) -{ - int ret; - - mutex_lock(&ced->io_mutex); /* Protect disconnect from new i/o */ - - ced_send_chars(ced); /* send any buffered chars */ - - /* no lock needed for single read */ - ret = (int)(OUTBUF_SZ - ced->num_output); - - dev_dbg(&ced->interface->dev, "%s: %d\n", __func__, ret); - - mutex_unlock(&ced->io_mutex); /* Protect disconnect from new i/o */ - return ret; -} - -/**************************************************************************** -** -** ced_clear_area -** -** Clears up a transfer area. This is always called in the context of a user -** request, never from a call-back. -****************************************************************************/ -int ced_clear_area(struct ced_data *ced, int area) -{ - int ret = U14ERR_NOERROR; - - if ((area < 0) || (area >= MAX_TRANSAREAS)) { - ret = U14ERR_BADAREA; - dev_err(&ced->interface->dev, "%s: Attempt to clear area %d\n", - __func__, area); - } else { - /* to save typing */ - struct transarea *ta = &ced->trans_def[area]; - - if (!ta->used) /* if not used... */ - ret = U14ERR_NOTSET; /* ...nothing to be done */ - else { - /* We must save the memory we return as we shouldn't */ - /* mess with memory while holding a spin lock. */ - struct page **pages = NULL; /*save page address list*/ - int n_pages = 0; /* and number of pages */ - int np; - - dev_dbg(&ced->interface->dev, "%s: area %d\n", - __func__, area); - spin_lock_irq(&ced->staged_lock); - if ((ced->staged_id == area) - && (ced->dma_flag > MODE_CHAR)) { - /* cannot delete as in use */ - ret = U14ERR_UNLOCKFAIL; - dev_err(&ced->interface->dev, - "%s: call on area %d while active\n", - __func__, area); - } else { - pages = ta->pages; /* save page address list */ - n_pages = ta->n_pages; /* and page count */ - if (ta->event_sz)/* if events flagging in use */ - /* release anything that was waiting */ - wake_up_interruptible(&ta->event); - - if (ced->xfer_waiting - && (ced->dma_info.ident == area)) - /* Cannot have pending xfer if */ - /* area cleared */ - ced->xfer_waiting = false; - - /* Clean out the struct transarea except for */ - /* the wait queue, which is at the end. This */ - /* sets used to false and event_sz to 0 to */ - /* say area not used and no events. */ - memset(ta, 0, - sizeof(struct transarea) - - sizeof(wait_queue_head_t)); - } - spin_unlock_irq(&ced->staged_lock); - - if (pages) { /* if we decided to release the memory */ - /* Now we must undo the pinning down of the */ - /* pages. We will assume the worst and mark */ - /* all the pages as dirty. Don't be tempted */ - /* to move this up above as you must not be */ - /* holding a spin lock to do this stuff as */ - /* it is not atomic. */ - dev_dbg(&ced->interface->dev, - "%s: n_pages=%d\n", - __func__, n_pages); - - for (np = 0; np < n_pages; ++np) { - if (pages[np]) { - SetPageDirty(pages[np]); - page_cache_release(pages[np]); - } - } - - kfree(pages); - dev_dbg(&ced->interface->dev, - "%s: kfree(pages) done\n", __func__); - } - } - } - - return ret; -} - -/**************************************************************************** -** ced_set_area -** -** Sets up a transfer area - the functional part. Called by both -** ced_set_transfer and ced_set_circular. -****************************************************************************/ -static int ced_set_area(struct ced_data *ced, int area, char __user *buf, - unsigned int length, bool circular, bool circ_to_host) -{ - /* Start by working out the page aligned start of the area and the */ - /* size of the area in pages, allowing for the start not being */ - /* aligned and the end needing to be rounded up to a page boundary. */ - unsigned long start = ((unsigned long)buf) & PAGE_MASK; - unsigned int offset = ((unsigned long)buf) & (PAGE_SIZE - 1); - int len = (length + offset + PAGE_SIZE - 1) >> PAGE_SHIFT; - - struct transarea *ta = &ced->trans_def[area]; /* to save typing */ - struct page **pages = NULL; /* space for page tables */ - int n_pages = 0; /* and number of pages */ - - int ret = ced_clear_area(ced, area); /* see if OK to use this area */ - - if ((ret != U14ERR_NOTSET) && /* if not area unused and... */ - (ret != U14ERR_NOERROR)) /* ...not all OK, then... */ - return ret; /* ...we cannot use this area */ - - /* if we cannot access the memory... */ - if (!access_ok(VERIFY_WRITE, buf, length)) - return -EFAULT; /* ...then we are done */ - - /* Now allocate space to hold the page pointer and */ - /* virtual address pointer tables */ - pages = kmalloc(len * sizeof(struct page *), GFP_KERNEL); - if (!pages) { - ret = U14ERR_NOMEMORY; - goto error; - } - dev_dbg(&ced->interface->dev, "%s: %p, length=%06x, circular %d\n", - __func__, buf, length, circular); - - /* To pin down user pages we must first */ - /* acquire the mapping semaphore. */ - n_pages = get_user_pages_fast(start, len, 1, pages); - dev_dbg(&ced->interface->dev, "%s: n_pages = %d\n", __func__, n_pages); - - if (n_pages > 0) { /* if we succeeded */ - /* If you are tempted to use page_address (form LDD3), forget */ - /* it. You MUST use kmap() or kmap_atomic() to get a virtual */ - /* address. page_address will give you (null) or at least it */ - /* does in this context with an x86 machine. */ - spin_lock_irq(&ced->staged_lock); - ta->buff = buf; /* keep start of region (user address) */ - ta->base_offset = offset; /* save offset in first page */ - /* to start of xfer */ - ta->length = length; /* Size if the region in bytes */ - ta->pages = pages; /* list of pages that are used by buffer */ - ta->n_pages = n_pages; /* number of pages */ - - ta->circular = circular; - ta->circ_to_host = circ_to_host; - - ta->blocks[0].offset = 0; - ta->blocks[0].size = 0; - ta->blocks[1].offset = 0; - ta->blocks[1].size = 0; - ta->used = true; /* This is now a used block */ - - spin_unlock_irq(&ced->staged_lock); - ret = U14ERR_NOERROR; /* say all was well */ - } else { - ret = U14ERR_LOCKFAIL; - goto error; - } - - return ret; - -error: - kfree(pages); - return ret; -} - -/**************************************************************************** -** ced_set_transfer -** -** Sets up a transfer area record. If the area is already set, we attempt to -** unset it. Unsetting will fail if the area is booked, and a transfer to that -** area is in progress. Otherwise, we will release the area and re-assign it. -****************************************************************************/ -int ced_set_transfer(struct ced_data *ced, - struct transfer_area_desc __user *utd) -{ - int ret; - struct transfer_area_desc td; - - if (copy_from_user(&td, utd, sizeof(td))) - return -EFAULT; - - mutex_lock(&ced->io_mutex); - dev_dbg(&ced->interface->dev, "%s: area:%d, size:%08x\n", - __func__, td.wAreaNum, td.dwLength); - /* The strange cast is done so that we don't get warnings in 32-bit */ - /* linux about the size of the pointer. The pointer is always passed */ - /* as a 64-bit object so that we don't have problems using a 32-bit */ - /* program on a 64-bit system. unsigned long is 64-bits on a 64-bit */ - /* system. */ - ret = - ced_set_area(ced, td.wAreaNum, - (char __user *)((unsigned long)td.lpvBuff), td.dwLength, - false, false); - mutex_unlock(&ced->io_mutex); - return ret; -} - -/**************************************************************************** -** ced_unset_transfer -** Erases a transfer area record -****************************************************************************/ -int ced_unset_transfer(struct ced_data *ced, int area) -{ - int ret; - - mutex_lock(&ced->io_mutex); - ret = ced_clear_area(ced, area); - mutex_unlock(&ced->io_mutex); - return ret; -} - -/**************************************************************************** -** ced_set_event -** Creates an event that we can test for based on a transfer to/from an area. -** The area must be setup for a transfer. We attempt to simulate the Windows -** driver behavior for events (as we don't actually use them), which is to -** pretend that whatever the user asked for was achieved, so we return 1 if -** try to create one, and 0 if they ask to remove (assuming all else was OK). -****************************************************************************/ -int ced_set_event(struct ced_data *ced, struct transfer_event __user *ute) -{ - int ret = U14ERR_NOERROR; - struct transfer_event te; - struct transarea *ta; - - /* get a local copy of the data */ - if (copy_from_user(&te, ute, sizeof(te))) - return -EFAULT; - - if (te.wAreaNum >= MAX_TRANSAREAS) /* the area must exist */ - return U14ERR_BADAREA; - - ta = &ced->trans_def[te.wAreaNum]; - - /* make sure we have no competitor */ - mutex_lock(&ced->io_mutex); - spin_lock_irq(&ced->staged_lock); - - if (ta->used) { /* area must be in use */ - ta->event_st = te.dwStart; /* set area regions */ - - /* set size (0 cancels it) */ - ta->event_sz = te.dwLength; - - /* set the direction */ - ta->event_to_host = te.wFlags & 1; - ta->wake_up = 0; /* zero the wake up count */ - } else - ret = U14ERR_NOTSET; - - spin_unlock_irq(&ced->staged_lock); - mutex_unlock(&ced->io_mutex); - - return ret == - U14ERR_NOERROR ? (te.iSetEvent ? 1 : U14ERR_NOERROR) : ret; -} - -/**************************************************************************** -** ced_wait_event -** Sleep the process with a timeout waiting for an event. Returns the number -** of times that a block met the event condition since we last cleared it or -** 0 if timed out, or -ve error (bad area or not set, or signal). -****************************************************************************/ -int ced_wait_event(struct ced_data *ced, int area, int time_out) -{ - int ret; - int wait; - struct transarea *ta; - - if ((unsigned)area >= MAX_TRANSAREAS) - return U14ERR_BADAREA; - - ta = &ced->trans_def[area]; - - /* convert timeout to jiffies */ - time_out = (time_out * HZ + 999) / 1000; - - /* We cannot wait holding the mutex, but we check the flags */ - /* while holding it. This may well be pointless as another */ - /* thread could get in between releasing it and the wait */ - /* call. However, this would have to clear the wake_up flag. */ - /* However, the !ta->used may help us in this case. */ - - /* make sure we have no competitor */ - mutex_lock(&ced->io_mutex); - if (!ta->used || !ta->event_sz) /* check something to */ - /* wait for... */ - return U14ERR_NOTSET; /* ...else we do nothing */ - mutex_unlock(&ced->io_mutex); - - if (time_out) - wait = wait_event_interruptible_timeout(ta->event, - ta->wake_up || - !ta->used, - time_out); - else - wait = wait_event_interruptible(ta->event, - ta->wake_up || - !ta->used); - - if (wait) - ret = -ERESTARTSYS; /* oops - we have had a SIGNAL */ - else - ret = ta->wake_up; /* else the wakeup count */ - - spin_lock_irq(&ced->staged_lock); - ta->wake_up = 0; /* clear the flag */ - spin_unlock_irq(&ced->staged_lock); - - return ret; -} - -/**************************************************************************** -** ced_test_event -** Test the event to see if a ced_wait_event would return immediately. Returns -** the number of times a block completed since the last call, or 0 if none or a -** negative error. -****************************************************************************/ -int ced_test_event(struct ced_data *ced, int area) -{ - int ret; - - if ((unsigned)area >= MAX_TRANSAREAS) - ret = U14ERR_BADAREA; - else { - struct transarea *ta = &ced->trans_def[area]; - - /* make sure we have no competitor */ - mutex_lock(&ced->io_mutex); - spin_lock_irq(&ced->staged_lock); - ret = ta->wake_up; /* get wakeup count since last call */ - ta->wake_up = 0; /* clear the count */ - spin_unlock_irq(&ced->staged_lock); - mutex_unlock(&ced->io_mutex); - } - return ret; -} - -/**************************************************************************** -** ced_get_transferInfo -** Puts the current state of the 1401 in a TGET_TX_BLOCK. -*****************************************************************************/ -int ced_get_transfer(struct ced_data *ced, TGET_TX_BLOCK __user *utx) -{ - int ret = U14ERR_NOERROR; - unsigned int dwIdent; - - mutex_lock(&ced->io_mutex); - dwIdent = ced->staged_id; /* area ident for last xfer */ - if (dwIdent >= MAX_TRANSAREAS) - ret = U14ERR_BADAREA; - else { - /* Return the best information we have - we */ - /* don't have physical addresses */ - TGET_TX_BLOCK *tx; - - tx = kzalloc(sizeof(*tx), GFP_KERNEL); - if (!tx) { - mutex_unlock(&ced->io_mutex); - return -ENOMEM; - } - tx->size = ced->trans_def[dwIdent].length; - tx->linear = (long long)((long)ced->trans_def[dwIdent].buff); - /* how many blocks we could return */ - tx->avail = GET_TX_MAXENTRIES; - tx->used = 1; /* number we actually return */ - tx->entries[0].physical = - (long long)(tx->linear + ced->staged_offset); - tx->entries[0].size = tx->size; - - if (copy_to_user(utx, tx, sizeof(*tx))) - ret = -EFAULT; - kfree(tx); - } - mutex_unlock(&ced->io_mutex); - return ret; -} - -/**************************************************************************** -** ced_kill_io -** -** Empties the host i/o buffers -****************************************************************************/ -int ced_kill_io(struct ced_data *ced) -{ - dev_dbg(&ced->interface->dev, "%s\n", __func__); - mutex_lock(&ced->io_mutex); - ced_flush_out_buff(ced); - ced_flush_in_buff(ced); - mutex_unlock(&ced->io_mutex); - return U14ERR_NOERROR; -} - -/**************************************************************************** -** ced_state_of_1401 -** -** Puts the current state of the 1401 in the Irp return buffer. -*****************************************************************************/ -int ced_state_of_1401(struct ced_data *ced) -{ - int ret; - - mutex_lock(&ced->io_mutex); - - ced_quick_check(ced, false, false); /* get state up to date, no reset */ - ret = ced->current_state; - - mutex_unlock(&ced->io_mutex); - dev_dbg(&ced->interface->dev, "%s: %d\n", __func__, ret); - - return ret; -} - -/**************************************************************************** -** ced_start_self_test -** -** Initiates a self-test cycle. The assumption is that we have no interrupts -** active, so we should make sure that this is the case. -*****************************************************************************/ -int ced_start_self_test(struct ced_data *ced) -{ - int got; - - mutex_lock(&ced->io_mutex); - dev_dbg(&ced->interface->dev, "%s\n", __func__); - - ced_draw_down(ced); /* wait for, then kill outstanding Urbs */ - ced_flush_in_buff(ced); /* Clear out input buffer & pipe */ - ced_flush_out_buff(ced); /* Clear output buffer & pipe */ - /* so things stay tidy */ - /* ced_read_write_cancel(pDeviceObject); */ - ced->dma_flag = MODE_CHAR; /* Clear DMA mode flags here */ - - got = usb_control_msg(ced->udev, usb_rcvctrlpipe(ced->udev, 0), - DB_SELFTEST, (H_TO_D | VENDOR | DEVREQ), - 0, 0, NULL, 0, HZ); /* allow 1 second timeout */ - ced->self_test_time = jiffies + HZ * 30; /* 30 seconds into the */ - /* future */ - - mutex_unlock(&ced->io_mutex); - if (got < 0) - dev_err(&ced->interface->dev, "%s: err=%d\n", __func__, got); - return got < 0 ? U14ERR_FAIL : U14ERR_NOERROR; -} - -/**************************************************************************** -** ced_check_self_test -** -** Check progress of a self-test cycle -****************************************************************************/ -int ced_check_self_test(struct ced_data *ced, TGET_SELFTEST __user *ugst) -{ - unsigned int state, error; - int ret; - TGET_SELFTEST gst; /* local work space */ - - memset(&gst, 0, sizeof(gst)); /* clear out the space (sets code 0) */ - - mutex_lock(&ced->io_mutex); - - dev_dbg(&ced->interface->dev, "%s\n", __func__); - ret = ced_get_state(ced, &state, &error); - if (ret == U14ERR_NOERROR) /* Only accept zero if it happens twice */ - ret = ced_get_state(ced, &state, &error); - - if (ret != U14ERR_NOERROR) { /* Self-test can cause comms errors */ - /* so we assume still testing */ - dev_err(&ced->interface->dev, - "%s: ced_get_state=%d, assuming still testing\n", - __func__, ret); - state = 0x80; /* Force still-testing, no error */ - error = 0; - ret = U14ERR_NOERROR; - } - - if ((state == -1) && (error == -1)) {/* If ced_get_state had problems */ - dev_err(&ced->interface->dev, - "%s: ced_get_state failed, assuming still testing\n", - __func__); - state = 0x80; /* Force still-testing, no error */ - error = 0; - } - - if ((state & 0xFF) == 0x80) { /* If we are still in self-test */ - if (state & 0x00FF0000) { /* Have we got an error? */ - /* read the error code */ - gst.code = (state & 0x00FF0000) >> 16; - gst.x = error & 0x0000FFFF; /* Error data X */ - gst.y = (error & 0xFFFF0000) >> 16; /* and data Y */ - dev_dbg(&ced->interface->dev, - "Self-test error code %d\n", gst.code); - } else { /* No error, check for timeout */ - unsigned long now = jiffies; /* get current time */ - - if (time_after(now, ced->self_test_time)) { - gst.code = -2; /* Flag the timeout */ - dev_dbg(&ced->interface->dev, - "Self-test timed-out\n"); - } else - dev_dbg(&ced->interface->dev, - "Self-test on-going\n"); - } - } else { - gst.code = -1; /* Flag the test is done */ - dev_dbg(&ced->interface->dev, "Self-test done\n"); - } - - if (gst.code < 0) { /* If we have a problem or finished */ - /* If using the 2890 we should reset properly */ - if ((ced->n_pipes == 4) && (ced->type <= TYPEPOWER)) - ced_is_1401(ced); /* Get 1401 reset and OK */ - else - /* Otherwise check without reset unless problems */ - ced_quick_check(ced, true, true); - } - mutex_unlock(&ced->io_mutex); - - if (copy_to_user(ugst, &gst, sizeof(gst))) - return -EFAULT; - - return ret; -} - -/**************************************************************************** -** ced_type_of_1401 -** -** Returns code for standard, plus, micro1401, power1401 or none -****************************************************************************/ -int ced_type_of_1401(struct ced_data *ced) -{ - int ret = TYPEUNKNOWN; - - mutex_lock(&ced->io_mutex); - dev_dbg(&ced->interface->dev, "%s\n", __func__); - - switch (ced->type) { - case TYPE1401: - ret = U14ERR_STD; - break; /* Handle these types directly */ - case TYPEPLUS: - ret = U14ERR_PLUS; - break; - case TYPEU1401: - ret = U14ERR_U1401; - break; - default: - if ((ced->type >= TYPEPOWER) && (ced->type <= 25)) - ret = ced->type + 4; /* We can calculate types */ - else /* for up-coming 1401 designs */ - ret = TYPEUNKNOWN; /* Don't know or not there */ - } - dev_dbg(&ced->interface->dev, "%s %d\n", __func__, ret); - mutex_unlock(&ced->io_mutex); - - return ret; -} - -/**************************************************************************** -** ced_transfer_flags -** -** Returns flags on block transfer abilities -****************************************************************************/ -int ced_transfer_flags(struct ced_data *ced) -{ - /* we always have multiple DMA area diagnostics, notify and circular */ - int ret = U14TF_MULTIA | U14TF_DIAG | - U14TF_NOTIFY | U14TF_CIRCTH; - - dev_dbg(&ced->interface->dev, "%s\n", __func__); - mutex_lock(&ced->io_mutex); - if (ced->is_usb2) /* Set flag for USB2 if appropriate */ - ret |= U14TF_USB2; - mutex_unlock(&ced->io_mutex); - - return ret; -} - -/*************************************************************************** -** ced_dbg_cmd -** Issues a debug\diagnostic command to the 1401 along with a 32-bit datum -** This is a utility command used for dbg operations. -*/ -static int ced_dbg_cmd(struct ced_data *ced, unsigned char cmd, - unsigned int data) -{ - int ret; - - dev_dbg(&ced->interface->dev, "%s: entry\n", __func__); - ret = usb_control_msg(ced->udev, usb_sndctrlpipe(ced->udev, 0), cmd, - (H_TO_D | VENDOR | DEVREQ), - (unsigned short)data, - (unsigned short)(data >> 16), NULL, 0, HZ); - /* allow 1 second timeout */ - if (ret < 0) - dev_err(&ced->interface->dev, "%s: fail code=%d\n", - __func__, ret); - - return ret; -} - -/**************************************************************************** -** ced_dbg_peek -** -** Execute the diagnostic peek operation. Uses address, width and repeats. -****************************************************************************/ -int ced_dbg_peek(struct ced_data *ced, TDBGBLOCK __user *udb) -{ - int ret; - TDBGBLOCK db; - - if (copy_from_user(&db, udb, sizeof(db))) - return -EFAULT; - - mutex_lock(&ced->io_mutex); - dev_dbg(&ced->interface->dev, "%s: @ %08x\n", __func__, db.iAddr); - - ret = ced_dbg_cmd(ced, DB_SETADD, db.iAddr); - if (ret == U14ERR_NOERROR) - ret = ced_dbg_cmd(ced, DB_WIDTH, db.iWidth); - if (ret == U14ERR_NOERROR) - ret = ced_dbg_cmd(ced, DB_REPEATS, db.iRepeats); - if (ret == U14ERR_NOERROR) - ret = ced_dbg_cmd(ced, DB_PEEK, 0); - mutex_unlock(&ced->io_mutex); - - return ret; -} - -/**************************************************************************** -** ced_dbg_poke -** -** Execute the diagnostic poke operation. Parameters are in the CSBLOCK struct -** in order address, size, repeats and value to poke. -****************************************************************************/ -int ced_dbg_poke(struct ced_data *ced, TDBGBLOCK __user *udb) -{ - int ret; - TDBGBLOCK db; - - if (copy_from_user(&db, udb, sizeof(db))) - return -EFAULT; - - mutex_lock(&ced->io_mutex); - dev_dbg(&ced->interface->dev, "%s: @ %08x\n", __func__, db.iAddr); - - ret = ced_dbg_cmd(ced, DB_SETADD, db.iAddr); - if (ret == U14ERR_NOERROR) - ret = ced_dbg_cmd(ced, DB_WIDTH, db.iWidth); - if (ret == U14ERR_NOERROR) - ret = ced_dbg_cmd(ced, DB_REPEATS, db.iRepeats); - if (ret == U14ERR_NOERROR) - ret = ced_dbg_cmd(ced, DB_POKE, db.iData); - mutex_unlock(&ced->io_mutex); - - return ret; -} - -/**************************************************************************** -** ced_dbg_ramp_data -** -** Execute the diagnostic ramp data operation. Parameters are in the CSBLOCK -** struct in order address, default, enable mask, size and repeats. -****************************************************************************/ -int ced_dbg_ramp_data(struct ced_data *ced, TDBGBLOCK __user *udb) -{ - int ret; - TDBGBLOCK db; - - if (copy_from_user(&db, udb, sizeof(db))) - return -EFAULT; - - mutex_lock(&ced->io_mutex); - dev_dbg(&ced->interface->dev, "%s: @ %08x\n", __func__, db.iAddr); - - ret = ced_dbg_cmd(ced, DB_SETADD, db.iAddr); - if (ret == U14ERR_NOERROR) - ret = ced_dbg_cmd(ced, DB_SETDEF, db.iDefault); - if (ret == U14ERR_NOERROR) - ret = ced_dbg_cmd(ced, DB_SETMASK, db.iMask); - if (ret == U14ERR_NOERROR) - ret = ced_dbg_cmd(ced, DB_WIDTH, db.iWidth); - if (ret == U14ERR_NOERROR) - ret = ced_dbg_cmd(ced, DB_REPEATS, db.iRepeats); - if (ret == U14ERR_NOERROR) - ret = ced_dbg_cmd(ced, DB_RAMPD, 0); - mutex_unlock(&ced->io_mutex); - - return ret; -} - -/**************************************************************************** -** ced_dbg_ramp_addr -** -** Execute the diagnostic ramp address operation -****************************************************************************/ -int ced_dbg_ramp_addr(struct ced_data *ced, TDBGBLOCK __user *udb) -{ - int ret; - TDBGBLOCK db; - - if (copy_from_user(&db, udb, sizeof(db))) - return -EFAULT; - - mutex_lock(&ced->io_mutex); - dev_dbg(&ced->interface->dev, "%s\n", __func__); - - ret = ced_dbg_cmd(ced, DB_SETDEF, db.iDefault); - if (ret == U14ERR_NOERROR) - ret = ced_dbg_cmd(ced, DB_SETMASK, db.iMask); - if (ret == U14ERR_NOERROR) - ret = ced_dbg_cmd(ced, DB_WIDTH, db.iWidth); - if (ret == U14ERR_NOERROR) - ret = ced_dbg_cmd(ced, DB_REPEATS, db.iRepeats); - if (ret == U14ERR_NOERROR) - ret = ced_dbg_cmd(ced, DB_RAMPA, 0); - mutex_unlock(&ced->io_mutex); - - return ret; -} - -/**************************************************************************** -** ced_dbg_get_data -** -** Retrieve the data resulting from the last debug Peek operation -****************************************************************************/ -int ced_dbg_get_data(struct ced_data *ced, TDBGBLOCK __user *udb) -{ - int ret; - TDBGBLOCK db; - - memset(&db, 0, sizeof(db)); /* fill returned block with 0s */ - - mutex_lock(&ced->io_mutex); - dev_dbg(&ced->interface->dev, "%s\n", __func__); - - /* Read back the last peeked value from the 1401. */ - ret = usb_control_msg(ced->udev, usb_rcvctrlpipe(ced->udev, 0), - DB_DATA, (D_TO_H | VENDOR | DEVREQ), 0, 0, - &db.iData, sizeof(db.iData), HZ); - if (ret == sizeof(db.iData)) { - if (copy_to_user(udb, &db, sizeof(db))) - ret = -EFAULT; - else - ret = U14ERR_NOERROR; - } else - dev_err(&ced->interface->dev, "%s: failed, code %d\n", - __func__, ret); - - mutex_unlock(&ced->io_mutex); - - return ret; -} - -/**************************************************************************** -** ced_dbg_stop_loop -** -** Stop any never-ending debug loop, we just call ced_get_state for USB -** -****************************************************************************/ -int ced_dbg_stop_loop(struct ced_data *ced) -{ - int ret; - unsigned int uState, uErr; - - mutex_lock(&ced->io_mutex); - dev_dbg(&ced->interface->dev, "%s\n", __func__); - ret = ced_get_state(ced, &uState, &uErr); - mutex_unlock(&ced->io_mutex); - - return ret; -} - -/**************************************************************************** -** ced_set_circular -** -** Sets up a transfer area record for circular transfers. If the area is -** already set, we attempt to unset it. Unsetting will fail if the area is -** booked and a transfer to that area is in progress. Otherwise, we will -** release the area and re-assign it. -****************************************************************************/ -int ced_set_circular(struct ced_data *ced, - struct transfer_area_desc __user *utd) -{ - int ret; - bool to_host; - struct transfer_area_desc td; - - if (copy_from_user(&td, utd, sizeof(td))) - return -EFAULT; - - mutex_lock(&ced->io_mutex); - dev_dbg(&ced->interface->dev, "%s: area:%d, size:%08x\n", - __func__, td.wAreaNum, td.dwLength); - to_host = td.eSize != 0; /* this is used as the tohost flag */ - - /* The strange cast is done so that we don't get warnings in 32-bit */ - /* linux about the size of the pointer. The pointer is always passed */ - /* as a 64-bit object so that we don't have problems using a 32-bit */ - /* program on a 64-bit system. unsigned long is 64-bits on a 64-bit */ - /* system. */ - ret = - ced_set_area(ced, td.wAreaNum, - (char __user *)((unsigned long)td.lpvBuff), td.dwLength, - true, to_host); - mutex_unlock(&ced->io_mutex); - return ret; -} - -/**************************************************************************** -** ced_get_circ_block -** -** Return the next available block of circularly-transferred data. -****************************************************************************/ -int ced_get_circ_block(struct ced_data *ced, TCIRCBLOCK __user *ucb) -{ - int ret = U14ERR_NOERROR; - unsigned int area; - TCIRCBLOCK cb; - - dev_dbg(&ced->interface->dev, "%s\n", __func__); - - if (copy_from_user(&cb, ucb, sizeof(cb))) - return -EFAULT; - - mutex_lock(&ced->io_mutex); - - area = cb.nArea; /* Retrieve parameters first */ - cb.dwOffset = 0; /* set default result (nothing) */ - cb.dwSize = 0; - - if (area < MAX_TRANSAREAS) { /* The area number must be OK */ - /* Pointer to relevant info */ - struct transarea *ta = &ced->trans_def[area]; - - spin_lock_irq(&ced->staged_lock); /* Lock others out */ - - if ((ta->used) && (ta->circular) && /* Must be circular area */ - (ta->circ_to_host)) { /* For now at least must be to host */ - if (ta->blocks[0].size > 0) { /* Got anything? */ - cb.dwOffset = ta->blocks[0].offset; - cb.dwSize = ta->blocks[0].size; - dev_dbg(&ced->interface->dev, - "%s: return block 0: %d bytes at %d\n", - __func__, cb.dwSize, cb.dwOffset); - } - } else - ret = U14ERR_NOTSET; - - spin_unlock_irq(&ced->staged_lock); - } else - ret = U14ERR_BADAREA; - - if (copy_to_user(ucb, &cb, sizeof(cb))) - ret = -EFAULT; - - mutex_unlock(&ced->io_mutex); - return ret; -} - -/**************************************************************************** -** ced_free_circ_block -** -** Frees a block of circularly-transferred data and returns the next one. -****************************************************************************/ -int ced_free_circ_block(struct ced_data *ced, TCIRCBLOCK __user *ucb) -{ - int ret = U14ERR_NOERROR; - unsigned int area, start, size; - TCIRCBLOCK cb; - - dev_dbg(&ced->interface->dev, "%s\n", __func__); - - if (copy_from_user(&cb, ucb, sizeof(cb))) - return -EFAULT; - - mutex_lock(&ced->io_mutex); - - area = cb.nArea; /* Retrieve parameters first */ - start = cb.dwOffset; - size = cb.dwSize; - cb.dwOffset = 0; /* then set default result (nothing) */ - cb.dwSize = 0; - - if (area < MAX_TRANSAREAS) { /* The area number must be OK */ - /* Pointer to relevant info */ - struct transarea *ta = &ced->trans_def[area]; - - spin_lock_irq(&ced->staged_lock); /* Lock others out */ - - if ((ta->used) && (ta->circular) && /* Must be circular area */ - (ta->circ_to_host)) { /* For now at least must be to host */ - bool waiting = false; - - if ((ta->blocks[0].size >= size) && /* Got anything? */ - /* Must be legal data */ - (ta->blocks[0].offset == start)) { - ta->blocks[0].size -= size; - ta->blocks[0].offset += size; - - /* Have we emptied this block? */ - if (ta->blocks[0].size == 0) { - /* Is there a second block? */ - if (ta->blocks[1].size) { - /* Copy down block 2 data */ - ta->blocks[0] = ta->blocks[1]; - /* and mark the second */ - /* block as unused */ - ta->blocks[1].size = 0; - ta->blocks[1].offset = 0; - } else - ta->blocks[0].offset = 0; - } - - dev_dbg(&ced->interface->dev, - "%s: free %d bytes at %d, " - "return %d bytes at %d, wait=%d\n", - __func__, size, start, - ta->blocks[0].size, - ta->blocks[0].offset, - ced->xfer_waiting); - - /* Return the next available block of */ - /* memory as well */ - if (ta->blocks[0].size > 0) {/* Got anything? */ - cb.dwOffset = - ta->blocks[0].offset; - cb.dwSize = ta->blocks[0].size; - } - - waiting = ced->xfer_waiting; - if (waiting && ced->staged_urb_pending) { - dev_err(&ced->interface->dev, - "%s: ERROR: waiting xfer and " - "staged Urb pending!\n", - __func__); - waiting = false; - } - } else { - dev_err(&ced->interface->dev, - "%s: ERROR: freeing %d bytes at %d, " - "block 0 is %d bytes at %d\n", - __func__, size, start, - ta->blocks[0].size, - ta->blocks[0].offset); - ret = U14ERR_NOMEMORY; - } - - /* If we have one, kick off pending transfer */ - if (waiting) { /* Got a block xfer waiting? */ - int RWMStat = - ced_read_write_mem(ced, - !ced->dma_info.outward, - ced->dma_info.ident, - ced->dma_info.offset, - ced->dma_info.size); - if (RWMStat != U14ERR_NOERROR) - dev_err(&ced->interface->dev, - "%s: rw setup failed %d\n", - __func__, RWMStat); - } - } else - ret = U14ERR_NOTSET; - - spin_unlock_irq(&ced->staged_lock); - } else - ret = U14ERR_BADAREA; - - if (copy_to_user(ucb, &cb, sizeof(cb))) - ret = -EFAULT; - - mutex_unlock(&ced->io_mutex); - return ret; -} diff --git a/drivers/staging/ced1401/ced_ioctl.h b/drivers/staging/ced1401/ced_ioctl.h deleted file mode 100644 index 4b6c9de..0000000 --- a/drivers/staging/ced1401/ced_ioctl.h +++ /dev/null @@ -1,336 +0,0 @@ -/* - * IOCTL calls for the CED1401 driver - * Copyright (C) 2010 Cambridge Electronic Design Ltd - * Author Greg P Smith (greg@ced.co.uk) - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * 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. - */ -#ifndef __CED_IOCTL_H__ -#define __CED_IOCTL_H__ - -#include <linux/ioctl.h> - -/* dma modes, only MODE_CHAR and MODE_LINEAR are used in this driver */ -#define MODE_CHAR 0 -#define MODE_LINEAR 1 - -/**************************************************************************** -** TypeDefs -*****************************************************************************/ - -struct transfer_area_desc { - long long lpvBuff; /* address of transfer area (for 64 or 32 bit) */ - unsigned int dwLength; /* length of the area */ - unsigned short wAreaNum; /* number of transfer area to set up */ - short eSize; /* element size - is tohost flag for circular */ -}; - - -struct transfer_event { - unsigned int dwStart; /* offset into the area */ - unsigned int dwLength; /* length of the region */ - unsigned short wAreaNum; /* the area number */ - unsigned short wFlags; /* bit 0 set for toHost */ - int iSetEvent; /* could be dummy in LINUX */ -}; - -#define MAX_TRANSFER_SIZE 0x4000 /* Maximum data bytes per IRP */ -#define MAX_AREA_LENGTH 0x100000 /* Maximum size of transfer area */ -#define MAX_TRANSAREAS 8 /* definitions for dma set up */ - -typedef struct TGetSelfTest { - int code; /* self-test error code */ - int x, y; /* additional information */ -} TGET_SELFTEST; - -/* Debug block used for several commands. Not all fields are used for all commands. */ -typedef struct TDbgBlock { - int iAddr; /* the address in the 1401 */ - int iRepeats; /* number of repeats */ - int iWidth; /* width in bytes 1, 2, 4 */ - int iDefault; /* default value */ - int iMask; /* mask to apply */ - int iData; /* data for poke, result for peek */ -} TDBGBLOCK; - -/* Used to collect information about a circular block from the device driver */ -typedef struct TCircBlock { - unsigned int nArea; /* the area to collect information from */ - unsigned int dwOffset; /* offset into the area to the available block */ - unsigned int dwSize; /* size of the area */ -} TCIRCBLOCK; - -/* Used to clollect the 1401 status */ -typedef struct TCSBlock { - unsigned int uiState; - unsigned int uiError; -} TCSBLOCK; - -/* - * As seen by the user, an ioctl call looks like: int ioctl(int fd, unsigned - * long cmd, char* argp); We will then have all sorts of variants on this that - * can be used to pass stuff to our driver. We will generate macros for each - * type of call so as to provide some sort of type safety in the calling: - */ -#define CED_MAGIC_IOC 0xce - -#define IOCTL_CED_SENDSTRING(n) _IOC(_IOC_WRITE, CED_MAGIC_IOC, 2, n) - -#define IOCTL_CED_RESET1401 _IO(CED_MAGIC_IOC, 3) -#define IOCTL_CED_GETCHAR _IO(CED_MAGIC_IOC, 4) -#define IOCTL_CED_SENDCHAR _IO(CED_MAGIC_IOC, 5) -#define IOCTL_CED_STAT1401 _IO(CED_MAGIC_IOC, 6) -#define IOCTL_CED_LINECOUNT _IO(CED_MAGIC_IOC, 7) -#define IOCTL_CED_GETSTRING(nMax) _IOC(_IOC_READ, CED_MAGIC_IOC, 8, nMax) - -#define IOCTL_CED_SETTRANSFER _IOW(CED_MAGIC_IOC, 11, struct transfer_area_desc) -#define IOCTL_CED_UNSETTRANSFER _IO(CED_MAGIC_IOC, 12) -#define IOCTL_CED_SETEVENT _IOW(CED_MAGIC_IOC, 13, struct transfer_event) -#define IOCTL_CED_GETOUTBUFSPACE _IO(CED_MAGIC_IOC, 14) -#define IOCTL_CED_GETBASEADDRESS _IO(CED_MAGIC_IOC, 15) -#define IOCTL_CED_GETDRIVERREVISION _IO(CED_MAGIC_IOC, 16) - -#define IOCTL_CED_GETTRANSFER _IOR(CED_MAGIC_IOC, 17, TGET_TX_BLOCK) -#define IOCTL_CED_KILLIO1401 _IO(CED_MAGIC_IOC, 18) -#define IOCTL_CED_BLKTRANSSTATE _IO(CED_MAGIC_IOC, 19) - -#define IOCTL_CED_STATEOF1401 _IO(CED_MAGIC_IOC, 23) -#define IOCTL_CED_GRAB1401 _IO(CED_MAGIC_IOC, 25) -#define IOCTL_CED_FREE1401 _IO(CED_MAGIC_IOC, 26) -#define IOCTL_CED_STARTSELFTEST _IO(CED_MAGIC_IOC, 31) -#define IOCTL_CED_CHECKSELFTEST _IOR(CED_MAGIC_IOC, 32, TGET_SELFTEST) -#define IOCTL_CED_TYPEOF1401 _IO(CED_MAGIC_IOC, 33) -#define IOCTL_CED_TRANSFERFLAGS _IO(CED_MAGIC_IOC, 34) - -#define IOCTL_CED_DBGPEEK _IOW(CED_MAGIC_IOC, 35, TDBGBLOCK) -#define IOCTL_CED_DBGPOKE _IOW(CED_MAGIC_IOC, 36, TDBGBLOCK) -#define IOCTL_CED_DBGRAMPDATA _IOW(CED_MAGIC_IOC, 37, TDBGBLOCK) -#define IOCTL_CED_DBGRAMPADDR _IOW(CED_MAGIC_IOC, 38, TDBGBLOCK) -#define IOCTL_CED_DBGGETDATA _IOR(CED_MAGIC_IOC, 39, TDBGBLOCK) -#define IOCTL_CED_DBGSTOPLOOP _IO(CED_MAGIC_IOC, 40) -#define IOCTL_CED_FULLRESET _IO(CED_MAGIC_IOC, 41) -#define IOCTL_CED_SETCIRCULAR _IOW(CED_MAGIC_IOC, 42, struct transfer_area_desc) -#define IOCTL_CED_GETCIRCBLOCK _IOWR(CED_MAGIC_IOC, 43, TCIRCBLOCK) -#define IOCTL_CED_FREECIRCBLOCK _IOWR(CED_MAGIC_IOC, 44, TCIRCBLOCK) -#define IOCTL_CED_WAITEVENT _IO(CED_MAGIC_IOC, 45) -#define IOCTL_CED_TESTEVENT _IO(CED_MAGIC_IOC, 46) - -#ifndef __KERNEL__ -/* - * If nothing said about return value, it is a U14ERR_... error code - * (U14ERR_NOERROR for none) - */ -inline int CED_SendString(int fh, const char *szText, int n) -{ - return ioctl(fh, IOCTL_CED_SENDSTRING(n), szText); -} - -inline int CED_Reset1401(int fh) -{ - return ioctl(fh, IOCTL_CED_RESET1401); -} - -/* Return the singe character or a -ve error code. */ -inline int CED_GetChar(int fh) -{ - return ioctl(fh, IOCTL_CED_GETCHAR); -} - -/* Return character count in input buffer */ -inline int CED_Stat1401(int fh) -{ - return ioctl(fh, IOCTL_CED_STAT1401); -} - -inline int CED_SendChar(int fh, char c) -{ - return ioctl(fh, IOCTL_CED_SENDCHAR, c); -} - -inline int CED_LineCount(int fh) -{ - return ioctl(fh, IOCTL_CED_LINECOUNT); -} - -/* - * return the count of characters returned. If the string was terminated by CR - * or 0, then the 0 is part of the count. Otherwise, we will add a zero if - * there is room, but it is not included in the count. The return value is 0 - * if there was nothing to read. - */ -inline int CED_GetString(int fh, char *szText, int nMax) -{ - return ioctl(fh, IOCTL_CED_GETSTRING(nMax), szText); -} - -/* returns space in the output buffer. */ -inline int CED_GetOutBufSpace(int fh) -{ - return ioctl(fh, IOCTL_CED_GETOUTBUFSPACE); -} - -/* This always returns -1 as not implemented. */ -inline int CED_GetBaseAddress(int fh) -{ - return ioctl(fh, IOCTL_CED_GETBASEADDRESS); -} - -/* returns the major revision <<16 | minor revision. */ -inline int CED_GetDriverRevision(int fh) -{ - return ioctl(fh, IOCTL_CED_GETDRIVERREVISION); -} - -inline int CED_SetTransfer(int fh, struct transfer_area_desc *pTD) -{ - return ioctl(fh, IOCTL_CED_SETTRANSFER, pTD); -} - -inline int CED_UnsetTransfer(int fh, int nArea) -{ - return ioctl(fh, IOCTL_CED_UNSETTRANSFER, nArea); -} - -inline int CED_SetEvent(int fh, struct transfer_event *pTE) -{ - return ioctl(fh, IOCTL_CED_SETEVENT, pTE); -} - -inline int CED_GetTransfer(int fh, TGET_TX_BLOCK *pTX) -{ - return ioctl(fh, IOCTL_CED_GETTRANSFER, pTX); -} - -inline int CED_KillIO1401(int fh) -{ - return ioctl(fh, IOCTL_CED_KILLIO1401); -} - -/* returns 0 if no active DMA, 1 if active */ -inline int CED_BlkTransState(int fh) -{ - return ioctl(fh, IOCTL_CED_BLKTRANSSTATE); -} - -inline int CED_StateOf1401(int fh) -{ - return ioctl(fh, IOCTL_CED_STATEOF1401); -} - -inline int CED_Grab1401(int fh) -{ - return ioctl(fh, IOCTL_CED_GRAB1401); -} - -inline int CED_Free1401(int fh) -{ - return ioctl(fh, IOCTL_CED_FREE1401); -} - -inline int CED_StartSelfTest(int fh) -{ - return ioctl(fh, IOCTL_CED_STARTSELFTEST); -} - -inline int CED_CheckSelfTest(int fh, TGET_SELFTEST *pGST) -{ - return ioctl(fh, IOCTL_CED_CHECKSELFTEST, pGST); -} - -inline int CED_TypeOf1401(int fh) -{ - return ioctl(fh, IOCTL_CED_TYPEOF1401); -} - -inline int CED_TransferFlags(int fh) -{ - return ioctl(fh, IOCTL_CED_TRANSFERFLAGS); -} - -inline int CED_DbgPeek(int fh, TDBGBLOCK *pDB) -{ - return ioctl(fh, IOCTL_CED_DBGPEEK, pDB); -} - -inline int CED_DbgPoke(int fh, TDBGBLOCK *pDB) -{ - return ioctl(fh, IOCTL_CED_DBGPOKE, pDB); -} - -inline int CED_DbgRampData(int fh, TDBGBLOCK *pDB) -{ - return ioctl(fh, IOCTL_CED_DBGRAMPDATA, pDB); -} - -inline int CED_DbgRampAddr(int fh, TDBGBLOCK *pDB) -{ - return ioctl(fh, IOCTL_CED_DBGRAMPADDR, pDB); -} - -inline int CED_DbgGetData(int fh, TDBGBLOCK *pDB) -{ - return ioctl(fh, IOCTL_CED_DBGGETDATA, pDB); -} - -inline int CED_DbgStopLoop(int fh) -{ - return ioctl(fh, IOCTL_CED_DBGSTOPLOOP); -} - -inline int CED_FullReset(int fh) -{ - return ioctl(fh, IOCTL_CED_FULLRESET); -} - -inline int CED_SetCircular(int fh, struct transfer_area_desc *pTD) -{ - return ioctl(fh, IOCTL_CED_SETCIRCULAR, pTD); -} - -inline int CED_GetCircBlock(int fh, TCIRCBLOCK *pCB) -{ - return ioctl(fh, IOCTL_CED_GETCIRCBLOCK, pCB); -} - -inline int CED_FreeCircBlock(int fh, TCIRCBLOCK *pCB) -{ - return ioctl(fh, IOCTL_CED_FREECIRCBLOCK, pCB); -} - -inline int CED_WaitEvent(int fh, int nArea, int msTimeOut) -{ - return ioctl(fh, IOCTL_CED_WAITEVENT, (nArea & 0xff)|(msTimeOut << 8)); -} - -inline int CED_TestEvent(int fh, int nArea) -{ - return ioctl(fh, IOCTL_CED_TESTEVENT, nArea); -} -#endif - -#ifdef NOTWANTEDYET -#define IOCTL_CED_REGCALLBACK _IO(CED_MAGIC_IOC, 9) /* Not used */ -#define IOCTL_CED_GETMONITORBUF _IO(CED_MAGIC_IOC, 10) /* Not used */ - -#define IOCTL_CED_BYTECOUNT _IO(CED_MAGIC_IOC, 20) /* Not used */ -#define IOCTL_CED_ZEROBLOCKCOUNT _IO(CED_MAGIC_IOC, 21) /* Not used */ -#define IOCTL_CED_STOPCIRCULAR _IO(CED_MAGIC_IOC, 22) /* Not used */ - -#define IOCTL_CED_REGISTERS1401 _IO(CED_MAGIC_IOC, 24) /* Not used */ -#define IOCTL_CED_STEP1401 _IO(CED_MAGIC_IOC, 27) /* Not used */ -#define IOCTL_CED_SET1401REGISTERS _IO(CED_MAGIC_IOC, 28) /* Not used */ -#define IOCTL_CED_STEPTILL1401 _IO(CED_MAGIC_IOC, 29) /* Not used */ -#define IOCTL_CED_SETORIN _IO(CED_MAGIC_IOC, 30) /* Not used */ - -#endif - -/* __CED_IOCTL_H__ */ -#endif diff --git a/drivers/staging/ced1401/machine.h b/drivers/staging/ced1401/machine.h deleted file mode 100644 index dbd4036d..0000000 --- a/drivers/staging/ced1401/machine.h +++ /dev/null @@ -1,119 +0,0 @@ -/***************************************************************************** -** -** machine.h -** -** Copyright (c) Cambridge Electronic Design Limited 1991,1992,2010 -** -** This program is free software; you can redistribute it and/or -** modify it under the terms of the GNU General Public License -** as published by the Free Software Foundation; either version 2 -** of the License, or (at your option) any later version. -** -** 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. -** -** Contact CED: Cambridge Electronic Design Limited, Science Park, Milton Road -** Cambridge, CB6 0FE. -** www.ced.co.uk -** greg@ced.co.uk -** -** This file is included at the start of 'C' or 'C++' source file to define -** things for cross-platform/compiler interoperability. This used to deal with -** MSDOS/16-bit stuff, but this was all removed in Decemeber 2010. There are -** three things to consider: Windows, LINUX, mac OSX (BSD Unix) and 32 vs 64 -** bit. At the time of writing (DEC 2010) there is a consensus on the following -** and their unsigned equivalents: -** -** type bits -** char 8 -** short 16 -** int 32 -** long long 64 -** -** long is a problem as it is always 64 bits on linux/unix and is always 32 bits -** on windows. -** On windows, we define _IS_WINDOWS_ and one of WIN32 or WIN64. -** On linux we define LINUX -** On Max OSX we define MACOSX -** -*/ - -#ifndef __MACHINE_H__ -#define __MACHINE_H__ -#ifndef __KERNEL__ -#include <float.h> -#include <limits.h> -#endif - -/* -** The initial section is to identify the operating system -*/ -#if (defined(__linux__) || defined(_linux) || defined(__linux)) && !defined(LINUX) -#define LINUX 1 -#endif - -#if (defined(__WIN32__) || defined(_WIN32)) && !defined(WIN32) -#define WIN32 1 -#endif - -#if defined(__APPLE__) -#define MACOSX -#endif - -#if defined(_WIN64) -#undef WIN32 -#undef WIN64 -#define WIN64 1 -#endif - -#if defined(WIN32) || defined(WIN64) -#define _IS_WINDOWS_ 1 -#endif - -#if defined(LINUX) || defined(MAXOSX) - #define FAR - - typedef int BOOL; /* To match Windows */ - typedef unsigned char BYTE; - #define __packed __attribute__((packed)) - #define HIWORD(x) (unsigned short)(((x)>>16) & 0xffff) - #define LOWORD(x) (unsigned short)((x) & 0xffff) -#endif - -#ifdef _IS_WINDOWS_ -#include <windows.h> -#define __packed -#endif - -/* -** Sort out the DllExport and DllImport macros. The GCC compiler has its own -** syntax for this, though it also supports the MS specific __declspec() as -** a synonym. -*/ -#ifdef GNUC - #define DllExport __attribute__((dllexport)) - #define DllImport __attribute__((dllimport)) -#endif - -#ifndef DllExport -#ifdef _IS_WINDOWS_ - #define DllExport __declspec(dllexport) - #define DllImport __declspec(dllimport) -#else - #define DllExport - #define DllImport -#endif -#endif /* _IS_WINDOWS_ */ - -#ifndef TRUE - #define TRUE 1 - #define FALSE 0 -#endif - -#endif diff --git a/drivers/staging/ced1401/usb1401.c b/drivers/staging/ced1401/usb1401.c deleted file mode 100644 index 9988677..0000000 --- a/drivers/staging/ced1401/usb1401.c +++ /dev/null @@ -1,1767 +0,0 @@ -/******************************************************************************* - CED1401 usb driver. This basic loading is based on the usb-skeleton.c code that - is: - Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com) - Copyright (C) 2012 Alois Schloegl <alois.schloegl@ist.ac.at> - There is not a great deal of the skeleton left. - - All the remainder dealing specifically with the CED1401 is based on drivers - written by CED for other systems (mainly Windows) and is: - Copyright (C) 2010 Cambridge Electronic Design Ltd - Author Greg P Smith (greg@ced.co.uk) - - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License - as published by the Free Software Foundation; either version 2 - of the License, or (at your option) any later version. - - 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - -Endpoints -********* -There are 4 endpoints plus the control endpoint in the standard interface -provided by most 1401s. The control endpoint is used for standard USB requests, -plus various CED-specific transactions such as start self test, debug and get -the 1401 status. The other endpoints are: - - 1 Characters to the 1401 - 2 Characters from the 1401 - 3 Block data to the 1401 - 4 Block data to the host. - -inside the driver these are indexed as an array from 0 to 3, transactions -over the control endpoint are carried out using a separate mechanism. The -use of the endpoints is mostly straightforward, with the driver issuing -IO request packets (IRPs) as required to transfer data to and from the 1401. -The handling of endpoint 2 is different because it is used for characters -from the 1401, which can appear spontaneously and without any other driver -activity - for example to repeatedly request DMA transfers in Spike2. The -desired effect is achieved by using an interrupt endpoint which can be -polled to see if it has data available, and writing the driver so that it -always maintains a pending read IRP from that endpoint which will read the -character data and terminate as soon as the 1401 makes data available. This -works very well, some care is taken with when you kick off this character -read IRP to avoid it being active when it is not wanted but generally it -is running all the time. - -In the 2270, there are only three endpoints plus the control endpoint. In -addition to the transactions mentioned above, the control endpoint is used -to transfer character data to the 1401. The other endpoints are used as: - - 1 Characters from the 1401 - 2 Block data to the 1401 - 3 Block data to the host. - -The type of interface available is specified by the interface subclass field -in the interface descriptor provided by the 1401. See the USB_INT_ constants -for the values that this field can hold. - -**************************************************************************** -Linux implementation - -Although Linux Device Drivers (3rd Edition) was a major source of information, -it is very out of date. A lot of information was gleaned from the latest -usb_skeleton.c code (you need to download the kernel sources to get this). - -To match the Windows version, everything is done using ioctl calls. All the -device state is held in the struct ced_data. -Block transfers are done by using get_user_pages() to pin down a list of -pages that we hold a pointer to in the device driver. We also allocate a -coherent transfer buffer of size STAGED_SZ (this must be a multiple of the -bulk endpoint size so that the 1401 does not realise that we break large -transfers down into smaller pieces). We use kmap_atomic() to get a kernel -va for each page, as it is required, for copying; see ced_copy_user_space(). - -All character and data transfers are done using asynchronous IO. All Urbs are -tracked by anchoring them. Status and debug ioctls are implemented with the -synchronous non-Urb based transfers. -*/ - -#include <linux/kernel.h> -#include <linux/errno.h> -#include <linux/usb.h> -#include <linux/mutex.h> -#include <linux/mm.h> -#include <linux/highmem.h> -#include <linux/slab.h> -#include <linux/module.h> -#include <linux/kref.h> -#include <linux/uaccess.h> - -#include "usb1401.h" - -/* Define these values to match your devices */ -#define USB_CED_VENDOR_ID 0x0525 -#define USB_CED_PRODUCT_ID 0xa0f0 - -/* table of devices that work with this driver */ -static const struct usb_device_id ced_table[] = { - {USB_DEVICE(USB_CED_VENDOR_ID, USB_CED_PRODUCT_ID)}, - {} /* Terminating entry */ -}; - -MODULE_DEVICE_TABLE(usb, ced_table); - -/* Get a minor range for your devices from the usb maintainer */ -#define USB_CED_MINOR_BASE 192 - -/* our private defines. if this grows any larger, use your own .h file */ -#define MAX_TRANSFER (PAGE_SIZE - 512) -/* MAX_TRANSFER is chosen so that the VM is not stressed by - allocations > PAGE_SIZE and the number of packets in a page - is an integer 512 is the largest possible packet on EHCI */ -#define WRITES_IN_FLIGHT 8 -/* arbitrarily chosen */ - -static struct usb_driver ced_driver; - -static void ced_delete(struct kref *kref) -{ - struct ced_data *ced = to_ced_data(kref); - - /* Free up the output buffer, then free the output urb. Note that the */ - /* interface member of ced will probably be NULL, so cannot be used */ - /* to get to dev. */ - usb_free_coherent(ced->udev, OUTBUF_SZ, ced->coher_char_out, - ced->urb_char_out->transfer_dma); - usb_free_urb(ced->urb_char_out); - - /* Do the same for chan input */ - usb_free_coherent(ced->udev, INBUF_SZ, ced->coher_char_in, - ced->urb_char_in->transfer_dma); - usb_free_urb(ced->urb_char_in); - - /* Do the same for the block transfers */ - usb_free_coherent(ced->udev, STAGED_SZ, ced->coher_staged_io, - ced->staged_urb->transfer_dma); - usb_free_urb(ced->staged_urb); - - usb_put_dev(ced->udev); - kfree(ced); -} - -/* This is the driver end of the open() call from user space. */ -static int ced_open(struct inode *inode, struct file *file) -{ - struct ced_data *ced; - int retval = 0; - int subminor = iminor(inode); - struct usb_interface *interface = - usb_find_interface(&ced_driver, subminor); - if (!interface) { - pr_err("%s - error, can't find device for minor %d", __func__, - subminor); - retval = -ENODEV; - goto exit; - } - - ced = usb_get_intfdata(interface); - if (!ced) { - retval = -ENODEV; - goto exit; - } - - dev_dbg(&interface->dev, "%s: got ced\n", __func__); - - /* increment our usage count for the device */ - kref_get(&ced->kref); - - /* lock the device to allow correctly handling errors - * in resumption */ - mutex_lock(&ced->io_mutex); - - if (!ced->open_count++) { - retval = usb_autopm_get_interface(interface); - if (retval) { - ced->open_count--; - mutex_unlock(&ced->io_mutex); - kref_put(&ced->kref, ced_delete); - goto exit; - } - } else { /* uncomment this block if you want exclusive open */ - dev_err(&interface->dev, "%s: fail: already open\n", __func__); - retval = -EBUSY; - ced->open_count--; - mutex_unlock(&ced->io_mutex); - kref_put(&ced->kref, ced_delete); - goto exit; - } - /* prevent the device from being autosuspended */ - - /* save our object in the file's private structure */ - file->private_data = ced; - mutex_unlock(&ced->io_mutex); - -exit: - return retval; -} - -static int ced_release(struct inode *inode, struct file *file) -{ - struct ced_data *ced = file->private_data; - - if (ced == NULL) - return -ENODEV; - - dev_dbg(&ced->interface->dev, "%s: called\n", __func__); - mutex_lock(&ced->io_mutex); - if (!--ced->open_count && ced->interface) /* Allow autosuspend */ - usb_autopm_put_interface(ced->interface); - mutex_unlock(&ced->io_mutex); - - /* decrement the count on our device */ - kref_put(&ced->kref, ced_delete); - return 0; -} - -static int ced_flush(struct file *file, fl_owner_t id) -{ - int res; - struct ced_data *ced = file->private_data; - - if (ced == NULL) - return -ENODEV; - - dev_dbg(&ced->interface->dev, "%s: char in pend=%d\n", - __func__, ced->read_chars_pending); - - /* wait for io to stop */ - mutex_lock(&ced->io_mutex); - dev_dbg(&ced->interface->dev, "%s: got io_mutex\n", __func__); - ced_draw_down(ced); - - /* read out errors, leave subsequent opens a clean slate */ - spin_lock_irq(&ced->err_lock); - res = ced->errors ? (ced->errors == -EPIPE ? -EPIPE : -EIO) : 0; - ced->errors = 0; - spin_unlock_irq(&ced->err_lock); - - mutex_unlock(&ced->io_mutex); - dev_dbg(&ced->interface->dev, "%s: exit reached\n", __func__); - - return res; -} - -/*************************************************************************** -** can_accept_io_requests -** If the device is removed, interface is set NULL. We also clear our pointer -** from the interface, so we should make sure that ced is not NULL. This will -** not help with a device extension held by a file. -** return true if can accept new io requests, else false -*/ -static bool can_accept_io_requests(struct ced_data *ced) -{ - return ced && ced->interface; /* Can we accept IO requests */ -} - -/**************************************************************************** -** Callback routine to complete writes. This may need to fire off another -** urb to complete the transfer. -****************************************************************************/ -static void ced_writechar_callback(struct urb *urb) -{ - struct ced_data *ced = urb->context; - int got = urb->actual_length; /* what we transferred */ - - if (urb->status) { /* sync/async unlink faults aren't errors */ - if (! - (urb->status == -ENOENT || urb->status == -ECONNRESET - || urb->status == -ESHUTDOWN)) { - dev_err(&ced->interface->dev, - "%s: nonzero write bulk status received: %d\n", - __func__, urb->status); - } - - spin_lock(&ced->err_lock); - ced->errors = urb->status; - spin_unlock(&ced->err_lock); - got = 0; /* and tidy up again if so */ - - spin_lock(&ced->char_out_lock); /* already at irq level */ - ced->out_buff_get = 0; /* Reset the output buffer */ - ced->out_buff_put = 0; - ced->num_output = 0; /* Clear the char count */ - ced->pipe_error[0] = 1; /* Flag an error for later */ - ced->send_chars_pending = false; /* Allow other threads again */ - spin_unlock(&ced->char_out_lock); /* already at irq level */ - dev_dbg(&ced->interface->dev, - "%s: char out done, 0 chars sent\n", __func__); - } else { - dev_dbg(&ced->interface->dev, - "%s: char out done, %d chars sent\n", __func__, got); - spin_lock(&ced->char_out_lock); /* already at irq level */ - ced->num_output -= got; /* Now adjust the char send buffer */ - ced->out_buff_get += got; /* to match what we did */ - - /* Can't do this any earlier as data could be overwritten */ - if (ced->out_buff_get >= OUTBUF_SZ) - ced->out_buff_get = 0; - - if (ced->num_output > 0) { /* if more to be done... */ - int pipe = 0; /* The pipe number to use */ - int ret; - char *pDat = &ced->output_buffer[ced->out_buff_get]; - /* maximum to send */ - unsigned int count = ced->num_output; - - /* does it cross buffer end? */ - if ((ced->out_buff_get + count) > OUTBUF_SZ) - count = OUTBUF_SZ - ced->out_buff_get; - - /* we are done with stuff that changes */ - spin_unlock(&ced->char_out_lock); - - /* copy output data to the buffer */ - memcpy(ced->coher_char_out, pDat, count); - usb_fill_bulk_urb(ced->urb_char_out, ced->udev, - usb_sndbulkpipe(ced->udev, - ced->ep_addr[0]), - ced->coher_char_out, count, - ced_writechar_callback, ced); - ced->urb_char_out->transfer_flags |= - URB_NO_TRANSFER_DMA_MAP; - - /* in case we need to kill it */ - usb_anchor_urb(ced->urb_char_out, &ced->submitted); - ret = usb_submit_urb(ced->urb_char_out, GFP_ATOMIC); - dev_dbg(&ced->interface->dev, "%s: n=%d>%s<\n", - __func__, count, pDat); - - /* grab lock for errors */ - spin_lock(&ced->char_out_lock); - - if (ret) { - /* Flag an error to be handled later */ - ced->pipe_error[pipe] = 1; - /* Allow other threads again */ - ced->send_chars_pending = false; - usb_unanchor_urb(ced->urb_char_out); - dev_err(&ced->interface->dev, - "%s: usb_submit_urb() returned %d\n", - __func__, ret); - } - } else - /* Allow other threads again */ - ced->send_chars_pending = false; - - spin_unlock(&ced->char_out_lock); /* already at irq level */ - } -} - -/**************************************************************************** -** ced_send_chars -** Transmit the characters in the output buffer to the 1401. This may need -** breaking down into multiple transfers. -****************************************************************************/ -int ced_send_chars(struct ced_data *ced) -{ - int retval = U14ERR_NOERROR; - - spin_lock_irq(&ced->char_out_lock); /* Protect ourselves */ - - if ((!ced->send_chars_pending) && /* Not currently sending */ - (ced->num_output > 0) && /* has characters to output */ - (can_accept_io_requests(ced))) { /* and current activity is OK */ - unsigned int count = ced->num_output; /* Get a copy of the */ - /* character count */ - - /* Set flag to lock out other threads */ - ced->send_chars_pending = true; - - dev_dbg(&ced->interface->dev, - "Send %d chars to 1401, EP0 flag %d\n", - count, ced->n_pipes == 3); - /* If we have only 3 end points we must send the characters */ - /* to the 1401 using EP0. */ - if (ced->n_pipes == 3) { - /* For EP0 character transmissions to the 1401, we */ - /* have to hang about until they are gone, as */ - /* otherwise without more character IO activity */ - /* they will never go. */ - unsigned int i = count; /* Local char counter */ - unsigned int index = 0; /* The index into the */ - /* char buffer */ - - /* Free spinlock as we call USBD */ - spin_unlock_irq(&ced->char_out_lock); - - while ((i > 0) && (retval == U14ERR_NOERROR)) { - /* We have to break the transfer up into 64-byte chunks because of a 2270 problem */ - int n = i > 64 ? 64 : i; /* Chars for this xfer, max of 64 */ - int sent = usb_control_msg(ced->udev, - usb_sndctrlpipe(ced->udev, 0), /* use end point 0 */ - DB_CHARS, /* bRequest */ - (H_TO_D | VENDOR | DEVREQ), /* to the device, vendor request to the device */ - 0, 0, /* value and index are both 0 */ - &ced->output_buffer[index], /* where to send from */ - n, /* how much to send */ - 1000); /* timeout in jiffies */ - if (sent <= 0) { - /* if 0 chars says we timed out */ - retval = sent ? sent : -ETIMEDOUT; - dev_err(&ced->interface->dev, - "Send %d chars by EP0 failed: %d\n", - n, retval); - } else { - dev_dbg(&ced->interface->dev, - "Sent %d chars by EP0\n", n); - i -= sent; - index += sent; - } - } - - /* Protect ced changes, released by general code */ - spin_lock_irq(&ced->char_out_lock); - ced->out_buff_get = 0; /* so reset the output buffer */ - ced->out_buff_put = 0; - ced->num_output = 0; /* and clear the buffer count */ - /* Allow other threads again */ - ced->send_chars_pending = false; - } else { /* Here for sending chars normally - we hold the */ - /* spin lock */ - int pipe = 0; /* The pipe number to use */ - char *pDat = &ced->output_buffer[ced->out_buff_get]; - - /* does it cross buffer end? */ - if ((ced->out_buff_get + count) > OUTBUF_SZ) - count = OUTBUF_SZ - ced->out_buff_get; - /* we are done with stuff that changes */ - spin_unlock_irq(&ced->char_out_lock); - /* copy output data to the buffer */ - memcpy(ced->coher_char_out, pDat, count); - usb_fill_bulk_urb(ced->urb_char_out, ced->udev, - usb_sndbulkpipe(ced->udev, - ced->ep_addr[0]), - ced->coher_char_out, count, - ced_writechar_callback, ced); - ced->urb_char_out->transfer_flags |= - URB_NO_TRANSFER_DMA_MAP; - usb_anchor_urb(ced->urb_char_out, &ced->submitted); - retval = usb_submit_urb(ced->urb_char_out, GFP_KERNEL); - - /* grab lock for errors */ - spin_lock_irq(&ced->char_out_lock); - - if (retval) { - /* Flag an error to be handled later */ - ced->pipe_error[pipe] = 1; - /* Allow other threads again */ - ced->send_chars_pending = false; - /* remove from list of active urbs */ - usb_unanchor_urb(ced->urb_char_out); - } - } - } else if (ced->send_chars_pending && (ced->num_output > 0)) - dev_dbg(&ced->interface->dev, - "%s: send_chars_pending:true\n", __func__); - - dev_dbg(&ced->interface->dev, "%s: exit code: %d\n", __func__, retval); - spin_unlock_irq(&ced->char_out_lock); /* Now let go of the spinlock */ - return retval; -} - -/*************************************************************************** -** ced_copy_user_space -** This moves memory between pinned down user space and the coher_staged_io -** memory buffer we use for transfers. Copy n bytes in the directions that -** is defined by ced->staged_read. The user space is determined by the area -** in ced->staged_id and the offset in ced->staged_done. The user -** area may well not start on a page boundary, so allow for that. -** -** We have a table of physical pages that describe the area, so we can use -** this to get a virtual address that the kernel can use. -** -** ced Is our device extension which holds all we know about the transfer. -** n The number of bytes to move one way or the other. -***************************************************************************/ -static void ced_copy_user_space(struct ced_data *ced, int n) -{ - unsigned int area = ced->staged_id; - - if (area < MAX_TRANSAREAS) { - /* area to be used */ - struct transarea *ta = &ced->trans_def[area]; - unsigned int offset = - ced->staged_done + ced->staged_offset + ta->base_offset; - char *coher_buf = ced->coher_staged_io; /* coherent buffer */ - - if (!ta->used) { - dev_err(&ced->interface->dev, "%s: area %d unused\n", - __func__, area); - return; - } - - while (n) { - /* page number in table */ - int page = offset >> PAGE_SHIFT; - - if (page < ta->n_pages) { - char *address = - (char *)kmap_atomic(ta->pages[page]); - if (address) { - /* offset into the page */ - unsigned int page_off = - offset & (PAGE_SIZE - 1); - /* max to transfer on this page */ - size_t xfer = PAGE_SIZE - page_off; - - /* limit byte count if too much */ - /* for the page */ - if (xfer > n) - xfer = n; - if (ced->staged_read) - memcpy(address + page_off, - coher_buf, xfer); - else - memcpy(coher_buf, - address + page_off, - xfer); - kunmap_atomic(address); - offset += xfer; - coher_buf += xfer; - n -= xfer; - } else { - dev_err(&ced->interface->dev, - "%s: did not map page %d\n", - __func__, page); - return; - } - - } else { - dev_err(&ced->interface->dev, - "%s: exceeded pages %d\n", - __func__, page); - return; - } - } - } else - dev_err(&ced->interface->dev, "%s: bad area %d\n", - __func__, area); -} - -/* Forward declarations for stuff used circularly */ -static int ced_stage_chunk(struct ced_data *ced); - -/*************************************************************************** -** ReadWrite_Complete -** -** Completion routine for our staged read/write Irps -*/ -static void staged_callback(struct urb *urb) -{ - struct ced_data *ced = urb->context; - unsigned int got = urb->actual_length; /* what we transferred */ - bool cancel = false; - bool restart_char_input; /* used at the end */ - - spin_lock(&ced->staged_lock); /* stop ced_read_write_mem() action */ - /* while this routine is running */ - - /* clear the flag for staged IRP pending */ - ced->staged_urb_pending = false; - - if (urb->status) { /* sync/async unlink faults aren't errors */ - if (! - (urb->status == -ENOENT || urb->status == -ECONNRESET - || urb->status == -ESHUTDOWN)) { - dev_err(&ced->interface->dev, - "%s: nonzero write bulk status received: %d\n", - __func__, urb->status); - } else - dev_info(&ced->interface->dev, - "%s: staged xfer cancelled\n", __func__); - - spin_lock(&ced->err_lock); - ced->errors = urb->status; - spin_unlock(&ced->err_lock); - got = 0; /* and tidy up again if so */ - cancel = true; - } else { - dev_dbg(&ced->interface->dev, "%s: %d chars xferred\n", - __func__, got); - if (ced->staged_read) /* if reading, save to user space */ - /* copy from buffer to user */ - ced_copy_user_space(ced, got); - if (got == 0) - dev_dbg(&ced->interface->dev, "%s: ZLP\n", __func__); - } - - /* Update the transfer length based on the TransferBufferLength value */ - /* in the URB */ - ced->staged_done += got; - - dev_dbg(&ced->interface->dev, "%s: done %d bytes of %d\n", - __func__, ced->staged_done, ced->staged_length); - - if ((ced->staged_done == ced->staged_length) || /* If no more to do */ - (cancel)) { /* or this IRP was cancelled */ - /* Transfer area info */ - struct transarea *ta = &ced->trans_def[ced->staged_id]; - - dev_dbg(&ced->interface->dev, - "%s: transfer done, bytes %d, cancel %d\n", - __func__, ced->staged_done, cancel); - - /* Here is where we sort out what to do with this transfer if */ - /* using a circular buffer. We have a completed transfer that */ - /* can be assumed to fit into the transfer area. We should be */ - /* able to add this to the end of a growing block or to use */ - /* it to start a new block unless the code that calculates */ - /* the offset to use (in ced_read_write_mem) is totally duff. */ - if ((ta->circular) && - (ta->circ_to_host) && - (!cancel) && /* Time to sort out circular buffer info? */ - (ced->staged_read)) {/* Only for tohost transfers for now */ - /* If block 1 is in use we must append to it */ - if (ta->blocks[1].size > 0) { - if (ced->staged_offset == - (ta->blocks[1].offset + - ta->blocks[1].size)) { - ta->blocks[1].size += - ced->staged_length; - dev_dbg(&ced->interface->dev, - "RWM_Complete, circ block 1 now %d bytes at %d\n", - ta->blocks[1].size, - ta->blocks[1].offset); - } else { - /* Here things have gone very, very */ - /* wrong, but I cannot see how this */ - /* can actually be achieved */ - ta->blocks[1].offset = - ced->staged_offset; - ta->blocks[1].size = - ced->staged_length; - dev_err(&ced->interface->dev, - "%s: ERROR, circ block 1 re-started %d bytes at %d\n", - __func__, - ta->blocks[1].size, - ta->blocks[1].offset); - } - } else { /* If block 1 is not used, we try to add */ - /*to block 0 */ - - /* Got stored block 0 information? */ - if (ta->blocks[0].size > 0) { - /* Must append onto the */ - /*existing block 0 */ - if (ced->staged_offset == - (ta->blocks[0].offset + - ta->blocks[0].size)) { - /* Just add this transfer in */ - ta->blocks[0].size += - ced->staged_length; - dev_dbg(&ced->interface->dev, - "RWM_Complete, circ block 0 now %d bytes at %d\n", - ta->blocks[0].size, - ta->blocks[0].offset); - - } else { /* If it doesn't append, put */ - /* into new block 1 */ - ta->blocks[1].offset = - ced->staged_offset; - ta->blocks[1].size = - ced->staged_length; - dev_dbg(&ced->interface->dev, - "RWM_Complete, circ block 1 started %d bytes at %d\n", - ta->blocks[1].size, - ta->blocks[1].offset); - } - } else { /* No info stored yet, just save */ - /* in block 0 */ - ta->blocks[0].offset = - ced->staged_offset; - ta->blocks[0].size = - ced->staged_length; - dev_dbg(&ced->interface->dev, - "RWM_Complete, circ block 0 started %d bytes at %d\n", - ta->blocks[0].size, - ta->blocks[0].offset); - } - } - } - - if (!cancel) { /* Don't generate an event if cancelled */ - dev_dbg(&ced->interface->dev, - "RWM_Complete, bCircular %d, bToHost %d, eStart %d, eSize %d\n", - ta->circular, ta->event_to_host, - ta->event_st, ta->event_sz); - /* Set a user-mode event... */ - /* ...on transfers in this direction? */ - if ((ta->event_sz) && - (ced->staged_read == ta->event_to_host)) { - int wakeup = 0; /* assume */ - - /* If we have completed the right sort of DMA */ - /* transfer then set the event to notify the */ - /* user code to wake up anyone that is */ - /* waiting. */ - if ((ta->circular) && /* Circular areas use a - simpler test */ - (ta->circ_to_host)) { /* only in supported - direction */ - /* Is total data waiting up */ - /* to size limit? */ - unsigned int dwTotal = - ta->blocks[0].size + - ta->blocks[1].size; - wakeup = (dwTotal >= ta->event_sz); - } else { - unsigned int transEnd = - ced->staged_offset + - ced->staged_length; - unsigned int eventEnd = - ta->event_st + ta->event_sz; - wakeup = (ced->staged_offset < eventEnd) - && (transEnd > ta->event_st); - } - - if (wakeup) { - dev_dbg(&ced->interface->dev, - "About to set event to notify app\n"); - - /* wake up waiting processes */ - wake_up_interruptible(&ta->event); - /* increment wakeup count */ - ++ta->wake_up; - } - } - } - - /* Switch back to char mode before ced_read_write_mem call */ - ced->dma_flag = MODE_CHAR; - - /* Don't look for waiting transfer if cancelled */ - if (!cancel) { - /* If we have a transfer waiting, kick it off */ - if (ced->xfer_waiting) {/* Got a block xfer waiting? */ - int retval; - - dev_info(&ced->interface->dev, - "*** RWM_Complete *** pending transfer will now be set up!!!\n"); - retval = - ced_read_write_mem(ced, - !ced->dma_info.outward, - ced->dma_info.ident, - ced->dma_info.offset, - ced->dma_info.size); - - if (retval) - dev_err(&ced->interface->dev, - "RWM_Complete rw setup failed %d\n", - retval); - } - } - - } else /* Here for more to do */ - ced_stage_chunk(ced); /* fire off the next bit */ - - /* While we hold the staged_lock, see if we should reallow character */ - /* input ints */ - /* Don't allow if cancelled, or if a new block has started or if */ - /* there is a waiting block. */ - /* This feels wrong as we should ask which spin lock protects */ - /* dma_flag. */ - restart_char_input = !cancel && (ced->dma_flag == MODE_CHAR) && - !ced->xfer_waiting; - - spin_unlock(&ced->staged_lock); /* Finally release the lock again */ - - /* This is not correct as dma_flag is protected by the staged lock, */ - /* but it is treated in ced_allowi as if it were protected by the */ - /* char lock. In any case, most systems will not be upset by char */ - /* input during DMA... sigh. Needs sorting out. */ - if (restart_char_input) /* may be out of date, but... */ - ced_allowi(ced); /* ...ced_allowi tests a lock too. */ - dev_dbg(&ced->interface->dev, "%s: done\n", __func__); -} - -/**************************************************************************** -** ced_stage_chunk -** -** Generates the next chunk of data making up a staged transfer. -** -** The calling code must have acquired the staging spinlock before calling -** this function, and is responsible for releasing it. We are at callback level. -****************************************************************************/ -static int ced_stage_chunk(struct ced_data *ced) -{ - int retval = U14ERR_NOERROR; - unsigned int chunk_size; - int pipe = ced->staged_read ? 3 : 2; /* The pipe number to use for */ - /* reads or writes */ - - if (ced->n_pipes == 3) - pipe--; /* Adjust for the 3-pipe case */ - - if (pipe < 0) /* and trap case that should never happen */ - return U14ERR_FAIL; - - if (!can_accept_io_requests(ced)) { /* got sudden remove? */ - dev_info(&ced->interface->dev, "%s: sudden remove, giving up\n", - __func__); - return U14ERR_FAIL; /* could do with a better error */ - } - - /* transfer length remaining */ - chunk_size = (ced->staged_length - ced->staged_done); - if (chunk_size > STAGED_SZ) /* make sure to keep legal */ - chunk_size = STAGED_SZ; /* limit to max allowed */ - - if (!ced->staged_read) /* if writing... */ - /* ...copy data into the buffer */ - ced_copy_user_space(ced, chunk_size); - - usb_fill_bulk_urb(ced->staged_urb, ced->udev, - ced->staged_read ? usb_rcvbulkpipe(ced->udev, - ced-> - ep_addr[pipe]) : - usb_sndbulkpipe(ced->udev, ced->ep_addr[pipe]), - ced->coher_staged_io, chunk_size, - staged_callback, ced); - ced->staged_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; - /* in case we need to kill it */ - usb_anchor_urb(ced->staged_urb, &ced->submitted); - retval = usb_submit_urb(ced->staged_urb, GFP_ATOMIC); - if (retval) { - usb_unanchor_urb(ced->staged_urb); /* kill it */ - ced->pipe_error[pipe] = 1; /* Flag an error to be */ - /* handled later */ - dev_err(&ced->interface->dev, - "%s: submit urb failed, code %d\n", - __func__, retval); - } else - /* Set the flag for staged URB pending */ - ced->staged_urb_pending = true; - dev_dbg(&ced->interface->dev, "%s: done so far:%d, this size:%d\n", - __func__, ced->staged_done, chunk_size); - - return retval; -} - -/*************************************************************************** -** ced_read_write_mem -** -** This routine is used generally for block read and write operations. -** Breaks up a read or write in to specified sized chunks, as specified by pipe -** information on maximum transfer size. -** -** Any code that calls this must be holding the staged_lock -** -** Arguments: -** DeviceObject - pointer to our FDO (Functional Device Object) -** read - TRUE for read, FALSE for write. This is from POV of the driver -** ident - the transfer area number - defines memory area and more. -** offs - the start offset within the transfer area of the start of this -** transfer. -** len - the number of bytes to transfer. -*/ -int ced_read_write_mem(struct ced_data *ced, bool read, unsigned short ident, - unsigned int offs, unsigned int len) -{ - /* Transfer area info */ - struct transarea *ta = &ced->trans_def[ident]; - - /* Are we in a state to accept new requests? */ - if (!can_accept_io_requests(ced)) { - dev_err(&ced->interface->dev, "%s: can't accept requests\n", - __func__); - return U14ERR_FAIL; - } - - dev_dbg(&ced->interface->dev, - "%s: xfer %d bytes to %s, offset %d, area %d\n", - __func__, len, read ? "host" : "1401", offs, ident); - - /* Amazingly, we can get an escape sequence back before the current */ - /* staged Urb is done, so we have to check for this situation and, if */ - /* so, wait until all is OK. */ - if (ced->staged_urb_pending) { - ced->xfer_waiting = true; /* Flag we are waiting */ - dev_info(&ced->interface->dev, - "%s: xfer is waiting, as previous staged pending\n", - __func__); - return U14ERR_NOERROR; - } - - if (len == 0) { /* allow 0-len read or write; just return success */ - dev_dbg(&ced->interface->dev, - "%s: OK; zero-len read/write request\n", __func__); - return U14ERR_NOERROR; - } - - if ((ta->circular) && /* Circular transfer? */ - (ta->circ_to_host) && (read)) { /* In a supported direction */ - /* If so, we sort out offset ourself */ - bool bWait = false; /* Flag for transfer having to wait */ - - dev_dbg(&ced->interface->dev, - "Circular buffers are %d at %d and %d at %d\n", - ta->blocks[0].size, ta->blocks[0].offset, - ta->blocks[1].size, ta->blocks[1].offset); - - /* Using the second block already? */ - if (ta->blocks[1].size > 0) { - /* take offset from that */ - offs = ta->blocks[1].offset + ta->blocks[1].size; - /* Wait if will overwrite block 0? */ - bWait = (offs + len) > ta->blocks[0].offset; - /* or if it overflows the buffer */ - bWait |= (offs + len) > ta->length; - } else { /* Area 1 not in use, try to use area 0 */ - /* Reset block 0 if not in use */ - if (ta->blocks[0].size == 0) - ta->blocks[0].offset = 0; - offs = - ta->blocks[0].offset + - ta->blocks[0].size; - /* Off the end of the buffer? */ - if ((offs + len) > ta->length) { - /* Set up to use second block */ - ta->blocks[1].offset = 0; - offs = 0; - /* Wait if will overwrite block 0? */ - bWait = (offs + len) > ta->blocks[0].offset; - /* or if it overflows the buffer */ - bWait |= (offs + len) > ta->length; - } - } - - if (bWait) { /* This transfer will have to wait? */ - ced->xfer_waiting = true; /* Flag we are waiting */ - dev_dbg(&ced->interface->dev, - "%s: xfer waiting for circular buffer space\n", - __func__); - return U14ERR_NOERROR; - } - - dev_dbg(&ced->interface->dev, - "%s: circular xfer, %d bytes starting at %d\n", - __func__, len, offs); - } - /* Save the parameters for the read\write transfer */ - ced->staged_read = read; /* Save the parameters for this read */ - ced->staged_id = ident; /* ID allows us to get transfer area info */ - ced->staged_offset = offs; /* The area within the transfer area */ - ced->staged_length = len; - ced->staged_done = 0; /* Initialise the byte count */ - ced->dma_flag = MODE_LINEAR; /* Set DMA mode flag at this point */ - ced->xfer_waiting = false; /* Clearly not a transfer waiting now */ - -/* KeClearEvent(&ced->StagingDoneEvent); // Clear the transfer done event */ - ced_stage_chunk(ced); /* fire off the first chunk */ - - return U14ERR_NOERROR; -} - -/**************************************************************************** -** -** ced_read_char -** -** Reads a character a buffer. If there is no more -** data we return FALSE. Used as part of decoding a DMA request. -** -****************************************************************************/ -static bool ced_read_char(unsigned char *character, char *buf, - unsigned int *n_done, unsigned int got) -{ - bool read = false; - unsigned int done = *n_done; - - if (done < got) { /* If there is more data */ - /* Extract the next char */ - *character = (unsigned char)buf[done]; - done++; /* Increment the done count */ - *n_done = done; - read = true; /* and flag success */ - } - - return read; -} - -#ifdef NOTUSED -/**************************************************************************** -** -** ced_read_word -** -** Reads a word from the 1401, just uses ced_read_char twice; -** passes on any error -** -*****************************************************************************/ -static bool ced_read_word(unsigned short *word, char *buf, unsigned int *n_done, - unsigned int got) -{ - if (ced_read_char((unsigned char *)word, buf, n_done, got)) - return ced_read_char(((unsigned char *)word) + 1, buf, n_done, - got); - else - return false; -} -#endif - -/**************************************************************************** -** ced_read_huff -** -** Reads a coded number in and returns it, Code is: -** If data is in range 0..127 we receive 1 byte. If data in range 128-16383 -** we receive two bytes, top bit of first indicates another on its way. If -** data in range 16384-4194303 we get three bytes, top two bits of first set -** to indicate three byte total. -** -*****************************************************************************/ -static bool ced_read_huff(volatile unsigned int *word, char *buf, - unsigned int *n_done, unsigned int got) -{ - unsigned char c; /* for each read to ced_read_char */ - bool retval = true; /* assume we will succeed */ - unsigned int data = 0; /* Accumulator for the data */ - - if (ced_read_char(&c, buf, n_done, got)) { - data = c; /* copy the data */ - if ((data & 0x00000080) != 0) { /* Bit set for more data ? */ - data &= 0x0000007F; /* Clear the relevant bit */ - if (ced_read_char(&c, buf, n_done, got)) { - data = (data << 8) | c; - - /* three byte sequence ? */ - if ((data & 0x00004000) != 0) { - /* Clear the relevant bit */ - data &= 0x00003FFF; - if (ced_read_char - (&c, buf, n_done, got)) - data = (data << 8) | c; - else - retval = false; - } - } else - retval = false; /* couldn't read data */ - } - } else - retval = false; - - *word = data; /* return the data */ - return retval; -} - -/*************************************************************************** -** -** ced_read_dma_info -** -** Tries to read info about the dma request from the 1401 and decode it into -** the dma descriptor block. We have at this point had the escape character -** from the 1401 and now we must read in the rest of the information about -** the transfer request. Returns FALSE if 1401 fails to respond or obselete -** code from 1401 or bad parameters. -** -** The buf char pointer does not include the initial escape character, so -** we start handling the data at offset zero. -** -*****************************************************************************/ -static bool ced_read_dma_info(volatile struct dmadesc *dma_desc, - struct ced_data *ced, - char *buf, unsigned int count) -{ - bool retval = false; /* assume we won't succeed */ - unsigned char c; - unsigned int n_done = 0; /* We haven't parsed anything so far */ - - dev_dbg(&ced->interface->dev, "%s\n", __func__); - - if (ced_read_char(&c, buf, &n_done, count)) { - /* get code for transfer type */ - unsigned char trans_code = (c & 0x0F); - /* and area identifier */ - unsigned short ident = ((c >> 4) & 0x07); - - /* fill in the structure we were given */ - dma_desc->trans_type = trans_code; /* type of transfer */ - dma_desc->ident = ident; /* area to use */ - dma_desc->size = 0; /* initialise other bits */ - dma_desc->offset = 0; - - dev_dbg(&ced->interface->dev, "%s: type: %d ident: %d\n", - __func__, dma_desc->trans_type, dma_desc->ident); - - /* set transfer direction */ - dma_desc->outward = (trans_code != TM_EXTTOHOST); - - switch (trans_code) { - - /* Extended linear transfer modes (the only ones!) */ - case TM_EXTTOHOST: - case TM_EXTTO1401: - { - retval = - ced_read_huff(&(dma_desc->offset), buf, - &n_done, count) - && ced_read_huff(&(dma_desc->size), buf, - &n_done, count); - if (retval) { - dev_dbg(&ced->interface->dev, - "%s: xfer offset & size %d %d\n", - __func__, dma_desc->offset, - dma_desc->size); - - if ((ident >= MAX_TRANSAREAS) || /* Illegal area number, or... */ - (!ced->trans_def[ident].used) || /* area not set up, or... */ - (dma_desc->offset > ced->trans_def[ident].length) || /* range/size */ - ((dma_desc->offset + - dma_desc->size) > - (ced->trans_def[ident].length))) { - /* bad parameter(s) */ - retval = false; - dev_dbg(&ced->interface->dev, - "%s: bad param - id %d, bUsed %d, offset %d, size %d, area length %d\n", - __func__, ident, - ced->trans_def[ident]. - used, - dma_desc->offset, - dma_desc->size, - ced->trans_def[ident]. - length); - } - } - break; - } - default: - break; - } - } else - retval = false; - - if (!retval) /* now check parameters for validity */ - dev_err(&ced->interface->dev, - "%s: error reading Esc sequence\n", - __func__); - - return retval; -} - -/**************************************************************************** -** -** ced_handle_esc -** -** Deals with an escape sequence coming from the 1401. This can either be -** a DMA transfer request of various types or a response to an escape sequence -** sent to the 1401. This is called from a callback. -** -** Parameters are -** -** count - the number of characters in the device extension char in buffer, -** this is known to be at least 2 or we will not be called. -** -****************************************************************************/ -static int ced_handle_esc(struct ced_data *ced, char *ch, - unsigned int count) -{ - int retval = U14ERR_FAIL; - - /* I have no idea what this next test is about. '?' is 0x3f, which is */ - /* area 3, code 15. At the moment, this is not used, so it does no */ - /* harm, but unless someone can tell me what this is for, it should */ - /* be removed from this and the Windows driver. */ - if (ch[0] == '?') { /* Is this an information response */ - /* Parse and save the information */ - } else { - spin_lock(&ced->staged_lock); /* Lock others out */ - - /* Get DMA parameters */ - if (ced_read_dma_info(&ced->dma_info, ced, ch, count)) { - /* check transfer type */ - unsigned short trans_type = ced->dma_info.trans_type; - - dev_dbg(&ced->interface->dev, - "%s: xfer to %s, offset %d, length %d\n", - __func__, - ced->dma_info.outward ? "1401" : "host", - ced->dma_info.offset, ced->dma_info.size); - - /* Check here for badly out of kilter... */ - if (ced->xfer_waiting) { - /* This can never happen, really */ - dev_err(&ced->interface->dev, - "ERROR: DMA setup while transfer still waiting\n"); - } else { - if ((trans_type == TM_EXTTOHOST) - || (trans_type == TM_EXTTO1401)) { - retval = - ced_read_write_mem(ced, - !ced->dma_info.outward, - ced->dma_info.ident, - ced->dma_info.offset, - ced->dma_info.size); - if (retval != U14ERR_NOERROR) - dev_err(&ced->interface->dev, - "%s: ced_read_write_mem() failed %d\n", - __func__, retval); - } else /* This covers non-linear - transfer setup */ - dev_err(&ced->interface->dev, - "%s: Unknown block xfer type %d\n", - __func__, trans_type); - } - } else /* Failed to read parameters */ - dev_err(&ced->interface->dev, "%s: ced_read_dma_info() fail\n", - __func__); - - spin_unlock(&ced->staged_lock); /* OK here */ - } - - dev_dbg(&ced->interface->dev, "%s: returns %d\n", __func__, retval); - - return retval; -} - -/**************************************************************************** -** Callback for the character read complete or error -****************************************************************************/ -static void ced_readchar_callback(struct urb *urb) -{ - struct ced_data *ced = urb->context; - int got = urb->actual_length; /* what we transferred */ - - if (urb->status) { /* Do we have a problem to handle? */ - /* The pipe number to use for error */ - int pipe = ced->n_pipes == 4 ? 1 : 0; - /* sync/async unlink faults aren't errors... */ - /* just saying device removed or stopped */ - if (! - (urb->status == -ENOENT || urb->status == -ECONNRESET - || urb->status == -ESHUTDOWN)) { - dev_err(&ced->interface->dev, - "%s: nonzero write bulk status received: %d\n", - __func__, urb->status); - } else - dev_dbg(&ced->interface->dev, - "%s: 0 chars urb->status=%d (shutdown?)\n", - __func__, urb->status); - - spin_lock(&ced->err_lock); - ced->errors = urb->status; - spin_unlock(&ced->err_lock); - got = 0; /* and tidy up again if so */ - - spin_lock(&ced->char_in_lock); /* already at irq level */ - ced->pipe_error[pipe] = 1; /* Flag an error for later */ - } else { - /* Esc sequence? */ - if ((got > 1) && ((ced->coher_char_in[0] & 0x7f) == 0x1b)) { - /* handle it */ - ced_handle_esc(ced, &ced->coher_char_in[1], got - 1); - - /* already at irq level */ - spin_lock(&ced->char_in_lock); - } else { - /* already at irq level */ - spin_lock(&ced->char_in_lock); - - if (got > 0) { - unsigned int i; - - if (got < INBUF_SZ) { - /* tidy the string */ - ced->coher_char_in[got] = 0; - dev_dbg(&ced->interface->dev, - "%s: got %d chars >%s<\n", - __func__, got, - ced->coher_char_in); - } - /* We know that whatever we read must fit */ - /* in the input buffer */ - for (i = 0; i < got; i++) { - ced->input_buffer[ced->in_buff_put++] = - ced->coher_char_in[i] & 0x7F; - if (ced->in_buff_put >= INBUF_SZ) - ced->in_buff_put = 0; - } - - if ((ced->num_input + got) <= INBUF_SZ) - /* Adjust the buffer count */ - /* accordingly */ - ced->num_input += got; - } else - dev_dbg(&ced->interface->dev, "%s: read ZLP\n", - __func__); - } - } - - ced->read_chars_pending = false; /* No longer have a pending read */ - spin_unlock(&ced->char_in_lock); /* already at irq level */ - - ced_allowi(ced); /* see if we can do the next one */ -} - -/**************************************************************************** -** ced_allowi -** -** This is used to make sure that there is always a pending input transfer so -** we can pick up any inward transfers. This can be called in multiple contexts -** so we use the irqsave version of the spinlock. -****************************************************************************/ -int ced_allowi(struct ced_data *ced) -{ - int retval = U14ERR_NOERROR; - unsigned long flags; - - /* can be called in multiple contexts */ - spin_lock_irqsave(&ced->char_in_lock, flags); - - /* We don't want char input running while DMA is in progress as we */ - /* know that this can cause sequencing problems for the 2270. So */ - /* don't. It will also allow the ERR response to get back to the host */ - /* code too early on some PCs, even if there is no actual driver */ - /* failure, so we don't allow this at all. */ - if (!ced->in_draw_down && /* stop input if */ - !ced->read_chars_pending && /* If no read request outstanding */ - (ced->num_input < (INBUF_SZ / 2)) && /* and there is some space */ - (ced->dma_flag == MODE_CHAR) && /* not doing any DMA */ - (!ced->xfer_waiting) && /* no xfer waiting to start */ - (can_accept_io_requests(ced))) { /* and activity is generally OK */ - /* then off we go */ - /* max we could read */ - unsigned int max = INBUF_SZ - ced->num_input; - /* The pipe number to use */ - int pipe = ced->n_pipes == 4 ? 1 : 0; - - dev_dbg(&ced->interface->dev, "%s: %d chars in input buffer\n", - __func__, ced->num_input); - - usb_fill_int_urb(ced->urb_char_in, ced->udev, - usb_rcvintpipe(ced->udev, ced->ep_addr[pipe]), - ced->coher_char_in, max, ced_readchar_callback, - ced, ced->interval); - - /* short xfers are OK by default */ - ced->urb_char_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; - - /* in case we need to kill it */ - usb_anchor_urb(ced->urb_char_in, &ced->submitted); - - retval = usb_submit_urb(ced->urb_char_in, GFP_ATOMIC); - if (retval) { - /* remove from list of active Urbs */ - usb_unanchor_urb(ced->urb_char_in); - /* Flag an error to be handled later */ - ced->pipe_error[pipe] = 1; - dev_err(&ced->interface->dev, - "%s: submit urb failed: %d\n", - __func__, retval); - } else - /* Flag that we are active here */ - ced->read_chars_pending = true; - } - - spin_unlock_irqrestore(&ced->char_in_lock, flags); - - return retval; -} - -/***************************************************************************** -** The ioctl entry point to the driver that is used by us to talk to it. -** inode The device node (no longer in 3.0.0 kernels) -** file The file that is open, which holds our ced pointer -** arg The argument passed in. Note that long is 64-bits in 64-bit system, -** i.e. it is big enough for a 64-bit pointer. -*****************************************************************************/ -static long ced_ioctl(struct file *file, unsigned int cmd, unsigned long arg) -{ - int err = 0; - struct ced_data *ced = file->private_data; - - if (!can_accept_io_requests(ced)) /* check we still exist */ - return -ENODEV; - - /* Check that access is allowed, where is is needed. Anything that */ - /* would have an indeterminate size will be checked by the */ - /* specific command. */ - if (_IOC_DIR(cmd) & _IOC_READ) /* read from point of view of user... */ - /* is kernel write */ - err = !access_ok(VERIFY_WRITE, - (void __user *)arg, _IOC_SIZE(cmd)); - else if (_IOC_DIR(cmd) & _IOC_WRITE) /* and write from point of */ - /* view of user... */ - /* is kernel read */ - err = !access_ok(VERIFY_READ, - (void __user *)arg, _IOC_SIZE(cmd)); - if (err) - return -EFAULT; - - switch (_IOC_NR(cmd)) { - case _IOC_NR(IOCTL_CED_SENDSTRING(0)): - return ced_send_string(ced, (const char __user *)arg, - _IOC_SIZE(cmd)); - - case _IOC_NR(IOCTL_CED_RESET1401): - return ced_reset(ced); - - case _IOC_NR(IOCTL_CED_GETCHAR): - return ced_get_char(ced); - - case _IOC_NR(IOCTL_CED_SENDCHAR): - return ced_send_char(ced, (char)arg); - - case _IOC_NR(IOCTL_CED_STAT1401): - return ced_stat_1401(ced); - - case _IOC_NR(IOCTL_CED_LINECOUNT): - return ced_line_count(ced); - - case _IOC_NR(IOCTL_CED_GETSTRING(0)): - return ced_get_string(ced, (char __user *)arg, _IOC_SIZE(cmd)); - - case _IOC_NR(IOCTL_CED_SETTRANSFER): - return ced_set_transfer(ced, - (struct transfer_area_desc __user *) arg); - - case _IOC_NR(IOCTL_CED_UNSETTRANSFER): - return ced_unset_transfer(ced, (int)arg); - - case _IOC_NR(IOCTL_CED_SETEVENT): - return ced_set_event(ced, - (struct transfer_event __user *) arg); - - case _IOC_NR(IOCTL_CED_GETOUTBUFSPACE): - return ced_get_out_buf_space(ced); - - case _IOC_NR(IOCTL_CED_GETBASEADDRESS): - return -1; - - case _IOC_NR(IOCTL_CED_GETDRIVERREVISION): - /* USB | MAJOR | MINOR */ - return (2 << 24) | (DRIVERMAJREV << 16) | DRIVERMINREV; - - case _IOC_NR(IOCTL_CED_GETTRANSFER): - return ced_get_transfer(ced, (TGET_TX_BLOCK __user *) arg); - - case _IOC_NR(IOCTL_CED_KILLIO1401): - return ced_kill_io(ced); - - case _IOC_NR(IOCTL_CED_STATEOF1401): - return ced_state_of_1401(ced); - - case _IOC_NR(IOCTL_CED_GRAB1401): - case _IOC_NR(IOCTL_CED_FREE1401): - return U14ERR_NOERROR; - - case _IOC_NR(IOCTL_CED_STARTSELFTEST): - return ced_start_self_test(ced); - - case _IOC_NR(IOCTL_CED_CHECKSELFTEST): - return ced_check_self_test(ced, (TGET_SELFTEST __user *) arg); - - case _IOC_NR(IOCTL_CED_TYPEOF1401): - return ced_type_of_1401(ced); - - case _IOC_NR(IOCTL_CED_TRANSFERFLAGS): - return ced_transfer_flags(ced); - - case _IOC_NR(IOCTL_CED_DBGPEEK): - return ced_dbg_peek(ced, (TDBGBLOCK __user *) arg); - - case _IOC_NR(IOCTL_CED_DBGPOKE): - return ced_dbg_poke(ced, (TDBGBLOCK __user *) arg); - - case _IOC_NR(IOCTL_CED_DBGRAMPDATA): - return ced_dbg_ramp_data(ced, (TDBGBLOCK __user *) arg); - - case _IOC_NR(IOCTL_CED_DBGRAMPADDR): - return ced_dbg_ramp_addr(ced, (TDBGBLOCK __user *) arg); - - case _IOC_NR(IOCTL_CED_DBGGETDATA): - return ced_dbg_get_data(ced, (TDBGBLOCK __user *) arg); - - case _IOC_NR(IOCTL_CED_DBGSTOPLOOP): - return ced_dbg_stop_loop(ced); - - case _IOC_NR(IOCTL_CED_FULLRESET): - ced->force_reset = true; /* Set a flag for a full reset */ - break; - - case _IOC_NR(IOCTL_CED_SETCIRCULAR): - return ced_set_circular(ced, - (struct transfer_area_desc __user *) arg); - - case _IOC_NR(IOCTL_CED_GETCIRCBLOCK): - return ced_get_circ_block(ced, (TCIRCBLOCK __user *) arg); - - case _IOC_NR(IOCTL_CED_FREECIRCBLOCK): - return ced_free_circ_block(ced, (TCIRCBLOCK __user *) arg); - - case _IOC_NR(IOCTL_CED_WAITEVENT): - return ced_wait_event(ced, (int)(arg & 0xff), (int)(arg >> 8)); - - case _IOC_NR(IOCTL_CED_TESTEVENT): - return ced_test_event(ced, (int)arg); - - default: - return U14ERR_NO_SUCH_FN; - } - return U14ERR_NOERROR; -} - -static const struct file_operations ced_fops = { - .owner = THIS_MODULE, - .open = ced_open, - .release = ced_release, - .flush = ced_flush, - .llseek = noop_llseek, - .unlocked_ioctl = ced_ioctl, -}; - -/* - * usb class driver info in order to get a minor number from the usb core, - * and to have the device registered with the driver core - */ -static struct usb_class_driver ced_class = { - .name = "cedusb%d", - .fops = &ced_fops, - .minor_base = USB_CED_MINOR_BASE, -}; - -/* Check that the device that matches a 1401 vendor and product ID is OK to */ -/* use and initialise our struct ced_data. */ -static int ced_probe(struct usb_interface *interface, - const struct usb_device_id *id) -{ - struct ced_data *ced; - struct usb_host_interface *iface_desc; - struct usb_endpoint_descriptor *endpoint; - int i, bcdDevice; - int retval = -ENOMEM; - - /* allocate memory for our device extension and initialize it */ - ced = kzalloc(sizeof(*ced), GFP_KERNEL); - if (!ced) - goto error; - - for (i = 0; i < MAX_TRANSAREAS; ++i) { /* Initialise the wait queues */ - init_waitqueue_head(&ced->trans_def[i].event); - } - - /* Put initialises for our stuff here. Note that all of *ced is - * zero, so no need to explicitly zero it. */ - spin_lock_init(&ced->char_out_lock); - spin_lock_init(&ced->char_in_lock); - spin_lock_init(&ced->staged_lock); - - /* Initialises from the skeleton stuff */ - kref_init(&ced->kref); - mutex_init(&ced->io_mutex); - spin_lock_init(&ced->err_lock); - init_usb_anchor(&ced->submitted); - - ced->udev = usb_get_dev(interface_to_usbdev(interface)); - ced->interface = interface; - - /* Attempt to identify the device */ - bcdDevice = ced->udev->descriptor.bcdDevice; - i = (bcdDevice >> 8); - if (i == 0) - ced->type = TYPEU1401; - else if ((i >= 1) && (i <= 23)) - ced->type = i + 2; - else { - dev_err(&interface->dev, "%s: Unknown device. bcdDevice = %d\n", - __func__, bcdDevice); - goto error; - } - /* set up the endpoint information. We only care about the number of */ - /* EP as we know that we are dealing with a 1401 device. */ - iface_desc = interface->cur_altsetting; - ced->n_pipes = iface_desc->desc.bNumEndpoints; - dev_info(&interface->dev, "1401Type=%d with %d End Points\n", - ced->type, ced->n_pipes); - if ((ced->n_pipes < 3) || (ced->n_pipes > 4)) - goto error; - - /* Allocate the URBs we hold for performing transfers */ - ced->urb_char_out = usb_alloc_urb(0, GFP_KERNEL);/* character output - URB */ - ced->urb_char_in = usb_alloc_urb(0, GFP_KERNEL); /* character input - URB */ - ced->staged_urb = usb_alloc_urb(0, GFP_KERNEL); /* block transfer URB */ - if (!ced->urb_char_out || !ced->urb_char_in || !ced->staged_urb) { - dev_err(&interface->dev, "%s: URB alloc failed\n", __func__); - goto error; - } - - ced->coher_staged_io = - usb_alloc_coherent(ced->udev, STAGED_SZ, GFP_KERNEL, - &ced->staged_urb->transfer_dma); - ced->coher_char_out = - usb_alloc_coherent(ced->udev, OUTBUF_SZ, GFP_KERNEL, - &ced->urb_char_out->transfer_dma); - ced->coher_char_in = - usb_alloc_coherent(ced->udev, INBUF_SZ, GFP_KERNEL, - &ced->urb_char_in->transfer_dma); - if (!ced->coher_char_out || !ced->coher_char_in || - !ced->coher_staged_io) { - dev_err(&interface->dev, "%s: Coherent buffer alloc failed\n", - __func__); - goto error; - } - - for (i = 0; i < ced->n_pipes; ++i) { - endpoint = &iface_desc->endpoint[i].desc; - ced->ep_addr[i] = endpoint->bEndpointAddress; - dev_info(&interface->dev, "Pipe %d, ep address %02x\n", - i, ced->ep_addr[i]); - - /* if char input end point */ - if (((ced->n_pipes == 3) && (i == 0)) || - ((ced->n_pipes == 4) && (i == 1))) { - /* save the endpoint interrupt interval */ - ced->interval = endpoint->bInterval; - dev_info(&interface->dev, "Pipe %d, interval = %d\n", - i, ced->interval); - } - /* Detect USB2 by checking last ep size (64 if USB1) */ - if (i == ced->n_pipes - 1) { /* if this is the last ep (bulk) */ - ced->is_usb2 = - le16_to_cpu(endpoint->wMaxPacketSize) > 64; - dev_info(&ced->interface->dev, "USB%d\n", - ced->is_usb2 + 1); - } - } - - /* save our data pointer in this interface device */ - usb_set_intfdata(interface, ced); - - /* we can register the device now, as it is ready */ - retval = usb_register_dev(interface, &ced_class); - if (retval) { - /* something prevented us from registering this driver */ - dev_err(&interface->dev, - "Not able to get a minor for this device\n"); - usb_set_intfdata(interface, NULL); - goto error; - } - - /* let the user know what node this device is now attached to */ - dev_info(&interface->dev, - "USB CEDUSB device now attached to cedusb #%d\n", - interface->minor); - return 0; - -error: - if (ced) - kref_put(&ced->kref, ced_delete); /* frees allocated memory */ - return retval; -} - -static void ced_disconnect(struct usb_interface *interface) -{ - struct ced_data *ced = usb_get_intfdata(interface); - int minor = interface->minor; - int i; - - /* remove the ced from the interface */ - usb_set_intfdata(interface, NULL); - /* give back our minor device number */ - usb_deregister_dev(interface, &ced_class); - - mutex_lock(&ced->io_mutex); /* stop more I/O starting while... */ - ced_draw_down(ced); /* ...wait for then kill any io */ - for (i = 0; i < MAX_TRANSAREAS; ++i) { - /* ...release any used memory */ - int err = ced_clear_area(ced, i); - - if (err == U14ERR_UNLOCKFAIL) - dev_err(&ced->interface->dev, - "%s: Area %d was in used\n", - __func__, i); - } - ced->interface = NULL; /* ...we kill off link to interface */ - mutex_unlock(&ced->io_mutex); - - usb_kill_anchored_urbs(&ced->submitted); - - kref_put(&ced->kref, ced_delete); /* decrement our usage count */ - - dev_info(&interface->dev, "USB cedusb #%d now disconnected\n", minor); -} - -/* Wait for all the urbs we know of to be done with, then kill off any that */ -/* are left. NBNB we will need to have a mechanism to stop circular xfers */ -/* from trying to fire off more urbs. We will wait up to 3 seconds for Urbs */ -/* to be done. */ -void ced_draw_down(struct ced_data *ced) -{ - int time; - - dev_dbg(&ced->interface->dev, "%s: called\n", __func__); - - ced->in_draw_down = true; - time = usb_wait_anchor_empty_timeout(&ced->submitted, 3000); - if (!time) { /* if we timed out we kill the urbs */ - usb_kill_anchored_urbs(&ced->submitted); - dev_err(&ced->interface->dev, "%s: timed out\n", __func__); - } - ced->in_draw_down = false; -} - -static int ced_suspend(struct usb_interface *intf, pm_message_t message) -{ - struct ced_data *ced = usb_get_intfdata(intf); - - if (!ced) - return 0; - ced_draw_down(ced); - - dev_dbg(&ced->interface->dev, "%s: called\n", __func__); - return 0; -} - -static int ced_resume(struct usb_interface *intf) -{ - struct ced_data *ced = usb_get_intfdata(intf); - - if (!ced) - return 0; - dev_dbg(&ced->interface->dev, "%s: called\n", __func__); - return 0; -} - -static int ced_pre_reset(struct usb_interface *intf) -{ - struct ced_data *ced = usb_get_intfdata(intf); - - dev_dbg(&ced->interface->dev, "%s\n", __func__); - mutex_lock(&ced->io_mutex); - ced_draw_down(ced); - return 0; -} - -static int ced_post_reset(struct usb_interface *intf) -{ - struct ced_data *ced = usb_get_intfdata(intf); - - dev_dbg(&ced->interface->dev, "%s\n", __func__); - - /* we are sure no URBs are active - no locking needed */ - ced->errors = -EPIPE; - mutex_unlock(&ced->io_mutex); - - return 0; -} - -static struct usb_driver ced_driver = { - .name = "cedusb", - .probe = ced_probe, - .disconnect = ced_disconnect, - .suspend = ced_suspend, - .resume = ced_resume, - .pre_reset = ced_pre_reset, - .post_reset = ced_post_reset, - .id_table = ced_table, - .supports_autosuspend = 1, -}; - -module_usb_driver(ced_driver); -MODULE_LICENSE("GPL"); diff --git a/drivers/staging/ced1401/usb1401.h b/drivers/staging/ced1401/usb1401.h deleted file mode 100644 index da4d90c..0000000 --- a/drivers/staging/ced1401/usb1401.h +++ /dev/null @@ -1,260 +0,0 @@ -/* usb1401.h - Header file for the CED 1401 USB device driver for Linux - Copyright (C) 2010 Cambridge Electronic Design Ltd - Author Greg P Smith (greg@ced.co.uk) - - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License - as published by the Free Software Foundation; either version 2 - of the License, or (at your option) any later version. - - 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. -*/ -#ifndef __USB1401_H__ -#define __USB1401_H__ -#include "use1401.h" -#include "ced_ioctl.h" - -#ifndef UINT -#define UINT unsigned int -#endif - -/** Device type codes, but these don't need to be extended - a succession is assumed -** These are set for usb from the bcdDevice field (suitably mangled). Future devices -** will be added in order of device creation to the list, so the names here are just -** to help use remember which device is which. The U14ERR_... values follow the same -** pattern for modern devices.a -**/ -#define TYPEUNKNOWN -1 /* dont know */ -#define TYPE1401 0 /* standard 1401 */ -#define TYPEPLUS 1 /* 1401 plus */ -#define TYPEU1401 2 /* u1401 */ -#define TYPEPOWER 3 /* Power1401 */ -#define TYPEU14012 4 /* u1401 mkII */ -#define TYPEPOWER2 5 /* Power1401 mk II */ -#define TYPEMICRO3 6 /* Micro1401-3 */ -#define TYPEPOWER3 7 /* Power1401-3 */ - -/* Some useful defines of constants. DONT FORGET to change the version in the */ -/* resources whenever you change it here!. */ -#define DRIVERMAJREV 2 /* driver revision level major (match windows) */ -#define DRIVERMINREV 0 /* driver revision level minor */ - -/* Definitions of the various block transfer command codes */ -#define TM_EXTTOHOST 8 /* extended tohost */ -#define TM_EXTTO1401 9 /* extended to1401 */ - -/* Definitions of values in usbReqtype. Used in sorting out setup actions */ -#define H_TO_D 0x00 -#define D_TO_H 0x80 -#define VENDOR 0x40 -#define DEVREQ 0x00 -#define INTREQ 0x01 -#define ENDREQ 0x02 - -/* Definition of values in usbRequest, again used to sort out setup */ -#define GET_STATUS 0x00 -#define CLEAR_FEATURE 0x01 -#define SET_FEATURE 0x03 -#define SET_ADDRESS 0x05 -#define GET_DESC 0x06 -#define SET_DESC 0x07 -#define GET_CONF 0x08 -#define SET_CONF 0x09 -#define GET_INTERFACE 0x0a -#define SET_INTERFACE 0x0b -#define SYNCH_FRAME 0x0c - -/* Definitions of the various debug command codes understood by the 1401. These */ -/* are used in various vendor-specific commands to achieve the desired effect */ -#define DB_GRAB 0x50 /* Grab is a NOP for USB */ -#define DB_FREE 0x51 /* Free is a NOP for the USB */ -#define DB_SETADD 0x52 /* Set debug address (double) */ -#define DB_SELFTEST 0x53 /* Start self test */ -#define DB_SETMASK 0x54 /* Set enable mask (double) */ -#define DB_SETDEF 0x55 /* Set default mask (double) */ -#define DB_PEEK 0x56 /* Peek address, save result */ -#define DB_POKE 0x57 /* Poke address with data (double) */ -#define DB_RAMPD 0x58 /* Ramp data at debug address */ -#define DB_RAMPA 0x59 /* Ramp address bus */ -#define DB_REPEATS 0x5A /* Set repeats for operations (double) */ -#define DB_WIDTH 0x5B /* Set width for operations (byte) */ -#define DB_DATA 0x5C /* Get 4-byte data read by PEEK */ -#define DB_CHARS 0x5D /* Send chars via EP0 control write */ - -#define CR_CHAR 0x0D /* The carriage return character */ -#define CR_CHAR_80 0x8d /* and with bit 7 set */ - -/* A structure holding information about a block */ -/* of memory for use in circular transfers */ -struct circ_blk { - volatile UINT offset; /* Offset within area of block start */ - volatile UINT size; /* Size of the block, in bytes (0 = unused) */ -}; - -/* A structure holding all of the information about a transfer area - an area */ -/* of memory set up for use either as a source or destination in DMA */ -/* transfers. */ -struct transarea { - /* User address of xfer area saved for completeness */ - void __user *buff; - - /* offset to start of xfer area in first page */ - UINT base_offset; - - UINT length; /* Length of xfer area, in bytes */ - struct page **pages; /* Points at array of locked down pages */ - int n_pages; /* number of pages that are locked down */ - bool used; /* Is this structure in use? */ - bool circular; /* Is this area for circular transfers? */ - bool circ_to_host; /* Flag for direction of circular transfer */ - bool event_to_host; /* Set event on transfer to host? */ - int wake_up; /* Set 1 on event, cleared by TestEvent() */ - UINT event_st; /* Defines section within xfer area for... */ - UINT event_sz; /* notification by the event SZ is 0 if unset */ - struct circ_blk blocks[2]; /* Info on a pair of circular blocks */ - - wait_queue_head_t event; /* The wait queue for events in this */ - /* area MUST BE LAST */ -}; - -/* The dmadesc structure is used to hold information on the transfer in */ -/* progress. It is set up by ReadDMAInfo, using information sent by the 1401 */ -/* in an escape sequence. */ -struct dmadesc { - unsigned short trans_type; /* transfer type as TM_xxx above */ - unsigned short ident; /* identifier word */ - unsigned int size; /* bytes to transfer */ - unsigned int offset; /* offset into transfer area for trans */ - bool outward; /* true when data is going TO 1401 */ -}; - -#define INBUF_SZ 256 /* input buffer size */ -#define OUTBUF_SZ 256 /* output buffer size */ -#define STAGED_SZ 0x10000 /* size of coherent buffer for staged transfers */ - -/* Structure to hold all of our device specific stuff. We are making this as */ -/* similar as we can to the Windows driver to help in our understanding of */ -/* what is going on. */ -struct ced_data { - char input_buffer[INBUF_SZ]; /* The two buffers */ - char output_buffer[OUTBUF_SZ]; /* accessed by the host functions */ - volatile unsigned int num_input; /* num of chars in input buffer */ - volatile unsigned int in_buff_get; /* where to get from input buffer */ - volatile unsigned int in_buff_put; /* where to put into input buffer */ - volatile unsigned int num_output; /* num of chars in output buffer */ - volatile unsigned int out_buff_get; /* where to get from output buffer*/ - volatile unsigned int out_buff_put; /* where to put into output buffer*/ - - volatile bool send_chars_pending; /* Flag to indicate sendchar active */ - volatile bool read_chars_pending; /* Flag to indicate a read is primed*/ - char *coher_char_out; /* special aligned buffer for chars to 1401 */ - struct urb *urb_char_out; /* urb used for chars to 1401 */ - char *coher_char_in; /* special aligned buffer for chars to host */ - struct urb *urb_char_in; /* urb used for chars to host */ - - spinlock_t char_out_lock; /* protect the output_buffer and outputting */ - spinlock_t char_in_lock; /* protect the input_buffer and char reads */ - __u8 interval; /* Interrupt end point interval */ - - volatile unsigned int dma_flag; /* state of DMA */ - struct transarea trans_def[MAX_TRANSAREAS]; /* transfer area info */ - volatile struct dmadesc dma_info; /* info on current DMA transfer */ - volatile bool xfer_waiting; /* Flag set if DMA transfer stalled */ - volatile bool in_draw_down; /* Flag that we want to halt transfers */ - - /* Parameters relating to a block read\write that is in progress. Some of these values */ - /* are equivalent to values in dma_info. The values here are those in use, while those */ - /* in dma_info are those received from the 1401 via an escape sequence. If another */ - /* escape sequence arrives before the previous xfer ends, dma_info values are updated while these */ - /* are used to finish off the current transfer. */ - volatile short staged_id; /* The transfer area id for this transfer */ - volatile bool staged_read; /* Flag TRUE for read from 1401, FALSE for write */ - volatile unsigned int staged_length; /* Total length of this transfer */ - volatile unsigned int staged_offset; /* Offset within memory area for transfer start */ - volatile unsigned int staged_done; /* Bytes transferred so far */ - volatile bool staged_urb_pending; /* Flag to indicate active */ - char *coher_staged_io; /* buffer used for block transfers */ - struct urb *staged_urb; /* The URB to use */ - spinlock_t staged_lock; /* protects ReadWriteMem() and */ - /* circular buffer stuff */ - - short type; /* type of 1401 attached */ - short current_state; /* current error state */ - bool is_usb2; /* type of the interface we connect to */ - bool force_reset; /* Flag to make sure we get a real reset */ - __u32 stat_buf[2]; /* buffer for 1401 state info */ - - unsigned long self_test_time; /* used to timeout self test */ - - int n_pipes; /* Should be 3 or 4 depending on 1401 usb chip */ - int pipe_error[4]; /* set non-zero if an error on one of the pipe */ - __u8 ep_addr[4]; /* addresses of the 3/4 end points */ - - struct usb_device *udev; /* the usb device for this device */ - struct usb_interface *interface; /* the interface for this device, NULL if removed */ - struct usb_anchor submitted; /* in case we need to retract our submissions */ - struct mutex io_mutex; /* synchronize I/O with disconnect, one user-mode caller at a time */ - - int errors; /* the last request tanked */ - int open_count; /* count the number of openers */ - spinlock_t err_lock; /* lock for errors */ - struct kref kref; -}; - -#define to_ced_data(d) container_of(d, struct ced_data, kref) - -/* Definitions of routimes used between compilation object files */ -/* in usb1401.c */ -extern int ced_allowi(struct ced_data *ced); -extern int ced_send_chars(struct ced_data *ced); -extern void ced_draw_down(struct ced_data *ced); -extern int ced_read_write_mem(struct ced_data *ced, bool read, - unsigned short ident, unsigned int offs, - unsigned int len); - -/* in ced_ioc.c */ -extern int ced_clear_area(struct ced_data *ced, int area); -extern int ced_send_string(struct ced_data *ced, const char __user *data, unsigned int n); -extern int ced_send_char(struct ced_data *ced, char c); -extern int ced_get_state(struct ced_data *ced, __u32 *state, __u32 *error); -extern int ced_read_write_cancel(struct ced_data *ced); -extern int ced_reset(struct ced_data *ced); -extern int ced_get_char(struct ced_data *ced); -extern int ced_get_string(struct ced_data *ced, char __user *user, int n); -extern int ced_set_transfer(struct ced_data *ced, - struct transfer_area_desc __user *utd); -extern int ced_unset_transfer(struct ced_data *ced, int area); -extern int ced_set_event(struct ced_data *ced, - struct transfer_event __user *ute); -extern int ced_stat_1401(struct ced_data *ced); -extern int ced_line_count(struct ced_data *ced); -extern int ced_get_out_buf_space(struct ced_data *ced); -extern int ced_get_transfer(struct ced_data *ced, TGET_TX_BLOCK __user *utx); -extern int ced_kill_io(struct ced_data *ced); -extern int ced_state_of_1401(struct ced_data *ced); -extern int ced_start_self_test(struct ced_data *ced); -extern int ced_check_self_test(struct ced_data *ced, - TGET_SELFTEST __user *ugst); -extern int ced_type_of_1401(struct ced_data *ced); -extern int ced_transfer_flags(struct ced_data *ced); -extern int ced_dbg_peek(struct ced_data *ced, TDBGBLOCK __user *udb); -extern int ced_dbg_poke(struct ced_data *ced, TDBGBLOCK __user *udb); -extern int ced_dbg_ramp_data(struct ced_data *ced, TDBGBLOCK __user *udb); -extern int ced_dbg_ramp_addr(struct ced_data *ced, TDBGBLOCK __user *udb); -extern int ced_dbg_get_data(struct ced_data *ced, TDBGBLOCK __user *udb); -extern int ced_dbg_stop_loop(struct ced_data *ced); -extern int ced_set_circular(struct ced_data *ced, - struct transfer_area_desc __user *utd); -extern int ced_get_circ_block(struct ced_data *ced, TCIRCBLOCK __user *ucb); -extern int ced_free_circ_block(struct ced_data *ced, TCIRCBLOCK __user *ucb); -extern int ced_wait_event(struct ced_data *ced, int area, int time_out); -extern int ced_test_event(struct ced_data *ced, int area); -#endif diff --git a/drivers/staging/ced1401/use1401.h b/drivers/staging/ced1401/use1401.h deleted file mode 100644 index b7997c9..0000000 --- a/drivers/staging/ced1401/use1401.h +++ /dev/null @@ -1,288 +0,0 @@ -/**************************************************************************** -** use1401.h -** Copyright (C) Cambridge Electronic Design Ltd, 1992-2010 -** Authors: Paul Cox, Tim Bergel, Greg Smith -** See CVS for revisions. -** -** Because the size of a long is different between 32-bit and 64-bit on some -** systems, we avoid this in this interface. -****************************************************************************/ -#ifndef __USE1401_H__ -#define __USE1401_H__ -#include "machine.h" - -/* Some definitions to make things compatible. If you want to use Use1401 directly */ -/* from a Windows program you should define U14_NOT_DLL, in which case you also */ -/* MUST make sure that your application startup code calls U14InitLib(). */ -/* DLL_USE1401 is defined when you are building the Use1401 dll, not otherwise. */ -#ifdef _IS_WINDOWS_ -#ifndef U14_NOT_DLL -#ifdef DLL_USE1401 -#define U14API(retType) (retType DllExport __stdcall) -#else -#define U14API(retType) (retType DllImport __stdcall) -#endif -#endif - -#define U14ERRBASE -500 -#define U14LONG long -#endif - -#ifdef LINUX -#define U14ERRBASE -1000 -#define U14LONG int -#endif - -#ifdef _QT -#ifndef U14_NOT_DLL -#undef U14API -#define U14API(retType) (retType __declspec(dllimport) __stdcall) -#endif -#undef U14LONG -#define U14LONG int -#endif - -#ifndef U14API -#define U14API(retType) retType -#endif - -#ifndef U14LONG -#define U14LONG long -#endif - -/* Error codes: We need them here as user space can see them. */ -#define U14ERR_NOERROR 0 /* no problems */ - -/* Device error codes, but these don't need to be extended - a succession is assumed */ -#define U14ERR_STD 4 /* standard 1401 connected */ -#define U14ERR_U1401 5 /* u1401 connected */ -#define U14ERR_PLUS 6 /* 1401 plus connected */ -#define U14ERR_POWER 7 /* Power1401 connected */ -#define U14ERR_U14012 8 /* u1401 mkII connected */ -#define U14ERR_POWER2 9 -#define U14ERR_U14013 10 -#define U14ERR_POWER3 11 - -/* NBNB Error numbers need shifting as some linux error codes start at 512 */ -#define U14ERR(n) (n+U14ERRBASE) -#define U14ERR_OFF U14ERR(0) /* 1401 there but switched off */ -#define U14ERR_NC U14ERR(-1) /* 1401 not connected */ -#define U14ERR_ILL U14ERR(-2) /* if present it is ill */ -#define U14ERR_NOIF U14ERR(-3) /* I/F card missing */ -#define U14ERR_TIME U14ERR(-4) /* 1401 failed to come ready */ -#define U14ERR_BADSW U14ERR(-5) /* I/F card bad switches */ -#define U14ERR_PTIME U14ERR(-6) /* 1401plus failed to come ready */ -#define U14ERR_NOINT U14ERR(-7) /* couldn't grab the int vector */ -#define U14ERR_INUSE U14ERR(-8) /* 1401 is already in use */ -#define U14ERR_NODMA U14ERR(-9) /* couldn't get DMA channel */ -#define U14ERR_BADHAND U14ERR(-10) /* handle provided was bad */ -#define U14ERR_BAD1401NUM U14ERR(-11) /* 1401 number provided was bad */ - -#define U14ERR_NO_SUCH_FN U14ERR(-20) /* no such function */ -#define U14ERR_NO_SUCH_SUBFN U14ERR(-21) /* no such sub function */ -#define U14ERR_NOOUT U14ERR(-22) /* no room in output buffer */ -#define U14ERR_NOIN U14ERR(-23) /* no input in buffer */ -#define U14ERR_STRLEN U14ERR(-24) /* string longer than buffer */ -#define U14ERR_ERR_STRLEN U14ERR(-24) /* string longer than buffer */ -#define U14ERR_LOCKFAIL U14ERR(-25) /* failed to lock memory */ -#define U14ERR_UNLOCKFAIL U14ERR(-26) /* failed to unlock memory */ -#define U14ERR_ALREADYSET U14ERR(-27) /* area already set up */ -#define U14ERR_NOTSET U14ERR(-28) /* area not set up */ -#define U14ERR_BADAREA U14ERR(-29) /* illegal area number */ -#define U14ERR_FAIL U14ERR(-30) /* we failed for some other reason*/ - -#define U14ERR_NOFILE U14ERR(-40) /* command file not found */ -#define U14ERR_READERR U14ERR(-41) /* error reading command file */ -#define U14ERR_UNKNOWN U14ERR(-42) /* unknown command */ -#define U14ERR_HOSTSPACE U14ERR(-43) /* not enough host space to load */ -#define U14ERR_LOCKERR U14ERR(-44) /* could not lock resource/command*/ -#define U14ERR_CLOADERR U14ERR(-45) /* CLOAD command failed */ - -#define U14ERR_TOXXXERR U14ERR(-60) /* tohost/1401 failed */ -#define U14ERR_NO386ENH U14ERR(-80) /* not 386 enhanced mode */ -#define U14ERR_NO1401DRIV U14ERR(-81) /* no device driver */ -#define U14ERR_DRIVTOOOLD U14ERR(-82) /* device driver too old */ - -#define U14ERR_TIMEOUT U14ERR(-90) /* timeout occurred */ - -#define U14ERR_BUFF_SMALL U14ERR(-100) /* buffer for getstring too small */ -#define U14ERR_CBALREADY U14ERR(-101) /* there is already a callback */ -#define U14ERR_BADDEREG U14ERR(-102) /* bad parameter to deregcallback */ -#define U14ERR_NOMEMORY U14ERR(-103) /* no memory for allocation */ - -#define U14ERR_DRIVCOMMS U14ERR(-110) /* failed talking to driver */ -#define U14ERR_OUTOFMEMORY U14ERR(-111) /* needed memory and couldnt get it*/ - -/* / 1401 type codes. */ -#define U14TYPE1401 0 /* standard 1401 */ -#define U14TYPEPLUS 1 /* 1401 plus */ -#define U14TYPEU1401 2 /* u1401 */ -#define U14TYPEPOWER 3 /* power1401 */ -#define U14TYPEU14012 4 /* u1401 mk II */ -#define U14TYPEPOWER2 5 /* power1401 mk II */ -#define U14TYPEU14013 6 /* u1401-3 */ -#define U14TYPEPOWER3 7 /* power1401-3 */ -#define U14TYPEUNKNOWN -1 /* dont know */ - -/* Transfer flags to allow driver capabilities to be interrogated */ - -/* Constants for transfer flags */ -#define U14TF_USEDMA 1 /* Transfer flag for use DMA */ -#define U14TF_MULTIA 2 /* Transfer flag for multi areas */ -#define U14TF_FIFO 4 /* for FIFO interface card */ -#define U14TF_USB2 8 /* for USB2 interface and 1401 */ -#define U14TF_NOTIFY 16 /* for event notifications */ -#define U14TF_SHORT 32 /* for PCI can short cycle */ -#define U14TF_PCI2 64 /* for new PCI card 1401-70 */ -#define U14TF_CIRCTH 128 /* Circular-mode to host */ -#define U14TF_DIAG 256 /* Diagnostics/debug functions */ -#define U14TF_CIRC14 512 /* Circular-mode to 1401 */ - -/* Definitions of element sizes for DMA transfers - to allow byte-swapping */ -#define ESZBYTES 0 /* BYTE element size value */ -#define ESZWORDS 1 /* unsigned short element size value */ -#define ESZLONGS 2 /* long element size value */ -#define ESZUNKNOWN 0 /* unknown element size value */ - -/* These define required access types for the debug/diagnostics function */ -#define BYTE_SIZE 1 /* 8-bit access */ -#define WORD_SIZE 2 /* 16-bit access */ -#define LONG_SIZE 3 /* 32-bit access */ - -/* Stuff used by U14_GetTransfer */ -#define GET_TX_MAXENTRIES 257 /* (max length / page size + 1) */ - -#ifdef _IS_WINDOWS_ -#pragma pack(1) - -typedef struct /* used for U14_GetTransfer results */ -{ /* Info on a single mapped block */ - U14LONG physical; - U14LONG size; -} TXENTRY; - -typedef struct TGetTxBlock /* used for U14_GetTransfer results */ -{ /* matches structure in VXD */ - U14LONG size; - U14LONG linear; - short seg; - short reserved; - short avail; /* number of available entries */ - short used; /* number of used entries */ - TXENTRY entries[GET_TX_MAXENTRIES]; /* Array of mapped block info */ -} TGET_TX_BLOCK; - -typedef TGET_TX_BLOCK *LPGET_TX_BLOCK; - -#pragma pack() -#endif - -#ifdef LINUX -typedef struct /* used for U14_GetTransfer results */ -{ /* Info on a single mapped block */ - long long physical; - long size; -} TXENTRY; - -typedef struct TGetTxBlock /* used for U14_GetTransfer results */ -{ /* matches structure in VXD */ - long long linear; /* linear address */ - long size; /* total size of the mapped area, holds id when called */ - short seg; /* segment of the address for Win16 */ - short reserved; - short avail; /* number of available entries */ - short used; /* number of used entries */ - TXENTRY entries[GET_TX_MAXENTRIES]; /* Array of mapped block info */ -} TGET_TX_BLOCK; -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -U14API(int) U14WhenToTimeOut(short hand); /* when to timeout in ms */ -U14API(short) U14PassedTime(int iTime); /* non-zero if iTime passed */ - -U14API(short) U14LastErrCode(short hand); - -U14API(short) U14Open1401(short n1401); -U14API(short) U14Close1401(short hand); -U14API(short) U14Reset1401(short hand); -U14API(short) U14ForceReset(short hand); -U14API(short) U14TypeOf1401(short hand); -U14API(short) U14NameOf1401(short hand, char *pBuf, unsigned short wMax); - -U14API(short) U14Stat1401(short hand); -U14API(short) U14CharCount(short hand); -U14API(short) U14LineCount(short hand); - -U14API(short) U14SendString(short hand, const char *pString); -U14API(short) U14GetString(short hand, char *pBuffer, unsigned short wMaxLen); -U14API(short) U14SendChar(short hand, char cChar); -U14API(short) U14GetChar(short hand, char *pcChar); - -U14API(short) U14LdCmd(short hand, const char *command); -U14API(unsigned int) U14Ld(short hand, const char *vl, const char *str); - -U14API(short) U14SetTransArea(short hand, unsigned short wArea, void *pvBuff, - unsigned int dwLength, short eSz); -U14API(short) U14UnSetTransfer(short hand, unsigned short wArea); -U14API(short) U14SetTransferEvent(short hand, unsigned short wArea, BOOL bEvent, - BOOL bToHost, unsigned int dwStart, unsigned int dwLength); -U14API(int) U14TestTransferEvent(short hand, unsigned short wArea); -U14API(int) U14WaitTransferEvent(short hand, unsigned short wArea, int msTimeOut); -U14API(short) U14GetTransfer(short hand, TGET_TX_BLOCK *pTransBlock); - -U14API(short) U14ToHost(short hand, char *pAddrHost, unsigned int dwSize, unsigned int dw1401, - short eSz); -U14API(short) U14To1401(short hand, const char *pAddrHost, unsigned int dwSize, unsigned int dw1401, - short eSz); - -U14API(short) U14SetCircular(short hand, unsigned short wArea, BOOL bToHost, void *pvBuff, - unsigned int dwLength); - -U14API(int) U14GetCircBlk(short hand, unsigned short wArea, unsigned int *pdwOffs); -U14API(int) U14FreeCircBlk(short hand, unsigned short wArea, unsigned int dwOffs, unsigned int dwSize, - unsigned int *pdwOffs); - -U14API(short) U14StrToLongs(const char *pszBuff, U14LONG *palNums, short sMaxLongs); -U14API(short) U14LongsFrom1401(short hand, U14LONG *palBuff, short sMaxLongs); - -U14API(void) U14SetTimeout(short hand, int lTimeout); -U14API(int) U14GetTimeout(short hand); -U14API(short) U14OutBufSpace(short hand); -U14API(int) U14BaseAddr1401(short hand); -U14API(int) U14DriverVersion(short hand); -U14API(int) U14DriverType(short hand); -U14API(short) U14DriverName(short hand, char *pBuf, unsigned short wMax); -U14API(short) U14GetUserMemorySize(short hand, unsigned int *pMemorySize); -U14API(short) U14KillIO1401(short hand); - -U14API(short) U14BlkTransState(short hand); -U14API(short) U14StateOf1401(short hand); - -U14API(short) U14Grab1401(short hand); -U14API(short) U14Free1401(short hand); -U14API(short) U14Peek1401(short hand, unsigned int dwAddr, int nSize, int nRepeats); -U14API(short) U14Poke1401(short hand, unsigned int dwAddr, unsigned int dwValue, int nSize, int nRepeats); -U14API(short) U14Ramp1401(short hand, unsigned int dwAddr, unsigned int dwDef, unsigned int dwEnable, int nSize, int nRepeats); -U14API(short) U14RampAddr(short hand, unsigned int dwDef, unsigned int dwEnable, int nSize, int nRepeats); -U14API(short) U14StopDebugLoop(short hand); -U14API(short) U14GetDebugData(short hand, U14LONG *plValue); - -U14API(short) U14StartSelfTest(short hand); -U14API(short) U14CheckSelfTest(short hand, U14LONG *pData); -U14API(short) U14TransferFlags(short hand); -U14API(void) U14GetErrorString(short nErr, char *pStr, unsigned short wMax); -U14API(int) U14MonitorRev(short hand); -U14API(void) U14CloseAll(void); - -U14API(short) U14WorkingSet(unsigned int dwMinKb, unsigned int dwMaxKb); -U14API(int) U14InitLib(void); - -#ifdef __cplusplus -} -#endif - -#endif /* End of ifndef __USE1401_H__ */ - diff --git a/drivers/staging/ced1401/use14_ioc.h b/drivers/staging/ced1401/use14_ioc.h deleted file mode 100644 index 42d2e4e..0000000 --- a/drivers/staging/ced1401/use14_ioc.h +++ /dev/null @@ -1,299 +0,0 @@ -/* use14_ioc.h -** definitions of use1401 module stuff that is shared between use1401 and the driver. -** Copyright (C) Cambridge Electronic Design Limited 2010 -** Author Greg P Smith -************************************************************************************/ -#ifndef __USE14_IOC_H__ -#define __USE14_IOC_H__ - -#define MAX_TRANSAREAS 8 /* The number of transfer areas supported by driver */ - -#define i386 -#include "winioctl.h" /* needed so we can access driver */ - -/* -** Defines for IOCTL functions to ask driver to perform. These must be matched -** in both use1401 and in the driver. The IOCTL code contains a command -** identifier, plus other information about the device, the type of access -** with which the file must have been opened, and the type of buffering. -** The IOCTL function codes from 0x80 to 0xFF are for developer use. -*/ -#define FILE_DEVICE_CED1401 0x8001 - FNNUMBASE 0x800 - -#define U14_OPEN1401 CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_CLOSE1401 CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+1, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_SENDSTRING CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+2, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_RESET1401 CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+3, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_GETCHAR CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+4, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_SENDCHAR CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+5, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_STAT1401 CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+6, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_LINECOUNT CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+7, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_GETSTRING CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+8, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_REGCALLBACK CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+9, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_GETMONITORBUF CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+10, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_SETTRANSFER CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+11, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_UNSETTRANSFER CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+12, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_SETTRANSEVENT CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+13, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_GETOUTBUFSPACE CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+14, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_GETBASEADDRESS CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+15, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_GETDRIVERREVISION CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+16, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_GETTRANSFER CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+17, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_KILLIO1401 CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+18, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_BLKTRANSSTATE CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+19, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_BYTECOUNT CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+20, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_ZEROBLOCKCOUNT CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+21, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_STOPCIRCULAR CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+22, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_STATEOF1401 CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+23, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_REGISTERS1401 CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+24, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_GRAB1401 CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+25, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_FREE1401 CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+26, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_STEP1401 CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+27, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_SET1401REGISTERS CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+28, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_STEPTILL1401 CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+29, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_SETORIN CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+30, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_STARTSELFTEST CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+31, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_CHECKSELFTEST CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+32, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_TYPEOF1401 CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+33, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_TRANSFERFLAGS CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+34, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_DBGPEEK CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+35, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_DBGPOKE CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+36, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_DBGRAMPDATA CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+37, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_DBGRAMPADDR CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+38, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_DBGGETDATA CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+39, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_DBGSTOPLOOP CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+40, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_FULLRESET CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+41, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_SETCIRCULAR CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+42, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_GETCIRCBLK CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+43, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -#define U14_FREECIRCBLK CTL_CODE(FILE_DEVICE_CED1401, \ - FNNUMBASE+44, \ - METHOD_BUFFERED, \ - FILE_ANY_ACCESS) - -/*--------------- Structures that are shared with the driver ------------- */ -#pragma pack(1) - -typedef struct /* used for get/set standard 1401 registers */ -{ - short sPC; - char A; - char X; - char Y; - char stat; - char rubbish; -} T1401REGISTERS; - -typedef union /* to communicate with 1401 driver status & control funcs */ -{ - char chrs[22]; - short ints[11]; - long longs[5]; - T1401REGISTERS registers; -} TCSBLOCK; - -typedef TCSBLOCK* LPTCSBLOCK; - -typedef struct paramBlk { - short sState; - TCSBLOCK csBlock; -} PARAMBLK; - -typedef PARAMBLK* PPARAMBLK; - -struct transfer_area_desc /* Structure and type for SetTransArea */ -{ - unsigned short wArea; /* number of transfer area to set up */ - void FAR *lpvBuff; /* address of transfer area */ - unsigned int dwLength; /* length of area to set up */ - short eSize; /* size to move (for swapping on MAC) */ -}; - - -/* This is the structure used to set up a transfer area */ -typedef struct VXTransferDesc /* use1401.c and use1432x.x use only */ -{ - unsigned short wArea; /* number of transfer area to set up */ - unsigned short wAddrSel; /* 16 bit selector for area */ - unsigned int dwAddrOfs; /* 32 bit offset for area start */ - unsigned int dwLength; /* length of area to set up */ -} VXTRANSFERDESC; - -#pragma pack() - -#endif diff --git a/drivers/staging/ced1401/userspace/use1401.c b/drivers/staging/ced1401/userspace/use1401.c deleted file mode 100644 index d589311..0000000 --- a/drivers/staging/ced1401/userspace/use1401.c +++ /dev/null @@ -1,3030 +0,0 @@ -/**************************************************************************** -** use1401.c -** Copyright (C) Cambridge Electronic Design Ltd, 1992-2010 -** -** This program is free software; you can redistribute it and/or -** modify it under the terms of the GNU General Public License -** as published by the Free Software Foundation; either version 2 -** of the License, or (at your option) any later version. -** -** 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. -** -** Contact CED: Cambridge Electronic Design Limited, Science Park, Milton Road -** Cambridge, CB6 0FE. -** www.ced.co.uk -** greg@ced.co.uk -** -** Title: USE1401.C -** Version: 4.00 -** Author: Paul Cox, Tim Bergel, Greg Smith -** -** The code was vigorously pruned in DEC 2010 to remove the macintosh options -** and to get rid of the 16-bit support. It has also been aligned with the -** Linux version. See CVS for revisions. This will work for Win 9x onwards. -**************************************************************************** -** -** Notes on Windows interface to driver -** ************************************ -** -** Under Windows 9x and NT, Use1401 uses DeviceIoControl to get access to -** the 1401 driver. This has parameters for the device handle, the function -** code, an input pointer and byte count, an output pointer and byte count -** and a pointer to a unsigned int to hold the output byte count. Note that input -** and output are from the point-of-view of the driver, so the output stuff -** is used to read values from the 1401, not send to the 1401. The use of -** these parameters varies with the function in use and the operating -** system; there are five separate DIOC calls SendString, GetString and -** SetTransferArea all have their own specialised calls, the rest use the -** Status1401 or Control1401 functions. -** -** There are two basic styles of DIOC call used, one for Win9x VxD drivers -** and one for NT Kernel-mode and WDM drivers (see below for tables showing -** the different parameters used. The array bUseNTDIOC[] selects between -** these two calling styles. -** -** Function codes -** In Win3.x, simple function codes from 0 to 40 were used, shifted left 8 -** bits with a sub-function code in the lower 8 bits. These were also used -** in the Windows 95 driver, though we had to add 1 to the code value to -** avoid problems (Open from CreateFile is zero), and the sub-function code -** is now unused. We found that this gave some problems with Windows 98 -** as the function code values are reserved by microsoft, so we switched to -** using the NT function codes instead. The NT codes are generated using the -** CTL_CODE macro, essentially this gives 0x80012000 | (func << 2), where -** func is the original 0 to 34 value. The driver will handle both types of -** code and Use1432 only uses the NT codes if it knows the driver is new -** enough. The array bUseNTCodes[] holds flags on the type of codes required. -** GPS/TDB Dec 2010: we removed the bUseNTCodes array as this is always true -** as we no longer support ancient versions. -** -** The CreateFile and CloseFile function calls are also handled -** by DIOC, using the special function codes 0 and -1 respectively. -** -** Input pointer and buffer size -** These are intended for data sent to the device driver. In nearly all cases -** they are unused in calls to the Win95 driver, the NT driver uses them -** for all information sent to the driver. The table below shows the pointer -** and byte count used for the various calls: -** -** Win 95 Win NT -** SendString NULL, 0 pStr, nStr -** GetString NULL, 0 NULL, 0 -** SetTransferArea pBuf, nBuf (unused?) pDesc, nDesc -** GetTransfer NULL, 0 NULL, 0 -** Status1401 NULL, 0 NULL, 0 -** Control1401 NULL, 0 pBlk, nBlk -** -** pStr and nStr are pointers to a char buffer and the buffer length for -** string I/O, note that these are temporary buffers owned by the DLL, not -** application memory, pBuf and nBuf are the transfer area buffer (I think -** these are unused), pDesc and nDesc are the TRANSFERDESC structure, pBlk -** and nBlk are the TCSBLOCK structure. -** -** -** Output pointer and buffer size -** These are intended for data read from the device driver. These are used -** for almost all information sent to the Win95 driver, the NT driver uses -** them for information read from the driver, chiefly the error code. The -** table below shows the pointer and byte count used for the various calls: -** -** Win 95 Win NT -** SendString pStr, nStr pPar, nPar -** GetString pStr, nStr+2 pStr, nStr+2 -** SetTransferArea pDesc, nDesc pPar, nPar -** GetTransfer pGet, nGet pGet, nGet -** Status1401 pBlk, nBlk pPar, nPar -** Control1401 pBlk, nBlk pPar, nPar -** -** pStr and nStr are pointers to a char buffer and the buffer length for -** string I/O, the +2 for GetString refers to two spare bytes at the start -** used to hold the string length and returning an error code for NT. Note -** again that these are (and must be) DLL-owned temporary buffers. pPar -** and nPar are a PARAM structure used in NT (it holds an error code and a -** TCSBLOCK structure). pDesc and nDesc are the VXTRANSFERDESC structure, -** pBlk and nBlk are the TCSBLOCK structure. pGet and nGet indicate the -** TGET_TX_BLOCK structure used for GetTransfer. -** -** -** The output byte count -** Both drivers return the output buffer size here, regardless of the actual -** bytes output. This is used to check that we did get through to the driver. -** -** Multiple 1401s -** ************** -** -** We have code that tries to support the use of multiple 1401s, but there -** are problems: The lDriverVersion and lDriverType variables are global, not -** per-1401 (a particular problem as the U14 functions that use them don't -** have a hand parameter). In addition, the mechansim for finding a free -** 1401 depends upon the 1401 device driver open operation failing if it's -** already in use, which doesn't always happen, particularly with the VxDs. -** The code in TryToOpen tries to fix this by relying on TYPEOF1401 to detect -** the 1401-in-use state - the VxDs contain special code to help this. This is -** working OK but multiple 1401 support works better with the Win2000 drivers. -** -** USB driver -** ********** -** -** The USB driver, which runs on both Win98 and NT2000, uses the NT-style -** calling convention, both for the DIOC codes and the DIOC parameters. The -** TryToOpen function has been altered to look for an NT driver first in -** the appropriate circumstances, and to set the driver DIOC flags up in -** the correct state. -** -** Adding a new 1401 type - now almost nothing to do -** ************************************************* -** -** The 1401 types are defined by a set of U14TYPExxxx codes in USE1401.H. -** You should add a new one of these to keep things tidy for applications. -** -** DRIVERET_MAX (below) specifies the maximum allowed type code from the -** 1401 driver; I have set this high to accommodate as yet undesigned 1401 -** types. Similarly, as long as the command file names follow the ARM, -** ARN, ARO sequence, these are calculated by the ExtForType function, so -** you don't need to do anything here either. -** -** Version number -** ************** -** The new U14InitLib() function returns 0 if the OS is incapable of use, -** otherwise is returns the version of the USE1401 library. This is done -** in three parts: Major(31-24).Minor(23-16).Revision.(15-0) (brackets are -** the bits used). The Major number starts at 2 for the first revision with -** the U14InitLib() function. Changes to the Major version means that we -** have broken backwards compatibility. Minor number changes mean that we -** have added new functionality that does not break backwards compatibility. -** we starts at 0. Revision changes mean we have fixed something. Each index -** returns to 0 when a higher one changes. -*/ -#define U14LIB_MAJOR 4 -#define U14LIB_MINOR 0 -#define U14LIB_REVISION 0 -#define U14LIB_VERSION ((U14LIB_MAJOR<<24) | (U14LIB_MINOR<<16) | U14LIB_REVISION) - -#include <stdlib.h> -#include <string.h> -#include <stdio.h> - -#include "USE1401.H" - -#ifdef _IS_WINDOWS_ -#include <io.h> -#include <windows.h> -#pragma warning(disable: 4100) /* Disable "Unused formal parameter" warning */ -#include <assert.h> -#include "process.h" - - -#define sprintf wsprintf -#define PATHSEP '\\' -#define PATHSEPSTR "\\" -#define DEFCMDPATH "\\1401\\" // default command path if all else fails -#define MINDRIVERMAJREV 1 // minimum driver revision level we need -#define __packed // does nothing in Windows - -#include "use14_ioc.h" // links to device driver stuff -#endif - -#ifdef LINUX -#include <fcntl.h> -#include <unistd.h> -#include <sys/ioctl.h> -#include <errno.h> -#include <sys/time.h> -#include <sched.h> -#include <libgen.h> -#define PATHSEP '/' -#define PATHSEPSTR "/" -#define DEFCMDPATH "/var/1401/" // default command path if all else fails -#define MINDRIVERMAJREV 2 // minimum driver revision level we need - -#include "ced_ioctl.h" // links to device driver stuff -#endif - -#define MAX1401 8 // The number of 1401s that can be supported - -/* -** These are the 1401 type codes returned by the driver, they are a slightly -** odd sequence & start for reasons of compatibility with the DOS driver. -** The maximum code value is the upper limit of 1401 device types. -*/ -#define DRIVRET_STD 4 // Codes for 1401 types matching driver values -#define DRIVRET_U1401 5 // This table does not need extending, as -#define DRIVRET_PLUS 6 // we can calculate values now. -#define DRIVRET_POWER 7 // but we need all of these values still -#define DRIVRET_MAX 26 // Maximum tolerated code - future designs - -/* -** These variables store data that will be used to generate the last -** error string. For now, a string will hold the 1401 command file name. -*/ -static char szLastName[20]; // additional text information - -/* -** Information stored per handle. NBNB, driverType and DriverVersion used to be -** only stored once for all handles... i.e. nonsensical. This change means that -** three U14...() calls now include handles that were previously void. We have -** set a constructor and a destructor call for the library (see the end) to -** initialise important structures, or call use1401_load(). -*/ -static short asDriverType[MAX1401] = {0}; -static int lLastDriverVersion = U14ERR_NO1401DRIV; -static int lLastDriverType = U14TYPEUNKNOWN; -static int alDriverVersion[MAX1401]; // version/type of each driver -static int alTimeOutPeriod[MAX1401]; // timeout time in milliseconds -static short asLastRetCode[MAX1401]; // last code from a fn call -static short asType1401[MAX1401] = {0}; // The type of the 1401 -static BOOL abGrabbed[MAX1401] = {0}; // Flag for grabbed, set true by grab1401 -static int iAttached = 0; // counts process attaches so can let go - -#ifdef _IS_WINDOWS_ -/**************************************************************************** -** Windows NT Specific Variables and internal types -****************************************************************************/ -static HANDLE aHand1401[MAX1401] = {0}; // handles for 1401s -static HANDLE aXferEvent[MAX1401] = {0}; // transfer events for the 1401s -static LPVOID apAreas[MAX1401][MAX_TRANSAREAS]; // Locked areas -static unsigned int auAreas[MAX1401][MAX_TRANSAREAS]; // Size of locked areas -static BOOL bWindows9x = FALSE; // if we are Windows 95 or better -#ifdef _WIN64 -#define USE_NT_DIOC(ind) TRUE -#else -static BOOL abUseNTDIOC[MAX1401]; // Use NT-style DIOC parameters */ -#define USE_NT_DIOC(ind) abUseNTDIOC[ind] -#endif - -#endif - -#ifdef LINUX -static int aHand1401[MAX1401] = {0}; // handles for 1401s -#define INVALID_HANDLE_VALUE 0 // to avoid code differences -#endif - - -/* -** The CmdHead relates to backwards compatibility with ancient Microsoft (and Sperry!) -** versions of BASIC, where this header was needed so we could load a command into -** memory. -*/ -#pragma pack(1) // pack our structure -typedef struct CmdHead // defines header block on command -{ // for PC commands - char acBasic[5]; // BASIC information - needed to align things - unsigned short wBasicSz; // size as seen by BASIC - unsigned short wCmdSize; // size of the following info -} __packed CMDHEAD; -#pragma pack() // back to normal - -/* -** The rest of the header looks like this... -** int iRelPnt; relocation pointer... actual start -** char acName[8]; string holding the command name -** BYTE bMonRev; monitor revision level -** BYTE bCmdRev; command revision level -*/ - -typedef CMDHEAD *LPCMDHEAD; // pointer to a command header - -#define MAXSTRLEN 255 // maximum string length we use -#define TOHOST FALSE -#define TO1401 TRUE - -static short CheckHandle(short h) -{ - if ((h < 0) || (h >= MAX1401)) // must be legal range... - return U14ERR_BADHAND; - if (aHand1401[h] <= 0) // must be open - return U14ERR_BADHAND; - return U14ERR_NOERROR; -} - -#ifdef _IS_WINDOWS_ -/**************************************************************************** -** U14Status1401 Used for functions which do not pass any data in but -** get data back -****************************************************************************/ -static short U14Status1401(short sHand, LONG lCode, TCSBLOCK* pBlk) -{ - unsigned int dwBytes = 0; - - if ((sHand < 0) || (sHand >= MAX1401)) /* Check parameters */ - return U14ERR_BADHAND; -#ifndef _WIN64 - if (!USE_NT_DIOC(sHand)) - { /* Windows 9x DIOC methods? */ - if (DeviceIoControl(aHand1401[sHand], lCode, NULL, 0, pBlk,sizeof(TCSBLOCK),&dwBytes,NULL)) - return (short)((dwBytes>=sizeof(TCSBLOCK)) ? U14ERR_NOERROR : U14ERR_DRIVCOMMS); - else - return (short)GetLastError(); - } - else -#endif - { /* Windows NT or USB driver */ - PARAMBLK rWork; - rWork.sState = U14ERR_DRIVCOMMS; - if (DeviceIoControl(aHand1401[sHand], lCode, NULL, 0, &rWork,sizeof(PARAMBLK),&dwBytes,NULL) && - (dwBytes >= sizeof(PARAMBLK))) - { - *pBlk = rWork.csBlock; - return rWork.sState; - } - } - - return U14ERR_DRIVCOMMS; -} - -/**************************************************************************** -** U14Control1401 Used for functions which pass data in and only expect -** an error code back -****************************************************************************/ -static short U14Control1401(short sHand, LONG lCode, TCSBLOCK* pBlk) -{ - unsigned int dwBytes = 0; - - if ((sHand < 0) || (sHand >= MAX1401)) /* Check parameters */ - return U14ERR_BADHAND; - -#ifndef _WIN64 - if (!USE_NT_DIOC(sHand)) - { /* Windows 9x DIOC methods */ - if (DeviceIoControl(aHand1401[sHand], lCode, NULL, 0, pBlk, sizeof(TCSBLOCK), &dwBytes, NULL)) - return (short)(dwBytes >= sizeof(TCSBLOCK) ? U14ERR_NOERROR : U14ERR_DRIVCOMMS); - else - return (short)GetLastError(); - } - else -#endif - { /* Windows NT or later */ - PARAMBLK rWork; - rWork.sState = U14ERR_DRIVCOMMS; - if (DeviceIoControl(aHand1401[sHand], lCode, pBlk, sizeof(TCSBLOCK), &rWork, sizeof(PARAMBLK), &dwBytes, NULL) && - (dwBytes >= sizeof(PARAMBLK))) - return rWork.sState; - } - - return U14ERR_DRIVCOMMS; -} -#endif - -/**************************************************************************** -** SafeTickCount -** Gets time in approximately units of a millisecond. -*****************************************************************************/ -static long SafeTickCount(void) -{ -#ifdef _IS_WINDOWS_ - return GetTickCount(); -#endif -#ifdef LINUX - struct timeval tv; - gettimeofday(&tv, NULL); - return (tv.tv_sec*1000 + tv.tv_usec/1000); -#endif -} - -/**************************************************************************** -** A utility routine to get the command file extension for a given type -** of 1401. We assume the type code is vaguely legal. -****************************************************************************/ -static int ExtForType(short sType, char* szExt) -{ - szExt[0] = 0; /* Default return is a blank string */ - switch (sType) - { - case U14TYPE1401: strcpy(szExt, ".CMD"); break; // Standard 1401 - case U14TYPEPLUS: strcpy(szExt, ".GXC"); break; // 1401 plus - default: // All others are in a predictable sequence - strcpy(szExt, ".ARM"); - szExt[3] = (char)('M' + sType - U14TYPEU1401); - if (szExt[3] > 'Z') // Wrap round to ARA after ARZ - szExt[3] = (char)(szExt[3] - 26); - } - return 0; -} - -/**************************************************************************** -** U14WhenToTimeOut -** Returns the time to time out in time units suitable for the machine -** we are running on ie millsecs for pc/linux, or Mac/ -****************************************************************************/ -U14API(int) U14WhenToTimeOut(short hand) -{ - int iNow = SafeTickCount(); - if ((hand >= 0) && (hand < MAX1401)) - iNow += alTimeOutPeriod[hand]; - return iNow; -} - -/**************************************************************************** -** U14PassedTime -** Returns non zero if the timed passed in has been passed 0 if not -****************************************************************************/ -U14API(short) U14PassedTime(int lCheckTime) -{ - return (short)((SafeTickCount()-lCheckTime) > 0); -} - -/**************************************************************************** -** TranslateString -** Tidies up string that U14GetString returns. Converts all the commas in a -** string to spaces. Removes terminating CR character. May do more in future. -****************************************************************************/ -static void TranslateString(char* pStr) -{ - int i = 0; - while (pStr[i]) - { - if (pStr[i] == ',') - pStr[i] = ' '; /* convert comma to space */ - ++i; - } - - if ((i > 0) && (pStr[i-1] == '\n')) /* kill terminating LF */ - pStr[i-1] = (char)0; -} - -/**************************************************************************** -** U14StrToLongs -** Converts a string to an array of longs and returns the number of values -****************************************************************************/ -U14API(short) U14StrToLongs(const char* pszBuff, U14LONG *palNums, short sMaxLongs) -{ - unsigned short wChInd = 0; // index into source - short sLgInd = 0; // index into result longs - - while (pszBuff[wChInd] && // until we get to end of string... - (sLgInd < sMaxLongs)) // ...or filled the buffer - { - // Why not use a C Library converter? - switch (pszBuff[wChInd]) - { - case '-': - case '0': case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - { - BOOL bDone = FALSE; // true at end of number - int iSign = 1; // sign of number - long lValue = 0; - - while ((!bDone) && pszBuff[wChInd]) - { - switch (pszBuff[wChInd]) - { - case '-': - iSign = -1; // swap sign - break; - - case '0': case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - lValue *= 10; // move to next digit base 10 - lValue += ((int)pszBuff[wChInd]-(int)'0'); - break; - - default: // end of number - bDone = TRUE; - break; - } - wChInd++; // move onto next character - } - palNums[sLgInd] = lValue * iSign; - sLgInd++; - } - break; - - default: - wChInd++; // look at next char - break; - } - } - return (sLgInd); -} - - -/**************************************************************************** -** U14LongsFrom1401 -** Gets the next waiting line from the 1401 and converts it longs -** Returns the number of numbers read or an error. -****************************************************************************/ -U14API(short) U14LongsFrom1401(short hand, U14LONG *palBuff, short sMaxLongs) -{ - char szWork[MAXSTRLEN]; - short sResult = U14GetString(hand, szWork, MAXSTRLEN);/* get reply from 1401 */ - if (sResult == U14ERR_NOERROR) /* if no error convert */ - sResult = U14StrToLongs(szWork, palBuff, sMaxLongs); - return sResult; -} - -/**************************************************************************** -** U14CheckErr -** Sends the ERR command to the 1401 and gets the result. Returns 0, a -** negative error code, or the first error value. -****************************************************************************/ -U14API(short) U14CheckErr(short hand) -{ - short sResult = U14SendString(hand, ";ERR;"); - if (sResult == U14ERR_NOERROR) - { - U14LONG er[3]; - sResult = U14LongsFrom1401(hand, er, 3); - if (sResult > 0) - { - sResult = (short)er[0]; /* Either zero or an error value */ -#ifdef _DEBUG - if (er[0] != 0) - { - char szMsg[50]; - sprintf(szMsg, "U14CheckErr returned %d,%d\n", er[0], er[1]); - OutputDebugString(szMsg); - } -#endif - } - else - { - if (sResult == 0) - sResult = U14ERR_TIMEOUT; /* No numbers equals timeout */ - } - } - - return sResult; -} - -/**************************************************************************** -** U14LastErrCode -** Returns the last code from the driver. This is for Windows where all calls -** go through the Control and Status routines, so we can save any error. -****************************************************************************/ -U14API(short) U14LastErrCode(short hand) -{ - if ((hand < 0) || (hand >= MAX1401)) - return U14ERR_BADHAND; - return asLastRetCode[hand]; -} - -/**************************************************************************** -** U14SetTimeout -** Set the timeout period for 1401 comms in milliseconds -****************************************************************************/ -U14API(void) U14SetTimeout(short hand, int lTimeOut) -{ - if ((hand < 0) || (hand >= MAX1401)) - return; - alTimeOutPeriod[hand] = lTimeOut; -} - -/**************************************************************************** -** U14GetTimeout -** Get the timeout period for 1401 comms in milliseconds -****************************************************************************/ -U14API(int) U14GetTimeout(short hand) -{ - if ((hand < 0) || (hand >= MAX1401)) - return U14ERR_BADHAND; - return alTimeOutPeriod[hand]; -} - -/**************************************************************************** -** U14OutBufSpace -** Return the space in the output buffer, or an error. -****************************************************************************/ -U14API(short) U14OutBufSpace(short hand) -{ -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - short sErr = U14Status1401(hand, U14_GETOUTBUFSPACE,&csBlock); - if (sErr == U14ERR_NOERROR) - sErr = csBlock.ints[0]; - return sErr; -#endif -#ifdef LINUX - short sErr = CheckHandle(hand); - return (sErr == U14ERR_NOERROR) ? CED_GetOutBufSpace(aHand1401[hand]) : sErr; -#endif -} - - -/**************************************************************************** -** U14BaseAddr1401 -** Returns the 1401 base address or an error code. Meaningless nowadays -****************************************************************************/ -U14API(int) U14BaseAddr1401(short hand) -{ -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - int iError = U14Status1401(hand, U14_GETBASEADDRESS,&csBlock); - if (iError == U14ERR_NOERROR) - iError = csBlock.longs[0]; - return iError; -#endif -#ifdef LINUX - short sErr = CheckHandle(hand); - return (sErr == U14ERR_NOERROR) ? CED_GetBaseAddress(aHand1401[hand]) : sErr; -#endif -} - -/**************************************************************************** -** U14StateOf1401 -** Return error state, either NOERROR or a negative code. -****************************************************************************/ -U14API(short) U14StateOf1401(short hand) -{ -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - short sErr = U14Status1401(hand, U14_STATEOF1401, &csBlock); - if (sErr == U14ERR_NOERROR) - { - sErr = csBlock.ints[0]; // returned 1401 state - if ((sErr >= DRIVRET_STD) && (sErr <= DRIVRET_MAX)) - sErr = U14ERR_NOERROR; - } -#endif -#ifdef LINUX - short sErr = CheckHandle(hand); - if (sErr == U14ERR_NOERROR) - { - sErr = (short)CED_StateOf1401(aHand1401[hand]); - if ((sErr >= DRIVRET_STD) && (sErr <= DRIVRET_MAX)) - sErr = U14ERR_NOERROR; - } -#endif - return sErr; -} - -/**************************************************************************** -** U14DriverVersion -** Returns the driver version. Hi word is major revision, low word is minor. -** If you pass in a silly handle (like -1), we return the version of the last -** driver we know of (to cope with PCI and no 1401 attached). -****************************************************************************/ -U14API(int) U14DriverVersion(short hand) -{ - return CheckHandle(hand) != U14ERR_NOERROR ? lLastDriverVersion : alDriverVersion[hand]; -} - -/**************************************************************************** -** U14DriverType -** Returns the driver type. The type, 0=ISA/NU-Bus, 1=PCI, 2=USB, 3=HSS -** If you pass in a silly handle (like -1), we return the type of the last -** driver we know of (to cope with PCI and no 1401 attached). -****************************************************************************/ -U14API(int) U14DriverType(short hand) -{ - return CheckHandle(hand) != U14ERR_NOERROR ? lLastDriverType : asDriverType[hand]; -} - -/**************************************************************************** -** U14DriverName -** Returns the driver type as 3 character (ISA, PCI, USB or HSS)) -****************************************************************************/ -U14API(short) U14DriverName(short hand, char* pBuf, unsigned short wMax) -{ - char* pName; - *pBuf = 0; // Start off with a blank string - switch (U14DriverType(hand)) // Results according to type - { - case 0: pName = "ISA"; break; - case 1: pName = "PCI"; break; - case 2: pName = "USB"; break; - case 3: pName = "HSS"; break; - default: pName = "???"; break; - } - strncpy(pBuf, pName, wMax); // Copy the correct name to return - - return U14ERR_NOERROR; -} - -/**************************************************************************** -** U14BlkTransState -** Returns 0 no transfer in progress, 1 transfer in progress or an error code -****************************************************************************/ -U14API(short) U14BlkTransState(short hand) -{ -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - short sErr = U14Status1401(hand, U14_BLKTRANSSTATE, &csBlock); - if (sErr == U14ERR_NOERROR) - sErr = csBlock.ints[0]; - return sErr; -#endif -#ifdef LINUX - short sErr = CheckHandle(hand); - return (sErr == U14ERR_NOERROR) ? CED_BlkTransState(aHand1401[hand]) : sErr; -#endif -} - -/**************************************************************************** -** U14Grab1401 -** Take control of the 1401 for diagnostics purposes. USB does nothing. -****************************************************************************/ -U14API(short) U14Grab1401(short hand) -{ - short sErr = CheckHandle(hand); - if (sErr == U14ERR_NOERROR) - { -#ifdef _IS_WINDOWS_ - if (abGrabbed[hand]) // 1401 should not have been grabbed - sErr = U14ERR_ALREADYSET; // Error code defined for this - else - { - TCSBLOCK csBlock; - sErr = U14Control1401(hand, U14_GRAB1401, &csBlock); - } -#endif -#ifdef LINUX - // 1401 should not have been grabbed - sErr = abGrabbed[hand] ? U14ERR_ALREADYSET : CED_Grab1401(aHand1401[hand]); -#endif - if (sErr == U14ERR_NOERROR) - abGrabbed[hand] = TRUE; - } - return sErr; -} - -/**************************************************************************** -** U14Free1401 -****************************************************************************/ -U14API(short) U14Free1401(short hand) -{ - short sErr = CheckHandle(hand); - if (sErr == U14ERR_NOERROR) - { -#ifdef _IS_WINDOWS_ - if (abGrabbed[hand]) // 1401 should have been grabbed - { - TCSBLOCK csBlock; - sErr = U14Control1401(hand, U14_FREE1401, &csBlock); - } - else - sErr = U14ERR_NOTSET; -#endif -#ifdef LINUX - // 1401 should not have been grabbed - sErr = abGrabbed[hand] ? CED_Free1401(aHand1401[hand]) : U14ERR_NOTSET; -#endif - if (sErr == U14ERR_NOERROR) - abGrabbed[hand] = FALSE; - } - return sErr; -} - -/**************************************************************************** -** U14Peek1401 -** DESCRIPTION Cause the 1401 to do one or more peek operations. -** If lRepeats is zero, the loop will continue until U14StopDebugLoop -** is called. After the peek is done, use U14GetDebugData to retrieve -** the results of the peek. -****************************************************************************/ -U14API(short) U14Peek1401(short hand, unsigned int dwAddr, int nSize, int nRepeats) -{ - short sErr = CheckHandle(hand); - if (sErr == U14ERR_NOERROR) - { - if (abGrabbed[hand]) // 1401 should have been grabbed - { -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - csBlock.longs[0] = (long)dwAddr; - csBlock.longs[1] = nSize; - csBlock.longs[2] = nRepeats; - sErr = U14Control1401(hand, U14_DBGPEEK, &csBlock); -#endif -#ifdef LINUX - TDBGBLOCK dbb; - dbb.iAddr = (int)dwAddr; - dbb.iWidth = nSize; - dbb.iRepeats = nRepeats; - sErr = CED_DbgPeek(aHand1401[hand], &dbb); -#endif - } - else - sErr = U14ERR_NOTSET; - } - return sErr; -} - -/**************************************************************************** -** U14Poke1401 -** DESCRIPTION Cause the 1401 to do one or more poke operations. -** If lRepeats is zero, the loop will continue until U14StopDebugLoop -** is called. -****************************************************************************/ -U14API(short) U14Poke1401(short hand, unsigned int dwAddr, unsigned int dwValue, - int nSize, int nRepeats) -{ - short sErr = CheckHandle(hand); - if (sErr == U14ERR_NOERROR) - { - if (abGrabbed[hand]) // 1401 should have been grabbed - { -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - csBlock.longs[0] = (long)dwAddr; - csBlock.longs[1] = nSize; - csBlock.longs[2] = nRepeats; - csBlock.longs[3] = (long)dwValue; - sErr = U14Control1401(hand, U14_DBGPOKE, &csBlock); -#endif -#ifdef LINUX - TDBGBLOCK dbb; - dbb.iAddr = (int)dwAddr; - dbb.iWidth = nSize; - dbb.iRepeats= nRepeats; - dbb.iData = (int)dwValue; - sErr = CED_DbgPoke(aHand1401[hand], &dbb); -#endif - } - else - sErr = U14ERR_NOTSET; - } - return sErr; -} - -/**************************************************************************** -** U14Ramp1401 -** DESCRIPTION Cause the 1401 to loop, writing a ramp to a location. -** If lRepeats is zero, the loop will continue until U14StopDebugLoop. -****************************************************************************/ -U14API(short) U14Ramp1401(short hand, unsigned int dwAddr, unsigned int dwDef, unsigned int dwEnable, - int nSize, int nRepeats) -{ - short sErr = CheckHandle(hand); - if (sErr == U14ERR_NOERROR) - { - if (abGrabbed[hand]) // 1401 should have been grabbed - { -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - csBlock.longs[0] = (long)dwAddr; - csBlock.longs[1] = (long)dwDef; - csBlock.longs[2] = (long)dwEnable; - csBlock.longs[3] = nSize; - csBlock.longs[4] = nRepeats; - sErr = U14Control1401(hand, U14_DBGRAMPDATA, &csBlock); -#endif -#ifdef LINUX - TDBGBLOCK dbb; - dbb.iAddr = (int)dwAddr; - dbb.iDefault = (int)dwDef; - dbb.iMask = (int)dwEnable; - dbb.iWidth = nSize; - dbb.iRepeats = nRepeats; - sErr = CED_DbgRampAddr(aHand1401[hand], &dbb); -#endif - } - else - sErr = U14ERR_NOTSET; - } - return sErr; -} - -/**************************************************************************** -** U14RampAddr -** DESCRIPTION Cause the 1401 to loop, reading from a ramping location. -** If lRepeats is zero, the loop will continue until U14StopDebugLoop -****************************************************************************/ -U14API(short) U14RampAddr(short hand, unsigned int dwDef, unsigned int dwEnable, - int nSize, int nRepeats) -{ - short sErr = CheckHandle(hand); - if (sErr == U14ERR_NOERROR) - { - if (abGrabbed[hand]) // 1401 should have been grabbed - { -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - csBlock.longs[0] = (long)dwDef; - csBlock.longs[1] = (long)dwEnable; - csBlock.longs[2] = nSize; - csBlock.longs[3] = nRepeats; - sErr = U14Control1401(hand, U14_DBGRAMPADDR, &csBlock); -#endif -#ifdef LINUX - TDBGBLOCK dbb; - dbb.iDefault = (int)dwDef; - dbb.iMask = (int)dwEnable; - dbb.iWidth = nSize; - dbb.iRepeats = nRepeats; - sErr = CED_DbgRampAddr(aHand1401[hand], &dbb); -#endif - } - else - sErr = U14ERR_NOTSET; - } - return sErr; -} - -/**************************************************************************** -** U14StopDebugLoop -** DESCRIPTION Stops a peek\poke\ramp that, with repeats set to zero, -** will otherwise continue forever. -****************************************************************************/ -U14API(short) U14StopDebugLoop(short hand) -{ - short sErr = CheckHandle(hand); - if (sErr == U14ERR_NOERROR) -#ifdef _IS_WINDOWS_ - { - if (abGrabbed[hand]) // 1401 should have been grabbed - { - TCSBLOCK csBlock; - sErr = U14Control1401(hand, U14_DBGSTOPLOOP, &csBlock); - } - else - sErr = U14ERR_NOTSET; - } -#endif -#ifdef LINUX - sErr = abGrabbed[hand] ? CED_DbgStopLoop(aHand1401[hand]) : U14ERR_NOTSET; -#endif - return sErr; -} - -/**************************************************************************** -** U14GetDebugData -** DESCRIPTION Returns the result from a previous peek operation. -****************************************************************************/ -U14API(short) U14GetDebugData(short hand, U14LONG* plValue) -{ - short sErr = CheckHandle(hand); - if (sErr == U14ERR_NOERROR) - { - if (abGrabbed[hand]) // 1401 should have been grabbed - { -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - sErr = U14Status1401(hand, U14_DBGGETDATA, &csBlock); - if (sErr == U14ERR_NOERROR) - *plValue = csBlock.longs[0]; // Return the data -#endif -#ifdef LINUX - TDBGBLOCK dbb; - sErr = CED_DbgGetData(aHand1401[hand], &dbb); - if (sErr == U14ERR_NOERROR) - *plValue = dbb.iData; /* Return the data */ -#endif - } - else - sErr = U14ERR_NOTSET; - } - return sErr; -} - -/**************************************************************************** -** U14StartSelfTest -****************************************************************************/ -U14API(short) U14StartSelfTest(short hand) -{ -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - return U14Control1401(hand, U14_STARTSELFTEST, &csBlock); -#endif -#ifdef LINUX - short sErr = CheckHandle(hand); - return (sErr == U14ERR_NOERROR) ? CED_StartSelfTest(aHand1401[hand]) : sErr; -#endif -} - -/**************************************************************************** -** U14CheckSelfTest -****************************************************************************/ -U14API(short) U14CheckSelfTest(short hand, U14LONG *pData) -{ -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - short sErr = U14Status1401(hand, U14_CHECKSELFTEST, &csBlock); - if (sErr == U14ERR_NOERROR) - { - pData[0] = csBlock.longs[0]; /* Return the results to user */ - pData[1] = csBlock.longs[1]; - pData[2] = csBlock.longs[2]; - } -#endif -#ifdef LINUX - short sErr = CheckHandle(hand); - if (sErr == U14ERR_NOERROR) /* Check parameters */ - { - TGET_SELFTEST gst; - sErr = CED_CheckSelfTest(aHand1401[hand], &gst); - if (sErr == U14ERR_NOERROR) - { - pData[0] = gst.code; /* Return the results to user */ - pData[1] = gst.x; - pData[2] = gst.y; - } - } -#endif - return sErr; -} - -/**************************************************************************** -** U14GetUserMemorySize -****************************************************************************/ -U14API(short) U14GetUserMemorySize(short hand, unsigned int *pMemorySize) -{ - // The original 1401 used a different command for getting the size - short sErr = U14SendString(hand, (asType1401[hand] == U14TYPE1401) ? "MEMTOP;" : "MEMTOP,?;"); - *pMemorySize = 0; /* if we get error then leave size set at 0 */ - if (sErr == U14ERR_NOERROR) - { - U14LONG alLimits[4]; - sErr = U14LongsFrom1401(hand, alLimits, 4); - if (sErr > 0) /* +ve sErr is the number of values read */ - { - sErr = U14ERR_NOERROR; /* All OK, flag success */ - if (asType1401[hand] == U14TYPE1401) /* result for standard */ - *pMemorySize = alLimits[0] - alLimits[1]; /* memtop-membot */ - else - *pMemorySize = alLimits[0]; /* result for plus or u1401 */ - } - } - return sErr; -} - -/**************************************************************************** -** U14TypeOf1401 -** Returns the type of the 1401, maybe unknown -****************************************************************************/ -U14API(short) U14TypeOf1401(short hand) -{ - if ((hand < 0) || (hand >= MAX1401)) /* Check parameters */ - return U14ERR_BADHAND; - else - return asType1401[hand]; -} - -/**************************************************************************** -** U14NameOf1401 -** Returns the type of the 1401 as a string, blank if unknown -****************************************************************************/ -U14API(short) U14NameOf1401(short hand, char* pBuf, unsigned short wMax) -{ - short sErr = CheckHandle(hand); - if (sErr == U14ERR_NOERROR) - { - char* pName; - switch (asType1401[hand]) // Results according to type - { - case U14TYPE1401: pName = "Std 1401"; break; - case U14TYPEPLUS: pName = "1401plus"; break; - case U14TYPEU1401: pName = "micro1401"; break; - case U14TYPEPOWER: pName = "Power1401"; break; - case U14TYPEU14012:pName = "Micro1401 mk II"; break; - case U14TYPEPOWER2:pName = "Power1401 mk II"; break; - case U14TYPEU14013:pName = "Micro1401-3"; break; - case U14TYPEPOWER3:pName = "Power1401-3"; break; - default: pName = "Unknown"; - } - strncpy(pBuf, pName, wMax); - } - return sErr; -} - -/**************************************************************************** -** U14TransferFlags -** Returns the driver block transfer flags. -** Bits can be set - see U14TF_ constants in use1401.h -*****************************************************************************/ -U14API(short) U14TransferFlags(short hand) -{ -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - short sErr = U14Status1401(hand, U14_TRANSFERFLAGS, &csBlock); - return (sErr == U14ERR_NOERROR) ? (short)csBlock.ints[0] : sErr; -#endif -#ifdef LINUX - short sErr = CheckHandle(hand); - return (sErr == U14ERR_NOERROR) ? CED_TransferFlags(aHand1401[hand]) : sErr; -#endif -} - -/**************************************************************************** -** GetDriverVersion -** Actually reads driver version from the device driver. -** Hi word is major revision, low word is minor revision. -** Assumes that hand has been checked. Also codes driver type in bits 24 up. -*****************************************************************************/ -static int GetDriverVersion(short hand) -{ -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - int iErr = U14Status1401(hand, U14_GETDRIVERREVISION, &csBlock); - if (iErr == U14ERR_NOERROR) - iErr = csBlock.longs[0]; - return iErr; -#endif -#ifdef LINUX - return CED_GetDriverRevision(aHand1401[hand]); -#endif -} - -/**************************************************************************** -** U14MonitorRev -** Returns the 1401 monitor revision number. -** The number returned is the minor revision - the part after the -** decimal point - plus the major revision times 1000. -*****************************************************************************/ -U14API(int) U14MonitorRev(short hand) -{ - int iRev = 0; - int iErr = CheckHandle(hand); - if (iErr != U14ERR_NOERROR) // Check open and in use - return iErr; - - if (asType1401[hand] >= U14TYPEPOWER2) // The Power2 onwards can give us the monitor - { // revision directly for all versions - iErr = U14SendString(hand, "INFO,S,28;"); - if (iErr == U14ERR_NOERROR) - { - U14LONG lVals[2]; // Read a single number being the revision - iErr = U14LongsFrom1401(hand, lVals, 1); - if (iErr > 0) - { - iErr = U14ERR_NOERROR; - iRev = lVals[0]; // This is the minor part of the revision - iRev += asType1401[hand] * 10000; - } - } - } - else - { /* Do it the hard way for older hardware */ - iErr = U14SendString(hand, ";CLIST;"); /* ask for command levels */ - if (iErr == U14ERR_NOERROR) - { - while (iErr == U14ERR_NOERROR) - { - char wstr[50]; - iErr = U14GetString(hand, wstr, 45); - if (iErr == U14ERR_NOERROR) - { - char *pstr = strstr(wstr,"RESET"); /* Is this the RESET command? */ - if ((pstr == wstr) && (wstr[5] == ' ')) - { - char *pstr2; - size_t l; - pstr += 6; /* Move past RESET and followinmg char */ - l = strlen(pstr); /* The length of text remaining */ - while (((pstr[l-1] == ' ') || (pstr[l-1] == 13)) && (l > 0)) - { - pstr[l-1] = 0; /* Tidy up string at the end */ - l--; /* by removing spaces and CRs */ - } - pstr2 = strchr(pstr, '.'); /* Find the decimal point */ - if (pstr2 != NULL) /* If we found the DP */ - { - *pstr2 = 0; /* End pstr string at DP */ - pstr2++; /* Now past the decimal point */ - iRev = atoi(pstr2); /* Get the number after point */ - } - iRev += (atoi(pstr) * 1000); /* Add first bit * 1000 */ - } - if ((strlen(wstr) < 3) && (wstr[0] == ' ')) - break; /* Spot the last line of results */ - } - } - } - } - if (iErr == U14ERR_NOERROR) /* Return revision if no error */ - iErr = iRev; - - return iErr; -} - -/**************************************************************************** -** U14TryToOpen Tries to open the 1401 number passed -** Note : This will succeed with NT driver even if no I/F card or -** 1401 switched off, so we check state and close the driver -** if the state is unsatisfactory in U14Open1401. -****************************************************************************/ -#ifdef _IS_WINDOWS_ -#define U14NAMEOLD "\\\\.\\CED_140%d" -#define U14NAMENEW "\\\\.\\CED%d" -static short U14TryToOpen(int n1401, long* plRetVal, short* psHandle) -{ - short sErr = U14ERR_NOERROR; - HANDLE hDevice = INVALID_HANDLE_VALUE; - unsigned int dwErr = 0; - int nFirst, nLast, nDev = 0; /* Used for the search for a 1401 */ - BOOL bOldName = FALSE; /* start by looking for a modern driver */ - - if (n1401 == 0) /* If we need to look for a 1401 */ - { - nFirst = 1; /* Set the search range */ - nLast = MAX1401; /* through all the possible 1401s */ - } - else - nFirst = nLast = n1401; /* Otherwise just one 1401 */ - - while (hDevice == INVALID_HANDLE_VALUE) /* Loop to try for a 1401 */ - { - for (nDev = nFirst; nDev <= nLast; nDev++) - { - char szDevName[40]; /* name of the device to open */ - sprintf(szDevName, bOldName ? U14NAMEOLD : U14NAMENEW, nDev); - hDevice = CreateFile(szDevName, GENERIC_WRITE | GENERIC_READ, - 0, 0, /* Unshared mode does nothing as this is a device */ - OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); - - if (hDevice != INVALID_HANDLE_VALUE)/* Check 1401 if opened */ - { - TCSBLOCK csBlock; - assert(aHand1401[nDev-1] == INVALID_HANDLE_VALUE); // assert if already open - aHand1401[nDev-1] = hDevice; /* Save handle for now */ - -#ifndef _WIN64 - // Use DIOC method if not windows 9x or if using new device name - abUseNTDIOC[nDev-1] = (BOOL)(!bWindows9x || !bOldName); -#endif - sErr = U14Status1401((short)(nDev-1), U14_TYPEOF1401, &csBlock); - if (sErr == U14ERR_NOERROR) - { - *plRetVal = csBlock.ints[0]; - if (csBlock.ints[0] == U14ERR_INUSE)/* Prevent multi opens */ - { - CloseHandle(hDevice); /* treat as open failure */ - hDevice = INVALID_HANDLE_VALUE; - aHand1401[nDev-1] = INVALID_HANDLE_VALUE; - sErr = U14ERR_INUSE; - } - else - break; /* Exit from for loop on success */ - } - else - { - CloseHandle(hDevice); /* Give up if func fails */ - hDevice = INVALID_HANDLE_VALUE; - aHand1401[nDev-1] = INVALID_HANDLE_VALUE; - } - } - else - { - unsigned int dwe = GetLastError(); /* Get error code otherwise */ - if ((dwe != ERROR_FILE_NOT_FOUND) || (dwErr == 0)) - dwErr = dwe; /* Ignore repeats of 'not found' */ - } - } - - if ((hDevice == INVALID_HANDLE_VALUE) &&/* No device found, and... */ - (bWindows9x) && /* ...old names are allowed, and... */ - (bOldName == FALSE)) /* ...not tried old names yet */ - bOldName = TRUE; /* Set flag and go round again */ - else - break; /* otherwise that's all folks */ - } - - if (hDevice != INVALID_HANDLE_VALUE) /* If we got our device open */ - *psHandle = (short)(nDev-1); /* return 1401 number opened */ - else - { - if (dwErr == ERROR_FILE_NOT_FOUND) /* Sort out the error codes */ - sErr = U14ERR_NO1401DRIV; /* if file not found */ - else if (dwErr == ERROR_NOT_SUPPORTED) - sErr = U14ERR_DRIVTOOOLD; /* if DIOC not supported */ - else if (dwErr == ERROR_ACCESS_DENIED) - sErr = U14ERR_INUSE; - else - sErr = U14ERR_DRIVCOMMS; /* otherwise assume comms problem */ - } - return sErr; -} -#endif -#ifdef LINUX -static short U14TryToOpen(int n1401, long* plRetVal, short* psHandle) -{ - short sErr = U14ERR_NOERROR; - int fh = 0; // will be 1401 handle - int iErr = 0; - int nFirst, nLast, nDev = 0; // Used for the search for a 1401 - - if (n1401 == 0) // If we need to look for a 1401 - { - nFirst = 1; /* Set the search range */ - nLast = MAX1401; /* through all the possible 1401s */ - } - else - nFirst = nLast = n1401; /* Otherwise just one 1401 */ - - for (nDev = nFirst; nDev <= nLast; nDev++) - { - char szDevName[40]; // name of the device to open - sprintf(szDevName,"/dev/cedusb/%d", nDev-1); - fh = open(szDevName, O_RDWR); // can only be opened once at a time - if (fh > 0) // Check 1401 if opened - { - int iType1401 = CED_TypeOf1401(fh); // get 1401 type - aHand1401[nDev-1] = fh; // Save handle for now - if (iType1401 >= 0) - { - *plRetVal = iType1401; - break; // Exit from for loop on success - } - else - { - close(fh); // Give up if func fails - fh = 0; - aHand1401[nDev-1] = 0; - } - } - else - { - if (((errno != ENODEV) && (errno != ENOENT)) || (iErr == 0)) - iErr = errno; // Ignore repeats of 'not found' - } - } - - - if (fh) // If we got our device open - *psHandle = (short)(nDev-1); // return 1401 number opened - else - { - if ((iErr == ENODEV) || (iErr == ENOENT)) // Sort out the error codes - sErr = U14ERR_NO1401DRIV; // if file not found - else if (iErr == EBUSY) - sErr = U14ERR_INUSE; - else - sErr = U14ERR_DRIVCOMMS; // otherwise assume comms problem - } - - return sErr; -} -#endif -/**************************************************************************** -** U14Open1401 -** Tries to get the 1401 for use by this application -*****************************************************************************/ -U14API(short) U14Open1401(short n1401) -{ - long lRetVal = -1; - short sErr; - short hand = 0; - - if ((n1401 < 0) || (n1401 > MAX1401)) // must check the 1401 number - return U14ERR_BAD1401NUM; - - szLastName[0] = 0; /* initialise the error info string */ - - sErr = U14TryToOpen(n1401, &lRetVal, &hand); - if (sErr == U14ERR_NOERROR) - { - long lDriverVersion = GetDriverVersion(hand); /* get driver revision */ - long lDriverRev = -1; - if (lDriverVersion >= 0) /* can use it if all OK */ - { - lLastDriverType = (lDriverVersion >> 24) & 0x000000FF; - asDriverType[hand] = (short)lLastDriverType; /* Drv type */ - lLastDriverVersion = lDriverVersion & 0x00FFFFFF; - alDriverVersion[hand] = lLastDriverVersion; /* Actual version */ - lDriverRev = ((lDriverVersion>>16) & 0x00FF); /* use hi word */ - } - else - { - U14Close1401(hand); /* If there is a problem we should close */ - return (short)lDriverVersion; /* and return the error code */ - } - - if (lDriverRev < MINDRIVERMAJREV) /* late enough version? */ - { - U14Close1401(hand); /* If there is a problem we should close */ - return U14ERR_DRIVTOOOLD; /* too old */ - } - - asLastRetCode[hand] = U14ERR_NOERROR; /* Initialise this 1401s info */ - abGrabbed[hand] = FALSE; /* we are not in single step mode */ - U14SetTimeout(hand, 3000); /* set 3 seconds as default timeout */ - - switch (lRetVal) - { - case DRIVRET_STD: asType1401[hand] = U14TYPE1401; break; /* Some we do by hand */ - case DRIVRET_U1401:asType1401[hand] = U14TYPEU1401; break; - case DRIVRET_PLUS: asType1401[hand] = U14TYPEPLUS; break; - default: // For the power upwards, we can calculate the codes - if ((lRetVal >= DRIVRET_POWER) && (lRetVal <= DRIVRET_MAX)) - asType1401[hand] = (short)(lRetVal - (DRIVRET_POWER - U14TYPEPOWER)); - else - asType1401[hand] = U14TYPEUNKNOWN; - break; - } - U14KillIO1401(hand); /* resets the 1401 buffers */ - - if (asType1401[hand] != U14TYPEUNKNOWN) /* If all seems OK so far */ - { - sErr = U14CheckErr(hand); /* we can check 1401 comms now */ - if (sErr != 0) /* If this failed to go OK */ - U14Reset1401(hand); /* Reset the 1401 to try to sort it out */ - } - - sErr = U14StateOf1401(hand);/* Get the state of the 1401 for return */ - if (sErr == U14ERR_NOERROR) - sErr = hand; /* return the handle if no problem */ - else - U14Close1401(hand); /* If there is a problem we should close */ - } - - return sErr; -} - - -/**************************************************************************** -** U14Close1401 -** Closes the 1401 so someone else can use it. -****************************************************************************/ -U14API(short) U14Close1401(short hand) -{ - int j; - int iAreaMask = 0; // Mask for active areas - short sErr = CheckHandle(hand); - if (sErr != U14ERR_NOERROR) // Check open and in use - return sErr; - - for (j = 0; j<MAX_TRANSAREAS; ++j) - { - TGET_TX_BLOCK gtb; - int iReturn = U14GetTransfer(hand, >b); // get area information - if (iReturn == U14ERR_NOERROR) // ignore if any problem - if (gtb.used) - iAreaMask |= (1 << j); // set a bit for each used area - } - - if (iAreaMask) // if any areas are in use - { - U14Reset1401(hand); // in case an active transfer running - for (j = 0; j < MAX_TRANSAREAS; ++j) // Locate locked areas - if (iAreaMask & (1 << j)) // And kill off any transfers - U14UnSetTransfer(hand, (unsigned short)j); - } - -#ifdef _IS_WINDOWS_ - if (aXferEvent[hand]) // if this 1401 has an open event handle - { - CloseHandle(aXferEvent[hand]); // close down the handle - aXferEvent[hand] = NULL; // and mark it as gone - } - - if (CloseHandle(aHand1401[hand])) -#endif -#ifdef LINUX - if (close(aHand1401[hand]) == 0) // make sure that close works -#endif - { - aHand1401[hand] = INVALID_HANDLE_VALUE; - asType1401[hand] = U14TYPEUNKNOWN; - return U14ERR_NOERROR; - } - else - return U14ERR_BADHAND; /* BUGBUG GetLastError() ? */ -} - -/************************************************************************** -** -** Look for open 1401s and attempt to close them down. 32-bit windows only. -**************************************************************************/ -U14API(void) U14CloseAll(void) -{ - int i; - for (i = 0; i < MAX1401; i++) // Tidy up and make safe - if (aHand1401[i] != INVALID_HANDLE_VALUE) - U14Close1401((short)i); // Last ditch close 1401 -} - -/**************************************************************************** -** U14Reset1401 -** Resets the 1401 -****************************************************************************/ -U14API(short) U14Reset1401(short hand) -{ -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - return U14Control1401(hand, U14_RESET1401, &csBlock); -#endif -#ifdef LINUX - short sErr = CheckHandle(hand); - return (sErr == U14ERR_NOERROR) ? CED_Reset1401(aHand1401[hand]) : sErr; -#endif -} - -/**************************************************************************** -** U14ForceReset -** Sets the 1401 full reset flag, so that next call to Reset1401 will -** always cause a genuine reset. -*****************************************************************************/ -U14API(short) U14ForceReset(short hand) -{ -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - return U14Control1401(hand, U14_FULLRESET, &csBlock); -#endif -#ifdef LINUX - short sErr = CheckHandle(hand); - return (sErr == U14ERR_NOERROR) ? CED_FullReset(aHand1401[hand]) : sErr; -#endif -} - -/**************************************************************************** -** U14KillIO1401 -** Removes any pending IO from the buffers. -*****************************************************************************/ -U14API(short) U14KillIO1401(short hand) -{ -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - return U14Control1401(hand, U14_KILLIO1401, &csBlock); -#endif -#ifdef LINUX - short sErr = CheckHandle(hand); - return (sErr == U14ERR_NOERROR) ? CED_KillIO1401(aHand1401[hand]) : sErr; -#endif -} - - -/**************************************************************************** -** U14SendString -** Send characters to the 1401 -*****************************************************************************/ -U14API(short) U14SendString(short hand, const char* pString) -{ - int nChars; // length we are sending - long lTimeOutTicks; // when to time out - BOOL bSpaceToSend; // space to send yet - short sErr = CheckHandle(hand); - if (sErr != U14ERR_NOERROR) - return sErr; - - nChars = (int)strlen(pString); // get string length we want to send - if (nChars > MAXSTRLEN) - return U14ERR_STRLEN; // String too long - -#ifdef _IS_WINDOWS_ - // To get here we must wait for the buffer to have some space - lTimeOutTicks = U14WhenToTimeOut(hand); - do - { - bSpaceToSend = (BOOL)((long)U14OutBufSpace(hand) >= nChars); - } - while (!bSpaceToSend && !U14PassedTime(lTimeOutTicks)); - - if (!bSpaceToSend) /* Last-ditch attempt to avoid timeout */ - { /* This can happen with anti-virus or network activity! */ - int i; - for (i = 0; (i < 4) && (!bSpaceToSend); ++i) - { - Sleep(25); /* Give other threads a chance for a while */ - bSpaceToSend = (BOOL)((long)U14OutBufSpace(hand) >= nChars); - } - } - - if (asLastRetCode[hand] == U14ERR_NOERROR) /* no errors? */ - { - if (bSpaceToSend) - { - PARAMBLK rData; - unsigned int dwBytes; - char tstr[MAXSTRLEN+5]; /* Buffer for chars */ - - if ((hand < 0) || (hand >= MAX1401)) - sErr = U14ERR_BADHAND; - else - { - strcpy(tstr, pString); /* Into local buf */ -#ifndef _WIN64 - if (!USE_NT_DIOC(hand)) /* Using WIN 95 driver access? */ - { - int iOK = DeviceIoControl(aHand1401[hand], (unsigned int)U14_SENDSTRING, - NULL, 0, tstr, nChars, - &dwBytes, NULL); - if (iOK) - sErr = (dwBytes >= (unsigned int)nChars) ? U14ERR_NOERROR : U14ERR_DRIVCOMMS; - else - sErr = (short)GetLastError(); - } - else -#endif - { - int iOK = DeviceIoControl(aHand1401[hand],(unsigned int)U14_SENDSTRING, - tstr, nChars, - &rData,sizeof(PARAMBLK),&dwBytes,NULL); - if (iOK && (dwBytes >= sizeof(PARAMBLK))) - sErr = rData.sState; - else - sErr = U14ERR_DRIVCOMMS; - } - - if (sErr != U14ERR_NOERROR) // If we have had a comms error - U14ForceReset(hand); // make sure we get real reset - } - - return sErr; - - } - else - { - U14ForceReset(hand); // make sure we get real reset - return U14ERR_TIMEOUT; - } - } - else - return asLastRetCode[hand]; -#endif -#ifdef LINUX - // Just try to send it and see what happens! - sErr = CED_SendString(aHand1401[hand], pString, nChars); - if (sErr != U14ERR_NOOUT) // if any result except "no room in output"... - { - if (sErr != U14ERR_NOERROR) // if a problem... - U14ForceReset(hand); // ...make sure we get real reset next time - return sErr; // ... we are done as nothing we can do - } - - // To get here we must wait for the buffer to have some space - lTimeOutTicks = U14WhenToTimeOut(hand); - do - { - bSpaceToSend = (BOOL)((long)U14OutBufSpace(hand) >= nChars); - if (!bSpaceToSend) - sched_yield(); // let others have fun while we wait - } - while (!bSpaceToSend && !U14PassedTime(lTimeOutTicks)); - - if (asLastRetCode[hand] == U14ERR_NOERROR) /* no errors? */ - { - if (bSpaceToSend) - { - sErr = CED_SendString(aHand1401[hand], pString, nChars); - if (sErr != U14ERR_NOERROR) // If we have had a comms error - U14ForceReset(hand); // make sure we get real reset - return sErr; - } - else - { - U14ForceReset(hand); // make sure we get real reset - return U14ERR_TIMEOUT; - } - } - else - return asLastRetCode[hand]; -#endif -} - -/**************************************************************************** -** U14SendChar -** Send character to the 1401 -*****************************************************************************/ -U14API(short) U14SendChar(short hand, char cChar) -{ -#ifdef _IS_WINDOWS_ - char sz[2]=" "; // convert to a string and send - sz[0] = cChar; - sz[1] = 0; - return(U14SendString(hand, sz)); // String routines are better -#endif -#ifdef LINUX - short sErr = CheckHandle(hand); - return (sErr == U14ERR_NOERROR) ? CED_SendChar(aHand1401[hand], cChar) : sErr; -#endif -} - -/**************************************************************************** -** U14GetString -** Get a string from the 1401. Returns a null terminated string. -** The string is all the characters up to the next CR in the buffer -** or the end of the buffer if that comes first. This only returns text -** if there is a CR in the buffer. The terminating CR character is removed. -** wMaxLen Is the size of the buffer and must be at least 2 or an error. -** Returns U14ERR_NOERR if OK with the result in the string or a negative -** error code. Any error from the device causes us to set up for -** a full reset. -****************************************************************************/ -U14API(short) U14GetString(short hand, char* pBuffer, unsigned short wMaxLen) -{ - short sErr = CheckHandle(hand); - if (sErr != U14ERR_NOERROR) // If an error... - return sErr; // ...bail out! - -#ifdef _IS_WINDOWS_ - if (wMaxLen>1) // we need space for terminating 0 - { - BOOL bLineToGet; // true when a line to get - long lTimeOutTicks = U14WhenToTimeOut(hand); - do - bLineToGet = (BOOL)(U14LineCount(hand) != 0); - while (!bLineToGet && !U14PassedTime(lTimeOutTicks)); - - if (!bLineToGet) /* Last-ditch attempt to avoid timeout */ - { /* This can happen with anti-virus or network activity! */ - int i; - for (i = 0; (i < 4) && (!bLineToGet); ++i) - { - Sleep(25); /* Give other threads a chance for a while */ - bLineToGet = (BOOL)(U14LineCount(hand) != 0); - } - } - - if (bLineToGet) - { - if (asLastRetCode[hand] == U14ERR_NOERROR) /* all ok so far */ - { - unsigned int dwBytes = 0; - *((unsigned short *)pBuffer) = wMaxLen; /* set up length */ -#ifndef _WIN64 - if (!USE_NT_DIOC(hand)) /* Win 95 DIOC here ? */ - { - char tstr[MAXSTRLEN+5]; /* Buffer for Win95 chars */ - int iOK; - - if (wMaxLen > MAXSTRLEN) /* Truncate length */ - wMaxLen = MAXSTRLEN; - - *((unsigned short *)tstr) = wMaxLen; /* set len */ - - iOK = DeviceIoControl(aHand1401[hand],(unsigned int)U14_GETSTRING, - NULL, 0, tstr, wMaxLen+sizeof(short), - &dwBytes, NULL); - if (iOK) /* Device IO control OK ? */ - { - strcpy(pBuffer, tstr); - sErr = U14ERR_NOERROR; - } - else - { - sErr = (short)GetLastError(); - if (sErr > 0) /* Errors are -ve */ - sErr = (short)-sErr; - } - } - else -#endif - { /* Here for NT, the DLL must own the buffer */ - HANDLE hMem = GlobalAlloc(GMEM_MOVEABLE,wMaxLen+sizeof(short)); - if (hMem) - { - char* pMem = (char*)GlobalLock(hMem); - if (pMem) - { - int iOK = DeviceIoControl(aHand1401[hand],(unsigned int)U14_GETSTRING, - NULL, 0, pMem, wMaxLen+sizeof(short), - &dwBytes, NULL); - if (iOK) /* Device IO control OK ? */ - { - if (dwBytes >= wMaxLen) - { - strcpy(pBuffer, pMem+sizeof(short)); - sErr = *((SHORT*)pMem); - } - else - sErr = U14ERR_DRIVCOMMS; - } - else - sErr = U14ERR_DRIVCOMMS; - - GlobalUnlock(hMem); - } - else - sErr = U14ERR_OUTOFMEMORY; - - GlobalFree(hMem); - } - else - sErr = U14ERR_OUTOFMEMORY; - } - - if (sErr == U14ERR_NOERROR) // If all OK... - TranslateString(pBuffer); // ...convert any commas to spaces - else // If we have had a comms error... - U14ForceReset(hand); // ...make sure we get real reset - - } - else - sErr = asLastRetCode[hand]; - } - else - { - sErr = U14ERR_TIMEOUT; - U14ForceReset(hand); // make sure we get real reset - } - } - else - sErr = U14ERR_BUFF_SMALL; - return sErr; -#endif -#ifdef LINUX - if (wMaxLen>1) // we need space for terminating 0 - { - BOOL bLineToGet; // true when a line to get - long lTimeOutTicks = U14WhenToTimeOut(hand); - do - { - bLineToGet = (BOOL)(U14LineCount(hand) != 0); - if (!bLineToGet) - sched_yield(); - - } - while (!bLineToGet && !U14PassedTime(lTimeOutTicks)); - - if (bLineToGet) - { - sErr = CED_GetString(aHand1401[hand], pBuffer, wMaxLen-1); // space for terminator - if (sErr >=0) // if we were OK... - { - if (sErr >= wMaxLen) // this should NOT happen unless - sErr = U14ERR_DRIVCOMMS; // ...driver Comms are very bad - else - { - pBuffer[sErr] = 0; // OK, so terminate the string... - TranslateString(pBuffer); // ...and convert commas to spaces. - } - } - - if (sErr < U14ERR_NOERROR) // If we have had a comms error - U14ForceReset(hand); // make sure we get real reset - } - else - { - sErr = U14ERR_TIMEOUT; - U14ForceReset(hand); // make sure we get real reset - } - } - else - sErr = U14ERR_BUFF_SMALL; - - return sErr >= U14ERR_NOERROR ? U14ERR_NOERROR : sErr; -#endif -} - -/**************************************************************************** -** U14GetChar -** Get a character from the 1401. CR returned as CR. -*****************************************************************************/ -U14API(short) U14GetChar(short hand, char* pcChar) -{ -#ifdef _IS_WINDOWS_ - char sz[2]; // read a very short string - short sErr = U14GetString(hand, sz, 2); // read one char and nul terminate it - *pcChar = sz[0]; // copy to result, NB char translate done by GetString - if (sErr == U14ERR_NOERROR) - { // undo translate of CR to zero - if (*pcChar == '\0') // by converting back - *pcChar = '\n'; // What a nasty thing to have to do - } - return sErr; -#endif -#ifdef LINUX - short sErr = CheckHandle(hand); - if (sErr != U14ERR_NOERROR) // Check parameters - return sErr; - sErr = CED_GetChar(aHand1401[hand]); // get one char, if available - if (sErr >= 0) - { - *pcChar = (char)sErr; // return if it we have one - return U14ERR_NOERROR; // say all OK - } - else - return sErr; -#endif -} - -/**************************************************************************** -** U14Stat1401 -** Returns 0 for no lines or error or non zero for something waiting -****************************************************************************/ -U14API(short) U14Stat1401(short hand) -{ - return ((short)(U14LineCount(hand) > 0)); -} - -/**************************************************************************** -** U14CharCount -** Returns the number of characters in the input buffer -*****************************************************************************/ -U14API(short) U14CharCount(short hand) -{ -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - short sErr = U14Status1401(hand, U14_STAT1401, &csBlock); - if (sErr == U14ERR_NOERROR) - sErr = csBlock.ints[0]; - return sErr; -#endif -#ifdef LINUX - short sErr = CheckHandle(hand); - return (sErr == U14ERR_NOERROR) ? CED_Stat1401(aHand1401[hand]) : sErr; -#endif -} - -/**************************************************************************** -** U14LineCount -** Returns the number of CR characters in the input buffer -*****************************************************************************/ -U14API(short) U14LineCount(short hand) -{ -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - short sErr = U14Status1401(hand, U14_LINECOUNT, &csBlock); - if (sErr == U14ERR_NOERROR) - sErr = csBlock.ints[0]; - return sErr; -#endif -#ifdef LINUX - short sErr = CheckHandle(hand); - return (sErr == U14ERR_NOERROR) ? CED_LineCount(aHand1401[hand]) : sErr; -#endif -} - -/**************************************************************************** -** U14GetErrorString -** Converts error code supplied to a decent descriptive string. -** NOTE: This function may use some extra information stored -** internally in the DLL. This information is stored on a -** per-process basis, but it might be altered if you call -** other functions after getting an error and before using -** this function. -****************************************************************************/ -U14API(void) U14GetErrorString(short nErr, char* pStr, unsigned short wMax) -{ - char wstr[150]; - - switch (nErr) /* Basically, we do this with a switch block */ - { - case U14ERR_OFF: - sprintf(wstr, "The 1401 is apparently switched off (code %d)", nErr); - break; - - case U14ERR_NC: - sprintf(wstr, "The 1401 is not connected to the interface card (code %d)", nErr); - break; - - case U14ERR_ILL: - sprintf(wstr, "The 1401 is not working correctly (code %d)", nErr); - break; - - case U14ERR_NOIF: - sprintf(wstr, "The 1401 interface card was not detected (code %d)", nErr); - break; - - case U14ERR_TIME: - sprintf(wstr, "The 1401 fails to become ready for use (code %d)", nErr); - break; - - case U14ERR_BADSW: - sprintf(wstr, "The 1401 interface card jumpers are incorrect (code %d)", nErr); - break; - - case U14ERR_NOINT: - sprintf(wstr, "The 1401 interrupt is not available for use (code %d)", nErr); - break; - - case U14ERR_INUSE: - sprintf(wstr, "The 1401 is already in use by another program (code %d)", nErr); - break; - - case U14ERR_NODMA: - sprintf(wstr, "The 1401 DMA channel is not available for use (code %d)", nErr); - break; - - case U14ERR_BADHAND: - sprintf(wstr, "The application supplied an incorrect 1401 handle (code %d)", nErr); - break; - - case U14ERR_BAD1401NUM: - sprintf(wstr, "The application used an incorrect 1401 number (code %d)", nErr); - break; - - case U14ERR_NO_SUCH_FN: - sprintf(wstr, "The code passed to the 1401 driver is invalid (code %d)", nErr); - break; - - case U14ERR_NO_SUCH_SUBFN: - sprintf(wstr, "The sub-code passed to the 1401 driver is invalid (code %d)", nErr); - break; - - case U14ERR_NOOUT: - sprintf(wstr, "No room in buffer for characters for the 1401 (code %d)", nErr); - break; - - case U14ERR_NOIN: - sprintf(wstr, "No characters from the 1401 are available (code %d)", nErr); - break; - - case U14ERR_STRLEN: - sprintf(wstr, "A string sent to or read from the 1401 was too long (code %d)", nErr); - break; - - case U14ERR_LOCKFAIL: - sprintf(wstr, "Failed to lock host memory for data transfer (code %d)", nErr); - break; - - case U14ERR_UNLOCKFAIL: - sprintf(wstr, "Failed to unlock host memory after data transfer (code %d)", nErr); - break; - - case U14ERR_ALREADYSET: - sprintf(wstr, "The transfer area used is already set up (code %d)", nErr); - break; - - case U14ERR_NOTSET: - sprintf(wstr, "The transfer area used has not been set up (code %d)", nErr); - break; - - case U14ERR_BADAREA: - sprintf(wstr, "The transfer area number is incorrect (code %d)", nErr); - break; - - case U14ERR_NOFILE: - sprintf(wstr, "The command file %s could not be opened (code %d)", szLastName, nErr); - break; - - case U14ERR_READERR: - sprintf(wstr, "The command file %s could not be read (code %d)", szLastName, nErr); - break; - - case U14ERR_UNKNOWN: - sprintf(wstr, "The %s command resource could not be found (code %d)", szLastName, nErr); - break; - - case U14ERR_HOSTSPACE: - sprintf(wstr, "Unable to allocate memory for loading command %s (code %d)", szLastName, nErr); - break; - - case U14ERR_LOCKERR: - sprintf(wstr, "Unable to lock memory for loading command %s (code %d)", szLastName, nErr); - break; - - case U14ERR_CLOADERR: - sprintf(wstr, "Error in loading command %s, bad command format (code %d)", szLastName, nErr); - break; - - case U14ERR_TOXXXERR: - sprintf(wstr, "Error detected after data transfer to or from the 1401 (code %d)", nErr); - break; - - case U14ERR_NO386ENH: - sprintf(wstr, "Windows 3.1 is not running in 386 enhanced mode (code %d)", nErr); - break; - - case U14ERR_NO1401DRIV: - sprintf(wstr, "The 1401 device driver cannot be found (code %d)\nUSB: check plugged in and powered\nOther: not installed?", nErr); - break; - - case U14ERR_DRIVTOOOLD: - sprintf(wstr, "The 1401 device driver is too old for use (code %d)", nErr); - break; - - case U14ERR_TIMEOUT: - sprintf(wstr, "Character transmissions to the 1401 timed-out (code %d)", nErr); - break; - - case U14ERR_BUFF_SMALL: - sprintf(wstr, "Buffer for text from the 1401 was too small (code %d)", nErr); - break; - - case U14ERR_CBALREADY: - sprintf(wstr, "1401 monitor callback already set up (code %d)", nErr); - break; - - case U14ERR_BADDEREG: - sprintf(wstr, "1401 monitor callback deregister invalid (code %d)", nErr); - break; - - case U14ERR_DRIVCOMMS: - sprintf(wstr, "1401 device driver communications failed (code %d)", nErr); - break; - - case U14ERR_OUTOFMEMORY: - sprintf(wstr, "Failed to allocate or lock memory for text from the 1401 (code %d)", nErr); - break; - - default: - sprintf(wstr, "1401 error code %d returned; this code is unknown", nErr); - break; - - } - if ((unsigned short)strlen(wstr) >= wMax-1) /* Check for string being too long */ - wstr[wMax-1] = 0; /* and truncate it if so */ - strcpy(pStr, wstr); /* Return the error string */ -} - -/*************************************************************************** -** U14GetTransfer -** Get a TGET_TX_BLOCK describing a transfer area (held in the block) -***************************************************************************/ -U14API(short) U14GetTransfer(short hand, TGET_TX_BLOCK *pTransBlock) -{ - short sErr = CheckHandle(hand); -#ifdef _IS_WINDOWS_ - if (sErr == U14ERR_NOERROR) - { - unsigned int dwBytes = 0; - BOOL bOK = DeviceIoControl(aHand1401[hand], (unsigned int)U14_GETTRANSFER, NULL, 0, pTransBlock, - sizeof(TGET_TX_BLOCK), &dwBytes, NULL); - - if (bOK && (dwBytes >= sizeof(TGET_TX_BLOCK))) - sErr = U14ERR_NOERROR; - else - sErr = U14ERR_DRIVCOMMS; - } - return sErr; -#endif -#ifdef LINUX - return (sErr == U14ERR_NOERROR) ? CED_GetTransfer(aHand1401[hand], pTransBlock) : sErr; -#endif -} -///////////////////////////////////////////////////////////////////////////// -// U14WorkingSet -// For Win32 only, adjusts process working set so that minimum is at least -// dwMinKb and maximum is at least dwMaxKb. -// Return value is zero if all went OK, or a code from 1 to 3 indicating the -// cause of the failure: -// -// 1 unable to access process (insufficient rights?) -// 2 unable to read process working set -// 3 unable to set process working set - bad parameters? -U14API(short) U14WorkingSet(unsigned int dwMinKb, unsigned int dwMaxKb) -{ -#ifdef _IS_WINDOWS_ - short sRetVal = 0; // 0 means all is OK - HANDLE hProcess; - unsigned int dwVer = GetVersion(); - if (dwVer & 0x80000000) // is this not NT? - return 0; // then give up right now - - // Now attempt to get information on working set size - hProcess = OpenProcess(STANDARD_RIGHTS_REQUIRED | - PROCESS_QUERY_INFORMATION | - PROCESS_SET_QUOTA, - FALSE, _getpid()); - if (hProcess) - { - SIZE_T dwMinSize,dwMaxSize; - if (GetProcessWorkingSetSize(hProcess, &dwMinSize, &dwMaxSize)) - { - unsigned int dwMin = dwMinKb << 10; // convert from kb to bytes - unsigned int dwMax = dwMaxKb << 10; - - // if we get here, we have managed to read the current size - if (dwMin > dwMinSize) // need to change sizes? - dwMinSize = dwMin; - - if (dwMax > dwMaxSize) - dwMaxSize = dwMax; - - if (!SetProcessWorkingSetSize(hProcess, dwMinSize, dwMaxSize)) - sRetVal = 3; // failed to change size - } - else - sRetVal = 2; // failed to read original size - - CloseHandle(hProcess); - } - else - sRetVal = 1; // failed to get handle - - return sRetVal; -#endif -#ifdef LINUX - if (dwMinKb | dwMaxKb) - { - // to stop compiler moaning - } - return U14ERR_NOERROR; -#endif -} - -/**************************************************************************** -** U14UnSetTransfer Cancels a transfer area -** wArea The index of a block previously used in by SetTransfer -*****************************************************************************/ -U14API(short) U14UnSetTransfer(short hand, unsigned short wArea) -{ - short sErr = CheckHandle(hand); -#ifdef _IS_WINDOWS_ - if (sErr == U14ERR_NOERROR) - { - TCSBLOCK csBlock; - csBlock.ints[0] = (short)wArea; /* Area number into control block */ - sErr = U14Control1401(hand, U14_UNSETTRANSFER, &csBlock); /* Free area */ - - VirtualUnlock(apAreas[hand][wArea], auAreas[hand][wArea]);/* Unlock */ - apAreas[hand][wArea] = NULL; /* Clear locations */ - auAreas[hand][wArea] = 0; - } - return sErr; -#endif -#ifdef LINUX - return (sErr == U14ERR_NOERROR) ? CED_UnsetTransfer(aHand1401[hand], wArea) : sErr; -#endif -} - -/**************************************************************************** -** U14SetTransArea Sets an area up to be used for transfers -** unsigned short wArea The area number to set up -** void *pvBuff The address of the buffer for the data. -** unsigned int dwLength The length of the buffer for the data -** short eSz The element size (used for byte swapping on the Mac) -****************************************************************************/ -U14API(short) U14SetTransArea(short hand, unsigned short wArea, void *pvBuff, - unsigned int dwLength, short eSz) -{ - struct transfer_area_desc td; - short sErr = CheckHandle(hand); - if (sErr != U14ERR_NOERROR) - return sErr; - if (wArea >= MAX_TRANSAREAS) // Is this a valid area number - return U14ERR_BADAREA; - -#ifdef _IS_WINDOWS_ - assert(apAreas[hand][wArea] == NULL); - assert(auAreas[hand][wArea] == 0); - - apAreas[hand][wArea] = pvBuff; /* Save data for later */ - auAreas[hand][wArea] = dwLength; - - if (!VirtualLock(pvBuff, dwLength)) /* Lock using WIN32 calls */ - { - apAreas[hand][wArea] = NULL; /* Clear locations */ - auAreas[hand][wArea] = 0; - return U14ERR_LOCKERR; /* VirtualLock failed */ - } -#ifndef _WIN64 - if (!USE_NT_DIOC(hand)) /* Use Win 9x DIOC? */ - { - unsigned int dwBytes; - VXTRANSFERDESC vxDesc; /* Structure to pass to VXD */ - vxDesc.wArea = wArea; /* Copy across simple params */ - vxDesc.dwLength = dwLength; - - // Check we are not asking an old driver for more than area 0 - if ((wArea != 0) && (U14DriverVersion(hand) < 0x00010002L)) - sErr = U14ERR_DRIVTOOOLD; - else - { - vxDesc.dwAddrOfs = (unsigned int)pvBuff; /* 32 bit offset */ - vxDesc.wAddrSel = 0; - - if (DeviceIoControl(aHand1401[hand], (unsigned int)U14_SETTRANSFER, - pvBuff,dwLength, /* Will translate pointer */ - &vxDesc,sizeof(VXTRANSFERDESC), - &dwBytes,NULL)) - { - if (dwBytes >= sizeof(VXTRANSFERDESC)) /* Driver OK ? */ - sErr = U14ERR_NOERROR; - else - sErr = U14ERR_DRIVCOMMS; /* Else never got there */ - } - else - sErr = (short)GetLastError(); - } - } - else -#endif - { - PARAMBLK rWork; - unsigned int dwBytes; - td.wArea = wArea; /* Pure NT - put data into struct */ - td.lpvBuff = pvBuff; - td.dwLength = dwLength; - td.eSize = 0; // Dummy element size - - if (DeviceIoControl(aHand1401[hand],(unsigned int)U14_SETTRANSFER, - &td,sizeof(struct transfer_area_desc), - &rWork,sizeof(PARAMBLK),&dwBytes,NULL)) - { - if (dwBytes >= sizeof(PARAMBLK)) // maybe error from driver? - sErr = rWork.sState; // will report any error - else - sErr = U14ERR_DRIVCOMMS; // Else never got there - } - else - sErr = U14ERR_DRIVCOMMS; - } - - if (sErr != U14ERR_NOERROR) - { - if (sErr != U14ERR_LOCKERR) // unless lock failed... - VirtualUnlock(pvBuff, dwLength); // ...release the lock - apAreas[hand][wArea] = NULL; // Clear locations - auAreas[hand][wArea] = 0; - } - - return sErr; -#endif -#ifdef LINUX - // The strange cast is so that it works in 64 and 32-bit linux as long is 64-bits - // in the 64 bit version. - td.lpvBuff = (long long)((unsigned long)pvBuff); - td.wAreaNum = wArea; - td.dwLength = dwLength; - td.eSize = eSz; // Dummy element size - return CED_SetTransfer(aHand1401[hand], &td); -#endif -} - -/**************************************************************************** -** U14SetTransferEvent Sets an event for notification of application -** wArea The transfer area index, from 0 to MAXAREAS-1 -** bEvent True to create an event, false to remove it -** bToHost Set 0 for notification on to1401 tranfers, 1 for -** notification of transfers to the host PC -** dwStart The offset of the sub-area of interest -** dwLength The size of the sub-area of interest -** -** The device driver will set the event supplied to the signalled state -** whenever a DMA transfer to/from the specified area is completed. The -** transfer has to be in the direction specified by bToHost, and overlap -** that part of the whole transfer area specified by dwStart and dwLength. -** It is important that this function is called with bEvent false to release -** the event once 1401 activity is finished. -** -** Returns 1 if an event handle exists, 0 if all OK and no event handle or -** a negative code for an error. -****************************************************************************/ -U14API(short) U14SetTransferEvent(short hand, unsigned short wArea, BOOL bEvent, - BOOL bToHost, unsigned int dwStart, unsigned int dwLength) -{ -#ifdef _IS_WINDOWS_ - TCSBLOCK csBlock; - short sErr = U14TransferFlags(hand); // see if we can handle events - if (sErr >= U14ERR_NOERROR) // check handle is OK - { - bEvent = bEvent && ((sErr & U14TF_NOTIFY) != 0); // remove request if we cannot do events - if (wArea >= MAX_TRANSAREAS) // Check a valid area... - return U14ERR_BADAREA; // ...and bail of not - - // We can hold an event for each area, so see if we need to change the - // state of the event. - if ((bEvent != 0) != (aXferEvent[hand] != 0)) // change of event state? - { - if (bEvent) // want one and none present - aXferEvent[hand] = CreateEvent(NULL, FALSE, FALSE, NULL); - else - { - CloseHandle(aXferEvent[hand]); // clear the existing event - aXferEvent[hand] = NULL; // and clear handle - } - } - - // We have to store the parameters differently for 64-bit operations - // because a handle is 64 bits long. The drivers know of this and - // handle the information appropriately. -#ifdef _WIN64 - csBlock.longs[0] = wArea; // Pass paramaters into the driver... - if (bToHost != 0) // The direction flag is held in the - csBlock.longs[0] |= 0x10000; // upper word of the transfer area value - *((HANDLE*)&csBlock.longs[1]) = aXferEvent[hand]; // The event handle is 64-bits - csBlock.longs[3] = dwStart; // Thankfully these two remain - csBlock.longs[4] = dwLength; // as unsigned 32-bit values -#else - csBlock.longs[0] = wArea; // pass paramaters into the driver... - csBlock.longs[1] = (long)aXferEvent[hand]; // ...especially the event handle - csBlock.longs[2] = bToHost; - csBlock.longs[3] = dwStart; - csBlock.longs[4] = dwLength; -#endif - sErr = U14Control1401(hand, U14_SETTRANSEVENT, &csBlock); - if (sErr == U14ERR_NOERROR) - sErr = (short)(aXferEvent[hand] != NULL); // report if we have a flag - } - - return sErr; -#endif -#ifdef LINUX - TRANSFEREVENT te; - short sErr = CheckHandle(hand); - if (sErr != U14ERR_NOERROR) - return sErr; - - if (wArea >= MAX_TRANSAREAS) // Is this a valid area number - return U14ERR_BADAREA; - - te.wAreaNum = wArea; // copy parameters to the control block - te.wFlags = bToHost ? 1 : 0; // bit 0 sets the direction - te.dwStart = dwStart; // start offset of the event area - te.dwLength = dwLength; // size of the event area - te.iSetEvent = bEvent; // in Windows, this creates/destroys the event - return CED_SetEvent(aHand1401[hand], &te); -#endif -} - -/**************************************************************************** -** U14TestTransferEvent -** Would a U14WaitTransferEvent() call return immediately? return 1 if so, -** 0 if not or a negative code if a problem. -****************************************************************************/ -U14API(int) U14TestTransferEvent(short hand, unsigned short wArea) -{ -#ifdef _IS_WINDOWS_ - int iErr = CheckHandle(hand); - if (iErr == U14ERR_NOERROR) - { - if (aXferEvent[hand]) // if a handle is set... - iErr = WaitForSingleObject(aXferEvent[hand], 0) == WAIT_OBJECT_0; - } - return iErr; -#endif -#ifdef LINUX - short sErr = CheckHandle(hand); - return (sErr == U14ERR_NOERROR) ? CED_TestEvent(aHand1401[hand], wArea) : sErr; -#endif -} - -/**************************************************************************** -** U14WaitTransferEvent -** Wait for a transfer event with a timeout. -** msTimeOut is 0 for an infinite wait, else it is the maximum time to wait -** in milliseconds in range 0-0x00ffffff. -** Returns If no event handle then return immediately. Else return 1 if -** timed out or 0=event, and a negative code if a problem. -****************************************************************************/ -U14API(int) U14WaitTransferEvent(short hand, unsigned short wArea, int msTimeOut) -{ -#ifdef _IS_WINDOWS_ - int iErr = CheckHandle(hand); - if (iErr == U14ERR_NOERROR) - { - if (aXferEvent[hand]) - { - if (msTimeOut == 0) - msTimeOut = INFINITE; - iErr = WaitForSingleObject(aXferEvent[hand], msTimeOut) != WAIT_OBJECT_0; - } - else - iErr = TRUE; // say we timed out if no event - } - return iErr; -#endif -#ifdef LINUX - short sErr = CheckHandle(hand); - return (sErr == U14ERR_NOERROR) ? CED_WaitEvent(aHand1401[hand], wArea, msTimeOut) : sErr; -#endif -} - -/**************************************************************************** -** U14SetCircular Sets an area up for circular DMA transfers -** unsigned short wArea The area number to set up -** BOOL bToHost Sets the direction of data transfer -** void *pvBuff The address of the buffer for the data -** unsigned int dwLength The length of the buffer for the data -****************************************************************************/ -U14API(short) U14SetCircular(short hand, unsigned short wArea, BOOL bToHost, - void *pvBuff, unsigned int dwLength) -{ - short sErr = CheckHandle(hand); - if (sErr != U14ERR_NOERROR) - return sErr; - - if (wArea >= MAX_TRANSAREAS) /* Is this a valid area number */ - return U14ERR_BADAREA; - - if (!bToHost) /* For now, support tohost transfers only */ - return U14ERR_BADAREA; /* best error code I can find */ -#ifdef _IS_WINDOWS_ - assert(apAreas[hand][wArea] == NULL); - assert(auAreas[hand][wArea] == 0); - - apAreas[hand][wArea] = pvBuff; /* Save data for later */ - auAreas[hand][wArea] = dwLength; - - if (!VirtualLock(pvBuff, dwLength)) /* Lock using WIN32 calls */ - sErr = U14ERR_LOCKERR; /* VirtualLock failed */ - else - { - PARAMBLK rWork; - unsigned int dwBytes; - struct transfer_area_desc txDesc; - txDesc.wArea = wArea; /* Pure NT - put data into struct */ - txDesc.lpvBuff = pvBuff; - txDesc.dwLength = dwLength; - txDesc.eSize = (short)bToHost; /* Use this for direction flag */ - - if (DeviceIoControl(aHand1401[hand],(unsigned int)U14_SETCIRCULAR, - &txDesc, sizeof(struct transfer_area_desc), - &rWork, sizeof(PARAMBLK),&dwBytes,NULL)) - { - if (dwBytes >= sizeof(PARAMBLK)) /* error from driver? */ - sErr = rWork.sState; /* No, just return driver data */ - else - sErr = U14ERR_DRIVCOMMS; /* Else never got there */ - } - else - sErr = U14ERR_DRIVCOMMS; - } - - if (sErr != U14ERR_NOERROR) - { - if (sErr != U14ERR_LOCKERR) - VirtualUnlock(pvBuff, dwLength); /* Release NT lock */ - apAreas[hand][wArea] = NULL; /* Clear locations */ - auAreas[hand][wArea] = 0; - } - - return sErr; -#endif -#ifdef LINUX - else - { - struct transfer_area_desc td; - td.lpvBuff = (long long)((unsigned long)pvBuff); - td.wAreaNum = wArea; - td.dwLength = dwLength; - td.eSize = (short)bToHost; /* Use this for direction flag */ - return CED_SetCircular(aHand1401[hand], &td); - } -#endif -} - -/**************************************************************************** -** Function GetCircBlk returns the size (& start offset) of the next -** available block of circular data. -****************************************************************************/ -U14API(int) U14GetCircBlk(short hand, unsigned short wArea, unsigned int *pdwOffs) -{ - int lErr = CheckHandle(hand); - if (lErr != U14ERR_NOERROR) - return lErr; - - if (wArea >= MAX_TRANSAREAS) // Is this a valid area number? - return U14ERR_BADAREA; - else - { -#ifdef _IS_WINDOWS_ - PARAMBLK rWork; - TCSBLOCK csBlock; - unsigned int dwBytes; - csBlock.longs[0] = wArea; // Area number into control block - rWork.sState = U14ERR_DRIVCOMMS; - if (DeviceIoControl(aHand1401[hand], (unsigned int)U14_GETCIRCBLK, &csBlock, sizeof(TCSBLOCK), &rWork, sizeof(PARAMBLK), &dwBytes, NULL) && - (dwBytes >= sizeof(PARAMBLK))) - lErr = rWork.sState; - else - lErr = U14ERR_DRIVCOMMS; - - if (lErr == U14ERR_NOERROR) // Did everything go OK? - { // Yes, we can pass the results back - lErr = rWork.csBlock.longs[1]; // Return the block information - *pdwOffs = rWork.csBlock.longs[0]; // Offset is first in array - } -#endif -#ifdef LINUX - TCIRCBLOCK cb; - cb.nArea = wArea; // Area number into control block - cb.dwOffset = 0; - cb.dwSize = 0; - lErr = CED_GetCircBlock(aHand1401[hand], &cb); - if (lErr == U14ERR_NOERROR) // Did everything go OK? - { // Yes, we can pass the results back - lErr = cb.dwSize; // return the size - *pdwOffs = cb.dwOffset; // and the offset - } -#endif - } - return lErr; -} - -/**************************************************************************** -** Function FreeCircBlk marks the specified area of memory as free for -** resuse for circular transfers and returns the size (& start -** offset) of the next available block of circular data. -****************************************************************************/ -U14API(int) U14FreeCircBlk(short hand, unsigned short wArea, unsigned int dwOffs, unsigned int dwSize, - unsigned int *pdwOffs) -{ - int lErr = CheckHandle(hand); - if (lErr != U14ERR_NOERROR) - return lErr; - - if (wArea < MAX_TRANSAREAS) // Is this a valid area number - { -#ifdef _IS_WINDOWS_ - PARAMBLK rWork; - TCSBLOCK csBlock; - unsigned int dwBytes; - csBlock.longs[0] = wArea; // Area number into control block - csBlock.longs[1] = dwOffs; - csBlock.longs[2] = dwSize; - rWork.sState = U14ERR_DRIVCOMMS; - if (DeviceIoControl(aHand1401[hand], (unsigned int)U14_FREECIRCBLK, &csBlock, sizeof(TCSBLOCK), - &rWork, sizeof(PARAMBLK), &dwBytes, NULL) && - (dwBytes >= sizeof(PARAMBLK))) - lErr = rWork.sState; - else - lErr = U14ERR_DRIVCOMMS; - if (lErr == U14ERR_NOERROR) // Did everything work OK? - { // Yes, we can pass the results back - lErr = rWork.csBlock.longs[1]; // Return the block information - *pdwOffs = rWork.csBlock.longs[0]; // Offset is first in array - } -#endif -#ifdef LINUX - TCIRCBLOCK cb; - cb.nArea = wArea; // Area number into control block - cb.dwOffset = dwOffs; - cb.dwSize = dwSize; - - lErr = CED_FreeCircBlock(aHand1401[hand], &cb); - if (lErr == U14ERR_NOERROR) // Did everything work OK? - { // Yes, we can pass the results back - lErr = cb.dwSize; // Return the block information - *pdwOffs = cb.dwOffset; // Offset is first in array - } -#endif - } - else - lErr = U14ERR_BADAREA; - - return lErr; -} - -/**************************************************************************** -** Transfer -** Transfer moves data to 1401 or to host -** Assumes memory is allocated and locked, -** which it should be to get a pointer -*****************************************************************************/ -static short Transfer(short hand, BOOL bTo1401, char* pData, - unsigned int dwSize, unsigned int dw1401, short eSz) -{ - char strcopy[MAXSTRLEN+1]; // to hold copy of work string - short sResult = U14SetTransArea(hand, 0, (void *)pData, dwSize, eSz); - if (sResult == U14ERR_NOERROR) // no error - { - sprintf(strcopy, // data offset is always 0 - "TO%s,$%X,$%X,0;", bTo1401 ? "1401" : "HOST", dw1401, dwSize); - - U14SendString(hand, strcopy); // send transfer string - - sResult = U14CheckErr(hand); // Use ERR command to check for done - if (sResult > 0) - sResult = U14ERR_TOXXXERR; // If a 1401 error, use this code - - U14UnSetTransfer(hand, 0); - } - return sResult; -} - -/**************************************************************************** -** Function ToHost transfers data into the host from the 1401 -****************************************************************************/ -U14API(short) U14ToHost(short hand, char* pAddrHost, unsigned int dwSize, - unsigned int dw1401, short eSz) -{ - short sErr = CheckHandle(hand); - if ((sErr == U14ERR_NOERROR) && dwSize) // TOHOST is a constant - sErr = Transfer(hand, TOHOST, pAddrHost, dwSize, dw1401, eSz); - return sErr; -} - -/**************************************************************************** -** Function To1401 transfers data into the 1401 from the host -****************************************************************************/ -U14API(short) U14To1401(short hand, const char* pAddrHost,unsigned int dwSize, - unsigned int dw1401, short eSz) -{ - short sErr = CheckHandle(hand); - if ((sErr == U14ERR_NOERROR) && dwSize) // TO1401 is a constant - sErr = Transfer(hand, TO1401, (char*)pAddrHost, dwSize, dw1401, eSz); - return sErr; -} - -/**************************************************************************** -** Function LdCmd Loads a command from a full path or just a file -*****************************************************************************/ -#ifdef _IS_WINDOWS_ -#define file_exist(name) (_access(name, 0) != -1) -#define file_open(name) _lopen(name, OF_READ) -#define file_close(h) _lclose(h) -#define file_seek(h, pos) _llseek(h, pos, FILE_BEGIN) -#define file_read(h, buffer, size) (_lread(h, buffer, size) == size) -#endif -#ifdef LINUX -#define file_exist(name) (access(name, F_OK) != -1) -#define file_open(name) open(name, O_RDONLY) -#define file_close(h) close(h) -#define file_seek(h, pos) lseek(h, pos, SEEK_SET) -#define file_read(h, buffer, size) (read(h, buffer, size) == (ssize_t)size) -static unsigned int GetModuleFileName(void* dummy, char* buffer, int max) -{ - // The following works for Linux systems with a /proc file system. - char szProcPath[32]; - sprintf(szProcPath, "/proc/%d/exe", getpid()); // attempt to read link - if (readlink(szProcPath, buffer, max) != -1) - { - dirname (buffer); - strcat (buffer, "/"); - return strlen(buffer); - } - return 0; -} -#endif - -U14API(short) U14LdCmd(short hand, const char* command) -{ - char strcopy[MAXSTRLEN+1]; // to hold copy of work string - BOOL bGotIt = FALSE; // have we found the command file? - int iFHandle; // file handle of command -#define FNSZ 260 - char filnam[FNSZ]; // space to build name in - char szCmd[25]; // just the command name with extension - - short sErr = CheckHandle(hand); - if (sErr != U14ERR_NOERROR) - return sErr; - - if (strchr(command, '.') != NULL) // see if we have full name - { - if (file_exist(command)) // If the file exists - { - strcpy(filnam, command); // use name as is - bGotIt = TRUE; // Flag no more searching - } - else // not found, get file name for search - { - char* pStr = strrchr(command, PATHSEP); // Point to last separator - if (pStr != NULL) // Check we got it - { - pStr++; // move past the backslash - strcpy(szCmd, pStr); // copy file name as is - } - else - strcpy(szCmd, command); // use as is - } - } - else // File extension not supplied, so build the command file name - { - char szExt[8]; - strcpy(szCmd, command); // Build command file name - ExtForType(asType1401[hand], szExt);// File extension string - strcat(szCmd, szExt); // add it to the end - } - - // Next place to look is in the 1401 folder in the same place as the - // application was run from. - if (!bGotIt) // Still not got it? - { - unsigned int dwLen = GetModuleFileName(NULL, filnam, FNSZ); // Get app path - if (dwLen > 0) // and use it as path if found - { - char* pStr = strrchr(filnam, PATHSEP); // Point to last separator - if (pStr != NULL) - { - *(++pStr) = 0; // Terminate string there - if (strlen(filnam) < FNSZ-6) // make sure we have space - { - strcat(filnam, "1401" PATHSEPSTR); // add in 1401 subdir - strcat(filnam,szCmd); - bGotIt = (BOOL)file_exist(filnam); // See if file exists - } - } - } - } - - // Next place to look is in whatever path is set by the 1401DIR environment - // variable, if it exists. - if (!bGotIt) // Need to do more searches?/ - { - char* pStr = getenv("1401DIR"); // Try to find environment var - if (pStr != NULL) // and use it as path if found - { - strcpy(filnam, pStr); // Use path in environment - if (filnam[strlen(filnam)-1] != PATHSEP)// We need separator - strcat(filnam, PATHSEPSTR); - strcat(filnam, szCmd); - bGotIt = (BOOL)file_exist(filnam); // Got this one? - } - } - - // Last place to look is the default location. - if (!bGotIt) // Need to do more searches? - { - strcpy(filnam, DEFCMDPATH); // Use default path - strcat(filnam, szCmd); - bGotIt = file_exist(filnam); // Got this one? - } - - iFHandle = file_open(filnam); - if (iFHandle == -1) - sErr = U14ERR_NOFILE; - else - { // first read in the header block - CMDHEAD rCmdHead; // to hold the command header - if (file_read(iFHandle, &rCmdHead, sizeof(CMDHEAD))) - { - size_t nComSize = rCmdHead.wCmdSize; - char* pMem = malloc(nComSize); - if (pMem != NULL) - { - file_seek(iFHandle, sizeof(CMDHEAD)); - if (file_read(iFHandle, pMem, (UINT)nComSize)) - { - sErr = U14SetTransArea(hand, 0, (void *)pMem, (unsigned int)nComSize, ESZBYTES); - if (sErr == U14ERR_NOERROR) - { - sprintf(strcopy, "CLOAD,0,$%X;", (int)nComSize); - sErr = U14SendString(hand, strcopy); - if (sErr == U14ERR_NOERROR) - { - sErr = U14CheckErr(hand); // Use ERR to check for done - if (sErr > 0) - sErr = U14ERR_CLOADERR; // If an error, this code - } - U14UnSetTransfer(hand, 0); // release transfer area - } - } - else - sErr = U14ERR_READERR; - free(pMem); - } - else - sErr = U14ERR_HOSTSPACE; // memory allocate failed - } - else - sErr = U14ERR_READERR; - - file_close(iFHandle); // close the file - } - - return sErr; -} - - -/**************************************************************************** -** Ld -** Loads a command into the 1401 -** Returns NOERROR code or a long with error in lo word and index of -** command that failed in high word -****************************************************************************/ -U14API(unsigned int) U14Ld(short hand, const char* vl, const char* str) -{ - unsigned int dwIndex = 0; // index to current command - long lErr = U14ERR_NOERROR; // what the error was that went wrong - char strcopy[MAXSTRLEN+1]; // stores unmodified str parameter - char szFExt[8]; // The command file extension - short sErr = CheckHandle(hand); - if (sErr != U14ERR_NOERROR) - return sErr; - - ExtForType(asType1401[hand], szFExt); // File extension string - strcpy(strcopy, str); // to avoid changing original - - // now break out one command at a time and see if loaded - if (*str) // if anything there - { - BOOL bDone = FALSE; // true when finished all commands - int iLoop1 = 0; // Point at start of string for command name - int iLoop2 = 0; // and at start of str parameter - do // repeat until end of str - { - char filnam[MAXSTRLEN+1]; // filename to use - char szFName[MAXSTRLEN+1]; // filename work string - - if (!strcopy[iLoop1]) // at the end of the string? - bDone = TRUE; // set the finish flag - - if (bDone || (strcopy[iLoop1] == ',')) // end of cmd? - { - U14LONG er[5]; // Used to read back error results - ++dwIndex; // Keep count of command number, first is 1 - szFName[iLoop2]=(char)0; // null terminate name of command - - strncpy(szLastName, szFName, sizeof(szLastName)); // Save for error info - szLastName[sizeof(szLastName)-1] = 0; - strncat(szLastName, szFExt, sizeof(szLastName)); // with extension included - szLastName[sizeof(szLastName)-1] = 0; - - U14SendString(hand, szFName); // ask if loaded - U14SendString(hand, ";ERR;"); // add err return - - lErr = U14LongsFrom1401(hand, er, 5); - if (lErr > 0) - { - lErr = U14ERR_NOERROR; - if (er[0] == 255) // if command not loaded at all - { - if (vl && *vl) // if we have a path name - { - strcpy(filnam, vl); - if (strchr("\\/:", filnam[strlen(filnam)-1]) == NULL) - strcat(filnam, PATHSEPSTR); // add separator if none found - strcat(filnam, szFName); // add the file name - strcat(filnam, szFExt); // and extension - } - else - strcpy(filnam, szFName); // simple name - - lErr = U14LdCmd(hand, filnam); // load cmd - if (lErr != U14ERR_NOERROR) // spot any errors - bDone = TRUE; // give up if an error - } - } - else - bDone = TRUE; // give up if an error - - iLoop2 = 0; // Reset pointer to command name string - ++iLoop1; // and move on through str parameter - } - else - szFName[iLoop2++] = strcopy[iLoop1++]; // no command end, so copy 1 char - } - while (!bDone); - } - - if (lErr == U14ERR_NOERROR) - { - szLastName[0] = 0; // No error, so clean out command name here - return lErr; - } - else - return ((dwIndex<<16) | ((unsigned int)lErr & 0x0000FFFF)); -} - -// Initialise the library (if not initialised) and return the library version -U14API(int) U14InitLib(void) -{ - int iRetVal = U14LIB_VERSION; - if (iAttached == 0) // only do this the first time please - { - int i; -#ifdef _IS_WINDOWS_ - int j; - unsigned int dwVersion = GetVersion(); - bWindows9x = FALSE; // Assume not Win9x - - if (dwVersion & 0x80000000) // if not windows NT - { - if ((LOBYTE(LOWORD(dwVersion)) < 4) && // if Win32s or... - (HIBYTE(LOWORD(dwVersion)) < 95)) // ...below Windows 95 - iRetVal = 0; // We do not support this - else - bWindows9x = TRUE; // Flag we have Win9x - } -#endif - - for (i = 0; i < MAX1401; i++) // initialise the device area - { - aHand1401[i] = INVALID_HANDLE_VALUE; // Clear handle values - asType1401[i] = U14TYPEUNKNOWN; // and 1401 type codes - alTimeOutPeriod[i] = 3000; // 3 second timeouts -#ifdef _IS_WINDOWS_ -#ifndef _WIN64 - abUseNTDIOC[i] = (BOOL)!bWindows9x; -#endif - aXferEvent[i] = NULL; // there are no Xfer events - for (j = 0; j < MAX_TRANSAREAS; j++) // Clear out locked area info - { - apAreas[i][j] = NULL; - auAreas[i][j] = 0; - } -#endif - } - } - return iRetVal; -} - -///-------------------------------------------------------------------------------- -/// Functions called when the library is loaded and unloaded to give us a chance to -/// setup the library. - - -#ifdef _IS_WINDOWS_ -#ifndef U14_NOT_DLL -/**************************************************************************** -** FUNCTION: DllMain(HANDLE, unsigned int, LPVOID) -** LibMain is called by Windows when the DLL is initialized, Thread Attached, -** and other times. Refer to SDK documentation, as to the different ways this -** may be called. -****************************************************************************/ -INT APIENTRY DllMain(HANDLE hInst, unsigned int ul_reason_being_called, LPVOID lpReserved) -{ - int iRetVal = 1; - - switch (ul_reason_being_called) - { - case DLL_PROCESS_ATTACH: - iRetVal = U14InitLib() > 0; // does nothing if iAttached != 0 - ++iAttached; // count times attached - break; - - case DLL_PROCESS_DETACH: - if (--iAttached == 0) // last man out? - U14CloseAll(); // release all open handles - break; - } - return iRetVal; - - UNREFERENCED_PARAMETER(lpReserved); -} -#endif -#endif -#ifdef LINUX -void __attribute__((constructor)) use1401_load(void) -{ - U14InitLib(); - ++iAttached; -} - -void __attribute__((destructor)) use1401_unload(void) -{ - if (--iAttached == 0) // last man out? - U14CloseAll(); // release all open handles -} -#endif |
