{-# LANGUAGE CPP
           , DeriveDataTypeable
           , DeriveGeneric
           , FlexibleContexts
           , GeneralizedNewtypeDeriving
           , NoImplicitPrelude
           , PatternGuards
           , ScopedTypeVariables
           , UnicodeSyntax
  #-}

module System.FTDI.Internal where

-------------------------------------------------------------------------------
-- Imports
-------------------------------------------------------------------------------

-- from base:
import Control.Applicative       ( Applicative, (<$>), Alternative )
import Control.Exception         ( Exception, bracket, throwIO )
import Control.Monad             ( Functor
                                 , Monad, (>>=), (>>), (=<<), return
                                 , MonadPlus
                                 )
import Control.Monad.Fix         ( MonadFix )
import Data.Bool
import Data.Bits                 ( (.|.)
                                 , setBit, shiftL, shiftR, testBit
                                 )
import Data.Data                 ( Data )
import Data.Eq                   ( Eq )
import Data.Function             ( ($), on )
import Data.Int                  ( Int )
import Data.List                 ( foldr, minimumBy, zip )
import Data.Maybe                ( Maybe(Just, Nothing), maybe )
import Data.Ord                  ( Ord, (<), (>), compare )
import Data.Tuple                ( fst, snd )
import Data.Typeable             ( Typeable )
import Data.Word                 ( Word8, Word16 )
import GHC.Generics              ( Generic )
import Prelude                   ( Enum, succ
                                 , Bounded, minBound, maxBound
                                 , Num, (+), (-), Integral, (^)
                                 , Fractional, Real, RealFrac
                                 , Double, Integer
                                 , fromEnum, fromIntegral
                                 , realToFrac, floor, ceiling
                                 , div, error
                                 , fmap, (.)
                                 )
import System.IO                 ( IO )
import Text.Read                 ( Read )
import Text.Show                 ( Show )

-- from base-unicode-symbols:
import Data.Eq.Unicode           ( (≡) )
import Data.Function.Unicode     ( (∘) )
import Data.Monoid.Unicode       ( (⊕) )
import Prelude.Unicode           ( (⋅), (÷) )

-- from bytestring:
import qualified Data.ByteString as BS ( empty, drop, length
                                       , null, splitAt, unpack
                                       )
import Data.ByteString           ( ByteString )

-- from ftdi:
import System.FTDI.Utils         ( divRndUp, clamp, genFromEnum, orBits )

-- from vector:
import qualified Data.Vector as V

-- from transformers:
import Control.Monad.Trans.State ( StateT, get, put, runStateT )
import Control.Monad.Trans.Class ( MonadTrans, lift )
import Control.Monad.IO.Class    ( MonadIO, liftIO )

-- from usb:
import qualified System.USB as USB


-------------------------------------------------------------------------------
-- Exceptions
-------------------------------------------------------------------------------

data FTDIException = InterfaceNotFound deriving (Int -> FTDIException -> ShowS
[FTDIException] -> ShowS
FTDIException -> String
(Int -> FTDIException -> ShowS)
-> (FTDIException -> String)
-> ([FTDIException] -> ShowS)
-> Show FTDIException
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FTDIException] -> ShowS
$cshowList :: [FTDIException] -> ShowS
show :: FTDIException -> String
$cshow :: FTDIException -> String
showsPrec :: Int -> FTDIException -> ShowS
$cshowsPrec :: Int -> FTDIException -> ShowS
Show, Typeable FTDIException
Typeable FTDIException
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FTDIException -> c FTDIException)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FTDIException)
-> (FTDIException -> Constr)
-> (FTDIException -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FTDIException))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FTDIException))
-> ((forall b. Data b => b -> b) -> FTDIException -> FTDIException)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FTDIException -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FTDIException -> r)
-> (forall u. (forall d. Data d => d -> u) -> FTDIException -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FTDIException -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FTDIException -> m FTDIException)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FTDIException -> m FTDIException)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FTDIException -> m FTDIException)
-> Data FTDIException
FTDIException -> DataType
FTDIException -> Constr
(forall b. Data b => b -> b) -> FTDIException -> FTDIException
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FTDIException -> u
forall u. (forall d. Data d => d -> u) -> FTDIException -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FTDIException -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FTDIException -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FTDIException -> m FTDIException
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FTDIException -> m FTDIException
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FTDIException
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FTDIException -> c FTDIException
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FTDIException)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FTDIException)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FTDIException -> m FTDIException
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FTDIException -> m FTDIException
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FTDIException -> m FTDIException
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FTDIException -> m FTDIException
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FTDIException -> m FTDIException
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FTDIException -> m FTDIException
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FTDIException -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FTDIException -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> FTDIException -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FTDIException -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FTDIException -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FTDIException -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FTDIException -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FTDIException -> r
gmapT :: (forall b. Data b => b -> b) -> FTDIException -> FTDIException
$cgmapT :: (forall b. Data b => b -> b) -> FTDIException -> FTDIException
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FTDIException)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FTDIException)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FTDIException)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FTDIException)
dataTypeOf :: FTDIException -> DataType
$cdataTypeOf :: FTDIException -> DataType
toConstr :: FTDIException -> Constr
$ctoConstr :: FTDIException -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FTDIException
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FTDIException
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FTDIException -> c FTDIException
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FTDIException -> c FTDIException
Data, Typeable)

instance Exception FTDIException


-------------------------------------------------------------------------------
-- Request codes and values
-------------------------------------------------------------------------------

type RequestCode  = Word8
type RequestValue = Word16

reqReset           ∷ RequestCode
reqSetModemCtrl    ∷ RequestCode
reqSetFlowCtrl     ∷ RequestCode
reqSetBaudRate     ∷ RequestCode
reqSetData         ∷ RequestCode
reqPollModemStatus ∷ RequestCode
reqSetEventChar    ∷ RequestCode
reqSetErrorChar    ∷ RequestCode
reqSetLatencyTimer ∷ RequestCode
reqGetLatencyTimer ∷ RequestCode
reqSetBitMode      ∷ RequestCode
reqReadPins        ∷ RequestCode
reqReadEEPROM      ∷ RequestCode
reqWriteEEPROM     ∷ RequestCode
reqEraseEEPROM     ∷ RequestCode

reqReset :: Word8
reqReset           = Word8
0x00
reqSetModemCtrl :: Word8
reqSetModemCtrl    = Word8
0x01
reqSetFlowCtrl :: Word8
reqSetFlowCtrl     = Word8
0x02
reqSetBaudRate :: Word8
reqSetBaudRate     = Word8
0x03
reqSetData :: Word8
reqSetData         = Word8
0x04
reqPollModemStatus :: Word8
reqPollModemStatus = Word8
0x05
reqSetEventChar :: Word8
reqSetEventChar    = Word8
0x06
reqSetErrorChar :: Word8
reqSetErrorChar    = Word8
0x07
reqSetLatencyTimer :: Word8
reqSetLatencyTimer = Word8
0x09
reqGetLatencyTimer :: Word8
reqGetLatencyTimer = Word8
0x0A
reqSetBitMode :: Word8
reqSetBitMode      = Word8
0x0B
reqReadPins :: Word8
reqReadPins        = Word8
0x0C
reqReadEEPROM :: Word8
reqReadEEPROM      = Word8
0x90
reqWriteEEPROM :: Word8
reqWriteEEPROM     = Word8
0x91
reqEraseEEPROM :: Word8
reqEraseEEPROM     = Word8
0x92

valResetSIO         ∷ RequestValue
valPurgeReadBuffer  ∷ RequestValue
valPurgeWriteBuffer ∷ RequestValue

valResetSIO :: Word16
valResetSIO         = Word16
0
valPurgeReadBuffer :: Word16
valPurgeReadBuffer  = Word16
1
valPurgeWriteBuffer :: Word16
valPurgeWriteBuffer = Word16
2

valSetDTRHigh ∷ RequestValue
valSetDTRLow  ∷ RequestValue
valSetRTSHigh ∷ RequestValue
valSetRTSLow  ∷ RequestValue

valSetDTRHigh :: Word16
valSetDTRHigh = Word16
0x0101
valSetDTRLow :: Word16
valSetDTRLow  = Word16
0x0100
valSetRTSHigh :: Word16
valSetRTSHigh = Word16
0x0202
valSetRTSLow :: Word16
valSetRTSLow  = Word16
0x0200


-------------------------------------------------------------------------------
-- Defaults
-------------------------------------------------------------------------------

-- |Default USB timeout. The timeout can be set per device handle with
-- the 'setTimeout' function.
defaultTimeout ∷ Int
defaultTimeout :: Int
defaultTimeout = Int
5000


-------------------------------------------------------------------------------
-- Devices
-------------------------------------------------------------------------------

-- |A representation of an FTDI device.
data Device = Device
    { Device -> Device
devUSB      ∷ USB.Device
    , Device -> ConfigDesc
devUSBConf  ∷ USB.ConfigDesc
    , Device -> ChipType
devChipType ∷ ChipType
    }

-- |The type of FTDI chip in a 'Device'. The capabilities of a device
-- depend on its chip type.
data ChipType = ChipType_AM
              | ChipType_BM
              | ChipType_2232C
              | ChipType_R
              | ChipType_2232H
              | ChipType_4232H
                deriving (Int -> ChipType
ChipType -> Int
ChipType -> [ChipType]
ChipType -> ChipType
ChipType -> ChipType -> [ChipType]
ChipType -> ChipType -> ChipType -> [ChipType]
(ChipType -> ChipType)
-> (ChipType -> ChipType)
-> (Int -> ChipType)
-> (ChipType -> Int)
-> (ChipType -> [ChipType])
-> (ChipType -> ChipType -> [ChipType])
-> (ChipType -> ChipType -> [ChipType])
-> (ChipType -> ChipType -> ChipType -> [ChipType])
-> Enum ChipType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: ChipType -> ChipType -> ChipType -> [ChipType]
$cenumFromThenTo :: ChipType -> ChipType -> ChipType -> [ChipType]
enumFromTo :: ChipType -> ChipType -> [ChipType]
$cenumFromTo :: ChipType -> ChipType -> [ChipType]
enumFromThen :: ChipType -> ChipType -> [ChipType]
$cenumFromThen :: ChipType -> ChipType -> [ChipType]
enumFrom :: ChipType -> [ChipType]
$cenumFrom :: ChipType -> [ChipType]
fromEnum :: ChipType -> Int
$cfromEnum :: ChipType -> Int
toEnum :: Int -> ChipType
$ctoEnum :: Int -> ChipType
pred :: ChipType -> ChipType
$cpred :: ChipType -> ChipType
succ :: ChipType -> ChipType
$csucc :: ChipType -> ChipType
Enum, ChipType -> ChipType -> Bool
(ChipType -> ChipType -> Bool)
-> (ChipType -> ChipType -> Bool) -> Eq ChipType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ChipType -> ChipType -> Bool
$c/= :: ChipType -> ChipType -> Bool
== :: ChipType -> ChipType -> Bool
$c== :: ChipType -> ChipType -> Bool
Eq, Eq ChipType
Eq ChipType
-> (ChipType -> ChipType -> Ordering)
-> (ChipType -> ChipType -> Bool)
-> (ChipType -> ChipType -> Bool)
-> (ChipType -> ChipType -> Bool)
-> (ChipType -> ChipType -> Bool)
-> (ChipType -> ChipType -> ChipType)
-> (ChipType -> ChipType -> ChipType)
-> Ord ChipType
ChipType -> ChipType -> Bool
ChipType -> ChipType -> Ordering
ChipType -> ChipType -> ChipType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ChipType -> ChipType -> ChipType
$cmin :: ChipType -> ChipType -> ChipType
max :: ChipType -> ChipType -> ChipType
$cmax :: ChipType -> ChipType -> ChipType
>= :: ChipType -> ChipType -> Bool
$c>= :: ChipType -> ChipType -> Bool
> :: ChipType -> ChipType -> Bool
$c> :: ChipType -> ChipType -> Bool
<= :: ChipType -> ChipType -> Bool
$c<= :: ChipType -> ChipType -> Bool
< :: ChipType -> ChipType -> Bool
$c< :: ChipType -> ChipType -> Bool
compare :: ChipType -> ChipType -> Ordering
$ccompare :: ChipType -> ChipType -> Ordering
Ord, Int -> ChipType -> ShowS
[ChipType] -> ShowS
ChipType -> String
(Int -> ChipType -> ShowS)
-> (ChipType -> String) -> ([ChipType] -> ShowS) -> Show ChipType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ChipType] -> ShowS
$cshowList :: [ChipType] -> ShowS
show :: ChipType -> String
$cshow :: ChipType -> String
showsPrec :: Int -> ChipType -> ShowS
$cshowsPrec :: Int -> ChipType -> ShowS
Show, Typeable ChipType
Typeable ChipType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ChipType -> c ChipType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ChipType)
-> (ChipType -> Constr)
-> (ChipType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ChipType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ChipType))
-> ((forall b. Data b => b -> b) -> ChipType -> ChipType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ChipType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ChipType -> r)
-> (forall u. (forall d. Data d => d -> u) -> ChipType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ChipType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ChipType -> m ChipType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ChipType -> m ChipType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ChipType -> m ChipType)
-> Data ChipType
ChipType -> DataType
ChipType -> Constr
(forall b. Data b => b -> b) -> ChipType -> ChipType
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ChipType -> u
forall u. (forall d. Data d => d -> u) -> ChipType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChipType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChipType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChipType -> m ChipType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChipType -> m ChipType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChipType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChipType -> c ChipType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChipType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ChipType)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChipType -> m ChipType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChipType -> m ChipType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChipType -> m ChipType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChipType -> m ChipType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChipType -> m ChipType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChipType -> m ChipType
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ChipType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ChipType -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ChipType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ChipType -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChipType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChipType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChipType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChipType -> r
gmapT :: (forall b. Data b => b -> b) -> ChipType -> ChipType
$cgmapT :: (forall b. Data b => b -> b) -> ChipType -> ChipType
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ChipType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ChipType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChipType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChipType)
dataTypeOf :: ChipType -> DataType
$cdataTypeOf :: ChipType -> DataType
toConstr :: ChipType -> Constr
$ctoConstr :: ChipType -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChipType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChipType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChipType -> c ChipType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChipType -> c ChipType
Data, Typeable, (forall x. ChipType -> Rep ChipType x)
-> (forall x. Rep ChipType x -> ChipType) -> Generic ChipType
forall x. Rep ChipType x -> ChipType
forall x. ChipType -> Rep ChipType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ChipType x -> ChipType
$cfrom :: forall x. ChipType -> Rep ChipType x
Generic)

getChipType ∷ Device → ChipType
getChipType :: Device -> ChipType
getChipType = Device -> ChipType
devChipType

setChipType ∷ Device → ChipType → Device
setChipType :: Device -> ChipType -> Device
setChipType Device
dev ChipType
ct = Device
dev {devChipType :: ChipType
devChipType = ChipType
ct}

-- |Promote a USB device to an FTDI device. You are responsible for
-- supplying the correct USB device and specifying the correct chip
-- type. There is no failsafe way to automatically determine whether a
-- random USB device is an actual FTDI device.
fromUSBDevice ∷ USB.Device -- ^ USB device
              → ChipType
              → IO Device     -- ^ FTDI device
fromUSBDevice :: Device -> ChipType -> IO Device
fromUSBDevice Device
dev ChipType
chip = do
  ConfigDesc
config <- Device -> Word8 -> IO ConfigDesc
USB.getConfigDesc Device
dev Word8
0
  Device -> IO Device
forall (m :: * -> *) a. Monad m => a -> m a
return Device :: Device -> ConfigDesc -> ChipType -> Device
Device { devUSB :: Device
devUSB      = Device
dev
                , devUSBConf :: ConfigDesc
devUSBConf  = ConfigDesc
config
                , devChipType :: ChipType
devChipType = ChipType
chip
                }

-- |Tries to guess the type of the FTDI chip by looking at the USB
-- device release number of a device's descriptor. Each FTDI chip uses
-- a specific release number to indicate its type.
guessChipType ∷ USB.DeviceDesc → Maybe ChipType
guessChipType :: DeviceDesc -> Maybe ChipType
guessChipType DeviceDesc
desc = case DeviceDesc -> ReleaseNumber
USB.deviceReleaseNumber DeviceDesc
desc of
                       -- Workaround for bug in BM type chips
                       (Int
0,Int
2,Int
0,Int
0) | DeviceDesc -> Maybe Word8
USB.deviceSerialNumberStrIx DeviceDesc
desc Maybe Word8 -> Maybe Word8 -> Bool
forall α. Eq α => α -> α -> Bool
≡ Word8 -> Maybe Word8
forall a. a -> Maybe a
Just Word8
0
                                             → ChipType -> Maybe ChipType
forall a. a -> Maybe a
Just ChipType
ChipType_BM
                                 | Bool
otherwise → ChipType -> Maybe ChipType
forall a. a -> Maybe a
Just ChipType
ChipType_AM
                       (Int
0,Int
4,Int
0,Int
0) → ChipType -> Maybe ChipType
forall a. a -> Maybe a
Just ChipType
ChipType_BM
                       (Int
0,Int
5,Int
0,Int
0) → ChipType -> Maybe ChipType
forall a. a -> Maybe a
Just ChipType
ChipType_2232C
                       (Int
0,Int
6,Int
0,Int
0) → ChipType -> Maybe ChipType
forall a. a -> Maybe a
Just ChipType
ChipType_R
                       (Int
0,Int
7,Int
0,Int
0) → ChipType -> Maybe ChipType
forall a. a -> Maybe a
Just ChipType
ChipType_2232H
                       (Int
0,Int
8,Int
0,Int
0) → ChipType -> Maybe ChipType
forall a. a -> Maybe a
Just ChipType
ChipType_4232H
                       ReleaseNumber
_         → Maybe ChipType
forall a. Maybe a
Nothing

-------------------------------------------------------------------------------
-- Interfaces
-------------------------------------------------------------------------------

-- |A device interface. You can imagine an interface as a port or a
-- communication channel. Some devices support communication over
-- multiple interfaces at the same time.
data Interface = Interface_A
               | Interface_B
               | Interface_C
               | Interface_D
                 deriving (Int -> Interface
Interface -> Int
Interface -> [Interface]
Interface -> Interface
Interface -> Interface -> [Interface]
Interface -> Interface -> Interface -> [Interface]
(Interface -> Interface)
-> (Interface -> Interface)
-> (Int -> Interface)
-> (Interface -> Int)
-> (Interface -> [Interface])
-> (Interface -> Interface -> [Interface])
-> (Interface -> Interface -> [Interface])
-> (Interface -> Interface -> Interface -> [Interface])
-> Enum Interface
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Interface -> Interface -> Interface -> [Interface]
$cenumFromThenTo :: Interface -> Interface -> Interface -> [Interface]
enumFromTo :: Interface -> Interface -> [Interface]
$cenumFromTo :: Interface -> Interface -> [Interface]
enumFromThen :: Interface -> Interface -> [Interface]
$cenumFromThen :: Interface -> Interface -> [Interface]
enumFrom :: Interface -> [Interface]
$cenumFrom :: Interface -> [Interface]
fromEnum :: Interface -> Int
$cfromEnum :: Interface -> Int
toEnum :: Int -> Interface
$ctoEnum :: Int -> Interface
pred :: Interface -> Interface
$cpred :: Interface -> Interface
succ :: Interface -> Interface
$csucc :: Interface -> Interface
Enum, Interface -> Interface -> Bool
(Interface -> Interface -> Bool)
-> (Interface -> Interface -> Bool) -> Eq Interface
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Interface -> Interface -> Bool
$c/= :: Interface -> Interface -> Bool
== :: Interface -> Interface -> Bool
$c== :: Interface -> Interface -> Bool
Eq, Eq Interface
Eq Interface
-> (Interface -> Interface -> Ordering)
-> (Interface -> Interface -> Bool)
-> (Interface -> Interface -> Bool)
-> (Interface -> Interface -> Bool)
-> (Interface -> Interface -> Bool)
-> (Interface -> Interface -> Interface)
-> (Interface -> Interface -> Interface)
-> Ord Interface
Interface -> Interface -> Bool
Interface -> Interface -> Ordering
Interface -> Interface -> Interface
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Interface -> Interface -> Interface
$cmin :: Interface -> Interface -> Interface
max :: Interface -> Interface -> Interface
$cmax :: Interface -> Interface -> Interface
>= :: Interface -> Interface -> Bool
$c>= :: Interface -> Interface -> Bool
> :: Interface -> Interface -> Bool
$c> :: Interface -> Interface -> Bool
<= :: Interface -> Interface -> Bool
$c<= :: Interface -> Interface -> Bool
< :: Interface -> Interface -> Bool
$c< :: Interface -> Interface -> Bool
compare :: Interface -> Interface -> Ordering
$ccompare :: Interface -> Interface -> Ordering
Ord, Int -> Interface -> ShowS
[Interface] -> ShowS
Interface -> String
(Int -> Interface -> ShowS)
-> (Interface -> String)
-> ([Interface] -> ShowS)
-> Show Interface
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Interface] -> ShowS
$cshowList :: [Interface] -> ShowS
show :: Interface -> String
$cshow :: Interface -> String
showsPrec :: Int -> Interface -> ShowS
$cshowsPrec :: Int -> Interface -> ShowS
Show, Typeable Interface
Typeable Interface
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Interface -> c Interface)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Interface)
-> (Interface -> Constr)
-> (Interface -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Interface))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Interface))
-> ((forall b. Data b => b -> b) -> Interface -> Interface)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Interface -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Interface -> r)
-> (forall u. (forall d. Data d => d -> u) -> Interface -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Interface -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Interface -> m Interface)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Interface -> m Interface)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Interface -> m Interface)
-> Data Interface
Interface -> DataType
Interface -> Constr
(forall b. Data b => b -> b) -> Interface -> Interface
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Interface -> u
forall u. (forall d. Data d => d -> u) -> Interface -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Interface -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Interface -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Interface -> m Interface
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Interface -> m Interface
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Interface
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Interface -> c Interface
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Interface)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Interface)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Interface -> m Interface
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Interface -> m Interface
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Interface -> m Interface
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Interface -> m Interface
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Interface -> m Interface
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Interface -> m Interface
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Interface -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Interface -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Interface -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Interface -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Interface -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Interface -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Interface -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Interface -> r
gmapT :: (forall b. Data b => b -> b) -> Interface -> Interface
$cgmapT :: (forall b. Data b => b -> b) -> Interface -> Interface
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Interface)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Interface)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Interface)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Interface)
dataTypeOf :: Interface -> DataType
$cdataTypeOf :: Interface -> DataType
toConstr :: Interface -> Constr
$ctoConstr :: Interface -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Interface
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Interface
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Interface -> c Interface
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Interface -> c Interface
Data, Typeable)

interfaceIndex ∷ Interface → Word16
interfaceIndex :: Interface -> Word16
interfaceIndex = Word16 -> Word16
forall a. Enum a => a -> a
succ (Word16 -> Word16) -> (Interface -> Word16) -> Interface -> Word16
forall β γ α. (β -> γ) -> (α -> β) -> α -> γ
∘ Interface -> Word16
forall e n. (Enum e, Num n) => e -> n
genFromEnum

interfaceToUSB ∷ Interface → USB.InterfaceNumber
interfaceToUSB :: Interface -> Word8
interfaceToUSB = Interface -> Word8
forall e n. (Enum e, Num n) => e -> n
genFromEnum

interfaceEndPointIn ∷ Interface → USB.EndpointAddress
interfaceEndPointIn :: Interface -> EndpointAddress
interfaceEndPointIn Interface
i =
    EndpointAddress :: Int -> TransferDirection -> EndpointAddress
USB.EndpointAddress { endpointNumber :: Int
USB.endpointNumber    = Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2 Int -> Int -> Int
forall a. Num a => a -> a -> a
⋅ Interface -> Int
forall e n. (Enum e, Num n) => e -> n
genFromEnum Interface
i
                        , transferDirection :: TransferDirection
USB.transferDirection = TransferDirection
USB.In
                        }

interfaceEndPointOut ∷ Interface → USB.EndpointAddress
interfaceEndPointOut :: Interface -> EndpointAddress
interfaceEndPointOut Interface
i =
    EndpointAddress :: Int -> TransferDirection -> EndpointAddress
USB.EndpointAddress { endpointNumber :: Int
USB.endpointNumber    = Int
2 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2 Int -> Int -> Int
forall a. Num a => a -> a -> a
⋅ Interface -> Int
forall e n. (Enum e, Num n) => e -> n
genFromEnum Interface
i
                        , transferDirection :: TransferDirection
USB.transferDirection = TransferDirection
USB.Out
                        }

-------------------------------------------------------------------------------
-- Device Handles
-------------------------------------------------------------------------------

-- |You need a handle in order to communicate with a 'Device'.
data DeviceHandle = DeviceHandle
    { DeviceHandle -> DeviceHandle
devHndUSB     ∷ USB.DeviceHandle
    , DeviceHandle -> Device
devHndDev     ∷ Device
    , DeviceHandle -> Int
devHndTimeout ∷ Int
    }

-- |Perform a USB device reset.
resetUSB ∷ DeviceHandle → IO ()
resetUSB :: DeviceHandle -> IO ()
resetUSB = DeviceHandle -> IO ()
USB.resetDevice (DeviceHandle -> IO ())
-> (DeviceHandle -> DeviceHandle) -> DeviceHandle -> IO ()
forall β γ α. (β -> γ) -> (α -> β) -> α -> γ
∘ DeviceHandle -> DeviceHandle
devHndUSB

-- |Returns the USB timeout associated with a handle.
getTimeout ∷ DeviceHandle → Int
getTimeout :: DeviceHandle -> Int
getTimeout = DeviceHandle -> Int
devHndTimeout

-- |Modifies the USB timeout associated with a handle.
setTimeout ∷ DeviceHandle → Int → DeviceHandle
setTimeout :: DeviceHandle -> Int -> DeviceHandle
setTimeout DeviceHandle
devHnd Int
timeout = DeviceHandle
devHnd {devHndTimeout :: Int
devHndTimeout = Int
timeout}

-- |Open a device handle to enable communication. Only use this if you
-- can't use 'withDeviceHandle' for some reason.
openDevice ∷ Device → IO DeviceHandle
openDevice :: Device -> IO DeviceHandle
openDevice Device
dev = do
  DeviceHandle
handle ← Device -> IO DeviceHandle
USB.openDevice (Device -> IO DeviceHandle) -> Device -> IO DeviceHandle
forall a b. (a -> b) -> a -> b
$ Device -> Device
devUSB Device
dev
--  USB.setConfig handle $ Just $ USB.configValue $ devUSBConf dev
  DeviceHandle -> IO DeviceHandle
forall (m :: * -> *) a. Monad m => a -> m a
return DeviceHandle :: DeviceHandle -> Device -> Int -> DeviceHandle
DeviceHandle { devHndUSB :: DeviceHandle
devHndUSB     = DeviceHandle
handle
                      , devHndDev :: Device
devHndDev     = Device
dev
                      , devHndTimeout :: Int
devHndTimeout = Int
defaultTimeout
                      }

-- |Release a device handle.
closeDevice ∷ DeviceHandle → IO ()
closeDevice :: DeviceHandle -> IO ()
closeDevice = DeviceHandle -> IO ()
USB.closeDevice (DeviceHandle -> IO ())
-> (DeviceHandle -> DeviceHandle) -> DeviceHandle -> IO ()
forall β γ α. (β -> γ) -> (α -> β) -> α -> γ
. DeviceHandle -> DeviceHandle
devHndUSB

-- |The recommended way to acquire a handle. Ensures that the handle
-- is released when the monadic computation is completed. Even, or
-- especially, when an exception is thrown.
withDeviceHandle ∷ Device → (DeviceHandle → IO α) → IO α
withDeviceHandle :: forall α. Device -> (DeviceHandle -> IO α) -> IO α
withDeviceHandle Device
dev = IO DeviceHandle
-> (DeviceHandle -> IO ()) -> (DeviceHandle -> IO α) -> IO α
forall a b c. IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracket (Device -> IO DeviceHandle
openDevice Device
dev) DeviceHandle -> IO ()
closeDevice

-------------------------------------------------------------------------------
-- Interface Handles
-------------------------------------------------------------------------------

data InterfaceHandle = InterfaceHandle
    { InterfaceHandle -> DeviceHandle
ifHndDevHnd    ∷ DeviceHandle
    , InterfaceHandle -> Interface
ifHndInterface ∷ Interface
    , InterfaceHandle -> EndpointDesc
ifHndInEPDesc  ∷ USB.EndpointDesc
    , InterfaceHandle -> EndpointDesc
ifHndOutEPDesc ∷ USB.EndpointDesc
    }

getDeviceHandle ∷ InterfaceHandle → DeviceHandle
getDeviceHandle :: InterfaceHandle -> DeviceHandle
getDeviceHandle = InterfaceHandle -> DeviceHandle
ifHndDevHnd

getInterface ∷ InterfaceHandle → Interface
getInterface :: InterfaceHandle -> Interface
getInterface = InterfaceHandle -> Interface
ifHndInterface

openInterface ∷ DeviceHandle → Interface → IO InterfaceHandle
openInterface :: DeviceHandle -> Interface -> IO InterfaceHandle
openInterface DeviceHandle
devHnd Interface
i =
    let conf :: ConfigDesc
conf    = Device -> ConfigDesc
devUSBConf (Device -> ConfigDesc) -> Device -> ConfigDesc
forall a b. (a -> b) -> a -> b
$ DeviceHandle -> Device
devHndDev DeviceHandle
devHnd
        ifIx :: Int
ifIx    = Interface -> Int
forall a. Enum a => a -> Int
fromEnum Interface
i
        mIfDesc :: Maybe InterfaceDesc
mIfDesc = (ConfigDesc -> Vector Interface
USB.configInterfaces ConfigDesc
conf Vector Interface -> Int -> Maybe Interface
forall a. Vector a -> Int -> Maybe a
V.!? Int
ifIx) Maybe Interface
-> (Interface -> Maybe InterfaceDesc) -> Maybe InterfaceDesc
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Interface -> Maybe InterfaceDesc
forall {a}. Vector a -> Maybe a
headMay
        mInOutEps :: Maybe (Vector EndpointDesc, Vector EndpointDesc)
mInOutEps = (EndpointDesc -> Bool)
-> Vector EndpointDesc
-> (Vector EndpointDesc, Vector EndpointDesc)
forall a. (a -> Bool) -> Vector a -> (Vector a, Vector a)
V.partition ((TransferDirection
USB.In TransferDirection -> TransferDirection -> Bool
forall α. Eq α => α -> α -> Bool
≡) (TransferDirection -> Bool)
-> (EndpointDesc -> TransferDirection) -> EndpointDesc -> Bool
forall β γ α. (β -> γ) -> (α -> β) -> α -> γ
∘ EndpointAddress -> TransferDirection
USB.transferDirection (EndpointAddress -> TransferDirection)
-> (EndpointDesc -> EndpointAddress)
-> EndpointDesc
-> TransferDirection
forall β γ α. (β -> γ) -> (α -> β) -> α -> γ
∘ EndpointDesc -> EndpointAddress
USB.endpointAddress)
                    (Vector EndpointDesc -> (Vector EndpointDesc, Vector EndpointDesc))
-> (InterfaceDesc -> Vector EndpointDesc)
-> InterfaceDesc
-> (Vector EndpointDesc, Vector EndpointDesc)
forall β γ α. (β -> γ) -> (α -> β) -> α -> γ
∘ InterfaceDesc -> Vector EndpointDesc
USB.interfaceEndpoints
                    (InterfaceDesc -> (Vector EndpointDesc, Vector EndpointDesc))
-> Maybe InterfaceDesc
-> Maybe (Vector EndpointDesc, Vector EndpointDesc)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe InterfaceDesc
mIfDesc
        mInEp :: Maybe EndpointDesc
mInEp   = Vector EndpointDesc -> Maybe EndpointDesc
forall {a}. Vector a -> Maybe a
headMay (Vector EndpointDesc -> Maybe EndpointDesc)
-> ((Vector EndpointDesc, Vector EndpointDesc)
    -> Vector EndpointDesc)
-> (Vector EndpointDesc, Vector EndpointDesc)
-> Maybe EndpointDesc
forall β γ α. (β -> γ) -> (α -> β) -> α -> γ
∘ (Vector EndpointDesc, Vector EndpointDesc) -> Vector EndpointDesc
forall a b. (a, b) -> a
fst ((Vector EndpointDesc, Vector EndpointDesc) -> Maybe EndpointDesc)
-> Maybe (Vector EndpointDesc, Vector EndpointDesc)
-> Maybe EndpointDesc
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe (Vector EndpointDesc, Vector EndpointDesc)
mInOutEps
        mOutEp :: Maybe EndpointDesc
mOutEp  = Vector EndpointDesc -> Maybe EndpointDesc
forall {a}. Vector a -> Maybe a
headMay (Vector EndpointDesc -> Maybe EndpointDesc)
-> ((Vector EndpointDesc, Vector EndpointDesc)
    -> Vector EndpointDesc)
-> (Vector EndpointDesc, Vector EndpointDesc)
-> Maybe EndpointDesc
forall β γ α. (β -> γ) -> (α -> β) -> α -> γ
∘ (Vector EndpointDesc, Vector EndpointDesc) -> Vector EndpointDesc
forall a b. (a, b) -> b
snd ((Vector EndpointDesc, Vector EndpointDesc) -> Maybe EndpointDesc)
-> Maybe (Vector EndpointDesc, Vector EndpointDesc)
-> Maybe EndpointDesc
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe (Vector EndpointDesc, Vector EndpointDesc)
mInOutEps
        headMay :: Vector a -> Maybe a
headMay = (Vector a -> Int -> Maybe a
forall a. Vector a -> Int -> Maybe a
V.!? Int
0)
    in IO InterfaceHandle
-> (InterfaceHandle -> IO InterfaceHandle)
-> Maybe InterfaceHandle
-> IO InterfaceHandle
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (FTDIException -> IO InterfaceHandle
forall e a. Exception e => e -> IO a
throwIO FTDIException
InterfaceNotFound)
             ( \InterfaceHandle
ifHnd → do DeviceHandle -> Word8 -> IO ()
USB.claimInterface (DeviceHandle -> DeviceHandle
devHndUSB DeviceHandle
devHnd) (Interface -> Word8
interfaceToUSB Interface
i)
                           InterfaceHandle -> IO InterfaceHandle
forall (m :: * -> *) a. Monad m => a -> m a
return InterfaceHandle
ifHnd
             )
             (Maybe InterfaceHandle -> IO InterfaceHandle)
-> Maybe InterfaceHandle -> IO InterfaceHandle
forall a b. (a -> b) -> a -> b
$ do EndpointDesc
inEp  ← Maybe EndpointDesc
mInEp
                  EndpointDesc
outEp ← Maybe EndpointDesc
mOutEp
                  InterfaceHandle -> Maybe InterfaceHandle
forall (m :: * -> *) a. Monad m => a -> m a
return InterfaceHandle :: DeviceHandle
-> Interface -> EndpointDesc -> EndpointDesc -> InterfaceHandle
InterfaceHandle
                     { ifHndDevHnd :: DeviceHandle
ifHndDevHnd    = DeviceHandle
devHnd
                     , ifHndInterface :: Interface
ifHndInterface = Interface
i
                     , ifHndInEPDesc :: EndpointDesc
ifHndInEPDesc  = EndpointDesc
inEp
                     , ifHndOutEPDesc :: EndpointDesc
ifHndOutEPDesc = EndpointDesc
outEp
                     }

closeInterface ∷ InterfaceHandle → IO ()
closeInterface :: InterfaceHandle -> IO ()
closeInterface InterfaceHandle
ifHnd = DeviceHandle -> Word8 -> IO ()
USB.releaseInterface (DeviceHandle -> DeviceHandle
devHndUSB (DeviceHandle -> DeviceHandle) -> DeviceHandle -> DeviceHandle
forall a b. (a -> b) -> a -> b
$ InterfaceHandle -> DeviceHandle
ifHndDevHnd InterfaceHandle
ifHnd)
                                            (Interface -> Word8
interfaceToUSB (Interface -> Word8) -> Interface -> Word8
forall a b. (a -> b) -> a -> b
$ InterfaceHandle -> Interface
ifHndInterface InterfaceHandle
ifHnd)

withInterfaceHandle ∷ DeviceHandle → Interface → (InterfaceHandle → IO α) → IO α
withInterfaceHandle :: forall α.
DeviceHandle -> Interface -> (InterfaceHandle -> IO α) -> IO α
withInterfaceHandle DeviceHandle
h Interface
i = IO InterfaceHandle
-> (InterfaceHandle -> IO ()) -> (InterfaceHandle -> IO α) -> IO α
forall a b c. IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracket (DeviceHandle -> Interface -> IO InterfaceHandle
openInterface DeviceHandle
h Interface
i) InterfaceHandle -> IO ()
closeInterface

-------------------------------------------------------------------------------
-- Kernel drivers
-------------------------------------------------------------------------------
withDetachedKernelDriver :: DeviceHandle -> Interface -> IO a -> IO a
withDetachedKernelDriver :: forall a. DeviceHandle -> Interface -> IO a -> IO a
withDetachedKernelDriver DeviceHandle
devHndl Interface
i =
  DeviceHandle -> Word8 -> IO a -> IO a
forall a. DeviceHandle -> Word8 -> IO a -> IO a
USB.withDetachedKernelDriver (DeviceHandle -> DeviceHandle
devHndUSB DeviceHandle
devHndl) (Interface -> Word8
interfaceToUSB Interface
i)

-------------------------------------------------------------------------------
-- Data transfer
-------------------------------------------------------------------------------

newtype ChunkedReaderT m α = ChunkedReaderT {forall (m :: * -> *) α. ChunkedReaderT m α -> StateT ByteString m α
unCR ∷ StateT ByteString m α}
    deriving ( (forall a b. (a -> b) -> ChunkedReaderT m a -> ChunkedReaderT m b)
-> (forall a b. a -> ChunkedReaderT m b -> ChunkedReaderT m a)
-> Functor (ChunkedReaderT m)
forall a b. a -> ChunkedReaderT m b -> ChunkedReaderT m a
forall a b. (a -> b) -> ChunkedReaderT m a -> ChunkedReaderT m b
forall (m :: * -> *) a b.
Functor m =>
a -> ChunkedReaderT m b -> ChunkedReaderT m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> ChunkedReaderT m a -> ChunkedReaderT m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> ChunkedReaderT m b -> ChunkedReaderT m a
$c<$ :: forall (m :: * -> *) a b.
Functor m =>
a -> ChunkedReaderT m b -> ChunkedReaderT m a
fmap :: forall a b. (a -> b) -> ChunkedReaderT m a -> ChunkedReaderT m b
$cfmap :: forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> ChunkedReaderT m a -> ChunkedReaderT m b
Functor
             , Functor (ChunkedReaderT m)
Functor (ChunkedReaderT m)
-> (forall a. a -> ChunkedReaderT m a)
-> (forall a b.
    ChunkedReaderT m (a -> b)
    -> ChunkedReaderT m a -> ChunkedReaderT m b)
-> (forall a b c.
    (a -> b -> c)
    -> ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m c)
-> (forall a b.
    ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m b)
-> (forall a b.
    ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m a)
-> Applicative (ChunkedReaderT m)
forall a. a -> ChunkedReaderT m a
forall a b.
ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m a
forall a b.
ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m b
forall a b.
ChunkedReaderT m (a -> b)
-> ChunkedReaderT m a -> ChunkedReaderT m b
forall a b c.
(a -> b -> c)
-> ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m c
forall {m :: * -> *}. Monad m => Functor (ChunkedReaderT m)
forall (m :: * -> *) a. Monad m => a -> ChunkedReaderT m a
forall (m :: * -> *) a b.
Monad m =>
ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m a
forall (m :: * -> *) a b.
Monad m =>
ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m b
forall (m :: * -> *) a b.
Monad m =>
ChunkedReaderT m (a -> b)
-> ChunkedReaderT m a -> ChunkedReaderT m b
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> c)
-> ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: forall a b.
ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m a
$c<* :: forall (m :: * -> *) a b.
Monad m =>
ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m a
*> :: forall a b.
ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m b
$c*> :: forall (m :: * -> *) a b.
Monad m =>
ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m b
liftA2 :: forall a b c.
(a -> b -> c)
-> ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m c
$cliftA2 :: forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> c)
-> ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m c
<*> :: forall a b.
ChunkedReaderT m (a -> b)
-> ChunkedReaderT m a -> ChunkedReaderT m b
$c<*> :: forall (m :: * -> *) a b.
Monad m =>
ChunkedReaderT m (a -> b)
-> ChunkedReaderT m a -> ChunkedReaderT m b
pure :: forall a. a -> ChunkedReaderT m a
$cpure :: forall (m :: * -> *) a. Monad m => a -> ChunkedReaderT m a
Applicative
             , Applicative (ChunkedReaderT m)
Applicative (ChunkedReaderT m)
-> (forall a. ChunkedReaderT m a)
-> (forall a.
    ChunkedReaderT m a -> ChunkedReaderT m a -> ChunkedReaderT m a)
-> (forall a. ChunkedReaderT m a -> ChunkedReaderT m [a])
-> (forall a. ChunkedReaderT m a -> ChunkedReaderT m [a])
-> Alternative (ChunkedReaderT m)
forall a. ChunkedReaderT m a
forall a. ChunkedReaderT m a -> ChunkedReaderT m [a]
forall a.
ChunkedReaderT m a -> ChunkedReaderT m a -> ChunkedReaderT m a
forall (f :: * -> *).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
forall {m :: * -> *}. MonadPlus m => Applicative (ChunkedReaderT m)
forall (m :: * -> *) a. MonadPlus m => ChunkedReaderT m a
forall (m :: * -> *) a.
MonadPlus m =>
ChunkedReaderT m a -> ChunkedReaderT m [a]
forall (m :: * -> *) a.
MonadPlus m =>
ChunkedReaderT m a -> ChunkedReaderT m a -> ChunkedReaderT m a
many :: forall a. ChunkedReaderT m a -> ChunkedReaderT m [a]
$cmany :: forall (m :: * -> *) a.
MonadPlus m =>
ChunkedReaderT m a -> ChunkedReaderT m [a]
some :: forall a. ChunkedReaderT m a -> ChunkedReaderT m [a]
$csome :: forall (m :: * -> *) a.
MonadPlus m =>
ChunkedReaderT m a -> ChunkedReaderT m [a]
<|> :: forall a.
ChunkedReaderT m a -> ChunkedReaderT m a -> ChunkedReaderT m a
$c<|> :: forall (m :: * -> *) a.
MonadPlus m =>
ChunkedReaderT m a -> ChunkedReaderT m a -> ChunkedReaderT m a
empty :: forall a. ChunkedReaderT m a
$cempty :: forall (m :: * -> *) a. MonadPlus m => ChunkedReaderT m a
Alternative
             , Applicative (ChunkedReaderT m)
Applicative (ChunkedReaderT m)
-> (forall a b.
    ChunkedReaderT m a
    -> (a -> ChunkedReaderT m b) -> ChunkedReaderT m b)
-> (forall a b.
    ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m b)
-> (forall a. a -> ChunkedReaderT m a)
-> Monad (ChunkedReaderT m)
forall a. a -> ChunkedReaderT m a
forall a b.
ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m b
forall a b.
ChunkedReaderT m a
-> (a -> ChunkedReaderT m b) -> ChunkedReaderT m b
forall (m :: * -> *). Monad m => Applicative (ChunkedReaderT m)
forall (m :: * -> *) a. Monad m => a -> ChunkedReaderT m a
forall (m :: * -> *) a b.
Monad m =>
ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m b
forall (m :: * -> *) a b.
Monad m =>
ChunkedReaderT m a
-> (a -> ChunkedReaderT m b) -> ChunkedReaderT m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: forall a. a -> ChunkedReaderT m a
$creturn :: forall (m :: * -> *) a. Monad m => a -> ChunkedReaderT m a
>> :: forall a b.
ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m b
$c>> :: forall (m :: * -> *) a b.
Monad m =>
ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m b
>>= :: forall a b.
ChunkedReaderT m a
-> (a -> ChunkedReaderT m b) -> ChunkedReaderT m b
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
ChunkedReaderT m a
-> (a -> ChunkedReaderT m b) -> ChunkedReaderT m b
Monad
             , Monad (ChunkedReaderT m)
Alternative (ChunkedReaderT m)
Alternative (ChunkedReaderT m)
-> Monad (ChunkedReaderT m)
-> (forall a. ChunkedReaderT m a)
-> (forall a.
    ChunkedReaderT m a -> ChunkedReaderT m a -> ChunkedReaderT m a)
-> MonadPlus (ChunkedReaderT m)
forall a. ChunkedReaderT m a
forall a.
ChunkedReaderT m a -> ChunkedReaderT m a -> ChunkedReaderT m a
forall (m :: * -> *).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
forall {m :: * -> *}. MonadPlus m => Monad (ChunkedReaderT m)
forall (m :: * -> *). MonadPlus m => Alternative (ChunkedReaderT m)
forall (m :: * -> *) a. MonadPlus m => ChunkedReaderT m a
forall (m :: * -> *) a.
MonadPlus m =>
ChunkedReaderT m a -> ChunkedReaderT m a -> ChunkedReaderT m a
mplus :: forall a.
ChunkedReaderT m a -> ChunkedReaderT m a -> ChunkedReaderT m a
$cmplus :: forall (m :: * -> *) a.
MonadPlus m =>
ChunkedReaderT m a -> ChunkedReaderT m a -> ChunkedReaderT m a
mzero :: forall a. ChunkedReaderT m a
$cmzero :: forall (m :: * -> *) a. MonadPlus m => ChunkedReaderT m a
MonadPlus
             , (forall (m :: * -> *) a. Monad m => m a -> ChunkedReaderT m a)
-> MonadTrans ChunkedReaderT
forall (m :: * -> *) a. Monad m => m a -> ChunkedReaderT m a
forall (t :: (* -> *) -> * -> *).
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
lift :: forall (m :: * -> *) a. Monad m => m a -> ChunkedReaderT m a
$clift :: forall (m :: * -> *) a. Monad m => m a -> ChunkedReaderT m a
MonadTrans
             , Monad (ChunkedReaderT m)
Monad (ChunkedReaderT m)
-> (forall a. IO a -> ChunkedReaderT m a)
-> MonadIO (ChunkedReaderT m)
forall a. IO a -> ChunkedReaderT m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
forall {m :: * -> *}. MonadIO m => Monad (ChunkedReaderT m)
forall (m :: * -> *) a. MonadIO m => IO a -> ChunkedReaderT m a
liftIO :: forall a. IO a -> ChunkedReaderT m a
$cliftIO :: forall (m :: * -> *) a. MonadIO m => IO a -> ChunkedReaderT m a
MonadIO
             , Monad (ChunkedReaderT m)
Monad (ChunkedReaderT m)
-> (forall a. (a -> ChunkedReaderT m a) -> ChunkedReaderT m a)
-> MonadFix (ChunkedReaderT m)
forall a. (a -> ChunkedReaderT m a) -> ChunkedReaderT m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
forall {m :: * -> *}. MonadFix m => Monad (ChunkedReaderT m)
forall (m :: * -> *) a.
MonadFix m =>
(a -> ChunkedReaderT m a) -> ChunkedReaderT m a
mfix :: forall a. (a -> ChunkedReaderT m a) -> ChunkedReaderT m a
$cmfix :: forall (m :: * -> *) a.
MonadFix m =>
(a -> ChunkedReaderT m a) -> ChunkedReaderT m a
MonadFix
             )

{-| Run the 'ChunkedReaderT' given an initial state.

The initial state represents excess bytes carried over from a previous
run. When invoking 'runChunkedReaderT' for the first time you can safely pass the
'BS.empty' bytestring as the initial state.

A contrived example showing how you can manually thread the excess bytes
through subsequent invocations of 'runChunkedReaderT':

@
  example :: 'InterfaceHandle' -> IO ()
  example ifHnd = do
    (packets1, rest1) <- runChunkedReaderT ('readData' ifHnd (return 'False') 400) 'BS.empty'
    print $ 'BS.concat' packets1
    (packets2, rest2) <- runChunkedReaderT ('readData' ifHnd (return 'False') 200) rest1
    print $ 'BS.concat' packets2
@

However, it is much easier to let 'ChunkedReaderT's monad instance handle the
plumbing:

@
  example :: 'InterfaceHandle' -> IO ()
  example ifHnd =
    let reader = do packets1 <- 'readData' ifHnd (return 'False') 400
                    'liftIO' $ print $ 'BS.concat' packets1
                    packets2 <- 'readData' ifHnd (return 'False') 200
                    'liftIO' $ print $ 'BS.concat' packets1
    in runChunkedReaderT reader 'BS.empty'
@

-}
runChunkedReaderT ∷ ChunkedReaderT m α → ByteString → m (α, ByteString)
runChunkedReaderT :: forall (m :: * -> *) α.
ChunkedReaderT m α -> ByteString -> m (α, ByteString)
runChunkedReaderT = StateT ByteString m α -> ByteString -> m (α, ByteString)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT (StateT ByteString m α -> ByteString -> m (α, ByteString))
-> (ChunkedReaderT m α -> StateT ByteString m α)
-> ChunkedReaderT m α
-> ByteString
-> m (α, ByteString)
forall β γ α. (β -> γ) -> (α -> β) -> α -> γ
∘ ChunkedReaderT m α -> StateT ByteString m α
forall (m :: * -> *) α. ChunkedReaderT m α -> StateT ByteString m α
unCR

{-| Reads data from the given FTDI interface by performing bulk reads.

This function produces an action in the 'ChunkedReaderT' monad that
will read exactly the requested number of bytes unless it is
explicitly asked to stop early. Executing the 'readData' action will
block until either:

 * All data are read

 * The given checkStop action returns 'True'

The result value is a list of chunks, represented as
@ByteString@s. This representation was choosen for efficiency reasons.

Data are read in packets. The function may choose to request more than
needed in order to get the highest possible bandwidth. The excess of
bytes is kept as the state of the 'ChunkedReaderT' monad. A subsequent
invocation of 'readData' will first return bytes from the stored state
before requesting more from the device itself. A consequence of this
behaviour is that even when you request 100 bytes the function will
actually request 512 bytes (depending on the packet size) and /block/
until all 512 bytes are read! There is no workaround since requesting
less bytes than the packet size is an error.

USB timeouts will not interrupt 'readData'. In case of a timeout
'readData' will simply resume reading data. A small USB timeout can
degrade performance.

The FTDI latency timer can cause poor performance. If the FTDI chip can't fill
a packet before the latency timer fires it is forced to send an incomplete
packet. This will cause a stream of tiny packets instead of a few large
packets. Performance will suffer horribly, but the request will still be
completed.

If you need to make a lot of small requests then a small latency can actually
improve performance.

Modem status bytes are filtered from the result. Every packet sent by the FTDI
chip contains 2 modem status bytes. They are not part of the data and do not
count for the number of bytes read. They will not appear in the result.

Example:

@
  -- Read 100 data bytes from ifHnd
  (packets, rest) <- 'runChunkedReaderT' ('readData' ifHnd (return 'False') 100) 'BS.empty'
@

-}
readData ∷ ∀ m. MonadIO m
         ⇒ InterfaceHandle
         → m Bool -- ^ Check stop action
         → Int -- ^ Number of bytes to read
         → ChunkedReaderT m [ByteString]
readData :: forall (m :: * -> *).
MonadIO m =>
InterfaceHandle -> m Bool -> Int -> ChunkedReaderT m [ByteString]
readData InterfaceHandle
ifHnd m Bool
checkStop Int
numBytes = StateT ByteString m [ByteString] -> ChunkedReaderT m [ByteString]
forall (m :: * -> *) α. StateT ByteString m α -> ChunkedReaderT m α
ChunkedReaderT (StateT ByteString m [ByteString] -> ChunkedReaderT m [ByteString])
-> StateT ByteString m [ByteString]
-> ChunkedReaderT m [ByteString]
forall a b. (a -> b) -> a -> b
$
    do ByteString
prevRest ← StateT ByteString m ByteString
forall (m :: * -> *) s. Monad m => StateT s m s
get
       let readNumBytes :: Int
readNumBytes = Int
numBytes Int -> Int -> Int
forall a. Num a => a -> a -> a
- ByteString -> Int
BS.length ByteString
prevRest
       if Int
readNumBytes Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0
         then do [ByteString]
chunks ← Int -> StateT ByteString m [ByteString]
readLoop Int
readNumBytes
                 [ByteString] -> StateT ByteString m [ByteString]
forall (m :: * -> *) a. Monad m => a -> m a
return ([ByteString] -> StateT ByteString m [ByteString])
-> [ByteString] -> StateT ByteString m [ByteString]
forall a b. (a -> b) -> a -> b
$ if ByteString -> Bool
BS.null ByteString
prevRest
                          then [ByteString]
chunks
                          else ByteString
prevRest ByteString -> [ByteString] -> [ByteString]
forall a. a -> [a] -> [a]
: [ByteString]
chunks
         else let (ByteString
bs, ByteString
newRest) = Int -> ByteString -> (ByteString, ByteString)
BS.splitAt Int
numBytes ByteString
prevRest
              in ByteString -> StateT ByteString m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put ByteString
newRest StateT ByteString m ()
-> StateT ByteString m [ByteString]
-> StateT ByteString m [ByteString]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [ByteString] -> StateT ByteString m [ByteString]
forall (m :: * -> *) a. Monad m => a -> m a
return [ByteString
bs]
    where
      readLoop ∷ Int → StateT ByteString m [ByteString]
      readLoop :: Int -> StateT ByteString m [ByteString]
readLoop Int
readNumBytes = do
        -- Amount of bytes we need to request in order to get atleast
        -- 'readNumBytes' bytes of data.
        let reqSize :: Int
reqSize    = Int
packetSize Int -> Int -> Int
forall a. Num a => a -> a -> a
⋅ Int
reqPackets
            reqPackets :: Int
reqPackets = Int
readNumBytes Int -> Int -> Int
forall α. Integral α => α -> α -> α
`divRndUp` Int
packetDataSize
        -- Timeout is ignored; the number of bytes that was read contains
        -- enough information.
        (ByteString
bytes, Status
_) ← IO (ByteString, Status) -> StateT ByteString m (ByteString, Status)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (ByteString, Status)
 -> StateT ByteString m (ByteString, Status))
-> IO (ByteString, Status)
-> StateT ByteString m (ByteString, Status)
forall a b. (a -> b) -> a -> b
$ InterfaceHandle -> Int -> IO (ByteString, Status)
readBulk InterfaceHandle
ifHnd Int
reqSize

        let receivedDataBytes :: Int
receivedDataBytes   = Int
receivedBytes Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
receivedHeaderBytes
            receivedBytes :: Int
receivedBytes       = ByteString -> Int
BS.length ByteString
bytes
            receivedHeaderBytes :: Int
receivedHeaderBytes = Int
packetHeaderSize Int -> Int -> Int
forall a. Num a => a -> a -> a
⋅ Int
receivedPackets
            receivedPackets :: Int
receivedPackets     = Int
receivedBytes Int -> Int -> Int
forall α. Integral α => α -> α -> α
`divRndUp` Int
packetSize

        -- The reason for not actually getting the requested amount of bytes
        -- could be either a USB timeout or the FTDI latency timer firing.
        --
        -- In case of a USB timeout:
        --   ∃ (n : Nat). receivedBytes ≡ n ⋅ packetSize
        --
        -- In case of FTDI latency timer:
        --   receivedBytes < packetSize
        if Int
receivedDataBytes Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
readNumBytes
          then let xs :: [ByteString]
xs = ByteString -> [ByteString]
splitPackets ByteString
bytes
               in m Bool -> StateT ByteString m Bool
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m Bool
checkStop StateT ByteString m Bool
-> (Bool -> StateT ByteString m [ByteString])
-> StateT ByteString m [ByteString]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
stop →
                  if Bool
stop
                  then ByteString -> StateT ByteString m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put ByteString
BS.empty StateT ByteString m ()
-> StateT ByteString m [ByteString]
-> StateT ByteString m [ByteString]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [ByteString] -> StateT ByteString m [ByteString]
forall (m :: * -> *) a. Monad m => a -> m a
return [ByteString]
xs
                  else ([ByteString] -> [ByteString])
-> StateT ByteString m [ByteString]
-> StateT ByteString m [ByteString]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([ByteString]
xs [ByteString] -> [ByteString] -> [ByteString]
forall α. Monoid α => α -> α -> α
⊕)
                            (Int -> StateT ByteString m [ByteString]
readLoop (Int -> StateT ByteString m [ByteString])
-> Int -> StateT ByteString m [ByteString]
forall a b. (a -> b) -> a -> b
$ Int
readNumBytes Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
receivedDataBytes)
          else -- We might have received too much data, since we can only
               -- request multiples of 'packetSize' bytes. Split the byte
               -- string at such an index that the first part contains
               -- readNumBytes of data. The rest is kept for future usage.
               let (ByteString
bs, ByteString
newRest) = Int -> ByteString -> (ByteString, ByteString)
BS.splitAt (Int -> Int
splitIndex Int
readNumBytes) ByteString
bytes
               in ByteString -> StateT ByteString m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put ByteString
newRest StateT ByteString m ()
-> StateT ByteString m [ByteString]
-> StateT ByteString m [ByteString]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [ByteString] -> StateT ByteString m [ByteString]
forall (m :: * -> *) a. Monad m => a -> m a
return (ByteString -> [ByteString]
splitPackets ByteString
bs)

      splitIndex :: Int -> Int
splitIndex Int
n = Int
p Int -> Int -> Int
forall a. Num a => a -> a -> a
⋅ Int
packetSize Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
packetHeaderSize
                     Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
p Int -> Int -> Int
forall a. Num a => a -> a -> a
⋅ Int
packetDataSize)
          where p :: Int
p = Int
n Int -> Int -> Int
forall α. Integral α => α -> α -> α
`div` Int
packetDataSize

      packetDataSize :: Int
packetDataSize   = Int
packetSize Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
packetHeaderSize
      packetHeaderSize :: Int
packetHeaderSize = Int
2
      packetSize :: Int
packetSize       = MaxPacketSize -> Int
USB.maxPacketSize
                         (MaxPacketSize -> Int)
-> (EndpointDesc -> MaxPacketSize) -> EndpointDesc -> Int
forall β γ α. (β -> γ) -> (α -> β) -> α -> γ
∘ EndpointDesc -> MaxPacketSize
USB.endpointMaxPacketSize
                         (EndpointDesc -> Int) -> EndpointDesc -> Int
forall a b. (a -> b) -> a -> b
$ InterfaceHandle -> EndpointDesc
ifHndInEPDesc InterfaceHandle
ifHnd

      -- |Split a stream of bytes into packets. The first 2 bytes of each
      -- packet are the modem status bytes and are dropped.
      splitPackets :: ByteString -> [ByteString]
splitPackets ByteString
xs | ByteString -> Bool
BS.null ByteString
xs = []
                      | Bool
otherwise  = case Int -> ByteString -> (ByteString, ByteString)
BS.splitAt Int
packetSize ByteString
xs of
                                       (ByteString
a, ByteString
b) → Int -> ByteString -> ByteString
BS.drop Int
2 ByteString
a ByteString -> [ByteString] -> [ByteString]
forall a. a -> [a] -> [a]
: ByteString -> [ByteString]
splitPackets ByteString
b

-- |Perform a bulk read.
--
-- Returns the bytes that where read (in the form of a 'ByteString') and a flag
-- which indicates whether a timeout occured during the request.
readBulk ∷ InterfaceHandle
         → Int -- ^Number of bytes to read
         → IO (ByteString, USB.Status)
readBulk :: InterfaceHandle -> Int -> IO (ByteString, Status)
readBulk InterfaceHandle
ifHnd =
    DeviceHandle -> EndpointAddress -> ReadAction
USB.readBulk (DeviceHandle -> DeviceHandle
devHndUSB (DeviceHandle -> DeviceHandle) -> DeviceHandle -> DeviceHandle
forall a b. (a -> b) -> a -> b
$ InterfaceHandle -> DeviceHandle
ifHndDevHnd InterfaceHandle
ifHnd)
                 (Interface -> EndpointAddress
interfaceEndPointIn (Interface -> EndpointAddress) -> Interface -> EndpointAddress
forall a b. (a -> b) -> a -> b
$ InterfaceHandle -> Interface
ifHndInterface InterfaceHandle
ifHnd)
                 (DeviceHandle -> Int
devHndTimeout (DeviceHandle -> Int) -> DeviceHandle -> Int
forall a b. (a -> b) -> a -> b
$ InterfaceHandle -> DeviceHandle
ifHndDevHnd InterfaceHandle
ifHnd)

-- |Perform a bulk write.
--
-- Returns the number of bytes that where written and a flag which indicates
-- whether a timeout occured during the request.
writeBulk ∷ InterfaceHandle
          → ByteString -- ^Data to be written
          → IO (Int, USB.Status)
writeBulk :: InterfaceHandle -> ByteString -> IO (Int, Status)
writeBulk InterfaceHandle
ifHnd ByteString
bs =
    DeviceHandle -> EndpointAddress -> WriteAction
USB.writeBulk (DeviceHandle -> DeviceHandle
devHndUSB (DeviceHandle -> DeviceHandle) -> DeviceHandle -> DeviceHandle
forall a b. (a -> b) -> a -> b
$ InterfaceHandle -> DeviceHandle
ifHndDevHnd InterfaceHandle
ifHnd)
                  (Interface -> EndpointAddress
interfaceEndPointOut (Interface -> EndpointAddress) -> Interface -> EndpointAddress
forall a b. (a -> b) -> a -> b
$ InterfaceHandle -> Interface
ifHndInterface InterfaceHandle
ifHnd)
                  ByteString
bs
                  (DeviceHandle -> Int
devHndTimeout (DeviceHandle -> Int) -> DeviceHandle -> Int
forall a b. (a -> b) -> a -> b
$ InterfaceHandle -> DeviceHandle
ifHndDevHnd InterfaceHandle
ifHnd)

-------------------------------------------------------------------------------
-- Control Requests
-------------------------------------------------------------------------------

-- |The type of a USB control request.
type USBControl α = USB.DeviceHandle
                  → USB.ControlSetup
                  → USB.Timeout
                  → α

-- |Generic FTDI control request with explicit index
genControl ∷ USBControl α
           → USB.Index -- ^Index
           → InterfaceHandle
           → RequestCode
           → RequestValue
           → α
genControl :: forall α.
USBControl α -> Word16 -> InterfaceHandle -> Word8 -> Word16 -> α
genControl USBControl α
usbCtrl Word16
index InterfaceHandle
ifHnd Word8
request Word16
value =
    USBControl α
usbCtrl DeviceHandle
usbHnd ControlSetup
setup (DeviceHandle -> Int
devHndTimeout DeviceHandle
devHnd)
    where devHnd :: DeviceHandle
devHnd = InterfaceHandle -> DeviceHandle
ifHndDevHnd InterfaceHandle
ifHnd
          usbHnd :: DeviceHandle
usbHnd = DeviceHandle -> DeviceHandle
devHndUSB DeviceHandle
devHnd
          index' :: Word16
index' = Word16
index Word16 -> Word16 -> Word16
forall a. Bits a => a -> a -> a
.|. Interface -> Word16
interfaceIndex (InterfaceHandle -> Interface
ifHndInterface InterfaceHandle
ifHnd)
          setup :: ControlSetup
setup  = ControlSetup :: RequestType
-> Recipient -> Word8 -> Word16 -> Word16 -> ControlSetup
USB.ControlSetup { controlSetupRequestType :: RequestType
USB.controlSetupRequestType = RequestType
USB.Vendor
                                    , controlSetupRecipient :: Recipient
USB.controlSetupRecipient   = Recipient
USB.ToDevice
                                    , controlSetupRequest :: Word8
USB.controlSetupRequest     = Word8
request
                                    , controlSetupValue :: Word16
USB.controlSetupValue       = Word16
value
                                    , controlSetupIndex :: Word16
USB.controlSetupIndex       = Word16
index'
                                    }

control ∷ InterfaceHandle → RequestCode → USB.Value → IO ()
control :: InterfaceHandle -> Word8 -> Word16 -> IO ()
control = USBControl (IO ())
-> Word16 -> InterfaceHandle -> Word8 -> Word16 -> IO ()
forall α.
USBControl α -> Word16 -> InterfaceHandle -> Word8 -> Word16 -> α
genControl USBControl (IO ())
USB.control Word16
0

readControl ∷ InterfaceHandle → RequestCode → USB.Value → USB.Size → IO (ByteString, USB.Status)
readControl :: InterfaceHandle
-> Word8 -> Word16 -> Int -> IO (ByteString, Status)
readControl = USBControl (Int -> IO (ByteString, Status))
-> Word16
-> InterfaceHandle
-> Word8
-> Word16
-> Int
-> IO (ByteString, Status)
forall α.
USBControl α -> Word16 -> InterfaceHandle -> Word8 -> Word16 -> α
genControl USBControl (Int -> IO (ByteString, Status))
USB.readControl Word16
0

writeControl ∷ InterfaceHandle → RequestCode → USB.Value → ByteString → IO (USB.Size, USB.Status)
writeControl :: InterfaceHandle
-> Word8 -> Word16 -> ByteString -> IO (Int, Status)
writeControl = USBControl (ByteString -> IO (Int, Status))
-> Word16
-> InterfaceHandle
-> Word8
-> Word16
-> ByteString
-> IO (Int, Status)
forall α.
USBControl α -> Word16 -> InterfaceHandle -> Word8 -> Word16 -> α
genControl (\DeviceHandle
hdl ControlSetup
setup Int
timeout ByteString
bs -> DeviceHandle -> ControlSetup -> WriteAction
USB.writeControl DeviceHandle
hdl ControlSetup
setup ByteString
bs Int
timeout) Word16
0

-------------------------------------------------------------------------------

-- |Reset the FTDI device.
reset ∷ InterfaceHandle → IO ()
reset :: InterfaceHandle -> IO ()
reset InterfaceHandle
ifHnd = InterfaceHandle -> Word8 -> Word16 -> IO ()
control InterfaceHandle
ifHnd Word8
reqReset Word16
valResetSIO

-- |Clear the on-chip read buffer.
purgeReadBuffer ∷ InterfaceHandle → IO ()
purgeReadBuffer :: InterfaceHandle -> IO ()
purgeReadBuffer InterfaceHandle
ifHnd = InterfaceHandle -> Word8 -> Word16 -> IO ()
control InterfaceHandle
ifHnd Word8
reqReset Word16
valPurgeReadBuffer

-- |Clear the on-chip write buffer.
purgeWriteBuffer ∷ InterfaceHandle → IO ()
purgeWriteBuffer :: InterfaceHandle -> IO ()
purgeWriteBuffer InterfaceHandle
ifHnd = InterfaceHandle -> Word8 -> Word16 -> IO ()
control InterfaceHandle
ifHnd Word8
reqReset Word16
valPurgeWriteBuffer

-------------------------------------------------------------------------------

-- |Returns the current value of the FTDI latency timer.
getLatencyTimer ∷ InterfaceHandle → IO Word8
getLatencyTimer :: InterfaceHandle -> IO Word8
getLatencyTimer InterfaceHandle
ifHnd = do
    (ByteString
bs, Status
_) ← InterfaceHandle
-> Word8 -> Word16 -> Int -> IO (ByteString, Status)
readControl InterfaceHandle
ifHnd Word8
reqGetLatencyTimer Word16
0 Int
1
    case ByteString -> [Word8]
BS.unpack ByteString
bs of
      [Word8
b] → Word8 -> IO Word8
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
b
      [Word8]
_   → String -> IO Word8
forall a. HasCallStack => String -> a
error String
"System.FTDI.getLatencyTimer: failed"

-- |Set the FTDI latency timer. The latency is the amount of
-- milliseconds after which the FTDI chip will send a packet
-- regardless of the number of bytes in the packet.
setLatencyTimer ∷ InterfaceHandle → Word8 → IO ()
setLatencyTimer :: InterfaceHandle -> Word8 -> IO ()
setLatencyTimer InterfaceHandle
ifHnd Word8
latency = InterfaceHandle -> Word8 -> Word16 -> IO ()
control InterfaceHandle
ifHnd Word8
reqSetLatencyTimer
                                        (Word16 -> IO ()) -> Word16 -> IO ()
forall a b. (a -> b) -> a -> b
$ Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
latency

-- |MPSSE bitbang modes
data BitMode = -- |Switch off bitbang mode, back to regular serial/FIFO.
               BitMode_Reset
               -- |Classical asynchronous bitbang mode, introduced with B-type
               -- chips.
             | BitMode_BitBang
               -- |Multi-Protocol Synchronous Serial Engine, available on 2232x
               -- chips.
             | BitMode_MPSSE
               -- |Synchronous Bit-Bang Mode, available on 2232x and R-type
               -- chips.
             | BitMode_SyncBitBang
               -- |MCU Host Bus Emulation Mode, available on 2232x
               -- chips. CPU-style fifo mode gets set via EEPROM.
             | BitMode_MCU
               -- |Fast Opto-Isolated Serial Interface Mode, available on 2232x
               -- chips.
             | BitMode_Opto
               -- |Bit-Bang on CBus pins of R-type chips, configure in EEPROM
               -- before use.
             | BitMode_CBus
               -- |Single Channel Synchronous FIFO Mode, available on 2232H
               -- chips.
             | BitMode_SyncFIFO
              deriving (BitMode -> BitMode -> Bool
(BitMode -> BitMode -> Bool)
-> (BitMode -> BitMode -> Bool) -> Eq BitMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BitMode -> BitMode -> Bool
$c/= :: BitMode -> BitMode -> Bool
== :: BitMode -> BitMode -> Bool
$c== :: BitMode -> BitMode -> Bool
Eq, Eq BitMode
Eq BitMode
-> (BitMode -> BitMode -> Ordering)
-> (BitMode -> BitMode -> Bool)
-> (BitMode -> BitMode -> Bool)
-> (BitMode -> BitMode -> Bool)
-> (BitMode -> BitMode -> Bool)
-> (BitMode -> BitMode -> BitMode)
-> (BitMode -> BitMode -> BitMode)
-> Ord BitMode
BitMode -> BitMode -> Bool
BitMode -> BitMode -> Ordering
BitMode -> BitMode -> BitMode
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BitMode -> BitMode -> BitMode
$cmin :: BitMode -> BitMode -> BitMode
max :: BitMode -> BitMode -> BitMode
$cmax :: BitMode -> BitMode -> BitMode
>= :: BitMode -> BitMode -> Bool
$c>= :: BitMode -> BitMode -> Bool
> :: BitMode -> BitMode -> Bool
$c> :: BitMode -> BitMode -> Bool
<= :: BitMode -> BitMode -> Bool
$c<= :: BitMode -> BitMode -> Bool
< :: BitMode -> BitMode -> Bool
$c< :: BitMode -> BitMode -> Bool
compare :: BitMode -> BitMode -> Ordering
$ccompare :: BitMode -> BitMode -> Ordering
Ord, Int -> BitMode -> ShowS
[BitMode] -> ShowS
BitMode -> String
(Int -> BitMode -> ShowS)
-> (BitMode -> String) -> ([BitMode] -> ShowS) -> Show BitMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BitMode] -> ShowS
$cshowList :: [BitMode] -> ShowS
show :: BitMode -> String
$cshow :: BitMode -> String
showsPrec :: Int -> BitMode -> ShowS
$cshowsPrec :: Int -> BitMode -> ShowS
Show, Typeable BitMode
Typeable BitMode
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BitMode -> c BitMode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BitMode)
-> (BitMode -> Constr)
-> (BitMode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BitMode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BitMode))
-> ((forall b. Data b => b -> b) -> BitMode -> BitMode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BitMode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BitMode -> r)
-> (forall u. (forall d. Data d => d -> u) -> BitMode -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> BitMode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BitMode -> m BitMode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BitMode -> m BitMode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BitMode -> m BitMode)
-> Data BitMode
BitMode -> DataType
BitMode -> Constr
(forall b. Data b => b -> b) -> BitMode -> BitMode
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> BitMode -> u
forall u. (forall d. Data d => d -> u) -> BitMode -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BitMode -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BitMode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BitMode -> m BitMode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BitMode -> m BitMode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BitMode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BitMode -> c BitMode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BitMode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BitMode)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BitMode -> m BitMode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BitMode -> m BitMode
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BitMode -> m BitMode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BitMode -> m BitMode
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BitMode -> m BitMode
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BitMode -> m BitMode
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BitMode -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BitMode -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> BitMode -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BitMode -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BitMode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BitMode -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BitMode -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BitMode -> r
gmapT :: (forall b. Data b => b -> b) -> BitMode -> BitMode
$cgmapT :: (forall b. Data b => b -> b) -> BitMode -> BitMode
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BitMode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BitMode)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BitMode)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BitMode)
dataTypeOf :: BitMode -> DataType
$cdataTypeOf :: BitMode -> DataType
toConstr :: BitMode -> Constr
$ctoConstr :: BitMode -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BitMode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BitMode
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BitMode -> c BitMode
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BitMode -> c BitMode
Data, Typeable)

marshalBitMode ∷ BitMode → Word8
marshalBitMode :: BitMode -> Word8
marshalBitMode BitMode
bm = case BitMode
bm of
                      BitMode
BitMode_Reset       → Word8
0x00
                      BitMode
BitMode_BitBang     → Word8
0x01
                      BitMode
BitMode_MPSSE       → Word8
0x02
                      BitMode
BitMode_SyncBitBang → Word8
0x04
                      BitMode
BitMode_MCU         → Word8
0x08
                      BitMode
BitMode_Opto        → Word8
0x10
                      BitMode
BitMode_CBus        → Word8
0x20
                      BitMode
BitMode_SyncFIFO    → Word8
0x40

-- |The bitmode controls the method of communication.
setBitMode ∷ InterfaceHandle → Word8 → BitMode → IO ()
setBitMode :: InterfaceHandle -> Word8 -> BitMode -> IO ()
setBitMode InterfaceHandle
ifHnd Word8
bitMask BitMode
bitMode = InterfaceHandle -> Word8 -> Word16 -> IO ()
control InterfaceHandle
ifHnd Word8
reqSetBitMode Word16
value
    where bitMask' :: Word16
bitMask' = Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
bitMask
          bitMode' :: Word16
bitMode' = Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8 -> Word16) -> Word8 -> Word16
forall a b. (a -> b) -> a -> b
$ BitMode -> Word8
marshalBitMode BitMode
bitMode
          value :: Word16
value    = Word16
bitMask' Word16 -> Word16 -> Word16
forall a. Bits a => a -> a -> a
.|. Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
shiftL Word16
bitMode' Int
8

-- |Sets the baud rate. Internally the baud rate is represented as a
-- fraction. The maximum baudrate is the numerator and a special
-- /divisor/ is used as the denominator. The maximum baud rate is
-- given by the 'BaudRate' instance for 'Bounded'. The divisor
-- consists of an integral part and a fractional part. Both parts are
-- limited in range. As a result not all baud rates can be accurately
          -- represented. This function returns the nearest representable baud
-- rate relative to the requested baud rate. According to FTDI
-- documentation the maximum allowed error is 3%. The nearest
-- representable baud rate can be calculated with the
-- 'nearestBaudRate' function.
setBaudRate ∷ RealFrac α ⇒ InterfaceHandle → BaudRate α → IO (BaudRate α)
setBaudRate :: forall α.
RealFrac α =>
InterfaceHandle -> BaudRate α -> IO (BaudRate α)
setBaudRate InterfaceHandle
ifHnd BaudRate α
baudRate =
  do USBControl (IO ())
-> Word16 -> InterfaceHandle -> Word8 -> Word16 -> IO ()
forall α.
USBControl α -> Word16 -> InterfaceHandle -> Word8 -> Word16 -> α
genControl USBControl (IO ())
USB.control Word16
ix InterfaceHandle
ifHnd Word8
reqSetBaudRate Word16
val
     BaudRate α -> IO (BaudRate α)
forall (m :: * -> *) a. Monad m => a -> m a
return BaudRate α
b
  where
    (Word16
val, Word16
ix) = ChipType -> BRDiv Int -> BRSubDiv Int -> (Word16, Word16)
encodeBaudRateDivisors ChipType
chip BRDiv Int
d BRSubDiv Int
s
    (BRDiv Int
d, BRSubDiv Int
s, BaudRate α
b) = ChipType -> BaudRate α -> (BRDiv Int, BRSubDiv Int, BaudRate α)
forall α.
RealFrac α =>
ChipType -> BaudRate α -> (BRDiv Int, BRSubDiv Int, BaudRate α)
calcBaudRateDivisors ChipType
chip BaudRate α
baudRate
    chip :: ChipType
chip = Device -> ChipType
devChipType (Device -> ChipType) -> Device -> ChipType
forall a b. (a -> b) -> a -> b
$ DeviceHandle -> Device
devHndDev (DeviceHandle -> Device) -> DeviceHandle -> Device
forall a b. (a -> b) -> a -> b
$ InterfaceHandle -> DeviceHandle
ifHndDevHnd InterfaceHandle
ifHnd


data Parity = -- |The parity bit is set to one if the number of ones in a given
              -- set of bits is even (making the total number of ones, including
              -- the parity bit, odd).
              Parity_Odd
              -- |The parity bit is set to one if the number of ones in a given
              -- set of bits is odd (making the total number of ones, including
              -- the parity bit, even).
            | Parity_Even
            | Parity_Mark  -- ^The parity bit is always 1.
            | Parity_Space -- ^The parity bit is always 0.
              deriving (Int -> Parity
Parity -> Int
Parity -> [Parity]
Parity -> Parity
Parity -> Parity -> [Parity]
Parity -> Parity -> Parity -> [Parity]
(Parity -> Parity)
-> (Parity -> Parity)
-> (Int -> Parity)
-> (Parity -> Int)
-> (Parity -> [Parity])
-> (Parity -> Parity -> [Parity])
-> (Parity -> Parity -> [Parity])
-> (Parity -> Parity -> Parity -> [Parity])
-> Enum Parity
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Parity -> Parity -> Parity -> [Parity]
$cenumFromThenTo :: Parity -> Parity -> Parity -> [Parity]
enumFromTo :: Parity -> Parity -> [Parity]
$cenumFromTo :: Parity -> Parity -> [Parity]
enumFromThen :: Parity -> Parity -> [Parity]
$cenumFromThen :: Parity -> Parity -> [Parity]
enumFrom :: Parity -> [Parity]
$cenumFrom :: Parity -> [Parity]
fromEnum :: Parity -> Int
$cfromEnum :: Parity -> Int
toEnum :: Int -> Parity
$ctoEnum :: Int -> Parity
pred :: Parity -> Parity
$cpred :: Parity -> Parity
succ :: Parity -> Parity
$csucc :: Parity -> Parity
Enum, Parity -> Parity -> Bool
(Parity -> Parity -> Bool)
-> (Parity -> Parity -> Bool) -> Eq Parity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Parity -> Parity -> Bool
$c/= :: Parity -> Parity -> Bool
== :: Parity -> Parity -> Bool
$c== :: Parity -> Parity -> Bool
Eq, Eq Parity
Eq Parity
-> (Parity -> Parity -> Ordering)
-> (Parity -> Parity -> Bool)
-> (Parity -> Parity -> Bool)
-> (Parity -> Parity -> Bool)
-> (Parity -> Parity -> Bool)
-> (Parity -> Parity -> Parity)
-> (Parity -> Parity -> Parity)
-> Ord Parity
Parity -> Parity -> Bool
Parity -> Parity -> Ordering
Parity -> Parity -> Parity
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Parity -> Parity -> Parity
$cmin :: Parity -> Parity -> Parity
max :: Parity -> Parity -> Parity
$cmax :: Parity -> Parity -> Parity
>= :: Parity -> Parity -> Bool
$c>= :: Parity -> Parity -> Bool
> :: Parity -> Parity -> Bool
$c> :: Parity -> Parity -> Bool
<= :: Parity -> Parity -> Bool
$c<= :: Parity -> Parity -> Bool
< :: Parity -> Parity -> Bool
$c< :: Parity -> Parity -> Bool
compare :: Parity -> Parity -> Ordering
$ccompare :: Parity -> Parity -> Ordering
Ord, Int -> Parity -> ShowS
[Parity] -> ShowS
Parity -> String
(Int -> Parity -> ShowS)
-> (Parity -> String) -> ([Parity] -> ShowS) -> Show Parity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Parity] -> ShowS
$cshowList :: [Parity] -> ShowS
show :: Parity -> String
$cshow :: Parity -> String
showsPrec :: Int -> Parity -> ShowS
$cshowsPrec :: Int -> Parity -> ShowS
Show, Typeable Parity
Typeable Parity
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Parity -> c Parity)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Parity)
-> (Parity -> Constr)
-> (Parity -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Parity))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parity))
-> ((forall b. Data b => b -> b) -> Parity -> Parity)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Parity -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Parity -> r)
-> (forall u. (forall d. Data d => d -> u) -> Parity -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Parity -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Parity -> m Parity)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Parity -> m Parity)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Parity -> m Parity)
-> Data Parity
Parity -> DataType
Parity -> Constr
(forall b. Data b => b -> b) -> Parity -> Parity
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Parity -> u
forall u. (forall d. Data d => d -> u) -> Parity -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Parity -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Parity -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Parity -> m Parity
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parity -> m Parity
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Parity
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parity -> c Parity
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Parity)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parity)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parity -> m Parity
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parity -> m Parity
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parity -> m Parity
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parity -> m Parity
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Parity -> m Parity
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Parity -> m Parity
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Parity -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Parity -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Parity -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Parity -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Parity -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Parity -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Parity -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Parity -> r
gmapT :: (forall b. Data b => b -> b) -> Parity -> Parity
$cgmapT :: (forall b. Data b => b -> b) -> Parity -> Parity
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parity)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parity)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Parity)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Parity)
dataTypeOf :: Parity -> DataType
$cdataTypeOf :: Parity -> DataType
toConstr :: Parity -> Constr
$ctoConstr :: Parity -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Parity
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Parity
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parity -> c Parity
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parity -> c Parity
Data, Typeable)

data BitDataFormat = Bits_7
                   | Bits_8

data StopBits = StopBit_1
              | StopBit_15
              | StopBit_2
                deriving (Int -> StopBits
StopBits -> Int
StopBits -> [StopBits]
StopBits -> StopBits
StopBits -> StopBits -> [StopBits]
StopBits -> StopBits -> StopBits -> [StopBits]
(StopBits -> StopBits)
-> (StopBits -> StopBits)
-> (Int -> StopBits)
-> (StopBits -> Int)
-> (StopBits -> [StopBits])
-> (StopBits -> StopBits -> [StopBits])
-> (StopBits -> StopBits -> [StopBits])
-> (StopBits -> StopBits -> StopBits -> [StopBits])
-> Enum StopBits
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: StopBits -> StopBits -> StopBits -> [StopBits]
$cenumFromThenTo :: StopBits -> StopBits -> StopBits -> [StopBits]
enumFromTo :: StopBits -> StopBits -> [StopBits]
$cenumFromTo :: StopBits -> StopBits -> [StopBits]
enumFromThen :: StopBits -> StopBits -> [StopBits]
$cenumFromThen :: StopBits -> StopBits -> [StopBits]
enumFrom :: StopBits -> [StopBits]
$cenumFrom :: StopBits -> [StopBits]
fromEnum :: StopBits -> Int
$cfromEnum :: StopBits -> Int
toEnum :: Int -> StopBits
$ctoEnum :: Int -> StopBits
pred :: StopBits -> StopBits
$cpred :: StopBits -> StopBits
succ :: StopBits -> StopBits
$csucc :: StopBits -> StopBits
Enum)

-- |Set RS232 line characteristics
setLineProperty ∷ InterfaceHandle
                → BitDataFormat -- ^Number of bits
                → StopBits      -- ^Number of stop bits
                → Maybe Parity  -- ^Optional parity mode
                → Bool          -- ^Break
                → IO ()
setLineProperty :: InterfaceHandle
-> BitDataFormat -> StopBits -> Maybe Parity -> Bool -> IO ()
setLineProperty InterfaceHandle
ifHnd BitDataFormat
bitDataFormat StopBits
stopBits Maybe Parity
parity Bool
break' =
    InterfaceHandle -> Word8 -> Word16 -> IO ()
control InterfaceHandle
ifHnd
            Word8
reqSetData
            (Word16 -> IO ()) -> Word16 -> IO ()
forall a b. (a -> b) -> a -> b
$ [Word16] -> Word16
forall α. (Num α, Bits α) => [α] -> α
orBits [ case BitDataFormat
bitDataFormat of
                         BitDataFormat
Bits_7 → Word16
7
                         BitDataFormat
Bits_8 → Word16
8
                     , Word16 -> (Parity -> Word16) -> Maybe Parity -> Word16
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Word16
0 (\Parity
p → (Word16
1 Word16 -> Word16 -> Word16
forall a. Num a => a -> a -> a
+ Parity -> Word16
forall e n. (Enum e, Num n) => e -> n
genFromEnum Parity
p) Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftL` Int
8) Maybe Parity
parity
                     , StopBits -> Word16
forall e n. (Enum e, Num n) => e -> n
genFromEnum StopBits
stopBits Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftL` Int
11
                     , Bool -> Word16
forall e n. (Enum e, Num n) => e -> n
genFromEnum Bool
break'   Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftL` Int
14
                     ]

-------------------------------------------------------------------------------
-- Modem status
-------------------------------------------------------------------------------

-- |Modem status information. The modem status is send as a header for
-- each read access. In the absence of data the FTDI chip will
-- generate the status every 40 ms.
--
-- The modem status can be explicitely requested with the
-- 'pollModemStatus' function.
data ModemStatus = ModemStatus
    { -- |Clear to send (CTS)
      ModemStatus -> Bool
msClearToSend ∷ Bool
      -- |Data set ready (DTS)
    , ModemStatus -> Bool
msDataSetReady ∷ Bool
      -- |Ring indicator (RI)
    , ModemStatus -> Bool
msRingIndicator ∷ Bool
      -- |Receive line signal detect (RLSD)
    , ModemStatus -> Bool
msReceiveLineSignalDetect ∷ Bool
      -- | Data ready (DR)
    , ModemStatus -> Bool
msDataReady ∷ Bool
      -- |Overrun error (OE)
    , ModemStatus -> Bool
msOverrunError ∷ Bool
      -- |Parity error (PE)
    , ModemStatus -> Bool
msParityError ∷ Bool
      -- |Framing error (FE)
    , ModemStatus -> Bool
msFramingError ∷ Bool
      -- |Break interrupt (BI)
    , ModemStatus -> Bool
msBreakInterrupt ∷ Bool
      -- |Transmitter holding register (THRE)
    , ModemStatus -> Bool
msTransmitterHoldingRegister ∷ Bool
      -- |Transmitter empty (TEMT)
    , ModemStatus -> Bool
msTransmitterEmpty ∷ Bool
      -- |Error in RCVR FIFO
    , ModemStatus -> Bool
msErrorInReceiverFIFO ∷ Bool
    } deriving (ModemStatus -> ModemStatus -> Bool
(ModemStatus -> ModemStatus -> Bool)
-> (ModemStatus -> ModemStatus -> Bool) -> Eq ModemStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModemStatus -> ModemStatus -> Bool
$c/= :: ModemStatus -> ModemStatus -> Bool
== :: ModemStatus -> ModemStatus -> Bool
$c== :: ModemStatus -> ModemStatus -> Bool
Eq, Eq ModemStatus
Eq ModemStatus
-> (ModemStatus -> ModemStatus -> Ordering)
-> (ModemStatus -> ModemStatus -> Bool)
-> (ModemStatus -> ModemStatus -> Bool)
-> (ModemStatus -> ModemStatus -> Bool)
-> (ModemStatus -> ModemStatus -> Bool)
-> (ModemStatus -> ModemStatus -> ModemStatus)
-> (ModemStatus -> ModemStatus -> ModemStatus)
-> Ord ModemStatus
ModemStatus -> ModemStatus -> Bool
ModemStatus -> ModemStatus -> Ordering
ModemStatus -> ModemStatus -> ModemStatus
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ModemStatus -> ModemStatus -> ModemStatus
$cmin :: ModemStatus -> ModemStatus -> ModemStatus
max :: ModemStatus -> ModemStatus -> ModemStatus
$cmax :: ModemStatus -> ModemStatus -> ModemStatus
>= :: ModemStatus -> ModemStatus -> Bool
$c>= :: ModemStatus -> ModemStatus -> Bool
> :: ModemStatus -> ModemStatus -> Bool
$c> :: ModemStatus -> ModemStatus -> Bool
<= :: ModemStatus -> ModemStatus -> Bool
$c<= :: ModemStatus -> ModemStatus -> Bool
< :: ModemStatus -> ModemStatus -> Bool
$c< :: ModemStatus -> ModemStatus -> Bool
compare :: ModemStatus -> ModemStatus -> Ordering
$ccompare :: ModemStatus -> ModemStatus -> Ordering
Ord, Int -> ModemStatus -> ShowS
[ModemStatus] -> ShowS
ModemStatus -> String
(Int -> ModemStatus -> ShowS)
-> (ModemStatus -> String)
-> ([ModemStatus] -> ShowS)
-> Show ModemStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModemStatus] -> ShowS
$cshowList :: [ModemStatus] -> ShowS
show :: ModemStatus -> String
$cshow :: ModemStatus -> String
showsPrec :: Int -> ModemStatus -> ShowS
$cshowsPrec :: Int -> ModemStatus -> ShowS
Show, Typeable ModemStatus
Typeable ModemStatus
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModemStatus -> c ModemStatus)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModemStatus)
-> (ModemStatus -> Constr)
-> (ModemStatus -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModemStatus))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ModemStatus))
-> ((forall b. Data b => b -> b) -> ModemStatus -> ModemStatus)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModemStatus -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModemStatus -> r)
-> (forall u. (forall d. Data d => d -> u) -> ModemStatus -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ModemStatus -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModemStatus -> m ModemStatus)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModemStatus -> m ModemStatus)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModemStatus -> m ModemStatus)
-> Data ModemStatus
ModemStatus -> DataType
ModemStatus -> Constr
(forall b. Data b => b -> b) -> ModemStatus -> ModemStatus
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ModemStatus -> u
forall u. (forall d. Data d => d -> u) -> ModemStatus -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModemStatus -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModemStatus -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModemStatus -> m ModemStatus
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModemStatus -> m ModemStatus
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModemStatus
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModemStatus -> c ModemStatus
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModemStatus)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModemStatus)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModemStatus -> m ModemStatus
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModemStatus -> m ModemStatus
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModemStatus -> m ModemStatus
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModemStatus -> m ModemStatus
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModemStatus -> m ModemStatus
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModemStatus -> m ModemStatus
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModemStatus -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModemStatus -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ModemStatus -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModemStatus -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModemStatus -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModemStatus -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModemStatus -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModemStatus -> r
gmapT :: (forall b. Data b => b -> b) -> ModemStatus -> ModemStatus
$cgmapT :: (forall b. Data b => b -> b) -> ModemStatus -> ModemStatus
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModemStatus)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModemStatus)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModemStatus)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModemStatus)
dataTypeOf :: ModemStatus -> DataType
$cdataTypeOf :: ModemStatus -> DataType
toConstr :: ModemStatus -> Constr
$ctoConstr :: ModemStatus -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModemStatus
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModemStatus
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModemStatus -> c ModemStatus
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModemStatus -> c ModemStatus
Data, Typeable, (forall x. ModemStatus -> Rep ModemStatus x)
-> (forall x. Rep ModemStatus x -> ModemStatus)
-> Generic ModemStatus
forall x. Rep ModemStatus x -> ModemStatus
forall x. ModemStatus -> Rep ModemStatus x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ModemStatus x -> ModemStatus
$cfrom :: forall x. ModemStatus -> Rep ModemStatus x
Generic)

marshalModemStatus ∷ ModemStatus → (Word8, Word8)
marshalModemStatus :: ModemStatus -> (Word8, Word8)
marshalModemStatus ModemStatus
ms = (Word8
a, Word8
b)
    where
      a :: Word8
a = [(Int, ModemStatus -> Bool)] -> Word8
mkByte ([(Int, ModemStatus -> Bool)] -> Word8)
-> [(Int, ModemStatus -> Bool)] -> Word8
forall a b. (a -> b) -> a -> b
$ [Int] -> [ModemStatus -> Bool] -> [(Int, ModemStatus -> Bool)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
4..]
                       [ ModemStatus -> Bool
msClearToSend
                       , ModemStatus -> Bool
msDataSetReady
                       , ModemStatus -> Bool
msRingIndicator
                       , ModemStatus -> Bool
msReceiveLineSignalDetect
                       ]
      b :: Word8
b = [(Int, ModemStatus -> Bool)] -> Word8
mkByte ([(Int, ModemStatus -> Bool)] -> Word8)
-> [(Int, ModemStatus -> Bool)] -> Word8
forall a b. (a -> b) -> a -> b
$ [Int] -> [ModemStatus -> Bool] -> [(Int, ModemStatus -> Bool)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0..]
                       [ ModemStatus -> Bool
msDataReady
                       , ModemStatus -> Bool
msOverrunError
                       , ModemStatus -> Bool
msParityError
                       , ModemStatus -> Bool
msFramingError
                       , ModemStatus -> Bool
msBreakInterrupt
                       , ModemStatus -> Bool
msTransmitterHoldingRegister
                       , ModemStatus -> Bool
msTransmitterEmpty
                       , ModemStatus -> Bool
msErrorInReceiverFIFO
                       ]

      mkByte ∷ [(Int, ModemStatus → Bool)] → Word8
      mkByte :: [(Int, ModemStatus -> Bool)] -> Word8
mkByte = ((Int, ModemStatus -> Bool) -> Word8 -> Word8)
-> Word8 -> [(Int, ModemStatus -> Bool)] -> Word8
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\(Int
n, ModemStatus -> Bool
f) Word8
x → if ModemStatus -> Bool
f ModemStatus
ms then Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
setBit Word8
x Int
n else Word8
x) Word8
0

unmarshalModemStatus ∷ Word8 → Word8 → ModemStatus
unmarshalModemStatus :: Word8 -> Word8 -> ModemStatus
unmarshalModemStatus Word8
a Word8
b =
    ModemStatus :: Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> ModemStatus
ModemStatus { msClearToSend :: Bool
msClearToSend                = Word8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Word8
a Int
4
                , msDataSetReady :: Bool
msDataSetReady               = Word8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Word8
a Int
5
                , msRingIndicator :: Bool
msRingIndicator              = Word8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Word8
a Int
6
                , msReceiveLineSignalDetect :: Bool
msReceiveLineSignalDetect    = Word8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Word8
a Int
7
                , msDataReady :: Bool
msDataReady                  = Word8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Word8
b Int
0
                , msOverrunError :: Bool
msOverrunError               = Word8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Word8
b Int
1
                , msParityError :: Bool
msParityError                = Word8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Word8
b Int
2
                , msFramingError :: Bool
msFramingError               = Word8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Word8
b Int
3
                , msBreakInterrupt :: Bool
msBreakInterrupt             = Word8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Word8
b Int
4
                , msTransmitterHoldingRegister :: Bool
msTransmitterHoldingRegister = Word8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Word8
b Int
5
                , msTransmitterEmpty :: Bool
msTransmitterEmpty           = Word8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Word8
b Int
6
                , msErrorInReceiverFIFO :: Bool
msErrorInReceiverFIFO        = Word8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Word8
b Int
7
                }

-- |Manually request the modem status.
pollModemStatus ∷ InterfaceHandle → IO ModemStatus
pollModemStatus :: InterfaceHandle -> IO ModemStatus
pollModemStatus InterfaceHandle
ifHnd = do
    (ByteString
bs, Status
_) ← InterfaceHandle
-> Word8 -> Word16 -> Int -> IO (ByteString, Status)
readControl InterfaceHandle
ifHnd Word8
reqPollModemStatus Word16
0 Int
2
    case ByteString -> [Word8]
BS.unpack ByteString
bs of
      [Word8
x,Word8
y] → ModemStatus -> IO ModemStatus
forall (m :: * -> *) a. Monad m => a -> m a
return (ModemStatus -> IO ModemStatus) -> ModemStatus -> IO ModemStatus
forall a b. (a -> b) -> a -> b
$ Word8 -> Word8 -> ModemStatus
unmarshalModemStatus Word8
x Word8
y
      [Word8]
_     → String -> IO ModemStatus
forall a. HasCallStack => String -> a
error String
"System.FTDI.pollModemStatus: failed"


-------------------------------------------------------------------------------
-- Flow control
-------------------------------------------------------------------------------

data FlowCtrl = RTS_CTS -- ^Request-To-Send \/ Clear-To-Send
              | DTR_DSR -- ^Data-Terminal-Ready \/ Data-Set-Ready
              | XOnXOff -- ^Transmitter on \/ Transmitter off

marshalFlowControl ∷ FlowCtrl → Word16
marshalFlowControl :: FlowCtrl -> Word16
marshalFlowControl FlowCtrl
f = case FlowCtrl
f of
                         FlowCtrl
RTS_CTS → Word16
0x0100
                         FlowCtrl
DTR_DSR → Word16
0x0200
                         FlowCtrl
XOnXOff → Word16
0x0400

-- |Set the flow control for the FTDI chip. Use 'Nothing' to disable flow
-- control.
setFlowControl ∷ InterfaceHandle → Maybe FlowCtrl → IO ()
setFlowControl :: InterfaceHandle -> Maybe FlowCtrl -> IO ()
setFlowControl InterfaceHandle
ifHnd Maybe FlowCtrl
mFC = USBControl (IO ())
-> Word16 -> InterfaceHandle -> Word8 -> Word16 -> IO ()
forall α.
USBControl α -> Word16 -> InterfaceHandle -> Word8 -> Word16 -> α
genControl USBControl (IO ())
USB.control
                                      (Word16 -> (FlowCtrl -> Word16) -> Maybe FlowCtrl -> Word16
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Word16
0 FlowCtrl -> Word16
marshalFlowControl Maybe FlowCtrl
mFC)
                                      InterfaceHandle
ifHnd
                                      Word8
reqSetFlowCtrl
                                      Word16
0

-- |Set DTR line.
setDTR ∷ InterfaceHandle → Bool → IO ()
setDTR :: InterfaceHandle -> Bool -> IO ()
setDTR InterfaceHandle
ifHnd Bool
b = InterfaceHandle -> Word8 -> Word16 -> IO ()
control InterfaceHandle
ifHnd Word8
reqSetModemCtrl
               (Word16 -> IO ()) -> Word16 -> IO ()
forall a b. (a -> b) -> a -> b
$ if Bool
b then Word16
valSetDTRHigh else Word16
valSetDTRLow

-- |Set RTS line.
setRTS ∷ InterfaceHandle → Bool → IO ()
setRTS :: InterfaceHandle -> Bool -> IO ()
setRTS InterfaceHandle
ifHnd Bool
b = InterfaceHandle -> Word8 -> Word16 -> IO ()
control InterfaceHandle
ifHnd Word8
reqSetModemCtrl
               (Word16 -> IO ()) -> Word16 -> IO ()
forall a b. (a -> b) -> a -> b
$ if Bool
b then Word16
valSetRTSHigh else Word16
valSetRTSLow

genSetCharacter ∷ RequestCode → InterfaceHandle → Maybe Word8 → IO ()
genSetCharacter :: Word8 -> InterfaceHandle -> Maybe Word8 -> IO ()
genSetCharacter Word8
req InterfaceHandle
ifHnd Maybe Word8
mEC =
    InterfaceHandle -> Word8 -> Word16 -> IO ()
control InterfaceHandle
ifHnd Word8
req (Word16 -> IO ()) -> Word16 -> IO ()
forall a b. (a -> b) -> a -> b
$ Word16 -> (Word8 -> Word16) -> Maybe Word8 -> Word16
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Word16
0 (\Word8
c → Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
setBit (Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
c) Int
8) Maybe Word8
mEC

-- |Set the special event character. Use 'Nothing' to disable the event
-- character.
setEventCharacter ∷ InterfaceHandle → Maybe Word8 → IO ()
setEventCharacter :: InterfaceHandle -> Maybe Word8 -> IO ()
setEventCharacter = Word8 -> InterfaceHandle -> Maybe Word8 -> IO ()
genSetCharacter Word8
reqSetEventChar

-- |Set the error character.  Use 'Nothing' to disable the error character.
setErrorCharacter ∷ InterfaceHandle → Maybe Word8 → IO ()
setErrorCharacter :: InterfaceHandle -> Maybe Word8 -> IO ()
setErrorCharacter = Word8 -> InterfaceHandle -> Maybe Word8 -> IO ()
genSetCharacter Word8
reqSetErrorChar


-------------------------------------------------------------------------------
-- Baud rate
-------------------------------------------------------------------------------

newtype BRDiv α = BRDiv {forall α. BRDiv α -> α
unBRDiv ∷ α}
    deriving ( BRDiv α -> BRDiv α -> Bool
(BRDiv α -> BRDiv α -> Bool)
-> (BRDiv α -> BRDiv α -> Bool) -> Eq (BRDiv α)
forall α. Eq α => BRDiv α -> BRDiv α -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BRDiv α -> BRDiv α -> Bool
$c/= :: forall α. Eq α => BRDiv α -> BRDiv α -> Bool
== :: BRDiv α -> BRDiv α -> Bool
$c== :: forall α. Eq α => BRDiv α -> BRDiv α -> Bool
Eq, Eq (BRDiv α)
Eq (BRDiv α)
-> (BRDiv α -> BRDiv α -> Ordering)
-> (BRDiv α -> BRDiv α -> Bool)
-> (BRDiv α -> BRDiv α -> Bool)
-> (BRDiv α -> BRDiv α -> Bool)
-> (BRDiv α -> BRDiv α -> Bool)
-> (BRDiv α -> BRDiv α -> BRDiv α)
-> (BRDiv α -> BRDiv α -> BRDiv α)
-> Ord (BRDiv α)
BRDiv α -> BRDiv α -> Bool
BRDiv α -> BRDiv α -> Ordering
BRDiv α -> BRDiv α -> BRDiv α
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {α}. Ord α => Eq (BRDiv α)
forall α. Ord α => BRDiv α -> BRDiv α -> Bool
forall α. Ord α => BRDiv α -> BRDiv α -> Ordering
forall α. Ord α => BRDiv α -> BRDiv α -> BRDiv α
min :: BRDiv α -> BRDiv α -> BRDiv α
$cmin :: forall α. Ord α => BRDiv α -> BRDiv α -> BRDiv α
max :: BRDiv α -> BRDiv α -> BRDiv α
$cmax :: forall α. Ord α => BRDiv α -> BRDiv α -> BRDiv α
>= :: BRDiv α -> BRDiv α -> Bool
$c>= :: forall α. Ord α => BRDiv α -> BRDiv α -> Bool
> :: BRDiv α -> BRDiv α -> Bool
$c> :: forall α. Ord α => BRDiv α -> BRDiv α -> Bool
<= :: BRDiv α -> BRDiv α -> Bool
$c<= :: forall α. Ord α => BRDiv α -> BRDiv α -> Bool
< :: BRDiv α -> BRDiv α -> Bool
$c< :: forall α. Ord α => BRDiv α -> BRDiv α -> Bool
compare :: BRDiv α -> BRDiv α -> Ordering
$ccompare :: forall α. Ord α => BRDiv α -> BRDiv α -> Ordering
Ord, Int -> BRDiv α -> ShowS
[BRDiv α] -> ShowS
BRDiv α -> String
(Int -> BRDiv α -> ShowS)
-> (BRDiv α -> String) -> ([BRDiv α] -> ShowS) -> Show (BRDiv α)
forall α. Show α => Int -> BRDiv α -> ShowS
forall α. Show α => [BRDiv α] -> ShowS
forall α. Show α => BRDiv α -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BRDiv α] -> ShowS
$cshowList :: forall α. Show α => [BRDiv α] -> ShowS
show :: BRDiv α -> String
$cshow :: forall α. Show α => BRDiv α -> String
showsPrec :: Int -> BRDiv α -> ShowS
$cshowsPrec :: forall α. Show α => Int -> BRDiv α -> ShowS
Show, ReadPrec [BRDiv α]
ReadPrec (BRDiv α)
Int -> ReadS (BRDiv α)
ReadS [BRDiv α]
(Int -> ReadS (BRDiv α))
-> ReadS [BRDiv α]
-> ReadPrec (BRDiv α)
-> ReadPrec [BRDiv α]
-> Read (BRDiv α)
forall α. Read α => ReadPrec [BRDiv α]
forall α. Read α => ReadPrec (BRDiv α)
forall α. Read α => Int -> ReadS (BRDiv α)
forall α. Read α => ReadS [BRDiv α]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BRDiv α]
$creadListPrec :: forall α. Read α => ReadPrec [BRDiv α]
readPrec :: ReadPrec (BRDiv α)
$creadPrec :: forall α. Read α => ReadPrec (BRDiv α)
readList :: ReadS [BRDiv α]
$creadList :: forall α. Read α => ReadS [BRDiv α]
readsPrec :: Int -> ReadS (BRDiv α)
$creadsPrec :: forall α. Read α => Int -> ReadS (BRDiv α)
Read, Int -> BRDiv α
BRDiv α -> Int
BRDiv α -> [BRDiv α]
BRDiv α -> BRDiv α
BRDiv α -> BRDiv α -> [BRDiv α]
BRDiv α -> BRDiv α -> BRDiv α -> [BRDiv α]
(BRDiv α -> BRDiv α)
-> (BRDiv α -> BRDiv α)
-> (Int -> BRDiv α)
-> (BRDiv α -> Int)
-> (BRDiv α -> [BRDiv α])
-> (BRDiv α -> BRDiv α -> [BRDiv α])
-> (BRDiv α -> BRDiv α -> [BRDiv α])
-> (BRDiv α -> BRDiv α -> BRDiv α -> [BRDiv α])
-> Enum (BRDiv α)
forall α. Enum α => Int -> BRDiv α
forall α. Enum α => BRDiv α -> Int
forall α. Enum α => BRDiv α -> [BRDiv α]
forall α. Enum α => BRDiv α -> BRDiv α
forall α. Enum α => BRDiv α -> BRDiv α -> [BRDiv α]
forall α. Enum α => BRDiv α -> BRDiv α -> BRDiv α -> [BRDiv α]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: BRDiv α -> BRDiv α -> BRDiv α -> [BRDiv α]
$cenumFromThenTo :: forall α. Enum α => BRDiv α -> BRDiv α -> BRDiv α -> [BRDiv α]
enumFromTo :: BRDiv α -> BRDiv α -> [BRDiv α]
$cenumFromTo :: forall α. Enum α => BRDiv α -> BRDiv α -> [BRDiv α]
enumFromThen :: BRDiv α -> BRDiv α -> [BRDiv α]
$cenumFromThen :: forall α. Enum α => BRDiv α -> BRDiv α -> [BRDiv α]
enumFrom :: BRDiv α -> [BRDiv α]
$cenumFrom :: forall α. Enum α => BRDiv α -> [BRDiv α]
fromEnum :: BRDiv α -> Int
$cfromEnum :: forall α. Enum α => BRDiv α -> Int
toEnum :: Int -> BRDiv α
$ctoEnum :: forall α. Enum α => Int -> BRDiv α
pred :: BRDiv α -> BRDiv α
$cpred :: forall α. Enum α => BRDiv α -> BRDiv α
succ :: BRDiv α -> BRDiv α
$csucc :: forall α. Enum α => BRDiv α -> BRDiv α
Enum, Integer -> BRDiv α
BRDiv α -> BRDiv α
BRDiv α -> BRDiv α -> BRDiv α
(BRDiv α -> BRDiv α -> BRDiv α)
-> (BRDiv α -> BRDiv α -> BRDiv α)
-> (BRDiv α -> BRDiv α -> BRDiv α)
-> (BRDiv α -> BRDiv α)
-> (BRDiv α -> BRDiv α)
-> (BRDiv α -> BRDiv α)
-> (Integer -> BRDiv α)
-> Num (BRDiv α)
forall α. Num α => Integer -> BRDiv α
forall α. Num α => BRDiv α -> BRDiv α
forall α. Num α => BRDiv α -> BRDiv α -> BRDiv α
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> BRDiv α
$cfromInteger :: forall α. Num α => Integer -> BRDiv α
signum :: BRDiv α -> BRDiv α
$csignum :: forall α. Num α => BRDiv α -> BRDiv α
abs :: BRDiv α -> BRDiv α
$cabs :: forall α. Num α => BRDiv α -> BRDiv α
negate :: BRDiv α -> BRDiv α
$cnegate :: forall α. Num α => BRDiv α -> BRDiv α
* :: BRDiv α -> BRDiv α -> BRDiv α
$c* :: forall α. Num α => BRDiv α -> BRDiv α -> BRDiv α
- :: BRDiv α -> BRDiv α -> BRDiv α
$c- :: forall α. Num α => BRDiv α -> BRDiv α -> BRDiv α
+ :: BRDiv α -> BRDiv α -> BRDiv α
$c+ :: forall α. Num α => BRDiv α -> BRDiv α -> BRDiv α
Num, Enum (BRDiv α)
Real (BRDiv α)
Real (BRDiv α)
-> Enum (BRDiv α)
-> (BRDiv α -> BRDiv α -> BRDiv α)
-> (BRDiv α -> BRDiv α -> BRDiv α)
-> (BRDiv α -> BRDiv α -> BRDiv α)
-> (BRDiv α -> BRDiv α -> BRDiv α)
-> (BRDiv α -> BRDiv α -> (BRDiv α, BRDiv α))
-> (BRDiv α -> BRDiv α -> (BRDiv α, BRDiv α))
-> (BRDiv α -> Integer)
-> Integral (BRDiv α)
BRDiv α -> Integer
BRDiv α -> BRDiv α -> (BRDiv α, BRDiv α)
BRDiv α -> BRDiv α -> BRDiv α
forall {α}. Integral α => Enum (BRDiv α)
forall {α}. Integral α => Real (BRDiv α)
forall α. Integral α => BRDiv α -> Integer
forall α. Integral α => BRDiv α -> BRDiv α -> (BRDiv α, BRDiv α)
forall α. Integral α => BRDiv α -> BRDiv α -> BRDiv α
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
toInteger :: BRDiv α -> Integer
$ctoInteger :: forall α. Integral α => BRDiv α -> Integer
divMod :: BRDiv α -> BRDiv α -> (BRDiv α, BRDiv α)
$cdivMod :: forall α. Integral α => BRDiv α -> BRDiv α -> (BRDiv α, BRDiv α)
quotRem :: BRDiv α -> BRDiv α -> (BRDiv α, BRDiv α)
$cquotRem :: forall α. Integral α => BRDiv α -> BRDiv α -> (BRDiv α, BRDiv α)
mod :: BRDiv α -> BRDiv α -> BRDiv α
$cmod :: forall α. Integral α => BRDiv α -> BRDiv α -> BRDiv α
div :: BRDiv α -> BRDiv α -> BRDiv α
$cdiv :: forall α. Integral α => BRDiv α -> BRDiv α -> BRDiv α
rem :: BRDiv α -> BRDiv α -> BRDiv α
$crem :: forall α. Integral α => BRDiv α -> BRDiv α -> BRDiv α
quot :: BRDiv α -> BRDiv α -> BRDiv α
$cquot :: forall α. Integral α => BRDiv α -> BRDiv α -> BRDiv α
Integral
             , Num (BRDiv α)
Ord (BRDiv α)
Num (BRDiv α)
-> Ord (BRDiv α) -> (BRDiv α -> Rational) -> Real (BRDiv α)
BRDiv α -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
forall {α}. Real α => Num (BRDiv α)
forall {α}. Real α => Ord (BRDiv α)
forall α. Real α => BRDiv α -> Rational
toRational :: BRDiv α -> Rational
$ctoRational :: forall α. Real α => BRDiv α -> Rational
Real, Num (BRDiv α)
Num (BRDiv α)
-> (BRDiv α -> BRDiv α -> BRDiv α)
-> (BRDiv α -> BRDiv α)
-> (Rational -> BRDiv α)
-> Fractional (BRDiv α)
Rational -> BRDiv α
BRDiv α -> BRDiv α
BRDiv α -> BRDiv α -> BRDiv α
forall {α}. Fractional α => Num (BRDiv α)
forall α. Fractional α => Rational -> BRDiv α
forall α. Fractional α => BRDiv α -> BRDiv α
forall α. Fractional α => BRDiv α -> BRDiv α -> BRDiv α
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> BRDiv α
$cfromRational :: forall α. Fractional α => Rational -> BRDiv α
recip :: BRDiv α -> BRDiv α
$crecip :: forall α. Fractional α => BRDiv α -> BRDiv α
/ :: BRDiv α -> BRDiv α -> BRDiv α
$c/ :: forall α. Fractional α => BRDiv α -> BRDiv α -> BRDiv α
Fractional, Fractional (BRDiv α)
Real (BRDiv α)
Real (BRDiv α)
-> Fractional (BRDiv α)
-> (forall b. Integral b => BRDiv α -> (b, BRDiv α))
-> (forall b. Integral b => BRDiv α -> b)
-> (forall b. Integral b => BRDiv α -> b)
-> (forall b. Integral b => BRDiv α -> b)
-> (forall b. Integral b => BRDiv α -> b)
-> RealFrac (BRDiv α)
forall b. Integral b => BRDiv α -> b
forall b. Integral b => BRDiv α -> (b, BRDiv α)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
forall {α}. RealFrac α => Fractional (BRDiv α)
forall {α}. RealFrac α => Real (BRDiv α)
forall α b. (RealFrac α, Integral b) => BRDiv α -> b
forall α b. (RealFrac α, Integral b) => BRDiv α -> (b, BRDiv α)
floor :: forall b. Integral b => BRDiv α -> b
$cfloor :: forall α b. (RealFrac α, Integral b) => BRDiv α -> b
ceiling :: forall b. Integral b => BRDiv α -> b
$cceiling :: forall α b. (RealFrac α, Integral b) => BRDiv α -> b
round :: forall b. Integral b => BRDiv α -> b
$cround :: forall α b. (RealFrac α, Integral b) => BRDiv α -> b
truncate :: forall b. Integral b => BRDiv α -> b
$ctruncate :: forall α b. (RealFrac α, Integral b) => BRDiv α -> b
properFraction :: forall b. Integral b => BRDiv α -> (b, BRDiv α)
$cproperFraction :: forall α b. (RealFrac α, Integral b) => BRDiv α -> (b, BRDiv α)
RealFrac
             )

instance Num α ⇒ Bounded (BRDiv α) where
    minBound :: BRDiv α
minBound = BRDiv α
0
    maxBound :: BRDiv α
maxBound = BRDiv α
2 BRDiv α -> Int -> BRDiv α
forall a b. (Num a, Integral b) => a -> b -> a
^ (Int
14 ∷ Int) BRDiv α -> BRDiv α -> BRDiv α
forall a. Num a => a -> a -> a
- BRDiv α
1

newtype BRSubDiv α = BRSubDiv {forall α. BRSubDiv α -> α
unBRSubDiv ∷ α}
    deriving ( BRSubDiv α -> BRSubDiv α -> Bool
(BRSubDiv α -> BRSubDiv α -> Bool)
-> (BRSubDiv α -> BRSubDiv α -> Bool) -> Eq (BRSubDiv α)
forall α. Eq α => BRSubDiv α -> BRSubDiv α -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BRSubDiv α -> BRSubDiv α -> Bool
$c/= :: forall α. Eq α => BRSubDiv α -> BRSubDiv α -> Bool
== :: BRSubDiv α -> BRSubDiv α -> Bool
$c== :: forall α. Eq α => BRSubDiv α -> BRSubDiv α -> Bool
Eq, Eq (BRSubDiv α)
Eq (BRSubDiv α)
-> (BRSubDiv α -> BRSubDiv α -> Ordering)
-> (BRSubDiv α -> BRSubDiv α -> Bool)
-> (BRSubDiv α -> BRSubDiv α -> Bool)
-> (BRSubDiv α -> BRSubDiv α -> Bool)
-> (BRSubDiv α -> BRSubDiv α -> Bool)
-> (BRSubDiv α -> BRSubDiv α -> BRSubDiv α)
-> (BRSubDiv α -> BRSubDiv α -> BRSubDiv α)
-> Ord (BRSubDiv α)
BRSubDiv α -> BRSubDiv α -> Bool
BRSubDiv α -> BRSubDiv α -> Ordering
BRSubDiv α -> BRSubDiv α -> BRSubDiv α
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {α}. Ord α => Eq (BRSubDiv α)
forall α. Ord α => BRSubDiv α -> BRSubDiv α -> Bool
forall α. Ord α => BRSubDiv α -> BRSubDiv α -> Ordering
forall α. Ord α => BRSubDiv α -> BRSubDiv α -> BRSubDiv α
min :: BRSubDiv α -> BRSubDiv α -> BRSubDiv α
$cmin :: forall α. Ord α => BRSubDiv α -> BRSubDiv α -> BRSubDiv α
max :: BRSubDiv α -> BRSubDiv α -> BRSubDiv α
$cmax :: forall α. Ord α => BRSubDiv α -> BRSubDiv α -> BRSubDiv α
>= :: BRSubDiv α -> BRSubDiv α -> Bool
$c>= :: forall α. Ord α => BRSubDiv α -> BRSubDiv α -> Bool
> :: BRSubDiv α -> BRSubDiv α -> Bool
$c> :: forall α. Ord α => BRSubDiv α -> BRSubDiv α -> Bool
<= :: BRSubDiv α -> BRSubDiv α -> Bool
$c<= :: forall α. Ord α => BRSubDiv α -> BRSubDiv α -> Bool
< :: BRSubDiv α -> BRSubDiv α -> Bool
$c< :: forall α. Ord α => BRSubDiv α -> BRSubDiv α -> Bool
compare :: BRSubDiv α -> BRSubDiv α -> Ordering
$ccompare :: forall α. Ord α => BRSubDiv α -> BRSubDiv α -> Ordering
Ord, Int -> BRSubDiv α -> ShowS
[BRSubDiv α] -> ShowS
BRSubDiv α -> String
(Int -> BRSubDiv α -> ShowS)
-> (BRSubDiv α -> String)
-> ([BRSubDiv α] -> ShowS)
-> Show (BRSubDiv α)
forall α. Show α => Int -> BRSubDiv α -> ShowS
forall α. Show α => [BRSubDiv α] -> ShowS
forall α. Show α => BRSubDiv α -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BRSubDiv α] -> ShowS
$cshowList :: forall α. Show α => [BRSubDiv α] -> ShowS
show :: BRSubDiv α -> String
$cshow :: forall α. Show α => BRSubDiv α -> String
showsPrec :: Int -> BRSubDiv α -> ShowS
$cshowsPrec :: forall α. Show α => Int -> BRSubDiv α -> ShowS
Show, ReadPrec [BRSubDiv α]
ReadPrec (BRSubDiv α)
Int -> ReadS (BRSubDiv α)
ReadS [BRSubDiv α]
(Int -> ReadS (BRSubDiv α))
-> ReadS [BRSubDiv α]
-> ReadPrec (BRSubDiv α)
-> ReadPrec [BRSubDiv α]
-> Read (BRSubDiv α)
forall α. Read α => ReadPrec [BRSubDiv α]
forall α. Read α => ReadPrec (BRSubDiv α)
forall α. Read α => Int -> ReadS (BRSubDiv α)
forall α. Read α => ReadS [BRSubDiv α]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BRSubDiv α]
$creadListPrec :: forall α. Read α => ReadPrec [BRSubDiv α]
readPrec :: ReadPrec (BRSubDiv α)
$creadPrec :: forall α. Read α => ReadPrec (BRSubDiv α)
readList :: ReadS [BRSubDiv α]
$creadList :: forall α. Read α => ReadS [BRSubDiv α]
readsPrec :: Int -> ReadS (BRSubDiv α)
$creadsPrec :: forall α. Read α => Int -> ReadS (BRSubDiv α)
Read, Int -> BRSubDiv α
BRSubDiv α -> Int
BRSubDiv α -> [BRSubDiv α]
BRSubDiv α -> BRSubDiv α
BRSubDiv α -> BRSubDiv α -> [BRSubDiv α]
BRSubDiv α -> BRSubDiv α -> BRSubDiv α -> [BRSubDiv α]
(BRSubDiv α -> BRSubDiv α)
-> (BRSubDiv α -> BRSubDiv α)
-> (Int -> BRSubDiv α)
-> (BRSubDiv α -> Int)
-> (BRSubDiv α -> [BRSubDiv α])
-> (BRSubDiv α -> BRSubDiv α -> [BRSubDiv α])
-> (BRSubDiv α -> BRSubDiv α -> [BRSubDiv α])
-> (BRSubDiv α -> BRSubDiv α -> BRSubDiv α -> [BRSubDiv α])
-> Enum (BRSubDiv α)
forall α. Enum α => Int -> BRSubDiv α
forall α. Enum α => BRSubDiv α -> Int
forall α. Enum α => BRSubDiv α -> [BRSubDiv α]
forall α. Enum α => BRSubDiv α -> BRSubDiv α
forall α. Enum α => BRSubDiv α -> BRSubDiv α -> [BRSubDiv α]
forall α.
Enum α =>
BRSubDiv α -> BRSubDiv α -> BRSubDiv α -> [BRSubDiv α]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: BRSubDiv α -> BRSubDiv α -> BRSubDiv α -> [BRSubDiv α]
$cenumFromThenTo :: forall α.
Enum α =>
BRSubDiv α -> BRSubDiv α -> BRSubDiv α -> [BRSubDiv α]
enumFromTo :: BRSubDiv α -> BRSubDiv α -> [BRSubDiv α]
$cenumFromTo :: forall α. Enum α => BRSubDiv α -> BRSubDiv α -> [BRSubDiv α]
enumFromThen :: BRSubDiv α -> BRSubDiv α -> [BRSubDiv α]
$cenumFromThen :: forall α. Enum α => BRSubDiv α -> BRSubDiv α -> [BRSubDiv α]
enumFrom :: BRSubDiv α -> [BRSubDiv α]
$cenumFrom :: forall α. Enum α => BRSubDiv α -> [BRSubDiv α]
fromEnum :: BRSubDiv α -> Int
$cfromEnum :: forall α. Enum α => BRSubDiv α -> Int
toEnum :: Int -> BRSubDiv α
$ctoEnum :: forall α. Enum α => Int -> BRSubDiv α
pred :: BRSubDiv α -> BRSubDiv α
$cpred :: forall α. Enum α => BRSubDiv α -> BRSubDiv α
succ :: BRSubDiv α -> BRSubDiv α
$csucc :: forall α. Enum α => BRSubDiv α -> BRSubDiv α
Enum, Integer -> BRSubDiv α
BRSubDiv α -> BRSubDiv α
BRSubDiv α -> BRSubDiv α -> BRSubDiv α
(BRSubDiv α -> BRSubDiv α -> BRSubDiv α)
-> (BRSubDiv α -> BRSubDiv α -> BRSubDiv α)
-> (BRSubDiv α -> BRSubDiv α -> BRSubDiv α)
-> (BRSubDiv α -> BRSubDiv α)
-> (BRSubDiv α -> BRSubDiv α)
-> (BRSubDiv α -> BRSubDiv α)
-> (Integer -> BRSubDiv α)
-> Num (BRSubDiv α)
forall α. Num α => Integer -> BRSubDiv α
forall α. Num α => BRSubDiv α -> BRSubDiv α
forall α. Num α => BRSubDiv α -> BRSubDiv α -> BRSubDiv α
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> BRSubDiv α
$cfromInteger :: forall α. Num α => Integer -> BRSubDiv α
signum :: BRSubDiv α -> BRSubDiv α
$csignum :: forall α. Num α => BRSubDiv α -> BRSubDiv α
abs :: BRSubDiv α -> BRSubDiv α
$cabs :: forall α. Num α => BRSubDiv α -> BRSubDiv α
negate :: BRSubDiv α -> BRSubDiv α
$cnegate :: forall α. Num α => BRSubDiv α -> BRSubDiv α
* :: BRSubDiv α -> BRSubDiv α -> BRSubDiv α
$c* :: forall α. Num α => BRSubDiv α -> BRSubDiv α -> BRSubDiv α
- :: BRSubDiv α -> BRSubDiv α -> BRSubDiv α
$c- :: forall α. Num α => BRSubDiv α -> BRSubDiv α -> BRSubDiv α
+ :: BRSubDiv α -> BRSubDiv α -> BRSubDiv α
$c+ :: forall α. Num α => BRSubDiv α -> BRSubDiv α -> BRSubDiv α
Num, Enum (BRSubDiv α)
Real (BRSubDiv α)
Real (BRSubDiv α)
-> Enum (BRSubDiv α)
-> (BRSubDiv α -> BRSubDiv α -> BRSubDiv α)
-> (BRSubDiv α -> BRSubDiv α -> BRSubDiv α)
-> (BRSubDiv α -> BRSubDiv α -> BRSubDiv α)
-> (BRSubDiv α -> BRSubDiv α -> BRSubDiv α)
-> (BRSubDiv α -> BRSubDiv α -> (BRSubDiv α, BRSubDiv α))
-> (BRSubDiv α -> BRSubDiv α -> (BRSubDiv α, BRSubDiv α))
-> (BRSubDiv α -> Integer)
-> Integral (BRSubDiv α)
BRSubDiv α -> Integer
BRSubDiv α -> BRSubDiv α -> (BRSubDiv α, BRSubDiv α)
BRSubDiv α -> BRSubDiv α -> BRSubDiv α
forall {α}. Integral α => Enum (BRSubDiv α)
forall {α}. Integral α => Real (BRSubDiv α)
forall α. Integral α => BRSubDiv α -> Integer
forall α.
Integral α =>
BRSubDiv α -> BRSubDiv α -> (BRSubDiv α, BRSubDiv α)
forall α. Integral α => BRSubDiv α -> BRSubDiv α -> BRSubDiv α
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
toInteger :: BRSubDiv α -> Integer
$ctoInteger :: forall α. Integral α => BRSubDiv α -> Integer
divMod :: BRSubDiv α -> BRSubDiv α -> (BRSubDiv α, BRSubDiv α)
$cdivMod :: forall α.
Integral α =>
BRSubDiv α -> BRSubDiv α -> (BRSubDiv α, BRSubDiv α)
quotRem :: BRSubDiv α -> BRSubDiv α -> (BRSubDiv α, BRSubDiv α)
$cquotRem :: forall α.
Integral α =>
BRSubDiv α -> BRSubDiv α -> (BRSubDiv α, BRSubDiv α)
mod :: BRSubDiv α -> BRSubDiv α -> BRSubDiv α
$cmod :: forall α. Integral α => BRSubDiv α -> BRSubDiv α -> BRSubDiv α
div :: BRSubDiv α -> BRSubDiv α -> BRSubDiv α
$cdiv :: forall α. Integral α => BRSubDiv α -> BRSubDiv α -> BRSubDiv α
rem :: BRSubDiv α -> BRSubDiv α -> BRSubDiv α
$crem :: forall α. Integral α => BRSubDiv α -> BRSubDiv α -> BRSubDiv α
quot :: BRSubDiv α -> BRSubDiv α -> BRSubDiv α
$cquot :: forall α. Integral α => BRSubDiv α -> BRSubDiv α -> BRSubDiv α
Integral
             , Num (BRSubDiv α)
Ord (BRSubDiv α)
Num (BRSubDiv α)
-> Ord (BRSubDiv α)
-> (BRSubDiv α -> Rational)
-> Real (BRSubDiv α)
BRSubDiv α -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
forall {α}. Real α => Num (BRSubDiv α)
forall {α}. Real α => Ord (BRSubDiv α)
forall α. Real α => BRSubDiv α -> Rational
toRational :: BRSubDiv α -> Rational
$ctoRational :: forall α. Real α => BRSubDiv α -> Rational
Real, Num (BRSubDiv α)
Num (BRSubDiv α)
-> (BRSubDiv α -> BRSubDiv α -> BRSubDiv α)
-> (BRSubDiv α -> BRSubDiv α)
-> (Rational -> BRSubDiv α)
-> Fractional (BRSubDiv α)
Rational -> BRSubDiv α
BRSubDiv α -> BRSubDiv α
BRSubDiv α -> BRSubDiv α -> BRSubDiv α
forall {α}. Fractional α => Num (BRSubDiv α)
forall α. Fractional α => Rational -> BRSubDiv α
forall α. Fractional α => BRSubDiv α -> BRSubDiv α
forall α. Fractional α => BRSubDiv α -> BRSubDiv α -> BRSubDiv α
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> BRSubDiv α
$cfromRational :: forall α. Fractional α => Rational -> BRSubDiv α
recip :: BRSubDiv α -> BRSubDiv α
$crecip :: forall α. Fractional α => BRSubDiv α -> BRSubDiv α
/ :: BRSubDiv α -> BRSubDiv α -> BRSubDiv α
$c/ :: forall α. Fractional α => BRSubDiv α -> BRSubDiv α -> BRSubDiv α
Fractional, Fractional (BRSubDiv α)
Real (BRSubDiv α)
Real (BRSubDiv α)
-> Fractional (BRSubDiv α)
-> (forall b. Integral b => BRSubDiv α -> (b, BRSubDiv α))
-> (forall b. Integral b => BRSubDiv α -> b)
-> (forall b. Integral b => BRSubDiv α -> b)
-> (forall b. Integral b => BRSubDiv α -> b)
-> (forall b. Integral b => BRSubDiv α -> b)
-> RealFrac (BRSubDiv α)
forall b. Integral b => BRSubDiv α -> b
forall b. Integral b => BRSubDiv α -> (b, BRSubDiv α)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
forall {α}. RealFrac α => Fractional (BRSubDiv α)
forall {α}. RealFrac α => Real (BRSubDiv α)
forall α b. (RealFrac α, Integral b) => BRSubDiv α -> b
forall α b.
(RealFrac α, Integral b) =>
BRSubDiv α -> (b, BRSubDiv α)
floor :: forall b. Integral b => BRSubDiv α -> b
$cfloor :: forall α b. (RealFrac α, Integral b) => BRSubDiv α -> b
ceiling :: forall b. Integral b => BRSubDiv α -> b
$cceiling :: forall α b. (RealFrac α, Integral b) => BRSubDiv α -> b
round :: forall b. Integral b => BRSubDiv α -> b
$cround :: forall α b. (RealFrac α, Integral b) => BRSubDiv α -> b
truncate :: forall b. Integral b => BRSubDiv α -> b
$ctruncate :: forall α b. (RealFrac α, Integral b) => BRSubDiv α -> b
properFraction :: forall b. Integral b => BRSubDiv α -> (b, BRSubDiv α)
$cproperFraction :: forall α b.
(RealFrac α, Integral b) =>
BRSubDiv α -> (b, BRSubDiv α)
RealFrac
             )

instance Num α ⇒ Bounded (BRSubDiv α) where
    minBound :: BRSubDiv α
minBound = BRSubDiv α
0
    maxBound :: BRSubDiv α
maxBound = BRSubDiv α
7

-- |Representation of a baud rate. The most interesting part is the
-- instance for 'Bounded'.
newtype BaudRate α = BaudRate {forall α. BaudRate α -> α
unBaudRate ∷ α}
    deriving ( BaudRate α -> BaudRate α -> Bool
(BaudRate α -> BaudRate α -> Bool)
-> (BaudRate α -> BaudRate α -> Bool) -> Eq (BaudRate α)
forall α. Eq α => BaudRate α -> BaudRate α -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BaudRate α -> BaudRate α -> Bool
$c/= :: forall α. Eq α => BaudRate α -> BaudRate α -> Bool
== :: BaudRate α -> BaudRate α -> Bool
$c== :: forall α. Eq α => BaudRate α -> BaudRate α -> Bool
Eq, Eq (BaudRate α)
Eq (BaudRate α)
-> (BaudRate α -> BaudRate α -> Ordering)
-> (BaudRate α -> BaudRate α -> Bool)
-> (BaudRate α -> BaudRate α -> Bool)
-> (BaudRate α -> BaudRate α -> Bool)
-> (BaudRate α -> BaudRate α -> Bool)
-> (BaudRate α -> BaudRate α -> BaudRate α)
-> (BaudRate α -> BaudRate α -> BaudRate α)
-> Ord (BaudRate α)
BaudRate α -> BaudRate α -> Bool
BaudRate α -> BaudRate α -> Ordering
BaudRate α -> BaudRate α -> BaudRate α
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {α}. Ord α => Eq (BaudRate α)
forall α. Ord α => BaudRate α -> BaudRate α -> Bool
forall α. Ord α => BaudRate α -> BaudRate α -> Ordering
forall α. Ord α => BaudRate α -> BaudRate α -> BaudRate α
min :: BaudRate α -> BaudRate α -> BaudRate α
$cmin :: forall α. Ord α => BaudRate α -> BaudRate α -> BaudRate α
max :: BaudRate α -> BaudRate α -> BaudRate α
$cmax :: forall α. Ord α => BaudRate α -> BaudRate α -> BaudRate α
>= :: BaudRate α -> BaudRate α -> Bool
$c>= :: forall α. Ord α => BaudRate α -> BaudRate α -> Bool
> :: BaudRate α -> BaudRate α -> Bool
$c> :: forall α. Ord α => BaudRate α -> BaudRate α -> Bool
<= :: BaudRate α -> BaudRate α -> Bool
$c<= :: forall α. Ord α => BaudRate α -> BaudRate α -> Bool
< :: BaudRate α -> BaudRate α -> Bool
$c< :: forall α. Ord α => BaudRate α -> BaudRate α -> Bool
compare :: BaudRate α -> BaudRate α -> Ordering
$ccompare :: forall α. Ord α => BaudRate α -> BaudRate α -> Ordering
Ord, Int -> BaudRate α -> ShowS
[BaudRate α] -> ShowS
BaudRate α -> String
(Int -> BaudRate α -> ShowS)
-> (BaudRate α -> String)
-> ([BaudRate α] -> ShowS)
-> Show (BaudRate α)
forall α. Show α => Int -> BaudRate α -> ShowS
forall α. Show α => [BaudRate α] -> ShowS
forall α. Show α => BaudRate α -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BaudRate α] -> ShowS
$cshowList :: forall α. Show α => [BaudRate α] -> ShowS
show :: BaudRate α -> String
$cshow :: forall α. Show α => BaudRate α -> String
showsPrec :: Int -> BaudRate α -> ShowS
$cshowsPrec :: forall α. Show α => Int -> BaudRate α -> ShowS
Show, ReadPrec [BaudRate α]
ReadPrec (BaudRate α)
Int -> ReadS (BaudRate α)
ReadS [BaudRate α]
(Int -> ReadS (BaudRate α))
-> ReadS [BaudRate α]
-> ReadPrec (BaudRate α)
-> ReadPrec [BaudRate α]
-> Read (BaudRate α)
forall α. Read α => ReadPrec [BaudRate α]
forall α. Read α => ReadPrec (BaudRate α)
forall α. Read α => Int -> ReadS (BaudRate α)
forall α. Read α => ReadS [BaudRate α]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BaudRate α]
$creadListPrec :: forall α. Read α => ReadPrec [BaudRate α]
readPrec :: ReadPrec (BaudRate α)
$creadPrec :: forall α. Read α => ReadPrec (BaudRate α)
readList :: ReadS [BaudRate α]
$creadList :: forall α. Read α => ReadS [BaudRate α]
readsPrec :: Int -> ReadS (BaudRate α)
$creadsPrec :: forall α. Read α => Int -> ReadS (BaudRate α)
Read, Int -> BaudRate α
BaudRate α -> Int
BaudRate α -> [BaudRate α]
BaudRate α -> BaudRate α
BaudRate α -> BaudRate α -> [BaudRate α]
BaudRate α -> BaudRate α -> BaudRate α -> [BaudRate α]
(BaudRate α -> BaudRate α)
-> (BaudRate α -> BaudRate α)
-> (Int -> BaudRate α)
-> (BaudRate α -> Int)
-> (BaudRate α -> [BaudRate α])
-> (BaudRate α -> BaudRate α -> [BaudRate α])
-> (BaudRate α -> BaudRate α -> [BaudRate α])
-> (BaudRate α -> BaudRate α -> BaudRate α -> [BaudRate α])
-> Enum (BaudRate α)
forall α. Enum α => Int -> BaudRate α
forall α. Enum α => BaudRate α -> Int
forall α. Enum α => BaudRate α -> [BaudRate α]
forall α. Enum α => BaudRate α -> BaudRate α
forall α. Enum α => BaudRate α -> BaudRate α -> [BaudRate α]
forall α.
Enum α =>
BaudRate α -> BaudRate α -> BaudRate α -> [BaudRate α]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: BaudRate α -> BaudRate α -> BaudRate α -> [BaudRate α]
$cenumFromThenTo :: forall α.
Enum α =>
BaudRate α -> BaudRate α -> BaudRate α -> [BaudRate α]
enumFromTo :: BaudRate α -> BaudRate α -> [BaudRate α]
$cenumFromTo :: forall α. Enum α => BaudRate α -> BaudRate α -> [BaudRate α]
enumFromThen :: BaudRate α -> BaudRate α -> [BaudRate α]
$cenumFromThen :: forall α. Enum α => BaudRate α -> BaudRate α -> [BaudRate α]
enumFrom :: BaudRate α -> [BaudRate α]
$cenumFrom :: forall α. Enum α => BaudRate α -> [BaudRate α]
fromEnum :: BaudRate α -> Int
$cfromEnum :: forall α. Enum α => BaudRate α -> Int
toEnum :: Int -> BaudRate α
$ctoEnum :: forall α. Enum α => Int -> BaudRate α
pred :: BaudRate α -> BaudRate α
$cpred :: forall α. Enum α => BaudRate α -> BaudRate α
succ :: BaudRate α -> BaudRate α
$csucc :: forall α. Enum α => BaudRate α -> BaudRate α
Enum, Integer -> BaudRate α
BaudRate α -> BaudRate α
BaudRate α -> BaudRate α -> BaudRate α
(BaudRate α -> BaudRate α -> BaudRate α)
-> (BaudRate α -> BaudRate α -> BaudRate α)
-> (BaudRate α -> BaudRate α -> BaudRate α)
-> (BaudRate α -> BaudRate α)
-> (BaudRate α -> BaudRate α)
-> (BaudRate α -> BaudRate α)
-> (Integer -> BaudRate α)
-> Num (BaudRate α)
forall α. Num α => Integer -> BaudRate α
forall α. Num α => BaudRate α -> BaudRate α
forall α. Num α => BaudRate α -> BaudRate α -> BaudRate α
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> BaudRate α
$cfromInteger :: forall α. Num α => Integer -> BaudRate α
signum :: BaudRate α -> BaudRate α
$csignum :: forall α. Num α => BaudRate α -> BaudRate α
abs :: BaudRate α -> BaudRate α
$cabs :: forall α. Num α => BaudRate α -> BaudRate α
negate :: BaudRate α -> BaudRate α
$cnegate :: forall α. Num α => BaudRate α -> BaudRate α
* :: BaudRate α -> BaudRate α -> BaudRate α
$c* :: forall α. Num α => BaudRate α -> BaudRate α -> BaudRate α
- :: BaudRate α -> BaudRate α -> BaudRate α
$c- :: forall α. Num α => BaudRate α -> BaudRate α -> BaudRate α
+ :: BaudRate α -> BaudRate α -> BaudRate α
$c+ :: forall α. Num α => BaudRate α -> BaudRate α -> BaudRate α
Num, Enum (BaudRate α)
Real (BaudRate α)
Real (BaudRate α)
-> Enum (BaudRate α)
-> (BaudRate α -> BaudRate α -> BaudRate α)
-> (BaudRate α -> BaudRate α -> BaudRate α)
-> (BaudRate α -> BaudRate α -> BaudRate α)
-> (BaudRate α -> BaudRate α -> BaudRate α)
-> (BaudRate α -> BaudRate α -> (BaudRate α, BaudRate α))
-> (BaudRate α -> BaudRate α -> (BaudRate α, BaudRate α))
-> (BaudRate α -> Integer)
-> Integral (BaudRate α)
BaudRate α -> Integer
BaudRate α -> BaudRate α -> (BaudRate α, BaudRate α)
BaudRate α -> BaudRate α -> BaudRate α
forall {α}. Integral α => Enum (BaudRate α)
forall {α}. Integral α => Real (BaudRate α)
forall α. Integral α => BaudRate α -> Integer
forall α.
Integral α =>
BaudRate α -> BaudRate α -> (BaudRate α, BaudRate α)
forall α. Integral α => BaudRate α -> BaudRate α -> BaudRate α
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
toInteger :: BaudRate α -> Integer
$ctoInteger :: forall α. Integral α => BaudRate α -> Integer
divMod :: BaudRate α -> BaudRate α -> (BaudRate α, BaudRate α)
$cdivMod :: forall α.
Integral α =>
BaudRate α -> BaudRate α -> (BaudRate α, BaudRate α)
quotRem :: BaudRate α -> BaudRate α -> (BaudRate α, BaudRate α)
$cquotRem :: forall α.
Integral α =>
BaudRate α -> BaudRate α -> (BaudRate α, BaudRate α)
mod :: BaudRate α -> BaudRate α -> BaudRate α
$cmod :: forall α. Integral α => BaudRate α -> BaudRate α -> BaudRate α
div :: BaudRate α -> BaudRate α -> BaudRate α
$cdiv :: forall α. Integral α => BaudRate α -> BaudRate α -> BaudRate α
rem :: BaudRate α -> BaudRate α -> BaudRate α
$crem :: forall α. Integral α => BaudRate α -> BaudRate α -> BaudRate α
quot :: BaudRate α -> BaudRate α -> BaudRate α
$cquot :: forall α. Integral α => BaudRate α -> BaudRate α -> BaudRate α
Integral
             , Num (BaudRate α)
Ord (BaudRate α)
Num (BaudRate α)
-> Ord (BaudRate α)
-> (BaudRate α -> Rational)
-> Real (BaudRate α)
BaudRate α -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
forall {α}. Real α => Num (BaudRate α)
forall {α}. Real α => Ord (BaudRate α)
forall α. Real α => BaudRate α -> Rational
toRational :: BaudRate α -> Rational
$ctoRational :: forall α. Real α => BaudRate α -> Rational
Real, Num (BaudRate α)
Num (BaudRate α)
-> (BaudRate α -> BaudRate α -> BaudRate α)
-> (BaudRate α -> BaudRate α)
-> (Rational -> BaudRate α)
-> Fractional (BaudRate α)
Rational -> BaudRate α
BaudRate α -> BaudRate α
BaudRate α -> BaudRate α -> BaudRate α
forall {α}. Fractional α => Num (BaudRate α)
forall α. Fractional α => Rational -> BaudRate α
forall α. Fractional α => BaudRate α -> BaudRate α
forall α. Fractional α => BaudRate α -> BaudRate α -> BaudRate α
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> BaudRate α
$cfromRational :: forall α. Fractional α => Rational -> BaudRate α
recip :: BaudRate α -> BaudRate α
$crecip :: forall α. Fractional α => BaudRate α -> BaudRate α
/ :: BaudRate α -> BaudRate α -> BaudRate α
$c/ :: forall α. Fractional α => BaudRate α -> BaudRate α -> BaudRate α
Fractional, Fractional (BaudRate α)
Real (BaudRate α)
Real (BaudRate α)
-> Fractional (BaudRate α)
-> (forall b. Integral b => BaudRate α -> (b, BaudRate α))
-> (forall b. Integral b => BaudRate α -> b)
-> (forall b. Integral b => BaudRate α -> b)
-> (forall b. Integral b => BaudRate α -> b)
-> (forall b. Integral b => BaudRate α -> b)
-> RealFrac (BaudRate α)
forall b. Integral b => BaudRate α -> b
forall b. Integral b => BaudRate α -> (b, BaudRate α)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
forall {α}. RealFrac α => Fractional (BaudRate α)
forall {α}. RealFrac α => Real (BaudRate α)
forall α b. (RealFrac α, Integral b) => BaudRate α -> b
forall α b.
(RealFrac α, Integral b) =>
BaudRate α -> (b, BaudRate α)
floor :: forall b. Integral b => BaudRate α -> b
$cfloor :: forall α b. (RealFrac α, Integral b) => BaudRate α -> b
ceiling :: forall b. Integral b => BaudRate α -> b
$cceiling :: forall α b. (RealFrac α, Integral b) => BaudRate α -> b
round :: forall b. Integral b => BaudRate α -> b
$cround :: forall α b. (RealFrac α, Integral b) => BaudRate α -> b
truncate :: forall b. Integral b => BaudRate α -> b
$ctruncate :: forall α b. (RealFrac α, Integral b) => BaudRate α -> b
properFraction :: forall b. Integral b => BaudRate α -> (b, BaudRate α)
$cproperFraction :: forall α b.
(RealFrac α, Integral b) =>
BaudRate α -> (b, BaudRate α)
RealFrac
             )

instance Num α ⇒ Bounded (BaudRate α) where
    -- Minimum baud rate is the maximum baudrate divided by the
    -- largest possible divider.
    minBound :: BaudRate α
minBound = BaudRate Integer -> BaudRate α
forall a b. (Integral a, Num b) => a -> b
fromIntegral
               (BaudRate Integer -> BaudRate α) -> BaudRate Integer -> BaudRate α
forall a b. (a -> b) -> a -> b
$ (BaudRate Double -> BaudRate Integer
forall a b. (RealFrac a, Integral b) => a -> b
ceiling ∷ BaudRate Double → BaudRate Integer)
               (BaudRate Double -> BaudRate Integer)
-> BaudRate Double -> BaudRate Integer
forall a b. (a -> b) -> a -> b
$ BRDiv Int -> BRSubDiv Double -> BaudRate Double
forall α.
(Eq α, Fractional α) =>
BRDiv Int -> BRSubDiv α -> BaudRate α
calcBaudRate BRDiv Int
forall a. Bounded a => a
maxBound BRSubDiv Double
forall a. Bounded a => a
maxBound

    maxBound :: BaudRate α
maxBound = α -> BaudRate α
forall α. α -> BaudRate α
BaudRate α
3000000

-- http://www.ftdichip.com/Documents/AppNotes/AN232B-05_BaudRates.pdf
encodeBaudRateDivisors ∷ ChipType → BRDiv Int → BRSubDiv Int → (Word16, Word16)
encodeBaudRateDivisors :: ChipType -> BRDiv Int -> BRSubDiv Int -> (Word16, Word16)
encodeBaudRateDivisors ChipType
chip BRDiv Int
d BRSubDiv Int
s = (Word16
v, Word16
i)
  where
    v :: Word16
v = BRDiv Int -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral BRDiv Int
d Word16 -> Word16 -> Word16
forall a. Bits a => a -> a -> a
.|. Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
shiftL Word16
s' Int
14
    i :: Word16
i | ChipType
ChipType_2232C ← ChipType
chip = Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
shiftL (Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
shiftR Word16
s' Int
2) Int
8
      | Bool
otherwise = Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
shiftR Word16
s' Int
2
    s' :: Word16
s' = Int -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word16) -> Int -> Word16
forall a b. (a -> b) -> a -> b
$ BRSubDiv Int -> Int
encodeSubDiv BRSubDiv Int
s ∷ Word16

    encodeSubDiv ∷ BRSubDiv Int → Int
    encodeSubDiv :: BRSubDiv Int -> Int
encodeSubDiv BRSubDiv Int
n =
        case BRSubDiv Int
n of
          BRSubDiv Int
0 → Int
0 -- 000 ==> 0/8 = 0
          BRSubDiv Int
4 → Int
1 -- 001 ==> 4/8 = 0.5
          BRSubDiv Int
2 → Int
2 -- 010 ==> 2/8 = 0.25
          BRSubDiv Int
1 → Int
3 -- 011 ==> 1/8 = 0.125
          BRSubDiv Int
3 → Int
4 -- 100 ==> 3/8 = 0.375
          BRSubDiv Int
5 → Int
5 -- 101 ==> 5/8 = 0.625
          BRSubDiv Int
6 → Int
6 -- 110 ==> 6/8 = 0.75
          BRSubDiv Int
7 → Int
7 -- 111 ==> 7/8 = 0.875
          BRSubDiv Int
_ → String -> Int
forall a. HasCallStack => String -> a
error String
"Illegal subdivisor"

-- |Calculates the nearest representable baud rate.
nearestBaudRate ∷ RealFrac α ⇒ ChipType → BaudRate α → BaudRate α
nearestBaudRate :: forall α. RealFrac α => ChipType -> BaudRate α -> BaudRate α
nearestBaudRate ChipType
chip BaudRate α
baudRate = BaudRate α
b
  where (BRDiv Int
_, BRSubDiv Int
_, BaudRate α
b) = ChipType -> BaudRate α -> (BRDiv Int, BRSubDiv Int, BaudRate α)
forall α.
RealFrac α =>
ChipType -> BaudRate α -> (BRDiv Int, BRSubDiv Int, BaudRate α)
calcBaudRateDivisors ChipType
chip BaudRate α
baudRate


-- |Finds the divisors that most closely represent the requested baud rate.
calcBaudRateDivisors ∷ ∀ α. RealFrac α
                     ⇒ ChipType
                     → BaudRate α
                     → (BRDiv Int, BRSubDiv Int, BaudRate α)
calcBaudRateDivisors :: forall α.
RealFrac α =>
ChipType -> BaudRate α -> (BRDiv Int, BRSubDiv Int, BaudRate α)
calcBaudRateDivisors ChipType
_    BaudRate α
3000000  = (BRDiv Int
0, BRSubDiv Int
0, BaudRate α
0)
calcBaudRateDivisors ChipType
_    BaudRate α
2000000  = (BRDiv Int
1, BRSubDiv Int
0, BaudRate α
0)
calcBaudRateDivisors ChipType
chip BaudRate α
baudRate =
    ((BRDiv Int, BRSubDiv Int, BaudRate α)
 -> (BRDiv Int, BRSubDiv Int, BaudRate α) -> Ordering)
-> [(BRDiv Int, BRSubDiv Int, BaudRate α)]
-> (BRDiv Int, BRSubDiv Int, BaudRate α)
forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
minimumBy (BaudRate α -> BaudRate α -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (BaudRate α -> BaudRate α -> Ordering)
-> ((BRDiv Int, BRSubDiv Int, BaudRate α) -> BaudRate α)
-> (BRDiv Int, BRSubDiv Int, BaudRate α)
-> (BRDiv Int, BRSubDiv Int, BaudRate α)
-> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` (\(BRDiv Int
_,BRSubDiv Int
_,BaudRate α
x) → BaudRate α
x))
              [ (BRDiv Int
d, BRSubDiv Int
s, BaudRate α
b')
              | BRSubDiv Int
s ← ChipType -> [BRSubDiv Int]
chipSubDivisors ChipType
chip
              , let s' :: BRSubDiv α
s' = BRSubDiv Int -> BRSubDiv α
forall a b. (Integral a, Num b) => a -> b
fromIntegral BRSubDiv Int
s BRSubDiv α -> BRSubDiv α -> BRSubDiv α
forall α. Fractional α => α -> α -> α
÷ BRSubDiv α
8
                    d :: BRDiv Int
d  = BaudRate α -> BRSubDiv α -> BRDiv Int
forall β. Integral β => BaudRate α -> BRSubDiv α -> BRDiv β
divisor BaudRate α
baudRate BRSubDiv α
s'
                    -- Baud rate calculated from found divisors.
                    b' :: BaudRate α
b' = BRDiv Int -> BRSubDiv α -> BaudRate α
forall α.
(Eq α, Fractional α) =>
BRDiv Int -> BRSubDiv α -> BaudRate α
calcBaudRate BRDiv Int
d BRSubDiv α
s'
              ]
    where
      -- |Calculates the divisor from a baud rate and a subdivisor.
      divisor ∷ Integral β ⇒ BaudRate α → BRSubDiv α → BRDiv β
      divisor :: forall β. Integral β => BaudRate α -> BRSubDiv α -> BRDiv β
divisor BaudRate α
br BRSubDiv α
s = BRDiv β -> BRDiv β
forall α. (Bounded α, Ord α) => α -> α
clamp (BRDiv β -> BRDiv β) -> BRDiv β -> BRDiv β
forall a b. (a -> b) -> a -> b
$ BaudRate α -> BRDiv β
forall a b. (RealFrac a, Integral b) => a -> b
floor (BaudRate α -> BRDiv β) -> BaudRate α -> BRDiv β
forall a b. (a -> b) -> a -> b
$ (BaudRate α
forall a. Bounded a => a
maxBound BaudRate α -> BaudRate α -> BaudRate α
forall a. Num a => a -> a -> a
- BaudRate α
br BaudRate α -> BaudRate α -> BaudRate α
forall a. Num a => a -> a -> a
⋅ BaudRate α
s') BaudRate α -> BaudRate α -> BaudRate α
forall α. Fractional α => α -> α -> α
÷ BaudRate α
br
          where s' :: BaudRate α
s' = α -> BaudRate α
forall α. α -> BaudRate α
BaudRate (α -> BaudRate α) -> α -> BaudRate α
forall a b. (a -> b) -> a -> b
$ BRSubDiv α -> α
forall α. BRSubDiv α -> α
unBRSubDiv BRSubDiv α
s

      chipSubDivisors ∷ ChipType → [BRSubDiv Int]
      chipSubDivisors :: ChipType -> [BRSubDiv Int]
chipSubDivisors ChipType
ChipType_AM = [BRSubDiv Int
0, BRSubDiv Int
1, BRSubDiv Int
2, BRSubDiv Int
4]
      chipSubDivisors ChipType
_           = [BRSubDiv Int
0..BRSubDiv Int
7]

-- |Calculates the baud rate from a divisor and a subdivisor.
calcBaudRate ∷ (Eq α, Fractional α) ⇒ BRDiv Int → BRSubDiv α → BaudRate α
calcBaudRate :: forall α.
(Eq α, Fractional α) =>
BRDiv Int -> BRSubDiv α -> BaudRate α
calcBaudRate BRDiv Int
0 BRSubDiv α
0 = BaudRate α
forall a. Bounded a => a
maxBound
calcBaudRate BRDiv Int
1 BRSubDiv α
0 = BaudRate α
2000000
calcBaudRate BRDiv Int
d BRSubDiv α
s = BaudRate α
forall a. Bounded a => a
maxBound BaudRate α -> BaudRate α -> BaudRate α
forall α. Fractional α => α -> α -> α
÷ α -> BaudRate α
forall α. α -> BaudRate α
BaudRate (BRDiv Int -> α
forall a b. (Real a, Fractional b) => a -> b
realToFrac BRDiv Int
d α -> α -> α
forall a. Num a => a -> a -> a
+ BRSubDiv α -> α
forall α. BRSubDiv α -> α
unBRSubDiv BRSubDiv α
s)