Esempio n. 1
0
        internal int setupAsync(TransferContext transferContext)
        {
            int ret = -1;

            lock (oLockTransferContext)
            {
                transferContext.Reset();
                switch (mEpType)
                {
                case EndpointTypes.Bulk:
                    ret = LibUsbAPI.usb_bulk_setup_async(mUsbDevice.Handle, ref transferContext.mContext, EpNum);
                    break;

                case EndpointTypes.Interrupt:
                    ret = LibUsbAPI.usb_interrupt_setup_async(mUsbDevice.Handle, ref transferContext.mContext, EpNum);
                    break;

                case EndpointTypes.Isochronous:
                    ret = LibUsbAPI.usb_isochronous_setup_async(mUsbDevice.Handle, ref transferContext.mContext, EpNum, mPacketSize);
                    break;
                }
                if (ret < 0 || !transferContext.mContext.IsValid)
                {
                    UsbGlobals.Error(this, UsbGlobals.LastError, "setupAsync", ret);
                }

                return(ret);
            }
        }
Esempio n. 2
0
        private void ReadData(object obj)
        {
            int               ret             = 0;
            TransferContext   transferContext = (TransferContext)obj;
            UsbEndpointReader reader          = (UsbEndpointReader)transferContext.mEndpointBase;

            reader.mDataReceivedEnabled = true;

            try
            {
                while (ret >= 0 && !reader.mEventCancelReadThread.WaitOne(0, false))
                {
                    lock (oLockTransferContext)
                        transferContext.Reset();

                    ret = setupAsync(transferContext);

                    if (ret >= 0)
                    {
                        bool bContinue = true;
                        while (bContinue)
                        {
                            ret = submitAsync(transferContext);
                            if (ret >= 0)
                            {
ReapRetry:
                                ret = reapAsyncNoCancel(transferContext);

                                if (ret < 0)
                                {
                                    if (ret == (int)ErrorCodes.ETIMEDOUT)
                                    {
                                        if (!transferContext.mbAsyncCancelled && !reader.mEventCancelReadThread.WaitOne(0, false))
                                        {
                                            goto ReapRetry;
                                        }
                                        else
                                        {
                                            ret = (int)ErrorCodes.EINTR;
                                        }
                                    }
                                }
                            }

                            lock (oLockTransferContext)
                                bContinue = ((transferContext.mCurrentRemaining > 0) && (ret == transferContext.mRequested));
                        }

                        freeAsync(transferContext);
                    }

                    if (ret >= 0)
                    {
                        EventHandler <DataReceivedArgs> temp = reader.DataReceived;
                        if (temp != null)
                        {
                            temp(this, new DataReceivedArgs(transferContext.Buffer, transferContext.currentTransmitted));
                        }
                    }
                }
            }
            catch (ThreadAbortException)
            {
                Debug.Print("ThreadAbortException:" + GetType().FullName + ".ReadData");
            }
            finally
            {
                if (transferContext.mContext.IsValid)
                {
                    freeAsync(transferContext);
                }

                reader.mDataReceivedEnabled = false;
                reader.TransferLock.Release();
            }
        }