{-# 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
DataType
Constr
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 d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FTDIException -> c FTDIException
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cInterfaceNotFound :: Constr
$tFTDIException :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> FTDIException -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FTDIException -> u
gmapQ :: (forall d. Data d => d -> u) -> FTDIException -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FTDIException -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable 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 :: RequestCode
reqReset           = RequestCode
0x00
reqSetModemCtrl :: RequestCode
reqSetModemCtrl    = RequestCode
0x01
reqSetFlowCtrl :: RequestCode
reqSetFlowCtrl     = RequestCode
0x02
reqSetBaudRate :: RequestCode
reqSetBaudRate     = RequestCode
0x03
reqSetData :: RequestCode
reqSetData         = RequestCode
0x04
reqPollModemStatus :: RequestCode
reqPollModemStatus = RequestCode
0x05
reqSetEventChar :: RequestCode
reqSetEventChar    = RequestCode
0x06
reqSetErrorChar :: RequestCode
reqSetErrorChar    = RequestCode
0x07
reqSetLatencyTimer :: RequestCode
reqSetLatencyTimer = RequestCode
0x09
reqGetLatencyTimer :: RequestCode
reqGetLatencyTimer = RequestCode
0x0A
reqSetBitMode :: RequestCode
reqSetBitMode      = RequestCode
0x0B
reqReadPins :: RequestCode
reqReadPins        = RequestCode
0x0C
reqReadEEPROM :: RequestCode
reqReadEEPROM      = RequestCode
0x90
reqWriteEEPROM :: RequestCode
reqWriteEEPROM     = RequestCode
0x91
reqEraseEEPROM :: RequestCode
reqEraseEEPROM     = RequestCode
0x92

valResetSIO         ∷ RequestValue
valPurgeReadBuffer  ∷ RequestValue
valPurgeWriteBuffer ∷ RequestValue

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

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

valSetDTRHigh :: RequestValue
valSetDTRHigh = RequestValue
0x0101
valSetDTRLow :: RequestValue
valSetDTRLow  = RequestValue
0x0100
valSetRTSHigh :: RequestValue
valSetRTSHigh = RequestValue
0x0202
valSetRTSLow :: RequestValue
valSetRTSLow  = RequestValue
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
$cp1Ord :: Eq ChipType
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
DataType
Constr
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 d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChipType -> c ChipType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cChipType_4232H :: Constr
$cChipType_2232H :: Constr
$cChipType_R :: Constr
$cChipType_2232C :: Constr
$cChipType_BM :: Constr
$cChipType_AM :: Constr
$tChipType :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> ChipType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ChipType -> u
gmapQ :: (forall d. Data d => d -> u) -> ChipType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ChipType -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable 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 -> RequestCode -> IO ConfigDesc
USB.getConfigDesc Device
dev RequestCode
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 RequestCode
USB.deviceSerialNumberStrIx DeviceDesc
desc Maybe RequestCode -> Maybe RequestCode -> Bool
forall α. Eq α => α -> α -> Bool
≡ RequestCode -> Maybe RequestCode
forall a. a -> Maybe a
Just RequestCode
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
$cp1Ord :: Eq Interface
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
DataType
Constr
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 d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Interface -> c Interface
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cInterface_D :: Constr
$cInterface_C :: Constr
$cInterface_B :: Constr
$cInterface_A :: Constr
$tInterface :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> Interface -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Interface -> u
gmapQ :: (forall d. Data d => d -> u) -> Interface -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Interface -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable Interface
Data, Typeable)

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

interfaceToUSB ∷ Interface → USB.InterfaceNumber
interfaceToUSB :: Interface -> RequestCode
interfaceToUSB = Interface -> RequestCode
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 :: 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 -> RequestCode -> IO ()
USB.claimInterface (DeviceHandle -> DeviceHandle
devHndUSB DeviceHandle
devHnd) (Interface -> RequestCode
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 -> RequestCode -> IO ()
USB.releaseInterface (DeviceHandle -> DeviceHandle
devHndUSB (DeviceHandle -> DeviceHandle) -> DeviceHandle -> DeviceHandle
forall a b. (a -> b) -> a -> b
$ InterfaceHandle -> DeviceHandle
ifHndDevHnd InterfaceHandle
ifHnd)
                                            (Interface -> RequestCode
interfaceToUSB (Interface -> RequestCode) -> Interface -> RequestCode
forall a b. (a -> b) -> a -> b
$ InterfaceHandle -> Interface
ifHndInterface InterfaceHandle
ifHnd)

withInterfaceHandle ∷ DeviceHandle → Interface → (InterfaceHandle → IO α) → IO α
withInterfaceHandle :: 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 :: DeviceHandle -> Interface -> IO a -> IO a
withDetachedKernelDriver DeviceHandle
devHndl Interface
i =
  DeviceHandle -> RequestCode -> IO a -> IO a
forall a. DeviceHandle -> RequestCode -> IO a -> IO a
USB.withDetachedKernelDriver (DeviceHandle -> DeviceHandle
devHndUSB DeviceHandle
devHndl) (Interface -> RequestCode
interfaceToUSB Interface
i)

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

newtype ChunkedReaderT m α = ChunkedReaderT {ChunkedReaderT m α -> StateT ByteString m α
unCR ∷ StateT ByteString m α}
    deriving ( a -> ChunkedReaderT m b -> ChunkedReaderT m a
(a -> b) -> ChunkedReaderT m a -> ChunkedReaderT m b
(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
<$ :: a -> ChunkedReaderT m b -> ChunkedReaderT m a
$c<$ :: forall (m :: * -> *) a b.
Functor m =>
a -> ChunkedReaderT m b -> ChunkedReaderT m a
fmap :: (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)
a -> ChunkedReaderT m a
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)
ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m b
ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m a
ChunkedReaderT m (a -> b)
-> ChunkedReaderT m a -> ChunkedReaderT m b
(a -> b -> c)
-> ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m c
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
<* :: 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
*> :: 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 :: (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
<*> :: 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 :: a -> ChunkedReaderT m a
$cpure :: forall (m :: * -> *) a. Monad m => a -> ChunkedReaderT m a
$cp1Applicative :: forall (m :: * -> *). Monad m => Functor (ChunkedReaderT m)
Applicative
             , Applicative (ChunkedReaderT m)
ChunkedReaderT m a
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)
ChunkedReaderT m a -> ChunkedReaderT m a -> ChunkedReaderT m a
ChunkedReaderT m a -> ChunkedReaderT m [a]
ChunkedReaderT m a -> ChunkedReaderT m [a]
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 :: ChunkedReaderT m a -> ChunkedReaderT m [a]
$cmany :: forall (m :: * -> *) a.
MonadPlus m =>
ChunkedReaderT m a -> ChunkedReaderT m [a]
some :: ChunkedReaderT m a -> ChunkedReaderT m [a]
$csome :: forall (m :: * -> *) a.
MonadPlus m =>
ChunkedReaderT m a -> ChunkedReaderT m [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 :: ChunkedReaderT m a
$cempty :: forall (m :: * -> *) a. MonadPlus m => ChunkedReaderT m a
$cp1Alternative :: forall (m :: * -> *). MonadPlus m => Applicative (ChunkedReaderT m)
Alternative
             , Applicative (ChunkedReaderT m)
a -> ChunkedReaderT m a
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)
ChunkedReaderT m a
-> (a -> ChunkedReaderT m b) -> ChunkedReaderT m b
ChunkedReaderT m a -> ChunkedReaderT m b -> ChunkedReaderT m b
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 :: a -> ChunkedReaderT m a
$creturn :: forall (m :: * -> *) a. Monad m => a -> ChunkedReaderT m a
>> :: 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
>>= :: 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
$cp1Monad :: forall (m :: * -> *). Monad m => Applicative (ChunkedReaderT m)
Monad
             , Monad (ChunkedReaderT m)
Alternative (ChunkedReaderT m)
ChunkedReaderT m a
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)
ChunkedReaderT m a -> ChunkedReaderT m a -> ChunkedReaderT m a
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 :: 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 :: ChunkedReaderT m a
$cmzero :: forall (m :: * -> *) a. MonadPlus m => ChunkedReaderT m a
$cp2MonadPlus :: forall (m :: * -> *). MonadPlus m => Monad (ChunkedReaderT m)
$cp1MonadPlus :: forall (m :: * -> *). MonadPlus m => Alternative (ChunkedReaderT m)
MonadPlus
             , m a -> ChunkedReaderT m a
(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 :: 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)
IO a -> ChunkedReaderT m a
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 :: IO a -> ChunkedReaderT m a
$cliftIO :: forall (m :: * -> *) a. MonadIO m => IO a -> ChunkedReaderT m a
$cp1MonadIO :: forall (m :: * -> *). MonadIO m => Monad (ChunkedReaderT m)
MonadIO
             , Monad (ChunkedReaderT m)
Monad (ChunkedReaderT m)
-> (forall a. (a -> ChunkedReaderT m a) -> ChunkedReaderT m a)
-> MonadFix (ChunkedReaderT m)
(a -> ChunkedReaderT m a) -> ChunkedReaderT m a
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 :: (a -> ChunkedReaderT m a) -> ChunkedReaderT m a
$cmfix :: forall (m :: * -> *) a.
MonadFix m =>
(a -> ChunkedReaderT m a) -> ChunkedReaderT m a
$cp1MonadFix :: forall (m :: * -> *). MonadFix m => Monad (ChunkedReaderT m)
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 &#x2237; 'InterfaceHandle' &#x2192; IO ()
  example ifHnd = do
    (packets1, rest1) &#x2190; runChunkedReaderT ('readData' ifHnd (return 'False') 400) 'BS.empty'
    print $ 'BS.concat' packets1
    (packets2, rest2) &#x2190; 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 &#x2237; 'InterfaceHandle' &#x2192; IO ()
  example ifHnd =
    let reader = do packets1 &#x2190; 'readData' ifHnd (return 'False') 400
                    liftIO $ print $ 'BS.concat' packets1
                    packets2 &#x2190; 'readData' ifHnd (return 'False') 200
                    liftIO $ print $ 'BS.concat' packets1
    in runChunkedReaderT reader 'BS.empty'
@

-}
runChunkedReaderT ∷ ChunkedReaderT m α → ByteString → m (α, ByteString)
runChunkedReaderT :: 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) &#x2190; '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 :: 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 :: USBControl α
-> RequestValue
-> InterfaceHandle
-> RequestCode
-> RequestValue
-> α
genControl USBControl α
usbCtrl RequestValue
index InterfaceHandle
ifHnd RequestCode
request RequestValue
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' :: RequestValue
index' = RequestValue
index RequestValue -> RequestValue -> RequestValue
forall a. Bits a => a -> a -> a
.|. Interface -> RequestValue
interfaceIndex (InterfaceHandle -> Interface
ifHndInterface InterfaceHandle
ifHnd)
          setup :: ControlSetup
setup  = ControlSetup :: RequestType
-> Recipient
-> RequestCode
-> RequestValue
-> RequestValue
-> ControlSetup
USB.ControlSetup { controlSetupRequestType :: RequestType
USB.controlSetupRequestType = RequestType
USB.Vendor
                                    , controlSetupRecipient :: Recipient
USB.controlSetupRecipient   = Recipient
USB.ToDevice
                                    , controlSetupRequest :: RequestCode
USB.controlSetupRequest     = RequestCode
request
                                    , controlSetupValue :: RequestValue
USB.controlSetupValue       = RequestValue
value
                                    , controlSetupIndex :: RequestValue
USB.controlSetupIndex       = RequestValue
index'
                                    }

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

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

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

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

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

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

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

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

-- |Returns the current value of the FTDI latency timer.
getLatencyTimer ∷ InterfaceHandle → IO Word8
getLatencyTimer :: InterfaceHandle -> IO RequestCode
getLatencyTimer InterfaceHandle
ifHnd = do
    (ByteString
bs, Status
_) ← InterfaceHandle
-> RequestCode -> RequestValue -> Int -> IO (ByteString, Status)
readControl InterfaceHandle
ifHnd RequestCode
reqGetLatencyTimer RequestValue
0 Int
1
    case ByteString -> [RequestCode]
BS.unpack ByteString
bs of
      [RequestCode
b] → RequestCode -> IO RequestCode
forall (m :: * -> *) a. Monad m => a -> m a
return RequestCode
b
      [RequestCode]
_   → String -> IO RequestCode
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 -> RequestCode -> IO ()
setLatencyTimer InterfaceHandle
ifHnd RequestCode
latency = InterfaceHandle -> RequestCode -> RequestValue -> IO ()
control InterfaceHandle
ifHnd RequestCode
reqSetLatencyTimer
                                        (RequestValue -> IO ()) -> RequestValue -> IO ()
forall a b. (a -> b) -> a -> b
$ RequestCode -> RequestValue
forall a b. (Integral a, Num b) => a -> b
fromIntegral RequestCode
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
$cp1Ord :: Eq BitMode
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
DataType
Constr
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 d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BitMode -> c BitMode
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cBitMode_SyncFIFO :: Constr
$cBitMode_CBus :: Constr
$cBitMode_Opto :: Constr
$cBitMode_MCU :: Constr
$cBitMode_SyncBitBang :: Constr
$cBitMode_MPSSE :: Constr
$cBitMode_BitBang :: Constr
$cBitMode_Reset :: Constr
$tBitMode :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> BitMode -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BitMode -> u
gmapQ :: (forall d. Data d => d -> u) -> BitMode -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BitMode -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable BitMode
Data, Typeable)

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

-- |The bitmode controls the method of communication.
setBitMode ∷ InterfaceHandle → Word8 → BitMode → IO ()
setBitMode :: InterfaceHandle -> RequestCode -> BitMode -> IO ()
setBitMode InterfaceHandle
ifHnd RequestCode
bitMask BitMode
bitMode = InterfaceHandle -> RequestCode -> RequestValue -> IO ()
control InterfaceHandle
ifHnd RequestCode
reqSetBitMode RequestValue
value
    where bitMask' :: RequestValue
bitMask' = RequestCode -> RequestValue
forall a b. (Integral a, Num b) => a -> b
fromIntegral RequestCode
bitMask
          bitMode' :: RequestValue
bitMode' = RequestCode -> RequestValue
forall a b. (Integral a, Num b) => a -> b
fromIntegral (RequestCode -> RequestValue) -> RequestCode -> RequestValue
forall a b. (a -> b) -> a -> b
$ BitMode -> RequestCode
marshalBitMode BitMode
bitMode
          value :: RequestValue
value    = RequestValue
bitMask' RequestValue -> RequestValue -> RequestValue
forall a. Bits a => a -> a -> a
.|. RequestValue -> Int -> RequestValue
forall a. Bits a => a -> Int -> a
shiftL RequestValue
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 :: InterfaceHandle -> BaudRate α -> IO (BaudRate α)
setBaudRate InterfaceHandle
ifHnd BaudRate α
baudRate =
  do USBControl (IO ())
-> RequestValue
-> InterfaceHandle
-> RequestCode
-> RequestValue
-> IO ()
forall α.
USBControl α
-> RequestValue
-> InterfaceHandle
-> RequestCode
-> RequestValue
-> α
genControl USBControl (IO ())
USB.control RequestValue
ix InterfaceHandle
ifHnd RequestCode
reqSetBaudRate RequestValue
val
     BaudRate α -> IO (BaudRate α)
forall (m :: * -> *) a. Monad m => a -> m a
return BaudRate α
b
  where
    (RequestValue
val, RequestValue
ix) = ChipType
-> BRDiv Int -> BRSubDiv Int -> (RequestValue, RequestValue)
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
$cp1Ord :: Eq Parity
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
DataType
Constr
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 d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parity -> c Parity
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cParity_Space :: Constr
$cParity_Mark :: Constr
$cParity_Even :: Constr
$cParity_Odd :: Constr
$tParity :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> Parity -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Parity -> u
gmapQ :: (forall d. Data d => d -> u) -> Parity -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Parity -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable 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 -> RequestCode -> RequestValue -> IO ()
control InterfaceHandle
ifHnd
            RequestCode
reqSetData
            (RequestValue -> IO ()) -> RequestValue -> IO ()
forall a b. (a -> b) -> a -> b
$ [RequestValue] -> RequestValue
forall α. (Num α, Bits α) => [α] -> α
orBits [ case BitDataFormat
bitDataFormat of
                         BitDataFormat
Bits_7 → RequestValue
7
                         BitDataFormat
Bits_8 → RequestValue
8
                     , RequestValue
-> (Parity -> RequestValue) -> Maybe Parity -> RequestValue
forall b a. b -> (a -> b) -> Maybe a -> b
maybe RequestValue
0 (\Parity
p → (RequestValue
1 RequestValue -> RequestValue -> RequestValue
forall a. Num a => a -> a -> a
+ Parity -> RequestValue
forall e n. (Enum e, Num n) => e -> n
genFromEnum Parity
p) RequestValue -> Int -> RequestValue
forall a. Bits a => a -> Int -> a
`shiftL` Int
8) Maybe Parity
parity
                     , StopBits -> RequestValue
forall e n. (Enum e, Num n) => e -> n
genFromEnum StopBits
stopBits RequestValue -> Int -> RequestValue
forall a. Bits a => a -> Int -> a
`shiftL` Int
11
                     , Bool -> RequestValue
forall e n. (Enum e, Num n) => e -> n
genFromEnum Bool
break'   RequestValue -> Int -> RequestValue
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
$cp1Ord :: Eq ModemStatus
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
DataType
Constr
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 d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModemStatus -> c ModemStatus
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cModemStatus :: Constr
$tModemStatus :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> ModemStatus -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModemStatus -> u
gmapQ :: (forall d. Data d => d -> u) -> ModemStatus -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModemStatus -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable 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 -> (RequestCode, RequestCode)
marshalModemStatus ModemStatus
ms = (RequestCode
a, RequestCode
b)
    where
      a :: RequestCode
a = [(Int, ModemStatus -> Bool)] -> RequestCode
mkByte ([(Int, ModemStatus -> Bool)] -> RequestCode)
-> [(Int, ModemStatus -> Bool)] -> RequestCode
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 :: RequestCode
b = [(Int, ModemStatus -> Bool)] -> RequestCode
mkByte ([(Int, ModemStatus -> Bool)] -> RequestCode)
-> [(Int, ModemStatus -> Bool)] -> RequestCode
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)] -> RequestCode
mkByte = ((Int, ModemStatus -> Bool) -> RequestCode -> RequestCode)
-> RequestCode -> [(Int, ModemStatus -> Bool)] -> RequestCode
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\(Int
n, ModemStatus -> Bool
f) RequestCode
x → if ModemStatus -> Bool
f ModemStatus
ms then RequestCode -> Int -> RequestCode
forall a. Bits a => a -> Int -> a
setBit RequestCode
x Int
n else RequestCode
x) RequestCode
0

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

-- |Manually request the modem status.
pollModemStatus ∷ InterfaceHandle → IO ModemStatus
pollModemStatus :: InterfaceHandle -> IO ModemStatus
pollModemStatus InterfaceHandle
ifHnd = do
    (ByteString
bs, Status
_) ← InterfaceHandle
-> RequestCode -> RequestValue -> Int -> IO (ByteString, Status)
readControl InterfaceHandle
ifHnd RequestCode
reqPollModemStatus RequestValue
0 Int
2
    case ByteString -> [RequestCode]
BS.unpack ByteString
bs of
      [RequestCode
x,RequestCode
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
$ RequestCode -> RequestCode -> ModemStatus
unmarshalModemStatus RequestCode
x RequestCode
y
      [RequestCode]
_     → 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 -> RequestValue
marshalFlowControl FlowCtrl
f = case FlowCtrl
f of
                         FlowCtrl
RTS_CTS → RequestValue
0x0100
                         FlowCtrl
DTR_DSR → RequestValue
0x0200
                         FlowCtrl
XOnXOff → RequestValue
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 ())
-> RequestValue
-> InterfaceHandle
-> RequestCode
-> RequestValue
-> IO ()
forall α.
USBControl α
-> RequestValue
-> InterfaceHandle
-> RequestCode
-> RequestValue
-> α
genControl USBControl (IO ())
USB.control
                                      (RequestValue
-> (FlowCtrl -> RequestValue) -> Maybe FlowCtrl -> RequestValue
forall b a. b -> (a -> b) -> Maybe a -> b
maybe RequestValue
0 FlowCtrl -> RequestValue
marshalFlowControl Maybe FlowCtrl
mFC)
                                      InterfaceHandle
ifHnd
                                      RequestCode
reqSetFlowCtrl
                                      RequestValue
0

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

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

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

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

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


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

newtype BRDiv α = BRDiv {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
$cp1Ord :: forall α. Ord α => Eq (BRDiv α)
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 α
$cp2Integral :: forall α. Integral α => Enum (BRDiv α)
$cp1Integral :: forall α. Integral α => Real (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
$cp2Real :: forall α. Real α => Ord (BRDiv α)
$cp1Real :: forall α. Real α => Num (BRDiv α)
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 α
$cp1Fractional :: forall α. Fractional α => Num (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 α)
BRDiv α -> b
BRDiv α -> b
BRDiv α -> b
BRDiv α -> b
BRDiv α -> (b, 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 :: BRDiv α -> b
$cfloor :: forall α b. (RealFrac α, Integral b) => BRDiv α -> b
ceiling :: BRDiv α -> b
$cceiling :: forall α b. (RealFrac α, Integral b) => BRDiv α -> b
round :: BRDiv α -> b
$cround :: forall α b. (RealFrac α, Integral b) => BRDiv α -> b
truncate :: BRDiv α -> b
$ctruncate :: forall α b. (RealFrac α, Integral b) => BRDiv α -> b
properFraction :: BRDiv α -> (b, BRDiv α)
$cproperFraction :: forall α b. (RealFrac α, Integral b) => BRDiv α -> (b, BRDiv α)
$cp2RealFrac :: forall α. RealFrac α => Fractional (BRDiv α)
$cp1RealFrac :: forall α. RealFrac α => Real (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 {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
$cp1Ord :: forall α. Ord α => Eq (BRSubDiv α)
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 α
$cp2Integral :: forall α. Integral α => Enum (BRSubDiv α)
$cp1Integral :: forall α. Integral α => Real (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
$cp2Real :: forall α. Real α => Ord (BRSubDiv α)
$cp1Real :: forall α. Real α => Num (BRSubDiv α)
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 α
$cp1Fractional :: forall α. Fractional α => Num (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 α)
BRSubDiv α -> b
BRSubDiv α -> b
BRSubDiv α -> b
BRSubDiv α -> b
BRSubDiv α -> (b, 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 :: BRSubDiv α -> b
$cfloor :: forall α b. (RealFrac α, Integral b) => BRSubDiv α -> b
ceiling :: BRSubDiv α -> b
$cceiling :: forall α b. (RealFrac α, Integral b) => BRSubDiv α -> b
round :: BRSubDiv α -> b
$cround :: forall α b. (RealFrac α, Integral b) => BRSubDiv α -> b
truncate :: BRSubDiv α -> b
$ctruncate :: forall α b. (RealFrac α, Integral b) => BRSubDiv α -> b
properFraction :: BRSubDiv α -> (b, BRSubDiv α)
$cproperFraction :: forall α b.
(RealFrac α, Integral b) =>
BRSubDiv α -> (b, BRSubDiv α)
$cp2RealFrac :: forall α. RealFrac α => Fractional (BRSubDiv α)
$cp1RealFrac :: forall α. RealFrac α => Real (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 {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
$cp1Ord :: forall α. Ord α => Eq (BaudRate α)
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 α
$cp2Integral :: forall α. Integral α => Enum (BaudRate α)
$cp1Integral :: forall α. Integral α => Real (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
$cp2Real :: forall α. Real α => Ord (BaudRate α)
$cp1Real :: forall α. Real α => Num (BaudRate α)
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 α
$cp1Fractional :: forall α. Fractional α => Num (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 α)
BaudRate α -> b
BaudRate α -> b
BaudRate α -> b
BaudRate α -> b
BaudRate α -> (b, 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 :: BaudRate α -> b
$cfloor :: forall α b. (RealFrac α, Integral b) => BaudRate α -> b
ceiling :: BaudRate α -> b
$cceiling :: forall α b. (RealFrac α, Integral b) => BaudRate α -> b
round :: BaudRate α -> b
$cround :: forall α b. (RealFrac α, Integral b) => BaudRate α -> b
truncate :: BaudRate α -> b
$ctruncate :: forall α b. (RealFrac α, Integral b) => BaudRate α -> b
properFraction :: BaudRate α -> (b, BaudRate α)
$cproperFraction :: forall α b.
(RealFrac α, Integral b) =>
BaudRate α -> (b, BaudRate α)
$cp2RealFrac :: forall α. RealFrac α => Fractional (BaudRate α)
$cp1RealFrac :: forall α. RealFrac α => Real (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 -> (RequestValue, RequestValue)
encodeBaudRateDivisors ChipType
chip BRDiv Int
d BRSubDiv Int
s = (RequestValue
v, RequestValue
i)
  where
    v :: RequestValue
v = BRDiv Int -> RequestValue
forall a b. (Integral a, Num b) => a -> b
fromIntegral BRDiv Int
d RequestValue -> RequestValue -> RequestValue
forall a. Bits a => a -> a -> a
.|. RequestValue -> Int -> RequestValue
forall a. Bits a => a -> Int -> a
shiftL RequestValue
s' Int
14
    i :: RequestValue
i | ChipType
ChipType_2232C ← ChipType
chip = RequestValue -> Int -> RequestValue
forall a. Bits a => a -> Int -> a
shiftL (RequestValue -> Int -> RequestValue
forall a. Bits a => a -> Int -> a
shiftR RequestValue
s' Int
2) Int
8
      | Bool
otherwise = RequestValue -> Int -> RequestValue
forall a. Bits a => a -> Int -> a
shiftR RequestValue
s' Int
2
    s' :: RequestValue
s' = Int -> RequestValue
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> RequestValue) -> Int -> RequestValue
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 :: 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 :: 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 :: 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 :: 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)