1600 lines
38 KiB
C
1600 lines
38 KiB
C
/* Copyright (c) 20XX 9front
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
/* Future Technology Devices International serial ports */
|
|
#include <u.h>
|
|
#include <lib9.h>
|
|
#include <thread.h>
|
|
#include <9P2000.h>
|
|
#include <9p.h>
|
|
#include "usb.h"
|
|
#include "serial.h"
|
|
|
|
enum {
|
|
/* used by devices which don't provide their own Vid */
|
|
FTVid = 0x0403,
|
|
|
|
FTSheevaVid = 0x9E88,
|
|
FTSheevaDid = 0x9E8F,
|
|
FTOpenRDUltDid = 0x9E90,
|
|
|
|
FTSIODid = 0x8372, /* Product Id SIO appl'n of 8U100AX */
|
|
FT8U232AMDid = 0x6001, /* Similar device to SIO above */
|
|
FT8U232AMALTDid = 0x6006, /* FT's alternate Did for above*/
|
|
FT8U2232CDid = 0x6010, /* Dual channel device */
|
|
FTRELAISDid = 0xFA10, /* Relais device */
|
|
|
|
/* NF reader */
|
|
FTNFRICVid = 0x0DCD,
|
|
FTNFRICDid = 0x0001,
|
|
|
|
FTACTZWAVEDid = 0xF2D0, /* www.irtrans.de device */
|
|
|
|
/*
|
|
* ACT Solutions HomePro ZWave interface
|
|
* http://www.act-solutions.com/HomePro.htm)
|
|
*/
|
|
FTIRTRANSDid = 0xFC60,
|
|
|
|
/*
|
|
* www.thoughttechnology.com/ TT-USB
|
|
*/
|
|
FTTTUSBDid = 0xFF20,
|
|
|
|
/* iPlus device */
|
|
FTIPLUSDid = 0xD070,
|
|
|
|
/* www.crystalfontz.com devices */
|
|
FTXF632Did = 0xFC08, /* 632: 16x2 Character Display */
|
|
FTXF634Did = 0xFC09, /* 634: 20x4 Character Display */
|
|
FTXF547Did = 0xFC0A, /* 547: Two line Display */
|
|
FTXF633Did = 0xFC0B, /* 633: 16x2 Character Display with Keys */
|
|
FTXF631Did = 0xFC0C, /* 631: 20x2 Character Display */
|
|
FTXF635Did = 0xFC0D, /* 635: 20x4 Character Display */
|
|
FTXF640Did = 0xFC0E, /* 640: Two line Display */
|
|
FTXF642Did = 0xFC0F, /* 642: Two line Display */
|
|
|
|
/*
|
|
* Video Networks Limited / Homechoice in the UK
|
|
* use an ftdi-based device for their 1Mb broadband
|
|
*/
|
|
FTVNHCPCUSBDDid = 0xfe38,
|
|
|
|
/*
|
|
* PCDJ use ftdi based dj-controllers
|
|
* DAC-2 device http://www.pcdjhardware.com/DAC2.asp
|
|
*/
|
|
FTPCDJDAC2Did = 0xFA88,
|
|
|
|
/*
|
|
* Matrix Orbital LCD displays,
|
|
* which are the FT232BM (similar to the 8U232AM)
|
|
*/
|
|
FTMTXORB0Did = 0xFA00,
|
|
FTMTXORB1Did = 0xFA01,
|
|
FTMTXORB2Did = 0xFA02,
|
|
FTMTXORB3Did = 0xFA03,
|
|
FTMTXORB4Did = 0xFA04,
|
|
FTMTXORB5Did = 0xFA05,
|
|
FTMTXORB6Did = 0xFA06,
|
|
|
|
/* Interbiometrics USB I/O Board */
|
|
INTERBIOMVid = 0x1209,
|
|
INTERBIOMIOBRDDid = 0x1002,
|
|
INTERBIOMMINIIOBRDDid = 0x1006,
|
|
|
|
/*
|
|
* The following are the values for the Perle Systems
|
|
* UltraPort USB serial converters
|
|
*/
|
|
FTPERLEULTRAPORTDid = 0xF0C0,
|
|
|
|
/*
|
|
* Sealevel SeaLINK+ adapters.
|
|
*/
|
|
|
|
SEALEVELVid = 0x0c52,
|
|
|
|
SEALEVEL2101Did = 0x2101, /* SeaLINK+232 (2101/2105) */
|
|
SEALEVEL2102Did = 0x2102, /* SeaLINK+485 (2102) */
|
|
SEALEVEL2103Did = 0x2103, /* SeaLINK+232I (2103) */
|
|
SEALEVEL2104Did = 0x2104, /* SeaLINK+485I (2104) */
|
|
SEALEVEL22011Did = 0x2211, /* SeaPORT+2/232 (2201) Port 1 */
|
|
SEALEVEL22012Did = 0x2221, /* SeaPORT+2/232 (2201) Port 2 */
|
|
SEALEVEL22021Did = 0x2212, /* SeaPORT+2/485 (2202) Port 1 */
|
|
SEALEVEL22022Did = 0x2222, /* SeaPORT+2/485 (2202) Port 2 */
|
|
SEALEVEL22031Did = 0x2213, /* SeaPORT+2 (2203) Port 1 */
|
|
SEALEVEL22032Did = 0x2223, /* SeaPORT+2 (2203) Port 2 */
|
|
SEALEVEL24011Did = 0x2411, /* SeaPORT+4/232 (2401) Port 1 */
|
|
SEALEVEL24012Did = 0x2421, /* SeaPORT+4/232 (2401) Port 2 */
|
|
SEALEVEL24013Did = 0x2431, /* SeaPORT+4/232 (2401) Port 3 */
|
|
SEALEVEL24014Did = 0x2441, /* SeaPORT+4/232 (2401) Port 4 */
|
|
SEALEVEL24021Did = 0x2412, /* SeaPORT+4/485 (2402) Port 1 */
|
|
SEALEVEL24022Did = 0x2422, /* SeaPORT+4/485 (2402) Port 2 */
|
|
SEALEVEL24023Did = 0x2432, /* SeaPORT+4/485 (2402) Port 3 */
|
|
SEALEVEL24024Did = 0x2442, /* SeaPORT+4/485 (2402) Port 4 */
|
|
SEALEVEL24031Did = 0x2413, /* SeaPORT+4 (2403) Port 1 */
|
|
SEALEVEL24032Did = 0x2423, /* SeaPORT+4 (2403) Port 2 */
|
|
SEALEVEL24033Did = 0x2433, /* SeaPORT+4 (2403) Port 3 */
|
|
SEALEVEL24034Did = 0x2443, /* SeaPORT+4 (2403) Port 4 */
|
|
SEALEVEL28011Did = 0x2811, /* SeaLINK+8/232 (2801) Port 1 */
|
|
SEALEVEL28012Did = 0x2821, /* SeaLINK+8/232 (2801) Port 2 */
|
|
SEALEVEL28013Did = 0x2831, /* SeaLINK+8/232 (2801) Port 3 */
|
|
SEALEVEL28014Did = 0x2841, /* SeaLINK+8/232 (2801) Port 4 */
|
|
SEALEVEL28015Did = 0x2851, /* SeaLINK+8/232 (2801) Port 5 */
|
|
SEALEVEL28016Did = 0x2861, /* SeaLINK+8/232 (2801) Port 6 */
|
|
SEALEVEL28017Did = 0x2871, /* SeaLINK+8/232 (2801) Port 7 */
|
|
SEALEVEL28018Did = 0x2881, /* SeaLINK+8/232 (2801) Port 8 */
|
|
SEALEVEL28021Did = 0x2812, /* SeaLINK+8/485 (2802) Port 1 */
|
|
SEALEVEL28022Did = 0x2822, /* SeaLINK+8/485 (2802) Port 2 */
|
|
SEALEVEL28023Did = 0x2832, /* SeaLINK+8/485 (2802) Port 3 */
|
|
SEALEVEL28024Did = 0x2842, /* SeaLINK+8/485 (2802) Port 4 */
|
|
SEALEVEL28025Did = 0x2852, /* SeaLINK+8/485 (2802) Port 5 */
|
|
SEALEVEL28026Did = 0x2862, /* SeaLINK+8/485 (2802) Port 6 */
|
|
SEALEVEL28027Did = 0x2872, /* SeaLINK+8/485 (2802) Port 7 */
|
|
SEALEVEL28028Did = 0x2882, /* SeaLINK+8/485 (2802) Port 8 */
|
|
SEALEVEL28031Did = 0x2813, /* SeaLINK+8 (2803) Port 1 */
|
|
SEALEVEL28032Did = 0x2823, /* SeaLINK+8 (2803) Port 2 */
|
|
SEALEVEL28033Did = 0x2833, /* SeaLINK+8 (2803) Port 3 */
|
|
SEALEVEL28034Did = 0x2843, /* SeaLINK+8 (2803) Port 4 */
|
|
SEALEVEL28035Did = 0x2853, /* SeaLINK+8 (2803) Port 5 */
|
|
SEALEVEL28036Did = 0x2863, /* SeaLINK+8 (2803) Port 6 */
|
|
SEALEVEL28037Did = 0x2873, /* SeaLINK+8 (2803) Port 7 */
|
|
SEALEVEL28038Did = 0x2883, /* SeaLINK+8 (2803) Port 8 */
|
|
|
|
/* KOBIL Vendor ID chipcard terminals */
|
|
KOBILVid = 0x0d46,
|
|
KOBILCONVB1Did = 0x2020, /* KOBIL Konverter for B1 */
|
|
KOBILCONVKAANDid = 0x2021, /* KOBILKonverter for KAAN */
|
|
|
|
/* Icom ID-1 digital transceiver */
|
|
ICOMID1Vid = 0x0C26,
|
|
ICOMID1Did = 0x0004,
|
|
|
|
FTASKRDR400Did = 0xC991, /* ASK RDR 400 series card reader */
|
|
FTDSS20Did = 0xFC82, /* DSS-20 Sync Station for Sony Ericsson P800 */
|
|
|
|
/*
|
|
* Home Electronics (www.home-electro.com) USB gadgets
|
|
*/
|
|
FTHETIRA1Did = 0xFA78, /* Tira-1 IR transceiver */
|
|
|
|
/*
|
|
* An infrared receiver and transmitter using the 8U232AM chip
|
|
* http://www.usbuirt.com
|
|
*/
|
|
FTUSBUIRTDid = 0xF850,
|
|
|
|
FTELVUR100Did = 0xFB58, /* USB-RS232-Umsetzer (UR 100) */
|
|
FTELVUM100Did = 0xFB5A, /* USB-Modul UM 100 */
|
|
FTELVUO100Did = 0xFB5B, /* USB-Modul UO 100 */
|
|
FTELVALC8500Did = 0xF06E, /* ALC 8500 Expert */
|
|
FTELVCLI7000Did = 0xFB59, /* Computer-Light-Interface */
|
|
FTELVPPS7330Did = 0xFB5C, /* Processor-Power-Supply (PPS 7330) */
|
|
FTELVTFM100Did = 0xFB5D, /* Temperartur-Feuchte Messgeraet (TFM 100) */
|
|
FTELVUDF77Did = 0xFB5E, /* USB DCF Funkurh (UDF 77) */
|
|
FTELVUIO88Did = 0xFB5F, /* USB-I/O Interface (UIO 88) */
|
|
FTELVUAD8Did = 0xF068, /* USB-AD-Wandler (UAD 8) */
|
|
FTELVUDA7Did = 0xF069, /* USB-DA-Wandler (UDA 7) */
|
|
FTELVUSI2Did = 0xF06A, /* USB-Schrittmotoren-Interface (USI 2) */
|
|
FTELVT1100Did = 0xF06B, /* Thermometer (T 1100) */
|
|
FTELVPCD200Did = 0xF06C, /* PC-Datenlogger (PCD 200) */
|
|
FTELVULA200Did = 0xF06D, /* USB-LCD-Ansteuerung (ULA 200) */
|
|
FTELVFHZ1000PCDid= 0xF06F, /* FHZ 1000 PC */
|
|
FTELVCSI8Did = 0xE0F0, /* Computer-Schalt-Interface (CSI 8) */
|
|
FTELVEM1000DLDid= 0xE0F1, /* PC-Datenlogger fuer Energiemonitor (EM 1000 DL) */
|
|
FTELVPCK100Did = 0xE0F2, /* PC-Kabeltester (PCK 100) */
|
|
FTELVRFP500Did = 0xE0F3, /* HF-Leistungsmesser (RFP 500) */
|
|
FTELVFS20SIGDid = 0xE0F4, /* Signalgeber (FS 20 SIG) */
|
|
FTELVWS300PCDid = 0xE0F6, /* PC-Wetterstation (WS 300 PC) */
|
|
FTELVFHZ1300PCDid= 0xE0E8, /* FHZ 1300 PC */
|
|
FTELVWS500Did = 0xE0E9, /* PC-Wetterstation (WS 500) */
|
|
|
|
/*
|
|
* Definitions for ID TECH (http://www.idt-net.com) devices
|
|
*/
|
|
IDTECHVid = 0x0ACD, /* ID TECH Vendor ID */
|
|
IDTECHIDT1221UDid= 0x0300, /* IDT1221U USB to RS-232 */
|
|
|
|
/*
|
|
* Definitions for Omnidirectional Control Technology, Inc. devices
|
|
*/
|
|
OCTVid = 0x0B39, /* OCT vendor ID */
|
|
|
|
/*
|
|
* Note: OCT US101 is also rebadged as Dick Smith Electronics
|
|
* (NZ) XH6381, Dick Smith Electronics (Aus) XH6451, and SIIG
|
|
* Inc. model US2308 hardware version 1.
|
|
*/
|
|
OCTUS101Did = 0x0421, /* OCT US101 USB to RS-232 */
|
|
|
|
/*
|
|
* infrared receiver for access control with IR tags
|
|
*/
|
|
FTPIEGROUPDid = 0xF208,
|
|
|
|
/*
|
|
* Definitions for Artemis astronomical USB based cameras
|
|
* http://www.artemisccd.co.uk/
|
|
*/
|
|
|
|
FTARTEMISDid = 0xDF28, /* All Artemis Cameras */
|
|
|
|
FTATIKATK16Did = 0xDF30, /* ATIK ATK-16 Grayscale Camera */
|
|
FTATIKATK16CDid = 0xDF32, /* ATIK ATK-16C Colour Camera */
|
|
FTATIKATK16HRDid= 0xDF31, /* ATIK ATK-16HR Grayscale */
|
|
FTATIKATK16HRCDid= 0xDF33, /* ATIK ATK-16HRC Colour Camera */
|
|
|
|
/*
|
|
* Protego products
|
|
*/
|
|
PROTEGOSPECIAL1 = 0xFC70, /* special/unknown device */
|
|
PROTEGOR2X0 = 0xFC71, /* R200-USB TRNG unit (R210, R220, and R230) */
|
|
PROTEGOSPECIAL3 = 0xFC72, /* special/unknown device */
|
|
PROTEGOSPECIAL4 = 0xFC73, /* special/unknown device */
|
|
|
|
/*
|
|
* Gude Analog- und Digitalsysteme GmbH
|
|
*/
|
|
FTGUDEADSE808Did = 0xE808,
|
|
FTGUDEADSE809Did = 0xE809,
|
|
FTGUDEADSE80ADid = 0xE80A,
|
|
FTGUDEADSE80BDid = 0xE80B,
|
|
FTGUDEADSE80CDid = 0xE80C,
|
|
FTGUDEADSE80DDid = 0xE80D,
|
|
FTGUDEADSE80EDid = 0xE80E,
|
|
FTGUDEADSE80FDid = 0xE80F,
|
|
FTGUDEADSE888Did = 0xE888, /* Expert ISDN Control USB */
|
|
FTGUDEADSE889Did = 0xE889, /* USB RS-232 OptoBridge */
|
|
FTGUDEADSE88ADid = 0xE88A,
|
|
FTGUDEADSE88BDid = 0xE88B,
|
|
FTGUDEADSE88CDid = 0xE88C,
|
|
FTGUDEADSE88DDid = 0xE88D,
|
|
FTGUDEADSE88EDid = 0xE88E,
|
|
FTGUDEADSE88FDid = 0xE88F,
|
|
|
|
/*
|
|
* Linx Technologies
|
|
*/
|
|
LINXSDMUSBQSSDid= 0xF448, /* Linx SDM-USB-QS-S */
|
|
LINXMASTERDEVEL2Did= 0xF449, /* Linx Master Development.0 */
|
|
LINXFUTURE0Did = 0xF44A, /* Linx future device */
|
|
LINXFUTURE1Did = 0xF44B, /* Linx future device */
|
|
LINXFUTURE2Did = 0xF44C, /* Linx future device */
|
|
|
|
/*
|
|
* CCS Inc. ICDU/ICDU40 - the FT232BM used in a in-circuit-debugger
|
|
* unit for PIC16's/PIC18's
|
|
*/
|
|
FTCCSICDU200Did = 0xF9D0,
|
|
FTCCSICDU401Did = 0xF9D1,
|
|
|
|
/* Inside Accesso contactless reader (http://www.insidefr.com) */
|
|
INSIDEACCESSO = 0xFAD0,
|
|
|
|
/*
|
|
* Intrepid Control Systems (http://www.intrepidcs.com/)
|
|
* ValueCAN and NeoVI
|
|
*/
|
|
INTREDidVid = 0x093C,
|
|
INTREDidVALUECANDid= 0x0601,
|
|
INTREDidNEOVIDid= 0x0701,
|
|
|
|
/*
|
|
* Falcom Wireless Communications GmbH
|
|
*/
|
|
FALCOMVid = 0x0F94,
|
|
FALCOMTWISTDid = 0x0001, /* Falcom Twist USB GPRS modem */
|
|
FALCOMSAMBADid = 0x0005, /* Falcom Samba USB GPRS modem */
|
|
|
|
/*
|
|
* SUUNTO
|
|
*/
|
|
FTSUUNTOSPORTSDid= 0xF680, /* Suunto Sports instrument */
|
|
|
|
/*
|
|
* B&B Electronics
|
|
*/
|
|
BANDBVid = 0x0856, /* B&B Electronics Vendor ID */
|
|
BANDBUSOTL4Did = 0xAC01, /* USOTL4 Isolated RS-485 */
|
|
BANDBUSTL4Did = 0xAC02, /* USTL4 RS-485 Converter */
|
|
BANDBUSO9ML2Did = 0xAC03, /* USO9ML2 Isolated RS-232 */
|
|
|
|
/*
|
|
* RM Michaelides CANview USB (http://www.rmcan.com)
|
|
* CAN fieldbus interface adapter
|
|
*/
|
|
FTRMCANVIEWDid = 0xfd60,
|
|
|
|
/*
|
|
* EVER Eco Pro UPS (http://www.ever.com.pl/)
|
|
*/
|
|
EVERECOPROCDSDid = 0xe520, /* RS-232 converter */
|
|
|
|
/*
|
|
* 4N-GALAXY.DE PIDs for CAN-USB, USB-RS232, USB-RS422, USB-RS485,
|
|
* USB-TTY activ, USB-TTY passiv. Some PIDs are used by several devices
|
|
*/
|
|
FT4NGALAXYDE0Did = 0x8372,
|
|
FT4NGALAXYDE1Did = 0xF3C0,
|
|
FT4NGALAXYDE2Did = 0xF3C1,
|
|
|
|
/*
|
|
* Mobility Electronics products.
|
|
*/
|
|
MOBILITYVid = 0x1342,
|
|
MOBILITYUSBSERIALDid= 0x0202, /* EasiDock USB 200 serial */
|
|
|
|
/*
|
|
* microHAM product IDs (http://www.microham.com)
|
|
*/
|
|
FTMHAMKWDid = 0xEEE8, /* USB-KW interface */
|
|
FTMHAMYSDid = 0xEEE9, /* USB-YS interface */
|
|
FTMHAMY6Did = 0xEEEA, /* USB-Y6 interface */
|
|
FTMHAMY8Did = 0xEEEB, /* USB-Y8 interface */
|
|
FTMHAMICDid = 0xEEEC, /* USB-IC interface */
|
|
FTMHAMDB9Did = 0xEEED, /* USB-DB9 interface */
|
|
FTMHAMRS232Did = 0xEEEE, /* USB-RS232 interface */
|
|
FTMHAMY9Did = 0xEEEF, /* USB-Y9 interface */
|
|
|
|
/*
|
|
* Active Robots product ids.
|
|
*/
|
|
FTACTIVEROBOTSDid = 0xE548, /* USB comms board */
|
|
XSENSCONVERTER0Did = 0xD388,
|
|
XSENSCONVERTER1Did = 0xD389,
|
|
XSENSCONVERTER2Did = 0xD38A,
|
|
XSENSCONVERTER3Did = 0xD38B,
|
|
XSENSCONVERTER4Did = 0xD38C,
|
|
XSENSCONVERTER5Did = 0xD38D,
|
|
XSENSCONVERTER6Did = 0xD38E,
|
|
XSENSCONVERTER7Did = 0xD38F,
|
|
|
|
/*
|
|
* Xsens Technologies BV products (http://www.xsens.com).
|
|
*/
|
|
FTTERATRONIKVCPDid = 0xEC88, /* Teratronik device */
|
|
FTTERATRONIKD2XXDid = 0xEC89, /* Teratronik device */
|
|
|
|
/*
|
|
* Evolution Robotics products (http://www.evolution.com/).
|
|
*/
|
|
EVOLUTIONVid = 0xDEEE,
|
|
EVOLUTIONER1Did = 0x0300, /* ER1 Control Module */
|
|
|
|
/* Pyramid Computer GmbH */
|
|
FTPYRAMIDDid = 0xE6C8, /* Pyramid Appliance Display */
|
|
|
|
/*
|
|
* Posiflex inc retail equipment (http://www.posiflex.com.tw)
|
|
*/
|
|
POSIFLEXVid = 0x0d3a,
|
|
POSIFLEXPP7000Did= 0x0300, /* PP-7000II thermal printer */
|
|
|
|
/*
|
|
* Westrex International devices
|
|
*/
|
|
FTWESTREXMODEL777Did = 0xDC00, /* Model 777 */
|
|
FTWESTREXMODEL8900FDid = 0xDC01, /* Model 8900F */
|
|
|
|
/*
|
|
* RR-CirKits LocoBuffer USB (http://www.rr-cirkits.com)
|
|
*/
|
|
FTRRCIRKITSLOCOBUFFERDid= 0xc7d0, /* LocoBuffer USB */
|
|
FTECLOCOM1WIREDid = 0xEA90, /* COM to 1-Wire USB */
|
|
|
|
/*
|
|
* Papouch products (http://www.papouch.com/)
|
|
*/
|
|
PAPOUCHVid = 0x5050,
|
|
PAPOUCHTMUDid = 0x0400, /* TMU USB Thermometer */
|
|
|
|
/*
|
|
* ACG Identification Technologies GmbH products http://www.acg.de/
|
|
*/
|
|
FTACGHFDUALDid = 0xDD20, /* HF Dual ISO Reader (RFID) */
|
|
/*
|
|
* new high speed devices
|
|
*/
|
|
FT4232HDid = 0x6011, /* FTDI FT4232H based device */
|
|
|
|
/*
|
|
* Amontec JTAGkey (http://www.amontec.com/)
|
|
*/
|
|
AMONKEYDid = 0xCFF8,
|
|
};
|
|
|
|
/* Commands */
|
|
enum {
|
|
FTRESET = 0, /* Reset the port */
|
|
FTSETMODEMCTRL, /* Set the modem control register */
|
|
FTSETFLOWCTRL, /* Set flow control register */
|
|
FTSETBAUDRATE, /* Set baud rate */
|
|
FTSETDATA, /* Set the parameters, parity */
|
|
FTGETMODEMSTATUS, /* Retrieve current value of modem ctl */
|
|
FTSETEVENTCHAR, /* Set the event character */
|
|
FTSETERRORCHAR, /* Set the error character */
|
|
FTUNKNOWN,
|
|
FTSETLATENCYTIMER, /* Set the latency timer */
|
|
FTGETLATENCYTIMER, /* Get the latency timer */
|
|
FTSETBITMODE, /* Set bit mode */
|
|
FTGETPINS, /* Read pins state */
|
|
FTGETE2READ = 0x90, /* Read address from 128-byte I2C EEPROM */
|
|
FTSETE2WRITE, /* Write to address on 128-byte I2C EEPROM */
|
|
FTSETE2ERASE, /* Erase address on 128-byte I2C EEPROM */
|
|
};
|
|
|
|
/* Port Identifier Table, index for interfaces */
|
|
enum {
|
|
PITDEFAULT = 0, /* SIOA */
|
|
PITA, /* SIOA jtag if there is one */
|
|
};
|
|
|
|
enum {
|
|
Rftdireq = 1<<6, /* bit for type of request */
|
|
};
|
|
|
|
/*
|
|
* Commands Data size
|
|
* Sets have wLength = 0
|
|
* Gets have wValue = 0
|
|
*/
|
|
enum {
|
|
FTMODEMSTATUSSZ = 1,
|
|
FTLATENCYTIMERSZ= 1,
|
|
FTPINSSZ = 1,
|
|
FTE2READSZ = 2,
|
|
};
|
|
|
|
/*
|
|
* bRequest: FTGETE2READ
|
|
* wIndex: Address of word to read
|
|
* Data: Will return a word (2 bytes) of data from E2Address
|
|
* Results put in the I2C 128 byte EEPROM string eeprom+(2*index)
|
|
*/
|
|
|
|
/*
|
|
* bRequest: FTSETE2WRITE
|
|
* wIndex: Address of word to read
|
|
* wValue: Value of the word
|
|
* Data: Will return a word (2 bytes) of data from E2Address
|
|
*/
|
|
|
|
/*
|
|
* bRequest: FTSETE2ERASE
|
|
* Erases the EEPROM
|
|
* wIndex: 0
|
|
*/
|
|
|
|
/*
|
|
* bRequest: FTRESET
|
|
* wValue: Ctl Val
|
|
* wIndex: Port
|
|
*/
|
|
enum {
|
|
FTRESETCTLVAL = 0,
|
|
FTRESETCTLVALPURGERX = 1,
|
|
FTRESETCTLVALPURGETX = 2,
|
|
};
|
|
|
|
/*
|
|
* BmRequestType: SET
|
|
* bRequest: FTSETBAUDRATE
|
|
* wValue: BaudDivisor value - see below
|
|
* Bits 15 to 0 of the 17-bit divisor are placed in the request value.
|
|
* Bit 16 is placed in bit 0 of the request index.
|
|
*/
|
|
|
|
/* chip type */
|
|
enum {
|
|
SIO = 1,
|
|
FT8U232AM = 2,
|
|
FT232BM = 3,
|
|
FT2232C = 4,
|
|
FTKINDR = 5,
|
|
FT2232H = 6,
|
|
FT4232H = 7,
|
|
};
|
|
|
|
enum {
|
|
FTb300 = 0,
|
|
FTb600 = 1,
|
|
FTb1200 = 2,
|
|
FTb2400 = 3,
|
|
FTb4800 = 4,
|
|
FTb9600 = 5,
|
|
FTb19200 = 6,
|
|
FTb38400 = 7,
|
|
FTb57600 = 8,
|
|
FTb115200 = 9,
|
|
};
|
|
|
|
/*
|
|
* bRequest: FTSETDATA
|
|
* wValue: Data characteristics
|
|
* bits 0-7 number of data bits
|
|
* wIndex: Port
|
|
*/
|
|
enum {
|
|
FTSETDATAParNONE = 0 << 8,
|
|
FTSETDATAParODD = 1 << 8,
|
|
FTSETDATAParEVEN = 2 << 8,
|
|
FTSETDATAParMARK = 3 << 8,
|
|
FTSETDATAParSPACE = 4 << 8,
|
|
FTSETDATASTOPBITS1 = 0 << 11,
|
|
FTSETDATASTOPBITS15 = 1 << 11,
|
|
FTSETDATASTOPBITS2 = 2 << 11,
|
|
FTSETBREAK = 1 << 14,
|
|
};
|
|
|
|
/*
|
|
* bRequest: FTSETMODEMCTRL
|
|
* wValue: ControlValue (see below)
|
|
* wIndex: Port
|
|
*/
|
|
|
|
/*
|
|
* bRequest: FTSETFLOWCTRL
|
|
* wValue: Xoff/Xon
|
|
* wIndex: Protocol/Port - hIndex is protocol; lIndex is port
|
|
*/
|
|
enum {
|
|
FTDISABLEFLOWCTRL= 0,
|
|
FTRTSCTSHS = 1 << 8,
|
|
FTDTRDSRHS = 2 << 8,
|
|
FTXONXOFFHS = 4 << 8,
|
|
};
|
|
|
|
/*
|
|
* bRequest: FTGETLATENCYTIMER
|
|
* wIndex: Port
|
|
* wLength: 0
|
|
* Data: latency (on return)
|
|
*/
|
|
|
|
/*
|
|
* bRequest: FTSETBITMODE
|
|
* wIndex: Port
|
|
* either it is big bang mode, in which case
|
|
* wValue: 1 byte L is the big bang mode BIG*
|
|
* or BM is
|
|
* wValue: 1 byte bitbang mode H, 1 byte bitmask for lines L
|
|
*/
|
|
enum {
|
|
BMSERIAL = 0, /* reset, turn off bit-bang mode */
|
|
|
|
BIGBMNORMAL = 1, /* normal bit-bang mode */
|
|
BIGBMSPI = 2, /* spi bit-bang mode */
|
|
|
|
BMABM = 1<<8, /* async mode */
|
|
BMMPSSE = 2<<8,
|
|
BMSYNCBB = 4<<8, /* sync bit-bang -- 2232x and R-type */
|
|
BMMCU = 8<<8, /* MCU Host Bus -- 2232x */
|
|
BMOPTO = 0x10<<8, /* opto-isolated<<8, 2232x */
|
|
BMCBUS = 0x20<<8, /* CBUS pins of R-type chips */
|
|
BMSYNCFF = 0x40<<8, /* Single Channel Sync FIFO, 2232H only */
|
|
};
|
|
|
|
/*
|
|
* bRequest: FTSETLATENCYTIMER
|
|
* wValue: Latency (milliseconds 1-255)
|
|
* wIndex: Port
|
|
*/
|
|
enum {
|
|
FTLATENCYDEFAULT = 2,
|
|
};
|
|
|
|
/*
|
|
* BmRequestType: SET
|
|
* bRequest: FTSETEVENTCHAR
|
|
* wValue: EventChar
|
|
* wIndex: Port
|
|
* 0-7 lower bits event char
|
|
* 8 enable
|
|
*/
|
|
enum {
|
|
FTEVCHARENAB = 1<<8,
|
|
};
|
|
|
|
/*
|
|
* BmRequestType: SET
|
|
* bRequest: FTSETERRORCHAR
|
|
* wValue: Error Char
|
|
* wIndex: Port
|
|
* 0-7 lower bits event char
|
|
* 8 enable
|
|
*/
|
|
enum {
|
|
FTERRCHARENAB = 1<<8,
|
|
};
|
|
/*
|
|
* BmRequestType: GET
|
|
* bRequest: FTGETMODEMSTATUS
|
|
* wIndex: Port
|
|
* wLength: 1
|
|
* Data: Status
|
|
*/
|
|
enum {
|
|
FTCTSMASK = 0x10,
|
|
FTDSRMASK = 0x20,
|
|
FTRIMASK = 0x40,
|
|
FTRLSDMASK = 0x80,
|
|
};
|
|
|
|
enum {
|
|
/* byte 0 of in data hdr */
|
|
FTICTS = 1 << 4,
|
|
FTIDSR = 1 << 5,
|
|
FTIRI = 1 << 6,
|
|
FTIRLSD = 1 << 7, /* receive line signal detect */
|
|
|
|
/* byte 1 of in data hdr */
|
|
FTIDR = 1<<0, /* data ready */
|
|
FTIOE = 1<<1, /* overrun error */
|
|
FTIPE = 1<<2, /* parity error */
|
|
FTIFE = 1<<3, /* framing error */
|
|
FTIBI = 1<<4, /* break interrupt */
|
|
FTITHRE = 1<<5, /* xmitter holding register */
|
|
FTITEMT = 1<<6, /* xmitter empty */
|
|
FTIFIFO = 1<<7, /* error in rcv fifo */
|
|
|
|
/* byte 0 of out data hdr len does not include byte 0 */
|
|
FTOLENMSK= 0x3F,
|
|
FTOPORT = 0x80, /* must be set */
|
|
};
|
|
|
|
/*
|
|
* BUG: This keeps growing, there has to be a better way, but without
|
|
* devices to try it... We can probably simply look for FTDI in the
|
|
* string, or use regular expressions somehow.
|
|
*/
|
|
Cinfo ftinfo[] = {
|
|
{ FTVid, FTACTZWAVEDid },
|
|
{ FTSheevaVid, FTSheevaDid },
|
|
{ FTVid, FTOpenRDUltDid},
|
|
{ FTVid, FTIRTRANSDid },
|
|
{ FTVid, FTIPLUSDid },
|
|
{ FTVid, FTSIODid },
|
|
{ FTVid, FT8U232AMDid },
|
|
{ FTVid, FT8U232AMALTDid },
|
|
{ FTVid, FT8U2232CDid },
|
|
{ FTVid, FTRELAISDid },
|
|
{ INTERBIOMVid, INTERBIOMIOBRDDid },
|
|
{ INTERBIOMVid, INTERBIOMMINIIOBRDDid },
|
|
{ FTVid, FTXF632Did },
|
|
{ FTVid, FTXF634Did },
|
|
{ FTVid, FTXF547Did },
|
|
{ FTVid, FTXF633Did },
|
|
{ FTVid, FTXF631Did },
|
|
{ FTVid, FTXF635Did },
|
|
{ FTVid, FTXF640Did },
|
|
{ FTVid, FTXF642Did },
|
|
{ FTVid, FTDSS20Did },
|
|
{ FTNFRICVid, FTNFRICDid },
|
|
{ FTVid, FTVNHCPCUSBDDid },
|
|
{ FTVid, FTMTXORB0Did },
|
|
{ FTVid, FTMTXORB1Did },
|
|
{ FTVid, FTMTXORB2Did },
|
|
{ FTVid, FTMTXORB3Did },
|
|
{ FTVid, FTMTXORB4Did },
|
|
{ FTVid, FTMTXORB5Did },
|
|
{ FTVid, FTMTXORB6Did },
|
|
{ FTVid, FTPERLEULTRAPORTDid },
|
|
{ FTVid, FTPIEGROUPDid },
|
|
{ SEALEVELVid, SEALEVEL2101Did },
|
|
{ SEALEVELVid, SEALEVEL2102Did },
|
|
{ SEALEVELVid, SEALEVEL2103Did },
|
|
{ SEALEVELVid, SEALEVEL2104Did },
|
|
{ SEALEVELVid, SEALEVEL22011Did },
|
|
{ SEALEVELVid, SEALEVEL22012Did },
|
|
{ SEALEVELVid, SEALEVEL22021Did },
|
|
{ SEALEVELVid, SEALEVEL22022Did },
|
|
{ SEALEVELVid, SEALEVEL22031Did },
|
|
{ SEALEVELVid, SEALEVEL22032Did },
|
|
{ SEALEVELVid, SEALEVEL24011Did },
|
|
{ SEALEVELVid, SEALEVEL24012Did },
|
|
{ SEALEVELVid, SEALEVEL24013Did },
|
|
{ SEALEVELVid, SEALEVEL24014Did },
|
|
{ SEALEVELVid, SEALEVEL24021Did },
|
|
{ SEALEVELVid, SEALEVEL24022Did },
|
|
{ SEALEVELVid, SEALEVEL24023Did },
|
|
{ SEALEVELVid, SEALEVEL24024Did },
|
|
{ SEALEVELVid, SEALEVEL24031Did },
|
|
{ SEALEVELVid, SEALEVEL24032Did },
|
|
{ SEALEVELVid, SEALEVEL24033Did },
|
|
{ SEALEVELVid, SEALEVEL24034Did },
|
|
{ SEALEVELVid, SEALEVEL28011Did },
|
|
{ SEALEVELVid, SEALEVEL28012Did },
|
|
{ SEALEVELVid, SEALEVEL28013Did },
|
|
{ SEALEVELVid, SEALEVEL28014Did },
|
|
{ SEALEVELVid, SEALEVEL28015Did },
|
|
{ SEALEVELVid, SEALEVEL28016Did },
|
|
{ SEALEVELVid, SEALEVEL28017Did },
|
|
{ SEALEVELVid, SEALEVEL28018Did },
|
|
{ SEALEVELVid, SEALEVEL28021Did },
|
|
{ SEALEVELVid, SEALEVEL28022Did },
|
|
{ SEALEVELVid, SEALEVEL28023Did },
|
|
{ SEALEVELVid, SEALEVEL28024Did },
|
|
{ SEALEVELVid, SEALEVEL28025Did },
|
|
{ SEALEVELVid, SEALEVEL28026Did },
|
|
{ SEALEVELVid, SEALEVEL28027Did },
|
|
{ SEALEVELVid, SEALEVEL28028Did },
|
|
{ SEALEVELVid, SEALEVEL28031Did },
|
|
{ SEALEVELVid, SEALEVEL28032Did },
|
|
{ SEALEVELVid, SEALEVEL28033Did },
|
|
{ SEALEVELVid, SEALEVEL28034Did },
|
|
{ SEALEVELVid, SEALEVEL28035Did },
|
|
{ SEALEVELVid, SEALEVEL28036Did },
|
|
{ SEALEVELVid, SEALEVEL28037Did },
|
|
{ SEALEVELVid, SEALEVEL28038Did },
|
|
{ IDTECHVid, IDTECHIDT1221UDid },
|
|
{ OCTVid, OCTUS101Did },
|
|
{ FTVid, FTHETIRA1Did }, /* special quirk div = 240 baud = B38400 rtscts = 1 */
|
|
{ FTVid, FTUSBUIRTDid }, /* special quirk div = 77, baud = B38400 */
|
|
{ FTVid, PROTEGOSPECIAL1 },
|
|
{ FTVid, PROTEGOR2X0 },
|
|
{ FTVid, PROTEGOSPECIAL3 },
|
|
{ FTVid, PROTEGOSPECIAL4 },
|
|
{ FTVid, FTGUDEADSE808Did },
|
|
{ FTVid, FTGUDEADSE809Did },
|
|
{ FTVid, FTGUDEADSE80ADid },
|
|
{ FTVid, FTGUDEADSE80BDid },
|
|
{ FTVid, FTGUDEADSE80CDid },
|
|
{ FTVid, FTGUDEADSE80DDid },
|
|
{ FTVid, FTGUDEADSE80EDid },
|
|
{ FTVid, FTGUDEADSE80FDid },
|
|
{ FTVid, FTGUDEADSE888Did },
|
|
{ FTVid, FTGUDEADSE889Did },
|
|
{ FTVid, FTGUDEADSE88ADid },
|
|
{ FTVid, FTGUDEADSE88BDid },
|
|
{ FTVid, FTGUDEADSE88CDid },
|
|
{ FTVid, FTGUDEADSE88DDid },
|
|
{ FTVid, FTGUDEADSE88EDid },
|
|
{ FTVid, FTGUDEADSE88FDid },
|
|
{ FTVid, FTELVUO100Did },
|
|
{ FTVid, FTELVUM100Did },
|
|
{ FTVid, FTELVUR100Did },
|
|
{ FTVid, FTELVALC8500Did },
|
|
{ FTVid, FTPYRAMIDDid },
|
|
{ FTVid, FTELVFHZ1000PCDid },
|
|
{ FTVid, FTELVCLI7000Did },
|
|
{ FTVid, FTELVPPS7330Did },
|
|
{ FTVid, FTELVTFM100Did },
|
|
{ FTVid, FTELVUDF77Did },
|
|
{ FTVid, FTELVUIO88Did },
|
|
{ FTVid, FTELVUAD8Did },
|
|
{ FTVid, FTELVUDA7Did },
|
|
{ FTVid, FTELVUSI2Did },
|
|
{ FTVid, FTELVT1100Did },
|
|
{ FTVid, FTELVPCD200Did },
|
|
{ FTVid, FTELVULA200Did },
|
|
{ FTVid, FTELVCSI8Did },
|
|
{ FTVid, FTELVEM1000DLDid },
|
|
{ FTVid, FTELVPCK100Did },
|
|
{ FTVid, FTELVRFP500Did },
|
|
{ FTVid, FTELVFS20SIGDid },
|
|
{ FTVid, FTELVWS300PCDid },
|
|
{ FTVid, FTELVFHZ1300PCDid },
|
|
{ FTVid, FTELVWS500Did },
|
|
{ FTVid, LINXSDMUSBQSSDid },
|
|
{ FTVid, LINXMASTERDEVEL2Did },
|
|
{ FTVid, LINXFUTURE0Did },
|
|
{ FTVid, LINXFUTURE1Did },
|
|
{ FTVid, LINXFUTURE2Did },
|
|
{ FTVid, FTCCSICDU200Did },
|
|
{ FTVid, FTCCSICDU401Did },
|
|
{ FTVid, INSIDEACCESSO },
|
|
{ INTREDidVid, INTREDidVALUECANDid },
|
|
{ INTREDidVid, INTREDidNEOVIDid },
|
|
{ FALCOMVid, FALCOMTWISTDid },
|
|
{ FALCOMVid, FALCOMSAMBADid },
|
|
{ FTVid, FTSUUNTOSPORTSDid },
|
|
{ FTVid, FTRMCANVIEWDid },
|
|
{ BANDBVid, BANDBUSOTL4Did },
|
|
{ BANDBVid, BANDBUSTL4Did },
|
|
{ BANDBVid, BANDBUSO9ML2Did },
|
|
{ FTVid, EVERECOPROCDSDid },
|
|
{ FTVid, FT4NGALAXYDE0Did },
|
|
{ FTVid, FT4NGALAXYDE1Did },
|
|
{ FTVid, FT4NGALAXYDE2Did },
|
|
{ FTVid, XSENSCONVERTER0Did },
|
|
{ FTVid, XSENSCONVERTER1Did },
|
|
{ FTVid, XSENSCONVERTER2Did },
|
|
{ FTVid, XSENSCONVERTER3Did },
|
|
{ FTVid, XSENSCONVERTER4Did },
|
|
{ FTVid, XSENSCONVERTER5Did },
|
|
{ FTVid, XSENSCONVERTER6Did },
|
|
{ FTVid, XSENSCONVERTER7Did },
|
|
{ MOBILITYVid, MOBILITYUSBSERIALDid },
|
|
{ FTVid, FTACTIVEROBOTSDid },
|
|
{ FTVid, FTMHAMKWDid },
|
|
{ FTVid, FTMHAMYSDid },
|
|
{ FTVid, FTMHAMY6Did },
|
|
{ FTVid, FTMHAMY8Did },
|
|
{ FTVid, FTMHAMICDid },
|
|
{ FTVid, FTMHAMDB9Did },
|
|
{ FTVid, FTMHAMRS232Did },
|
|
{ FTVid, FTMHAMY9Did },
|
|
{ FTVid, FTTERATRONIKVCPDid },
|
|
{ FTVid, FTTERATRONIKD2XXDid },
|
|
{ EVOLUTIONVid, EVOLUTIONER1Did },
|
|
{ FTVid, FTARTEMISDid },
|
|
{ FTVid, FTATIKATK16Did },
|
|
{ FTVid, FTATIKATK16CDid },
|
|
{ FTVid, FTATIKATK16HRDid },
|
|
{ FTVid, FTATIKATK16HRCDid },
|
|
{ KOBILVid, KOBILCONVB1Did },
|
|
{ KOBILVid, KOBILCONVKAANDid },
|
|
{ POSIFLEXVid, POSIFLEXPP7000Did },
|
|
{ FTVid, FTTTUSBDid },
|
|
{ FTVid, FTECLOCOM1WIREDid },
|
|
{ FTVid, FTWESTREXMODEL777Did },
|
|
{ FTVid, FTWESTREXMODEL8900FDid },
|
|
{ FTVid, FTPCDJDAC2Did },
|
|
{ FTVid, FTRRCIRKITSLOCOBUFFERDid },
|
|
{ FTVid, FTASKRDR400Did },
|
|
{ ICOMID1Vid, ICOMID1Did },
|
|
{ PAPOUCHVid, PAPOUCHTMUDid },
|
|
{ FTVid, FTACGHFDUALDid },
|
|
{ FT8U232AMDid, FT4232HDid },
|
|
{ FTVid, AMONKEYDid },
|
|
{ 0, 0 },
|
|
};
|
|
|
|
static Serialops ftops;
|
|
|
|
enum {
|
|
Packsz = 64, /* default size */
|
|
Maxpacksz = 512,
|
|
Bufsiz = 4 * 1024,
|
|
};
|
|
|
|
static int
|
|
ftdiread(Serialport *p, int index, int req, uint8_t *buf, int len)
|
|
{
|
|
int res;
|
|
Serial *ser;
|
|
|
|
ser = p->s;
|
|
|
|
if(req != FTGETE2READ)
|
|
index |= p->interfc + 1;
|
|
dsprint(2, "serial: ftdiread %#p [%d] req: %#x val: %#x idx:%d buf:%p len:%d\n",
|
|
p, p->interfc, req, 0, index, buf, len);
|
|
res = usbcmd(ser->dev, Rd2h | Rftdireq | Rdev, req, 0, index, buf, len);
|
|
dsprint(2, "serial: ftdiread res:%d\n", res);
|
|
return res;
|
|
}
|
|
|
|
static int
|
|
ftdiwrite(Serialport *p, int val, int index, int req)
|
|
{
|
|
int res;
|
|
Serial *ser;
|
|
|
|
ser = p->s;
|
|
|
|
if(req != FTGETE2READ || req != FTSETE2ERASE || req != FTSETBAUDRATE)
|
|
index |= p->interfc + 1;
|
|
dsprint(2, "serial: ftdiwrite %#p [%d] req: %#x val: %#x idx:%d\n",
|
|
p, p->interfc, req, val, index);
|
|
res = usbcmd(ser->dev, Rh2d | Rftdireq | Rdev, req, val, index, nil, 0);
|
|
dsprint(2, "serial: ftdiwrite res:%d\n", res);
|
|
return res;
|
|
}
|
|
|
|
static int
|
|
ftmodemctl(Serialport *p, int set)
|
|
{
|
|
if(set == 0){
|
|
p->mctl = 0;
|
|
ftdiwrite(p, 0, 0, FTSETMODEMCTRL);
|
|
return 0;
|
|
}
|
|
p->mctl = 1;
|
|
ftdiwrite(p, 0, FTRTSCTSHS, FTSETFLOWCTRL);
|
|
return 0;
|
|
}
|
|
|
|
static uint16_t
|
|
ft232ambaudbase2div(int baud, int base)
|
|
{
|
|
int divisor3;
|
|
uint16_t divisor;
|
|
|
|
divisor3 = (base / 2) / baud;
|
|
if((divisor3 & 7) == 7)
|
|
divisor3++; /* round x.7/8 up to x+1 */
|
|
divisor = divisor3 >> 3;
|
|
divisor3 &= 7;
|
|
|
|
if(divisor3 == 1)
|
|
divisor |= 0xc000; /* 0.125 */
|
|
else if(divisor3 >= 4)
|
|
divisor |= 0x4000; /* 0.5 */
|
|
else if(divisor3 != 0)
|
|
divisor |= 0x8000; /* 0.25 */
|
|
if( divisor == 1)
|
|
divisor = 0; /* special case for maximum baud rate */
|
|
return divisor;
|
|
}
|
|
|
|
enum{
|
|
ClockNew = 48000000,
|
|
ClockOld = 12000000 / 16,
|
|
HetiraDiv = 240,
|
|
UirtDiv = 77,
|
|
};
|
|
|
|
static uint16_t
|
|
ft232ambaud2div(int baud)
|
|
{
|
|
return ft232ambaudbase2div(baud, ClockNew);
|
|
}
|
|
|
|
static uint32_t divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7};
|
|
|
|
static uint32_t
|
|
ft232bmbaudbase2div(int baud, int base)
|
|
{
|
|
int divisor3;
|
|
uint32_t divisor;
|
|
|
|
divisor3 = (base / 2) / baud;
|
|
divisor = divisor3 >> 3 | divfrac[divisor3 & 7] << 14;
|
|
|
|
/* Deal with special cases for highest baud rates. */
|
|
if( divisor == 1)
|
|
divisor = 0; /* 1.0 */
|
|
else if( divisor == 0x4001)
|
|
divisor = 1; /* 1.5 */
|
|
return divisor;
|
|
}
|
|
|
|
static uint32_t
|
|
ft232bmbaud2div (int baud)
|
|
{
|
|
return ft232bmbaudbase2div (baud, ClockNew);
|
|
}
|
|
|
|
static int
|
|
customdiv(Serial *ser)
|
|
{
|
|
if(ser->dev->usb->vid == FTVid && ser->dev->usb->did == FTHETIRA1Did)
|
|
return HetiraDiv;
|
|
else if(ser->dev->usb->vid == FTVid && ser->dev->usb->did == FTUSBUIRTDid)
|
|
return UirtDiv;
|
|
|
|
fprint(2, "serial: weird custom divisor\n");
|
|
return 0; /* shouldn't happen, break as much as I can */
|
|
}
|
|
|
|
static uint32_t
|
|
ftbaudcalcdiv(Serial *ser, int baud)
|
|
{
|
|
int cusdiv;
|
|
uint32_t divval;
|
|
|
|
if(baud == 38400 && (cusdiv = customdiv(ser)) != 0)
|
|
baud = ser->baudbase / cusdiv;
|
|
|
|
if(baud == 0)
|
|
baud = 9600;
|
|
|
|
switch(ser->type) {
|
|
case SIO:
|
|
switch(baud) {
|
|
case 300:
|
|
divval = FTb300;
|
|
break;
|
|
case 600:
|
|
divval = FTb600;
|
|
break;
|
|
case 1200:
|
|
divval = FTb1200;
|
|
break;
|
|
case 2400:
|
|
divval = FTb2400;
|
|
break;
|
|
case 4800:
|
|
divval = FTb4800;
|
|
break;
|
|
case 9600:
|
|
divval = FTb9600;
|
|
break;
|
|
case 19200:
|
|
divval = FTb19200;
|
|
break;
|
|
case 38400:
|
|
divval = FTb38400;
|
|
break;
|
|
case 57600:
|
|
divval = FTb57600;
|
|
break;
|
|
case 115200:
|
|
divval = FTb115200;
|
|
break;
|
|
default:
|
|
divval = FTb9600;
|
|
break;
|
|
}
|
|
break;
|
|
case FT8U232AM:
|
|
if(baud <= 3000000)
|
|
divval = ft232ambaud2div(baud);
|
|
else
|
|
divval = ft232ambaud2div(9600);
|
|
break;
|
|
case FT232BM:
|
|
case FT2232C:
|
|
case FTKINDR:
|
|
case FT2232H:
|
|
case FT4232H:
|
|
if(baud <= 3000000)
|
|
divval = ft232bmbaud2div(baud);
|
|
else
|
|
divval = ft232bmbaud2div(9600);
|
|
break;
|
|
default:
|
|
divval = ft232bmbaud2div(9600);
|
|
break;
|
|
}
|
|
return divval;
|
|
}
|
|
|
|
static int
|
|
ftsetparam(Serialport *p)
|
|
{
|
|
int res;
|
|
uint16_t val;
|
|
uint32_t bauddiv;
|
|
|
|
val = 0;
|
|
if(p->stop == 1)
|
|
val |= FTSETDATASTOPBITS1;
|
|
else if(p->stop == 2)
|
|
val |= FTSETDATASTOPBITS2;
|
|
else if(p->stop == 15)
|
|
val |= FTSETDATASTOPBITS15;
|
|
switch(p->parity){
|
|
case 0:
|
|
val |= FTSETDATAParNONE;
|
|
break;
|
|
case 1:
|
|
val |= FTSETDATAParODD;
|
|
break;
|
|
case 2:
|
|
val |= FTSETDATAParEVEN;
|
|
break;
|
|
case 3:
|
|
val |= FTSETDATAParMARK;
|
|
break;
|
|
case 4:
|
|
val |= FTSETDATAParSPACE;
|
|
break;
|
|
};
|
|
|
|
dsprint(2, "serial: setparam\n");
|
|
|
|
res = ftdiwrite(p, val, 0, FTSETDATA);
|
|
if(res < 0)
|
|
return res;
|
|
|
|
res = ftmodemctl(p, p->mctl);
|
|
if(res < 0)
|
|
return res;
|
|
|
|
bauddiv = ftbaudcalcdiv(p->s, p->baud);
|
|
res = ftdiwrite(p, bauddiv, (bauddiv>>16) & 1, FTSETBAUDRATE);
|
|
|
|
dsprint(2, "serial: setparam res: %d\n", res);
|
|
return res;
|
|
}
|
|
|
|
static int
|
|
hasjtag(Usbdev *udev)
|
|
{
|
|
/* no string, for now, by default we detect no jtag */
|
|
if(udev->product != nil && cistrstr(udev->product, "jtag") != nil)
|
|
return 1;
|
|
/* blank aijuboard has jtag for initial bringup */
|
|
if(udev->csp == 0xffffff)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
/* ser locked */
|
|
static void
|
|
ftgettype(Serial *ser)
|
|
{
|
|
int i, outhdrsz, dno, pksz;
|
|
uint32_t baudbase;
|
|
Conf *cnf;
|
|
|
|
pksz = Packsz;
|
|
/* Assume it is not the original SIO device for now. */
|
|
baudbase = ClockNew / 2;
|
|
outhdrsz = 0;
|
|
dno = ser->dev->usb->dno;
|
|
cnf = ser->dev->usb->conf[0];
|
|
ser->nifcs = 0;
|
|
for(i = 0; i < Niface; i++)
|
|
if(cnf->iface[i] != nil)
|
|
ser->nifcs++;
|
|
if(ser->nifcs > 1) {
|
|
/*
|
|
* Multiple interfaces. default assume FT2232C,
|
|
*/
|
|
if(dno == 0x500)
|
|
ser->type = FT2232C;
|
|
else if(dno == 0x600)
|
|
ser->type = FTKINDR;
|
|
else if(dno == 0x700){
|
|
ser->type = FT2232H;
|
|
pksz = Maxpacksz;
|
|
} else if(dno == 0x800){
|
|
ser->type = FT4232H;
|
|
pksz = Maxpacksz;
|
|
} else
|
|
ser->type = FT2232C;
|
|
|
|
if(hasjtag(ser->dev->usb))
|
|
ser->jtag = 0;
|
|
|
|
/*
|
|
* BM-type devices have a bug where dno gets set
|
|
* to 0x200 when serial is 0.
|
|
*/
|
|
if(dno < 0x500)
|
|
fprint(2, "serial: warning: dno %d too low for "
|
|
"multi-interface device\n", dno);
|
|
} else if(dno < 0x200) {
|
|
/* Old device. Assume it is the original SIO. */
|
|
ser->type = SIO;
|
|
baudbase = ClockOld/16;
|
|
outhdrsz = 1;
|
|
} else if(dno < 0x400)
|
|
/*
|
|
* Assume its an FT8U232AM (or FT8U245AM)
|
|
* (It might be a BM because of the iSerialNumber bug,
|
|
* but it will still work as an AM device.)
|
|
*/
|
|
ser->type = FT8U232AM;
|
|
else /* Assume it is an FT232BM (or FT245BM) */
|
|
ser->type = FT232BM;
|
|
|
|
ser->maxrtrans = ser->maxwtrans = pksz;
|
|
ser->baudbase = baudbase;
|
|
ser->outhdrsz = outhdrsz;
|
|
ser->inhdrsz = 2;
|
|
ser->Serialops = ftops;
|
|
|
|
dsprint (2, "serial: detected type: %#x\n", ser->type);
|
|
}
|
|
|
|
int
|
|
ftprobe(Serial *ser)
|
|
{
|
|
Usbdev *ud = ser->dev->usb;
|
|
|
|
if(matchid(ftinfo, ud->vid, ud->did) == nil)
|
|
return -1;
|
|
ftgettype(ser);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
ftuseinhdr(Serialport *p, uint8_t *b)
|
|
{
|
|
if(b[0] & FTICTS)
|
|
p->cts = 1;
|
|
else
|
|
p->cts = 0;
|
|
if(b[0] & FTIDSR)
|
|
p->dsr = 1;
|
|
else
|
|
p->dsr = 0;
|
|
if(b[0] & FTIRI)
|
|
p->ring = 1;
|
|
else
|
|
p->ring = 0;
|
|
if(b[0] & FTIRLSD)
|
|
p->rlsd = 1;
|
|
else
|
|
p->rlsd = 0;
|
|
|
|
if(b[1] & FTIOE)
|
|
p->novererr++;
|
|
if(b[1] & FTIPE)
|
|
p->nparityerr++;
|
|
if(b[1] & FTIFE)
|
|
p->nframeerr++;
|
|
if(b[1] & FTIBI)
|
|
p->nbreakerr++;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
ftsetouthdr(Serialport *p, uint8_t *b, int len)
|
|
{
|
|
if(p->s->outhdrsz != 0)
|
|
b[0] = FTOPORT | (FTOLENMSK & len);
|
|
return p->s->outhdrsz;
|
|
}
|
|
|
|
static int
|
|
wait4data(Serialport *p, uint8_t *data, int count)
|
|
{
|
|
int d;
|
|
Serial *ser;
|
|
|
|
ser = p->s;
|
|
|
|
qunlock(&ser->ql);
|
|
d = sendul(p->w4data, 1);
|
|
qlock(&ser->ql);
|
|
if(d <= 0)
|
|
return -1;
|
|
if(p->ndata >= count)
|
|
p->ndata -= count;
|
|
else{
|
|
count = p->ndata;
|
|
p->ndata = 0;
|
|
}
|
|
memmove(data, p->data, count);
|
|
if(p->ndata != 0)
|
|
memmove(p->data, p->data+count, p->ndata);
|
|
recvul(p->gotdata);
|
|
return count;
|
|
}
|
|
|
|
static int
|
|
wait4write(Serialport *p, uint8_t *data, int count)
|
|
{
|
|
int off, fd;
|
|
uint8_t *b;
|
|
Serial *ser;
|
|
|
|
ser = p->s;
|
|
|
|
b = emallocz(count+ser->outhdrsz, 1);
|
|
off = ftsetouthdr(p, b, count);
|
|
memmove(b+off, data, count);
|
|
|
|
fd = p->epout->dfd;
|
|
qunlock(&ser->ql);
|
|
count = jehanne_write(fd, b, count+off);
|
|
qlock(&ser->ql);
|
|
free(b);
|
|
return count;
|
|
}
|
|
|
|
typedef struct Packser Packser;
|
|
struct Packser{
|
|
int nb;
|
|
uint8_t b[Bufsiz];
|
|
};
|
|
|
|
typedef struct Areader Areader;
|
|
struct Areader{
|
|
Serialport *p;
|
|
Channel *c;
|
|
};
|
|
|
|
static void
|
|
shutdownchan(Channel *c)
|
|
{
|
|
Packser *bp;
|
|
|
|
while((bp=nbrecvp(c)) != nil)
|
|
free(bp);
|
|
chanfree(c);
|
|
}
|
|
|
|
int
|
|
cpdata(Serial *ser, Serialport *port, uint8_t *out, uint8_t *in, int sz)
|
|
{
|
|
int i, ncp, ntotcp, pksz;
|
|
|
|
pksz = ser->maxrtrans;
|
|
ntotcp = 0;
|
|
|
|
for(i = 0; i < sz; i+= pksz){
|
|
ftuseinhdr(port, in + i);
|
|
if(sz - i > pksz)
|
|
ncp = pksz - ser->inhdrsz;
|
|
else
|
|
ncp = sz - i - ser->inhdrsz;
|
|
memmove(out, in + i + ser->inhdrsz, ncp);
|
|
out += ncp;
|
|
ntotcp += ncp;
|
|
}
|
|
return ntotcp;
|
|
}
|
|
|
|
static void
|
|
epreader(void *u)
|
|
{
|
|
int dfd, rcount, cl, ntries, recov;
|
|
Areader *a;
|
|
Channel *c;
|
|
Packser *pk;
|
|
Serial *ser;
|
|
Serialport *p;
|
|
|
|
threadsetname("epreader proc");
|
|
a = u;
|
|
p = a->p;
|
|
ser = p->s;
|
|
c = a->c;
|
|
free(a);
|
|
|
|
qlock(&ser->ql); /* this makes the reader wait end of initialization too */
|
|
dfd = p->epin->dfd;
|
|
qunlock(&ser->ql);
|
|
|
|
ntries = 0;
|
|
pk = nil;
|
|
for(;;) {
|
|
if (pk == nil)
|
|
pk = emallocz(sizeof(Packser), 1);
|
|
Eagain:
|
|
rcount = jehanne_read(dfd, pk->b, sizeof pk->b);
|
|
if(serialdebug > 5)
|
|
dsprint(2, "%d %#ux%#ux ", rcount, p->data[0],
|
|
p->data[1]);
|
|
|
|
if(rcount < 0){
|
|
if(ntries++ > 100)
|
|
break;
|
|
qlock(&ser->ql);
|
|
recov = serialrecover(ser, p, nil, "epreader: bulkin error");
|
|
qunlock(&ser->ql);
|
|
if(recov >= 0)
|
|
goto Eagain;
|
|
}
|
|
if(rcount == 0)
|
|
continue;
|
|
if(rcount >= ser->inhdrsz){
|
|
rcount = cpdata(ser, p, pk->b, pk->b, rcount);
|
|
if(rcount != 0){
|
|
pk->nb = rcount;
|
|
cl = sendp(c, pk);
|
|
if(cl < 0){
|
|
/*
|
|
* if it was a time-out, I don't want
|
|
* to give back an error.
|
|
*/
|
|
rcount = 0;
|
|
break;
|
|
}
|
|
}else
|
|
free(pk);
|
|
qlock(&ser->ql);
|
|
ser->recover = 0;
|
|
qunlock(&ser->ql);
|
|
ntries = 0;
|
|
pk = nil;
|
|
}
|
|
}
|
|
|
|
if(rcount < 0)
|
|
fprint(2, "%s: error reading %s: %r\n", argv0, p->name);
|
|
free(pk);
|
|
nbsendp(c, nil);
|
|
if(p->w4data != nil)
|
|
chanclose(p->w4data);
|
|
if(p->gotdata != nil)
|
|
chanclose(p->gotdata);
|
|
devctl(ser->dev, "detach");
|
|
closedev(ser->dev);
|
|
}
|
|
|
|
static void
|
|
statusreader(void *u)
|
|
{
|
|
Areader *a;
|
|
Channel *c;
|
|
Packser *pk;
|
|
Serialport *p;
|
|
Serial *ser;
|
|
int cl;
|
|
|
|
p = u;
|
|
ser = p->s;
|
|
threadsetname("statusreader thread");
|
|
/* big buffering, fewer bytes lost */
|
|
c = chancreate(sizeof(Packser *), 128);
|
|
a = emallocz(sizeof(Areader), 1);
|
|
a->p = p;
|
|
a->c = c;
|
|
incref(&ser->dev->ref);
|
|
proccreate(epreader, a, 16*1024);
|
|
|
|
while((pk = recvp(c)) != nil){
|
|
memmove(p->data, pk->b, pk->nb);
|
|
p->ndata = pk->nb;
|
|
free(pk);
|
|
/* consume it all */
|
|
while(p->ndata != 0){
|
|
cl = recvul(p->w4data);
|
|
if(cl < 0)
|
|
break;
|
|
cl = sendul(p->gotdata, 1);
|
|
if(cl < 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
shutdownchan(c);
|
|
devctl(ser->dev, "detach");
|
|
closedev(ser->dev);
|
|
}
|
|
|
|
static int
|
|
ftreset(Serial *ser, Serialport *p)
|
|
{
|
|
int i;
|
|
|
|
if(p != nil){
|
|
ftdiwrite(p, FTRESETCTLVAL, 0, FTRESET);
|
|
return 0;
|
|
}
|
|
p = ser->p;
|
|
for(i = 0; i < Maxifc; i++)
|
|
if(p[i].s != nil)
|
|
ftdiwrite(&p[i], FTRESETCTLVAL, 0, FTRESET);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
ftinit(Serialport *p)
|
|
{
|
|
Serial *ser;
|
|
uint32_t timerval;
|
|
int res;
|
|
|
|
ser = p->s;
|
|
if(p->isjtag){
|
|
res = ftdiwrite(p, FTSETFLOWCTRL, 0, FTDISABLEFLOWCTRL);
|
|
if(res < 0)
|
|
return -1;
|
|
res = ftdiread(p, FTSETLATENCYTIMER, 0, (uint8_t *)&timerval,
|
|
FTLATENCYTIMERSZ);
|
|
if(res < 0)
|
|
return -1;
|
|
dsprint(2, "serial: jtag latency timer is %d\n", timerval);
|
|
timerval = 2;
|
|
ftdiwrite(p, FTLATENCYDEFAULT, 0, FTSETLATENCYTIMER);
|
|
res = ftdiread(p, FTSETLATENCYTIMER, 0, (uint8_t *)&timerval,
|
|
FTLATENCYTIMERSZ);
|
|
if(res < 0)
|
|
return -1;
|
|
|
|
dsprint(2, "serial: jtag latency timer set to %d\n", timerval);
|
|
/* 0xb is the mask for lines. plug dependant? */
|
|
ftdiwrite(p, BMMPSSE|0x0b, 0, FTSETBITMODE);
|
|
}
|
|
incref(&ser->dev->ref);
|
|
proccreate(statusreader, p, 8*1024);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
ftsetbreak(Serialport *p, int val)
|
|
{
|
|
return ftdiwrite(p, (val != 0? FTSETBREAK: 0), 0, FTSETDATA);
|
|
}
|
|
|
|
static int
|
|
ftclearpipes(Serialport *p)
|
|
{
|
|
/* maybe can be done in one... */
|
|
ftdiwrite(p, FTRESETCTLVALPURGETX, 0, FTRESET);
|
|
ftdiwrite(p, FTRESETCTLVALPURGERX, 0, FTRESET);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
setctlline(Serialport *p, uint8_t val)
|
|
{
|
|
return ftdiwrite(p, val | (val << 8), 0, FTSETMODEMCTRL);
|
|
}
|
|
|
|
static void
|
|
updatectlst(Serialport *p, int val)
|
|
{
|
|
if(p->rts)
|
|
p->ctlstate |= val;
|
|
else
|
|
p->ctlstate &= ~val;
|
|
}
|
|
|
|
static int
|
|
setctl(Serialport *p)
|
|
{
|
|
int res;
|
|
Serial *ser;
|
|
|
|
ser = p->s;
|
|
|
|
if(ser->dev->usb->vid == FTVid && ser->dev->usb->did == FTHETIRA1Did){
|
|
fprint(2, "serial: cannot set lines for this device\n");
|
|
updatectlst(p, CtlRTS|CtlDTR);
|
|
p->rts = p->dtr = 1;
|
|
return -1;
|
|
}
|
|
|
|
/* NB: you can not set DTR and RTS with one control message */
|
|
updatectlst(p, CtlRTS);
|
|
res = setctlline(p, (CtlRTS<<8)|p->ctlstate);
|
|
if(res < 0)
|
|
return res;
|
|
|
|
updatectlst(p, CtlDTR);
|
|
res = setctlline(p, (CtlDTR<<8)|p->ctlstate);
|
|
if(res < 0)
|
|
return res;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
ftsendlines(Serialport *p)
|
|
{
|
|
int res;
|
|
|
|
dsprint(2, "serial: sendlines: %#2.2x\n", p->ctlstate);
|
|
res = setctl(p);
|
|
dsprint(2, "serial: sendlines res: %d\n", res);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
ftseteps(Serialport *p)
|
|
{
|
|
char *s;
|
|
Serial *ser;
|
|
|
|
ser = p->s;
|
|
|
|
s = smprint("maxpkt %d", ser->maxrtrans);
|
|
devctl(p->epin, s);
|
|
free(s);
|
|
|
|
s = smprint("maxpkt %d", ser->maxwtrans);
|
|
devctl(p->epout, s);
|
|
free(s);
|
|
return 0;
|
|
}
|
|
|
|
static Serialops ftops = {
|
|
.init = ftinit,
|
|
.seteps = ftseteps,
|
|
.setparam = ftsetparam,
|
|
.clearpipes = ftclearpipes,
|
|
.reset = ftreset,
|
|
.sendlines = ftsendlines,
|
|
.modemctl = ftmodemctl,
|
|
.setbreak = ftsetbreak,
|
|
.wait4data = wait4data,
|
|
.wait4write = wait4write,
|
|
};
|