119 lines
2.8 KiB
C++
119 lines
2.8 KiB
C++
/**
|
|
* Copyright (C) ARM Limited 2013-2014. All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
|
|
#ifndef DRIVER_H
|
|
#define DRIVER_H
|
|
|
|
#include <stdint.h>
|
|
|
|
#include "mxml/mxml.h"
|
|
|
|
class Buffer;
|
|
class Counter;
|
|
|
|
class DriverCounter {
|
|
public:
|
|
DriverCounter(DriverCounter *const next, const char *const name);
|
|
virtual ~DriverCounter();
|
|
|
|
DriverCounter *getNext() const { return mNext; }
|
|
const char *getName() const { return mName; }
|
|
int getKey() const { return mKey; }
|
|
bool isEnabled() const { return mEnabled; }
|
|
void setEnabled(const bool enabled) { mEnabled = enabled; }
|
|
virtual int64_t read() { return -1; }
|
|
|
|
private:
|
|
DriverCounter *const mNext;
|
|
const char *const mName;
|
|
const int mKey;
|
|
bool mEnabled;
|
|
|
|
// Intentionally unimplemented
|
|
DriverCounter(const DriverCounter &);
|
|
DriverCounter &operator=(const DriverCounter &);
|
|
};
|
|
|
|
class Driver {
|
|
public:
|
|
static Driver *getHead() { return head; }
|
|
|
|
virtual ~Driver() {}
|
|
|
|
// Returns true if this driver can manage the counter
|
|
virtual bool claimCounter(const Counter &counter) const = 0;
|
|
// Clears and disables all counters
|
|
virtual void resetCounters() = 0;
|
|
// Enables and prepares the counter for capture
|
|
virtual void setupCounter(Counter &counter) = 0;
|
|
|
|
// Performs any actions needed for setup or based on eventsXML
|
|
virtual void readEvents(mxml_node_t *const) {}
|
|
// Emits available counters
|
|
virtual int writeCounters(mxml_node_t *const root) const = 0;
|
|
// Emits possible dynamically generated events/counters
|
|
virtual void writeEvents(mxml_node_t *const) const {}
|
|
|
|
Driver *getNext() const { return next; }
|
|
|
|
protected:
|
|
Driver();
|
|
|
|
private:
|
|
static Driver *head;
|
|
Driver *next;
|
|
|
|
// Intentionally unimplemented
|
|
Driver(const Driver &);
|
|
Driver &operator=(const Driver &);
|
|
};
|
|
|
|
class SimpleDriver : public Driver {
|
|
public:
|
|
virtual ~SimpleDriver();
|
|
|
|
bool claimCounter(const Counter &counter) const;
|
|
bool countersEnabled() const;
|
|
void resetCounters();
|
|
void setupCounter(Counter &counter);
|
|
int writeCounters(mxml_node_t *root) const;
|
|
|
|
protected:
|
|
SimpleDriver() : mCounters(NULL) {}
|
|
|
|
DriverCounter *getCounters() const { return mCounters; }
|
|
void setCounters(DriverCounter *const counter) { mCounters = counter; }
|
|
|
|
DriverCounter *findCounter(const Counter &counter) const;
|
|
|
|
private:
|
|
DriverCounter *mCounters;
|
|
|
|
// Intentionally unimplemented
|
|
SimpleDriver(const SimpleDriver &);
|
|
SimpleDriver &operator=(const SimpleDriver &);
|
|
};
|
|
|
|
class PolledDriver : public SimpleDriver {
|
|
public:
|
|
virtual ~PolledDriver();
|
|
|
|
virtual void start() {}
|
|
virtual void read(Buffer *const buffer);
|
|
|
|
protected:
|
|
PolledDriver() {}
|
|
|
|
private:
|
|
// Intentionally unimplemented
|
|
PolledDriver(const PolledDriver &);
|
|
PolledDriver &operator=(const PolledDriver &);
|
|
};
|
|
|
|
#endif // DRIVER_H
|