libffado/src/dice/dice_avdevice.h

   1 /*
   2  * Copyright (C) 2005-2008 by Pieter Palmers
   3  *
   4  * This file is part of FFADO
   5  * FFADO = Free Firewire (pro-)audio drivers for linux
   6  *
   7  * FFADO is based upon FreeBoB
   8  *
   9  * This program is free software: you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation, either version 2 of the License, or
  12  * (at your option) version 3 of the License.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  *
  22  */
  23
  24 #ifndef DICEDEVICE_H
  25 #define DICEDEVICE_H
  26
  27 #include "dice_firmware_loader.h"
  28
  29 #include "ffadotypes.h"
  30 #include "ffadodevice.h"
  31
  32 #include "debugmodule/debugmodule.h"
  33 #include "libavc/avc_definitions.h"
  34
  35 #include "libstreaming/amdtp/AmdtpReceiveStreamProcessor.h"
  36 #include "libstreaming/amdtp/AmdtpTransmitStreamProcessor.h"
  37 #include "libstreaming/amdtp/AmdtpPort.h"
  38
  39 #include "libieee1394/ieee1394service.h"
  40
  41 #include "libcontrol/Element.h"
  42 #include "libcontrol/MatrixMixer.h"
  43 #include "libcontrol/CrossbarRouter.h"
  44
  45 #include <string>
  46 #include <vector>
  47
  48 class ConfigRom;
  49 class Ieee1394Service;
  50
  51 namespace Util {
  52     class Configuration;
  53 }
  54
  55 namespace Dice {
  56
  57 class EAP;
  58
  59
  60 /**
  61   @brief Devices based on the DICE-platform
  62
  63   This class is the basic implementation for devices using the DICE-chip.
  64   */
  65 class Device : public FFADODevice {
  66 private:
  67     friend class EAP;
  68
  69 public:
  70     /// constructor
  71     Device( DeviceManager& d, std::auto_ptr<ConfigRom>( configRom ));
  72     /// destructor
  73     ~Device();
  74
  75     static bool probe( Util::Configuration& c, ConfigRom& configRom, bool generic = false );
  76     static FFADODevice * createDevice( DeviceManager& d, std::auto_ptr<ConfigRom>( configRom ));
  77     virtual bool discover();
  78
  79     static int getConfigurationId( );
  80
  81     virtual void showDevice();
  82     bool canChangeNickname() { return true; }
  83
  84     virtual bool deleteImgFL(const char*, bool v = true);
  85     virtual bool flashDiceFL(const char*, const char* image = "dice");
  86     virtual bool dumpFirmwareFL(const char*);
  87     virtual bool showDiceInfoFL();
  88     virtual bool showImgInfoFL();
  89     virtual bool testDiceFL(int);
  90     virtual DICE_FL_INFO_PARAM* showFlashInfoFL(bool v = true);
  91     virtual bool showAppInfoFL();
  92
  93     virtual bool setSamplingFrequency( int samplingFrequency );
  94     virtual int getSamplingFrequency( );
  95     virtual std::vector<int> getSupportedSamplingFrequencies();
  96
  97     virtual ClockSourceVector getSupportedClockSources();
  98     virtual bool setActiveClockSource(ClockSource);
  99     virtual ClockSource getActiveClockSource();
 100
 101     virtual int getStreamCount();
 102     virtual Streaming::StreamProcessor *getStreamProcessorByIndex(int i);
 103     virtual enum FFADODevice::eStreamingState getStreamingState();
 104
 105     virtual bool prepare();
 106
 107     virtual bool lock();
 108     virtual bool unlock();
 109
 110     virtual bool startStreamByIndex(int i);
 111     virtual bool stopStreamByIndex(int i);
 112
 113     virtual bool enableStreaming();
 114     virtual bool disableStreaming();
 115
 116     virtual std::string getNickname();
 117     virtual bool setNickname(std::string name);
 118
 119 protected:
 120     // streaming stuff
 121     typedef std::vector< Streaming::StreamProcessor * > StreamProcessorVector;
 122     typedef std::vector< Streaming::StreamProcessor * >::iterator StreamProcessorVectorIterator;
 123     StreamProcessorVector m_receiveProcessors;
 124     StreamProcessorVector m_transmitProcessors;
 125
 126 private: // streaming & port helpers
 127     enum EPortTypes {
 128         ePT_Analog,
 129         ePT_MIDI,
 130     };
 131
 132     typedef struct {
 133         std::string name;
 134         enum EPortTypes portType;
 135         unsigned int streamPosition;
 136         unsigned int streamLocation;
 137     } diceChannelInfo;
 138
 139     bool addChannelToProcessor( diceChannelInfo *,
 140                               Streaming::StreamProcessor *,
 141                               Streaming::Port::E_Direction direction);
 142
 143     int allocateIsoChannel(unsigned int packet_size);
 144     bool deallocateIsoChannel(int channel);
 145
 146 private: // active config
 147     enum eDiceConfig {
 148         eDC_Unknown,
 149         eDC_Low,
 150         eDC_Mid,
 151         eDC_High,
 152     };
 153
 154     enum eDiceConfig getCurrentConfig();
 155
 156 private: // helper functions
 157     bool enableIsoStreaming();
 158     bool disableIsoStreaming();
 159     bool isIsoStreamingEnabled();
 160
 161     bool maskedCheckZeroGlobalReg(fb_nodeaddr_t offset, fb_quadlet_t mask);
 162     bool maskedCheckNotZeroGlobalReg(fb_nodeaddr_t offset, fb_quadlet_t mask);
 163
 164     stringlist splitNameString(std::string in);
 165     stringlist getTxNameString(unsigned int i);
 166     stringlist getRxNameString(unsigned int i);
 167     stringlist getCptrNameString(unsigned int);
 168     stringlist getPbckNameString(unsigned int);
 169     stringlist getClockSourceNameString();
 170
 171     enum eClockSourceType  clockIdToType(unsigned int id);
 172     bool isClockSourceIdLocked(unsigned int id, quadlet_t ext_status_reg);
 173     bool isClockSourceIdSlipping(unsigned int id, quadlet_t ext_status_reg);
 174
 175 // EAP stuff
 176 private:
 177     EAP*         m_eap;
 178 protected:
 179     virtual EAP* createEAP();
 180 public:
 181     EAP* getEAP() {return m_eap;};
 182
 183 private: // register I/O routines
 184     bool initIoFunctions();
 185     // functions used for RX/TX abstraction
 186     bool startstopStreamByIndex(int i, const bool start);
 187     bool prepareSP (unsigned int, const Streaming::Port::E_Direction direction_requested);
 188     void setRXTXfuncs (const Streaming::Port::E_Direction direction);
 189
 190     // quadlet read/write routines
 191     bool readReg(fb_nodeaddr_t, fb_quadlet_t *);
 192     bool writeReg(fb_nodeaddr_t, fb_quadlet_t);
 193     bool readRegBlock(fb_nodeaddr_t, fb_quadlet_t *, size_t);
 194     bool writeRegBlock(fb_nodeaddr_t, fb_quadlet_t *, size_t);
 195
 196     bool readGlobalReg(fb_nodeaddr_t, fb_quadlet_t *);
 197     bool writeGlobalReg(fb_nodeaddr_t, fb_quadlet_t);
 198     bool readGlobalRegBlock(fb_nodeaddr_t, fb_quadlet_t *, size_t);
 199     bool writeGlobalRegBlock(fb_nodeaddr_t, fb_quadlet_t *, size_t);
 200     fb_nodeaddr_t globalOffsetGen(fb_nodeaddr_t, size_t);
 201
 202     bool readTxReg(unsigned int i, fb_nodeaddr_t, fb_quadlet_t *);
 203     bool writeTxReg(unsigned int i, fb_nodeaddr_t, fb_quadlet_t);
 204     bool readTxRegBlock(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length);
 205     bool writeTxRegBlock(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length);
 206     fb_nodeaddr_t txOffsetGen(unsigned int, fb_nodeaddr_t, size_t);
 207
 208     bool readRxReg(unsigned int i, fb_nodeaddr_t, fb_quadlet_t *);
 209     bool writeRxReg(unsigned int i, fb_nodeaddr_t, fb_quadlet_t);
 210     bool readRxRegBlock(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length);
 211     bool writeRxRegBlock(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length);
 212     fb_nodeaddr_t rxOffsetGen(unsigned int, fb_nodeaddr_t, size_t);
 213
 214     fb_quadlet_t m_global_reg_offset;
 215     fb_quadlet_t m_global_reg_size;
 216     fb_quadlet_t m_tx_reg_offset;
 217     fb_quadlet_t m_tx_reg_size;
 218     fb_quadlet_t m_rx_reg_offset;
 219     fb_quadlet_t m_rx_reg_size;
 220     fb_quadlet_t m_unused1_reg_offset;
 221     fb_quadlet_t m_unused1_reg_size;
 222     fb_quadlet_t m_unused2_reg_offset;
 223     fb_quadlet_t m_unused2_reg_size;
 224
 225     fb_quadlet_t m_nb_tx;
 226     fb_quadlet_t m_tx_size;
 227     fb_quadlet_t m_nb_rx;
 228     fb_quadlet_t m_rx_size;
 229
 230     fb_quadlet_t audio_base_register;
 231     fb_quadlet_t midi_base_register;
 232     char dir[3];
 233
 234     // Function pointers to call readTxReg/readRxReg or writeTxReg/writeRxReg respectively
 235     bool (Device::*writeFunc) (unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t data);
 236     bool (Device::*readFunc) (unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *result);
 237
 238 // private:
 239 public:
 240     /**
 241      * this class reacts on the DICE device writing to the
 242      * hosts notify address
 243      */
 244     #define DICE_NOTIFIER_BASE_ADDRESS 0x0000FFFFE0000000ULL
 245     #define DICE_NOTIFIER_BLOCK_LENGTH 4
 246
 247     class Notifier : public Ieee1394Service::ARMHandler
 248     {
 249     public:
 250         Notifier(Device &, nodeaddr_t start);
 251         virtual ~Notifier();
 252
 253     private:
 254         Device &m_device;
 255     };
 256
 257     // notification
 258     Notifier *m_notifier;
 259
 260
 261
 262 };
 263
 264 }
 265
 266 #endif