/*
    tests/test_virtual_functions.cpp -- overriding virtual functions from Python

    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>

    All rights reserved. Use of this source code is governed by a
    BSD-style license that can be found in the LICENSE file.
*/

#include "pybind11_tests.h"
#include "constructor_stats.h"
#include <pybind11/functional.h>
#include <thread>

/* This is an example class that we'll want to be able to extend from Python */
class ExampleVirt  {
public:
    ExampleVirt(int state) : state(state) { print_created(this, state); }
    ExampleVirt(const ExampleVirt &e) : state(e.state) { print_copy_created(this); }
    ExampleVirt(ExampleVirt &&e) : state(e.state) { print_move_created(this); e.state = 0; }
    virtual ~ExampleVirt() { print_destroyed(this); }

    virtual int run(int value) {
        py::print("Original implementation of "
                  "ExampleVirt::run(state={}, value={}, str1={}, str2={})"_s.format(state, value, get_string1(), *get_string2()));
        return state + value;
    }

    virtual bool run_bool() = 0;
    virtual void pure_virtual() = 0;

    // Returning a reference/pointer to a type converted from python (numbers, strings, etc.) is a
    // bit trickier, because the actual int& or std::string& or whatever only exists temporarily, so
    // we have to handle it specially in the trampoline class (see below).
    virtual const std::string &get_string1() { return str1; }
    virtual const std::string *get_string2() { return &str2; }

private:
    int state;
    const std::string str1{"default1"}, str2{"default2"};
};

/* This is a wrapper class that must be generated */
class PyExampleVirt : public ExampleVirt {
public:
    using ExampleVirt::ExampleVirt; /* Inherit constructors */

    int run(int value) override {
        /* Generate wrapping code that enables native function overloading */
        PYBIND11_OVERRIDE(
            int,         /* Return type */
            ExampleVirt, /* Parent class */
            run,         /* Name of function */
            value        /* Argument(s) */
        );
    }

    bool run_bool() override {
        PYBIND11_OVERRIDE_PURE(
            bool,         /* Return type */
            ExampleVirt,  /* Parent class */
            run_bool,     /* Name of function */
                          /* This function has no arguments. The trailing comma
                             in the previous line is needed for some compilers */
        );
    }

    void pure_virtual() override {
        PYBIND11_OVERRIDE_PURE(
            void,         /* Return type */
            ExampleVirt,  /* Parent class */
            pure_virtual, /* Name of function */
                          /* This function has no arguments. The trailing comma
                             in the previous line is needed for some compilers */
        );
    }

    // We can return reference types for compatibility with C++ virtual interfaces that do so, but
    // note they have some significant limitations (see the documentation).
    const std::string &get_string1() override {
        PYBIND11_OVERRIDE(
            const std::string &, /* Return type */
            ExampleVirt,         /* Parent class */
            get_string1,         /* Name of function */
                                 /* (no arguments) */
        );
    }

    const std::string *get_string2() override {
        PYBIND11_OVERRIDE(
            const std::string *, /* Return type */
            ExampleVirt,         /* Parent class */
            get_string2,         /* Name of function */
                                 /* (no arguments) */
        );
    }

};

class NonCopyable {
public:
    NonCopyable(int a, int b) : value{new int(a*b)} { print_created(this, a, b); }
    NonCopyable(NonCopyable &&o) { value = std::move(o.value); print_move_created(this); }
    NonCopyable(const NonCopyable &) = delete;
    NonCopyable() = delete;
    void operator=(const NonCopyable &) = delete;
    void operator=(NonCopyable &&) = delete;
    std::string get_value() const {
        if (value) return std::to_string(*value); else return "(null)";
    }
    ~NonCopyable() { print_destroyed(this); }

private:
    std::unique_ptr<int> value;
};

// This is like the above, but is both copy and movable.  In effect this means it should get moved
// when it is not referenced elsewhere, but copied if it is still referenced.
class Movable {
public:
    Movable(int a, int b) : value{a+b} { print_created(this, a, b); }
    Movable(const Movable &m) { value = m.value; print_copy_created(this); }
    Movable(Movable &&m) { value = std::move(m.value); print_move_created(this); }
    std::string get_value() const { return std::to_string(value); }
    ~Movable() { print_destroyed(this); }
private:
    int value;
};

class NCVirt {
public:
    virtual ~NCVirt() = default;
    NCVirt() = default;
    NCVirt(const NCVirt&) = delete;
    virtual NonCopyable get_noncopyable(int a, int b) { return NonCopyable(a, b); }
    virtual Movable get_movable(int a, int b) = 0;

    std::string print_nc(int a, int b) { return get_noncopyable(a, b).get_value(); }
    std::string print_movable(int a, int b) { return get_movable(a, b).get_value(); }
};
class NCVirtTrampoline : public NCVirt {
#if !defined(__INTEL_COMPILER) && !defined(__CUDACC__) && !defined(__PGIC__)
    NonCopyable get_noncopyable(int a, int b) override {
        PYBIND11_OVERRIDE(NonCopyable, NCVirt, get_noncopyable, a, b);
    }
#endif
    Movable get_movable(int a, int b) override {
        PYBIND11_OVERRIDE_PURE(Movable, NCVirt, get_movable, a, b);
    }
};

struct Base {
    /* for some reason MSVC2015 can't compile this if the function is pure virtual */
    virtual std::string dispatch() const { return {}; };
    virtual ~Base() = default;
    Base() = default;
    Base(const Base&) = delete;
};

struct DispatchIssue : Base {
    std::string dispatch() const override {
        PYBIND11_OVERRIDE_PURE(std::string, Base, dispatch, /* no arguments */);
    }
};

static void test_gil() {
    {
        py::gil_scoped_acquire lock;
        py::print("1st lock acquired");

    }

    {
        py::gil_scoped_acquire lock;
        py::print("2nd lock acquired");
    }

}

static void test_gil_from_thread() {
    py::gil_scoped_release release;

    std::thread t(test_gil);
    t.join();
}


// Forward declaration (so that we can put the main tests here; the inherited virtual approaches are
// rather long).
void initialize_inherited_virtuals(py::module_ &m);

TEST_SUBMODULE(virtual_functions, m) {
    // test_override
    py::class_<ExampleVirt, PyExampleVirt>(m, "ExampleVirt")
        .def(py::init<int>())
        /* Reference original class in function definitions */
        .def("run", &ExampleVirt::run)
        .def("run_bool", &ExampleVirt::run_bool)
        .def("pure_virtual", &ExampleVirt::pure_virtual);

    py::class_<NonCopyable>(m, "NonCopyable")
        .def(py::init<int, int>());

    py::class_<Movable>(m, "Movable")
        .def(py::init<int, int>());

    // test_move_support
#if !defined(__INTEL_COMPILER) && !defined(__CUDACC__) && !defined(__PGIC__)
    py::class_<NCVirt, NCVirtTrampoline>(m, "NCVirt")
        .def(py::init<>())
        .def("get_noncopyable", &NCVirt::get_noncopyable)
        .def("get_movable", &NCVirt::get_movable)
        .def("print_nc", &NCVirt::print_nc)
        .def("print_movable", &NCVirt::print_movable);
#endif

    m.def("runExampleVirt", [](ExampleVirt *ex, int value) { return ex->run(value); });
    m.def("runExampleVirtBool", [](ExampleVirt* ex) { return ex->run_bool(); });
    m.def("runExampleVirtVirtual", [](ExampleVirt *ex) { ex->pure_virtual(); });

    m.def("cstats_debug", &ConstructorStats::get<ExampleVirt>);
    initialize_inherited_virtuals(m);

    // test_alias_delay_initialization1
    // don't invoke Python dispatch classes by default when instantiating C++ classes
    // that were not extended on the Python side
    struct A {
        A() = default;
        A(const A&) = delete;
        virtual ~A() = default;
        virtual void f() { py::print("A.f()"); }
    };

    struct PyA : A {
        PyA() { py::print("PyA.PyA()"); }
        PyA(const PyA&) = delete;
        ~PyA() override { py::print("PyA.~PyA()"); }

        void f() override {
            py::print("PyA.f()");
            // This convolution just gives a `void`, but tests that PYBIND11_TYPE() works to protect
            // a type containing a ,
            PYBIND11_OVERRIDE(PYBIND11_TYPE(typename std::enable_if<true, void>::type), A, f);
        }
    };

    py::class_<A, PyA>(m, "A")
        .def(py::init<>())
        .def("f", &A::f);

    m.def("call_f", [](A *a) { a->f(); });

    // test_alias_delay_initialization2
    // ... unless we explicitly request it, as in this example:
    struct A2 {
        A2() = default;
        A2(const A2&) = delete;
        virtual ~A2() = default;
        virtual void f() { py::print("A2.f()"); }
    };

    struct PyA2 : A2 {
        PyA2() { py::print("PyA2.PyA2()"); }
        PyA2(const PyA2&) = delete;
        ~PyA2() override { py::print("PyA2.~PyA2()"); }
        void f() override {
            py::print("PyA2.f()");
            PYBIND11_OVERRIDE(void, A2, f);
        }
    };

    py::class_<A2, PyA2>(m, "A2")
        .def(py::init_alias<>())
        .def(py::init([](int) { return new PyA2(); }))
        .def("f", &A2::f);

    m.def("call_f", [](A2 *a2) { a2->f(); });

    // test_dispatch_issue
    // #159: virtual function dispatch has problems with similar-named functions
    py::class_<Base, DispatchIssue>(m, "DispatchIssue")
        .def(py::init<>())
        .def("dispatch", &Base::dispatch);

    m.def("dispatch_issue_go", [](const Base * b) { return b->dispatch(); });

    // test_override_ref
    // #392/397: overriding reference-returning functions
    class OverrideTest {
    public:
        struct A { std::string value = "hi"; };
        std::string v;
        A a;
        explicit OverrideTest(const std::string &v) : v{v} {}
        OverrideTest() = default;
        OverrideTest(const OverrideTest&) = delete;
        virtual std::string str_value() { return v; }
        virtual std::string &str_ref() { return v; }
        virtual A A_value() { return a; }
        virtual A &A_ref() { return a; }
        virtual ~OverrideTest() = default;
    };

    class PyOverrideTest : public OverrideTest {
    public:
        using OverrideTest::OverrideTest;
        std::string str_value() override { PYBIND11_OVERRIDE(std::string, OverrideTest, str_value); }
        // Not allowed (uncommenting should hit a static_assert failure): we can't get a reference
        // to a python numeric value, since we only copy values in the numeric type caster:
//      std::string &str_ref() override { PYBIND11_OVERRIDE(std::string &, OverrideTest, str_ref); }
        // But we can work around it like this:
    private:
        std::string _tmp;
        std::string str_ref_helper() { PYBIND11_OVERRIDE(std::string, OverrideTest, str_ref); }
    public:
        std::string &str_ref() override { return _tmp = str_ref_helper(); }

        A A_value() override { PYBIND11_OVERRIDE(A, OverrideTest, A_value); }
        A &A_ref() override { PYBIND11_OVERRIDE(A &, OverrideTest, A_ref); }
    };

    py::class_<OverrideTest::A>(m, "OverrideTest_A")
        .def_readwrite("value", &OverrideTest::A::value);
    py::class_<OverrideTest, PyOverrideTest>(m, "OverrideTest")
        .def(py::init<const std::string &>())
        .def("str_value", &OverrideTest::str_value)
//      .def("str_ref", &OverrideTest::str_ref)
        .def("A_value", &OverrideTest::A_value)
        .def("A_ref", &OverrideTest::A_ref);
}


// Inheriting virtual methods.  We do two versions here: the repeat-everything version and the
// templated trampoline versions mentioned in docs/advanced.rst.
//
// These base classes are exactly the same, but we technically need distinct
// classes for this example code because we need to be able to bind them
// properly (pybind11, sensibly, doesn't allow us to bind the same C++ class to
// multiple python classes).
class A_Repeat {
#define A_METHODS \
public: \
    virtual int unlucky_number() = 0; \
    virtual std::string say_something(unsigned times) { \
        std::string s = ""; \
        for (unsigned i = 0; i < times; ++i) \
            s += "hi"; \
        return s; \
    } \
    std::string say_everything() { \
        return say_something(1) + " " + std::to_string(unlucky_number()); \
    }
A_METHODS
    A_Repeat() = default;
    A_Repeat(const A_Repeat&) = delete;
    virtual ~A_Repeat() = default;
};
class B_Repeat : public A_Repeat {
#define B_METHODS \
public: \
    int unlucky_number() override { return 13; } \
    std::string say_something(unsigned times) override { \
        return "B says hi " + std::to_string(times) + " times"; \
    } \
    virtual double lucky_number() { return 7.0; }
B_METHODS
};
class C_Repeat : public B_Repeat {
#define C_METHODS \
public: \
    int unlucky_number() override { return 4444; } \
    double lucky_number() override { return 888; }
C_METHODS
};
class D_Repeat : public C_Repeat {
#define D_METHODS // Nothing overridden.
D_METHODS
};

// Base classes for templated inheritance trampolines.  Identical to the repeat-everything version:
class A_Tpl {
    A_METHODS;
    A_Tpl() = default;
    A_Tpl(const A_Tpl&) = delete;
    virtual ~A_Tpl() = default;
};
class B_Tpl : public A_Tpl { B_METHODS };
class C_Tpl : public B_Tpl { C_METHODS };
class D_Tpl : public C_Tpl { D_METHODS };


// Inheritance approach 1: each trampoline gets every virtual method (11 in total)
class PyA_Repeat : public A_Repeat {
public:
    using A_Repeat::A_Repeat;
    int unlucky_number() override { PYBIND11_OVERRIDE_PURE(int, A_Repeat, unlucky_number, ); }
    std::string say_something(unsigned times) override { PYBIND11_OVERRIDE(std::string, A_Repeat, say_something, times); }
};
class PyB_Repeat : public B_Repeat {
public:
    using B_Repeat::B_Repeat;
    int unlucky_number() override { PYBIND11_OVERRIDE(int, B_Repeat, unlucky_number, ); }
    std::string say_something(unsigned times) override { PYBIND11_OVERRIDE(std::string, B_Repeat, say_something, times); }
    double lucky_number() override { PYBIND11_OVERRIDE(double, B_Repeat, lucky_number, ); }
};
class PyC_Repeat : public C_Repeat {
public:
    using C_Repeat::C_Repeat;
    int unlucky_number() override { PYBIND11_OVERRIDE(int, C_Repeat, unlucky_number, ); }
    std::string say_something(unsigned times) override { PYBIND11_OVERRIDE(std::string, C_Repeat, say_something, times); }
    double lucky_number() override { PYBIND11_OVERRIDE(double, C_Repeat, lucky_number, ); }
};
class PyD_Repeat : public D_Repeat {
public:
    using D_Repeat::D_Repeat;
    int unlucky_number() override { PYBIND11_OVERRIDE(int, D_Repeat, unlucky_number, ); }
    std::string say_something(unsigned times) override { PYBIND11_OVERRIDE(std::string, D_Repeat, say_something, times); }
    double lucky_number() override { PYBIND11_OVERRIDE(double, D_Repeat, lucky_number, ); }
};

// Inheritance approach 2: templated trampoline classes.
//
// Advantages:
// - we have only 2 (template) class and 4 method declarations (one per virtual method, plus one for
//   any override of a pure virtual method), versus 4 classes and 6 methods (MI) or 4 classes and 11
//   methods (repeat).
// - Compared to MI, we also don't have to change the non-trampoline inheritance to virtual, and can
//   properly inherit constructors.
//
// Disadvantage:
// - the compiler must still generate and compile 14 different methods (more, even, than the 11
//   required for the repeat approach) instead of the 6 required for MI.  (If there was no pure
//   method (or no pure method override), the number would drop down to the same 11 as the repeat
//   approach).
template <class Base = A_Tpl>
class PyA_Tpl : public Base {
public:
    using Base::Base; // Inherit constructors
    int unlucky_number() override { PYBIND11_OVERRIDE_PURE(int, Base, unlucky_number, ); }
    std::string say_something(unsigned times) override { PYBIND11_OVERRIDE(std::string, Base, say_something, times); }
};
template <class Base = B_Tpl>
class PyB_Tpl : public PyA_Tpl<Base> {
public:
    using PyA_Tpl<Base>::PyA_Tpl; // Inherit constructors (via PyA_Tpl's inherited constructors)
    int unlucky_number() override { PYBIND11_OVERRIDE(int, Base, unlucky_number, ); }
    double lucky_number() override { PYBIND11_OVERRIDE(double, Base, lucky_number, ); }
};
// Since C_Tpl and D_Tpl don't declare any new virtual methods, we don't actually need these (we can
// use PyB_Tpl<C_Tpl> and PyB_Tpl<D_Tpl> for the trampoline classes instead):
/*
template <class Base = C_Tpl> class PyC_Tpl : public PyB_Tpl<Base> {
public:
    using PyB_Tpl<Base>::PyB_Tpl;
};
template <class Base = D_Tpl> class PyD_Tpl : public PyC_Tpl<Base> {
public:
    using PyC_Tpl<Base>::PyC_Tpl;
};
*/

void initialize_inherited_virtuals(py::module_ &m) {
    // test_inherited_virtuals

    // Method 1: repeat
    py::class_<A_Repeat, PyA_Repeat>(m, "A_Repeat")
        .def(py::init<>())
        .def("unlucky_number", &A_Repeat::unlucky_number)
        .def("say_something", &A_Repeat::say_something)
        .def("say_everything", &A_Repeat::say_everything);
    py::class_<B_Repeat, A_Repeat, PyB_Repeat>(m, "B_Repeat")
        .def(py::init<>())
        .def("lucky_number", &B_Repeat::lucky_number);
    py::class_<C_Repeat, B_Repeat, PyC_Repeat>(m, "C_Repeat")
        .def(py::init<>());
    py::class_<D_Repeat, C_Repeat, PyD_Repeat>(m, "D_Repeat")
        .def(py::init<>());

    // test_
    // Method 2: Templated trampolines
    py::class_<A_Tpl, PyA_Tpl<>>(m, "A_Tpl")
        .def(py::init<>())
        .def("unlucky_number", &A_Tpl::unlucky_number)
        .def("say_something", &A_Tpl::say_something)
        .def("say_everything", &A_Tpl::say_everything);
    py::class_<B_Tpl, A_Tpl, PyB_Tpl<>>(m, "B_Tpl")
        .def(py::init<>())
        .def("lucky_number", &B_Tpl::lucky_number);
    py::class_<C_Tpl, B_Tpl, PyB_Tpl<C_Tpl>>(m, "C_Tpl")
        .def(py::init<>());
    py::class_<D_Tpl, C_Tpl, PyB_Tpl<D_Tpl>>(m, "D_Tpl")
        .def(py::init<>()<style>pre { line-height: 125%; margin: 0; }
td.linenos pre { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; }
span.linenos { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; }
td.linenos pre.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight { background: #ffffff; }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */</style><div class="highlight"><pre><span></span><span class="cm">/**</span>
<span class="cm">  ******************************************************************************</span>
<span class="cm">  * @file    stm32f10x_dma.h</span>
<span class="cm">  * @author  MCD Application Team</span>
<span class="cm">  * @version V3.1.0</span>
<span class="cm">  * @date    06/19/2009</span>
<span class="cm">  * @brief   This file contains all the functions prototypes for the DMA firmware </span>
<span class="cm">  *          library.</span>
<span class="cm">  ******************************************************************************</span>
<span class="cm">  * @copy</span>
<span class="cm">  *</span>
<span class="cm">  * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS</span>
<span class="cm">  * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE</span>
<span class="cm">  * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY</span>
<span class="cm">  * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING</span>
<span class="cm">  * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE</span>
<span class="cm">  * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.</span>
<span class="cm">  *</span>
<span class="cm">  * &lt;h2&gt;&lt;center&gt;&amp;copy; COPYRIGHT 2009 STMicroelectronics&lt;/center&gt;&lt;/h2&gt;</span>
<span class="cm">  */</span> 

<span class="cm">/* Define to prevent recursive inclusion -------------------------------------*/</span>
<span class="cp">#ifndef __STM32F10x_DMA_H</span>
<span class="cp">#define __STM32F10x_DMA_H</span>

<span class="cp">#ifdef __cplusplus</span>
 <span class="k">extern</span> <span class="s">&quot;C&quot;</span> <span class="p">{</span>
<span class="cp">#endif</span>

<span class="cm">/* Includes ------------------------------------------------------------------*/</span>
<span class="cp">#include</span> <span class="cpf">&quot;stm32f10x.h&quot;</span><span class="cp"></span>

<span class="cm">/** @addtogroup STM32F10x_StdPeriph_Driver</span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>

<span class="cm">/** @addtogroup DMA</span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>

<span class="cm">/** @defgroup DMA_Exported_Types</span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>

<span class="cm">/** </span>
<span class="cm">  * @brief  DMA Init structure definition</span>
<span class="cm">  */</span>

<span class="k">typedef</span> <span class="k">struct</span>
<span class="p">{</span>
  <span class="kt">uint32_t</span> <span class="n">DMA_PeripheralBaseAddr</span><span class="p">;</span> <span class="cm">/*!&lt; Specifies the peripheral base address for DMAy Channelx. */</span>

  <span class="kt">uint32_t</span> <span class="n">DMA_MemoryBaseAddr</span><span class="p">;</span>     <span class="cm">/*!&lt; Specifies the memory base address for DMAy Channelx. */</span>

  <span class="kt">uint32_t</span> <span class="n">DMA_DIR</span><span class="p">;</span>                <span class="cm">/*!&lt; Specifies if the peripheral is the source or destination.</span>
<span class="cm">                                        This parameter can be a value of @ref DMA_data_transfer_direction */</span>

  <span class="kt">uint32_t</span> <span class="n">DMA_BufferSize</span><span class="p">;</span>         <span class="cm">/*!&lt; Specifies the buffer size, in data unit, of the specified Channel. </span>
<span class="cm">                                        The data unit is equal to the configuration set in DMA_PeripheralDataSize</span>
<span class="cm">                                        or DMA_MemoryDataSize members depending in the transfer direction. */</span>

  <span class="kt">uint32_t</span> <span class="n">DMA_PeripheralInc</span><span class="p">;</span>      <span class="cm">/*!&lt; Specifies whether the Peripheral address register is incremented or not.</span>
<span class="cm">                                        This parameter can be a value of @ref DMA_peripheral_incremented_mode */</span>

  <span class="kt">uint32_t</span> <span class="n">DMA_MemoryInc</span><span class="p">;</span>          <span class="cm">/*!&lt; Specifies whether the memory address register is incremented or not.</span>
<span class="cm">                                        This parameter can be a value of @ref DMA_memory_incremented_mode */</span>

  <span class="kt">uint32_t</span> <span class="n">DMA_PeripheralDataSize</span><span class="p">;</span> <span class="cm">/*!&lt; Specifies the Peripheral data width.</span>
<span class="cm">                                        This parameter can be a value of @ref DMA_peripheral_data_size */</span>

  <span class="kt">uint32_t</span> <span class="n">DMA_MemoryDataSize</span><span class="p">;</span>     <span class="cm">/*!&lt; Specifies the Memory data width.</span>
<span class="cm">                                        This parameter can be a value of @ref DMA_memory_data_size */</span>

  <span class="kt">uint32_t</span> <span class="n">DMA_Mode</span><span class="p">;</span>               <span class="cm">/*!&lt; Specifies the operation mode of the DMAy Channelx.</span>
<span class="cm">                                        This parameter can be a value of @ref DMA_circular_normal_mode.</span>
<span class="cm">                                        @note: The circular buffer mode cannot be used if the memory-to-memory</span>
<span class="cm">                                              data transfer is configured on the selected Channel */</span>

  <span class="kt">uint32_t</span> <span class="n">DMA_Priority</span><span class="p">;</span>           <span class="cm">/*!&lt; Specifies the software priority for the DMAy Channelx.</span>
<span class="cm">                                        This parameter can be a value of @ref DMA_priority_level */</span>

  <span class="kt">uint32_t</span> <span class="n">DMA_M2M</span><span class="p">;</span>                <span class="cm">/*!&lt; Specifies if the DMAy Channelx will be used in memory-to-memory transfer.</span>
<span class="cm">                                        This parameter can be a value of @ref DMA_memory_to_memory */</span>
<span class="p">}</span><span class="n">DMA_InitTypeDef</span><span class="p">;</span>

<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/** @defgroup DMA_Exported_Constants</span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>

<span class="cp">#define IS_DMA_ALL_PERIPH(PERIPH) (((PERIPH) == DMA1_Channel1) || \</span>
<span class="cp">                                   ((PERIPH) == DMA1_Channel2) || \</span>
<span class="cp">                                   ((PERIPH) == DMA1_Channel3) || \</span>
<span class="cp">                                   ((PERIPH) == DMA1_Channel4) || \</span>
<span class="cp">                                   ((PERIPH) == DMA1_Channel5) || \</span>
<span class="cp">                                   ((PERIPH) == DMA1_Channel6) || \</span>
<span class="cp">                                   ((PERIPH) == DMA1_Channel7) || \</span>
<span class="cp">                                   ((PERIPH) == DMA2_Channel1) || \</span>
<span class="cp">                                   ((PERIPH) == DMA2_Channel2) || \</span>
<span class="cp">                                   ((PERIPH) == DMA2_Channel3) || \</span>
<span class="cp">                                   ((PERIPH) == DMA2_Channel4) || \</span>
<span class="cp">                                   ((PERIPH) == DMA2_Channel5))</span>

<span class="cm">/** @defgroup DMA_data_transfer_direction </span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>

<span class="cp">#define DMA_DIR_PeripheralDST              ((uint32_t)0x00000010)</span>
<span class="cp">#define DMA_DIR_PeripheralSRC              ((uint32_t)0x00000000)</span>
<span class="cp">#define IS_DMA_DIR(DIR) (((DIR) == DMA_DIR_PeripheralDST) || \</span>
<span class="cp">                         ((DIR) == DMA_DIR_PeripheralSRC))</span>
<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/** @defgroup DMA_peripheral_incremented_mode </span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>

<span class="cp">#define DMA_PeripheralInc_Enable           ((uint32_t)0x00000040)</span>
<span class="cp">#define DMA_PeripheralInc_Disable          ((uint32_t)0x00000000)</span>
<span class="cp">#define IS_DMA_PERIPHERAL_INC_STATE(STATE) (((STATE) == DMA_PeripheralInc_Enable) || \</span>
<span class="cp">                                            ((STATE) == DMA_PeripheralInc_Disable))</span>
<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/** @defgroup DMA_memory_incremented_mode </span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>

<span class="cp">#define DMA_MemoryInc_Enable               ((uint32_t)0x00000080)</span>
<span class="cp">#define DMA_MemoryInc_Disable              ((uint32_t)0x00000000)</span>
<span class="cp">#define IS_DMA_MEMORY_INC_STATE(STATE) (((STATE) == DMA_MemoryInc_Enable) || \</span>
<span class="cp">                                        ((STATE) == DMA_MemoryInc_Disable))</span>
<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/** @defgroup DMA_peripheral_data_size </span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>

<span class="cp">#define DMA_PeripheralDataSize_Byte        ((uint32_t)0x00000000)</span>
<span class="cp">#define DMA_PeripheralDataSize_HalfWord    ((uint32_t)0x00000100)</span>
<span class="cp">#define DMA_PeripheralDataSize_Word        ((uint32_t)0x00000200)</span>
<span class="cp">#define IS_DMA_PERIPHERAL_DATA_SIZE(SIZE) (((SIZE) == DMA_PeripheralDataSize_Byte) || \</span>
<span class="cp">                                           ((SIZE) == DMA_PeripheralDataSize_HalfWord) || \</span>
<span class="cp">                                           ((SIZE) == DMA_PeripheralDataSize_Word))</span>
<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/** @defgroup DMA_memory_data_size </span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>

<span class="cp">#define DMA_MemoryDataSize_Byte            ((uint32_t)0x00000000)</span>
<span class="cp">#define DMA_MemoryDataSize_HalfWord        ((uint32_t)0x00000400)</span>
<span class="cp">#define DMA_MemoryDataSize_Word            ((uint32_t)0x00000800)</span>
<span class="cp">#define IS_DMA_MEMORY_DATA_SIZE(SIZE) (((SIZE) == DMA_MemoryDataSize_Byte) || \</span>
<span class="cp">                                       ((SIZE) == DMA_MemoryDataSize_HalfWord) || \</span>
<span class="cp">                                       ((SIZE) == DMA_MemoryDataSize_Word))</span>
<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/** @defgroup DMA_circular_normal_mode </span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>

<span class="cp">#define DMA_Mode_Circular                  ((uint32_t)0x00000020)</span>
<span class="cp">#define DMA_Mode_Normal                    ((uint32_t)0x00000000)</span>
<span class="cp">#define IS_DMA_MODE(MODE) (((MODE) == DMA_Mode_Circular) || ((MODE) == DMA_Mode_Normal))</span>
<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/** @defgroup DMA_priority_level </span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>

<span class="cp">#define DMA_Priority_VeryHigh              ((uint32_t)0x00003000)</span>
<span class="cp">#define DMA_Priority_High                  ((uint32_t)0x00002000)</span>
<span class="cp">#define DMA_Priority_Medium                ((uint32_t)0x00001000)</span>
<span class="cp">#define DMA_Priority_Low                   ((uint32_t)0x00000000)</span>
<span class="cp">#define IS_DMA_PRIORITY(PRIORITY) (((PRIORITY) == DMA_Priority_VeryHigh) || \</span>
<span class="cp">                                   ((PRIORITY) == DMA_Priority_High) || \</span>
<span class="cp">                                   ((PRIORITY) == DMA_Priority_Medium) || \</span>
<span class="cp">                                   ((PRIORITY) == DMA_Priority_Low))</span>
<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/** @defgroup DMA_memory_to_memory </span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>

<span class="cp">#define DMA_M2M_Enable                     ((uint32_t)0x00004000)</span>
<span class="cp">#define DMA_M2M_Disable                    ((uint32_t)0x00000000)</span>
<span class="cp">#define IS_DMA_M2M_STATE(STATE) (((STATE) == DMA_M2M_Enable) || ((STATE) == DMA_M2M_Disable))</span>

<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/** @defgroup DMA_interrupts_definition </span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>

<span class="cp">#define DMA_IT_TC                          ((uint32_t)0x00000002)</span>
<span class="cp">#define DMA_IT_HT                          ((uint32_t)0x00000004)</span>
<span class="cp">#define DMA_IT_TE                          ((uint32_t)0x00000008)</span>
<span class="cp">#define IS_DMA_CONFIG_IT(IT) ((((IT) &amp; 0xFFFFFFF1) == 0x00) &amp;&amp; ((IT) != 0x00))</span>

<span class="cp">#define DMA1_IT_GL1                        ((uint32_t)0x00000001)</span>
<span class="cp">#define DMA1_IT_TC1                        ((uint32_t)0x00000002)</span>
<span class="cp">#define DMA1_IT_HT1                        ((uint32_t)0x00000004)</span>
<span class="cp">#define DMA1_IT_TE1                        ((uint32_t)0x00000008)</span>
<span class="cp">#define DMA1_IT_GL2                        ((uint32_t)0x00000010)</span>
<span class="cp">#define DMA1_IT_TC2                        ((uint32_t)0x00000020)</span>
<span class="cp">#define DMA1_IT_HT2                        ((uint32_t)0x00000040)</span>
<span class="cp">#define DMA1_IT_TE2                        ((uint32_t)0x00000080)</span>
<span class="cp">#define DMA1_IT_GL3                        ((uint32_t)0x00000100)</span>
<span class="cp">#define DMA1_IT_TC3                        ((uint32_t)0x00000200)</span>
<span class="cp">#define DMA1_IT_HT3                        ((uint32_t)0x00000400)</span>
<span class="cp">#define DMA1_IT_TE3                        ((uint32_t)0x00000800)</span>
<span class="cp">#define DMA1_IT_GL4                        ((uint32_t)0x00001000)</span>
<span class="cp">#define DMA1_IT_TC4                        ((uint32_t)0x00002000)</span>
<span class="cp">#define DMA1_IT_HT4                        ((uint32_t)0x00004000)</span>
<span class="cp">#define DMA1_IT_TE4                        ((uint32_t)0x00008000)</span>
<span class="cp">#define DMA1_IT_GL5                        ((uint32_t)0x00010000)</span>
<span class="cp">#define DMA1_IT_TC5                        ((uint32_t)0x00020000)</span>
<span class="cp">#define DMA1_IT_HT5                        ((uint32_t)0x00040000)</span>
<span class="cp">#define DMA1_IT_TE5                        ((uint32_t)0x00080000)</span>
<span class="cp">#define DMA1_IT_GL6                        ((uint32_t)0x00100000)</span>
<span class="cp">#define DMA1_IT_TC6                        ((uint32_t)0x00200000)</span>
<span class="cp">#define DMA1_IT_HT6                        ((uint32_t)0x00400000)</span>
<span class="cp">#define DMA1_IT_TE6                        ((uint32_t)0x00800000)</span>
<span class="cp">#define DMA1_IT_GL7                        ((uint32_t)0x01000000)</span>
<span class="cp">#define DMA1_IT_TC7                        ((uint32_t)0x02000000)</span>
<span class="cp">#define DMA1_IT_HT7                        ((uint32_t)0x04000000)</span>
<span class="cp">#define DMA1_IT_TE7                        ((uint32_t)0x08000000)</span>

<span class="cp">#define DMA2_IT_GL1                        ((uint32_t)0x10000001)</span>
<span class="cp">#define DMA2_IT_TC1                        ((uint32_t)0x10000002)</span>
<span class="cp">#define DMA2_IT_HT1                        ((uint32_t)0x10000004)</span>
<span class="cp">#define DMA2_IT_TE1                        ((uint32_t)0x10000008)</span>
<span class="cp">#define DMA2_IT_GL2                        ((uint32_t)0x10000010)</span>
<span class="cp">#define DMA2_IT_TC2                        ((uint32_t)0x10000020)</span>
<span class="cp">#define DMA2_IT_HT2                        ((uint32_t)0x10000040)</span>
<span class="cp">#define DMA2_IT_TE2                        ((uint32_t)0x10000080)</span>
<span class="cp">#define DMA2_IT_GL3                        ((uint32_t)0x10000100)</span>
<span class="cp">#define DMA2_IT_TC3                        ((uint32_t)0x10000200)</span>
<span class="cp">#define DMA2_IT_HT3                        ((uint32_t)0x10000400)</span>
<span class="cp">#define DMA2_IT_TE3                        ((uint32_t)0x10000800)</span>
<span class="cp">#define DMA2_IT_GL4                        ((uint32_t)0x10001000)</span>
<span class="cp">#define DMA2_IT_TC4                        ((uint32_t)0x10002000)</span>
<span class="cp">#define DMA2_IT_HT4                        ((uint32_t)0x10004000)</span>
<span class="cp">#define DMA2_IT_TE4                        ((uint32_t)0x10008000)</span>
<span class="cp">#define DMA2_IT_GL5                        ((uint32_t)0x10010000)</span>
<span class="cp">#define DMA2_IT_TC5                        ((uint32_t)0x10020000)</span>
<span class="cp">#define DMA2_IT_HT5                        ((uint32_t)0x10040000)</span>
<span class="cp">#define DMA2_IT_TE5                        ((uint32_t)0x10080000)</span>

<span class="cp">#define IS_DMA_CLEAR_IT(IT) (((((IT) &amp; 0xF0000000) == 0x00) || (((IT) &amp; 0xEFF00000) == 0x00)) &amp;&amp; ((IT) != 0x00))</span>

<span class="cp">#define IS_DMA_GET_IT(IT) (((IT) == DMA1_IT_GL1) || ((IT) == DMA1_IT_TC1) || \</span>
<span class="cp">                           ((IT) == DMA1_IT_HT1) || ((IT) == DMA1_IT_TE1) || \</span>
<span class="cp">                           ((IT) == DMA1_IT_GL2) || ((IT) == DMA1_IT_TC2) || \</span>
<span class="cp">                           ((IT) == DMA1_IT_HT2) || ((IT) == DMA1_IT_TE2) || \</span>
<span class="cp">                           ((IT) == DMA1_IT_GL3) || ((IT) == DMA1_IT_TC3) || \</span>
<span class="cp">                           ((IT) == DMA1_IT_HT3) || ((IT) == DMA1_IT_TE3) || \</span>
<span class="cp">                           ((IT) == DMA1_IT_GL4) || ((IT) == DMA1_IT_TC4) || \</span>
<span class="cp">                           ((IT) == DMA1_IT_HT4) || ((IT) == DMA1_IT_TE4) || \</span>
<span class="cp">                           ((IT) == DMA1_IT_GL5) || ((IT) == DMA1_IT_TC5) || \</span>
<span class="cp">                           ((IT) == DMA1_IT_HT5) || ((IT) == DMA1_IT_TE5) || \</span>
<span class="cp">                           ((IT) == DMA1_IT_GL6) || ((IT) == DMA1_IT_TC6) || \</span>
<span class="cp">                           ((IT) == DMA1_IT_HT6) || ((IT) == DMA1_IT_TE6) || \</span>
<span class="cp">                           ((IT) == DMA1_IT_GL7) || ((IT) == DMA1_IT_TC7) || \</span>
<span class="cp">                           ((IT) == DMA1_IT_HT7) || ((IT) == DMA1_IT_TE7) || \</span>
<span class="cp">                           ((IT) == DMA2_IT_GL1) || ((IT) == DMA2_IT_TC1) || \</span>
<span class="cp">                           ((IT) == DMA2_IT_HT1) || ((IT) == DMA2_IT_TE1) || \</span>
<span class="cp">                           ((IT) == DMA2_IT_GL2) || ((IT) == DMA2_IT_TC2) || \</span>
<span class="cp">                           ((IT) == DMA2_IT_HT2) || ((IT) == DMA2_IT_TE2) || \</span>
<span class="cp">                           ((IT) == DMA2_IT_GL3) || ((IT) == DMA2_IT_TC3) || \</span>
<span class="cp">                           ((IT) == DMA2_IT_HT3) || ((IT) == DMA2_IT_TE3) || \</span>
<span class="cp">                           ((IT) == DMA2_IT_GL4) || ((IT) == DMA2_IT_TC4) || \</span>
<span class="cp">                           ((IT) == DMA2_IT_HT4) || ((IT) == DMA2_IT_TE4) || \</span>
<span class="cp">                           ((IT) == DMA2_IT_GL5) || ((IT) == DMA2_IT_TC5) || \</span>
<span class="cp">                           ((IT) == DMA2_IT_HT5) || ((IT) == DMA2_IT_TE5))</span>

<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/** @defgroup DMA_flags_definition </span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>
<span class="cp">#define DMA1_FLAG_GL1                      ((uint32_t)0x00000001)</span>
<span class="cp">#define DMA1_FLAG_TC1                      ((uint32_t)0x00000002)</span>
<span class="cp">#define DMA1_FLAG_HT1                      ((uint32_t)0x00000004)</span>
<span class="cp">#define DMA1_FLAG_TE1                      ((uint32_t)0x00000008)</span>
<span class="cp">#define DMA1_FLAG_GL2                      ((uint32_t)0x00000010)</span>
<span class="cp">#define DMA1_FLAG_TC2                      ((uint32_t)0x00000020)</span>
<span class="cp">#define DMA1_FLAG_HT2                      ((uint32_t)0x00000040)</span>
<span class="cp">#define DMA1_FLAG_TE2                      ((uint32_t)0x00000080)</span>
<span class="cp">#define DMA1_FLAG_GL3                      ((uint32_t)0x00000100)</span>
<span class="cp">#define DMA1_FLAG_TC3                      ((uint32_t)0x00000200)</span>
<span class="cp">#define DMA1_FLAG_HT3                      ((uint32_t)0x00000400)</span>
<span class="cp">#define DMA1_FLAG_TE3                      ((uint32_t)0x00000800)</span>
<span class="cp">#define DMA1_FLAG_GL4                      ((uint32_t)0x00001000)</span>
<span class="cp">#define DMA1_FLAG_TC4                      ((uint32_t)0x00002000)</span>
<span class="cp">#define DMA1_FLAG_HT4                      ((uint32_t)0x00004000)</span>
<span class="cp">#define DMA1_FLAG_TE4                      ((uint32_t)0x00008000)</span>
<span class="cp">#define DMA1_FLAG_GL5                      ((uint32_t)0x00010000)</span>
<span class="cp">#define DMA1_FLAG_TC5                      ((uint32_t)0x00020000)</span>
<span class="cp">#define DMA1_FLAG_HT5                      ((uint32_t)0x00040000)</span>
<span class="cp">#define DMA1_FLAG_TE5                      ((uint32_t)0x00080000)</span>
<span class="cp">#define DMA1_FLAG_GL6                      ((uint32_t)0x00100000)</span>
<span class="cp">#define DMA1_FLAG_TC6                      ((uint32_t)0x00200000)</span>
<span class="cp">#define DMA1_FLAG_HT6                      ((uint32_t)0x00400000)</span>
<span class="cp">#define DMA1_FLAG_TE6                      ((uint32_t)0x00800000)</span>
<span class="cp">#define DMA1_FLAG_GL7                      ((uint32_t)0x01000000)</span>
<span class="cp">#define DMA1_FLAG_TC7                      ((uint32_t)0x02000000)</span>
<span class="cp">#define DMA1_FLAG_HT7                      ((uint32_t)0x04000000)</span>
<span class="cp">#define DMA1_FLAG_TE7                      ((uint32_t)0x08000000)</span>

<span class="cp">#define DMA2_FLAG_GL1                      ((uint32_t)0x10000001)</span>
<span class="cp">#define DMA2_FLAG_TC1                      ((uint32_t)0x10000002)</span>
<span class="cp">#define DMA2_FLAG_HT1                      ((uint32_t)0x10000004)</span>
<span class="cp">#define DMA2_FLAG_TE1                      ((uint32_t)0x10000008)</span>
<span class="cp">#define DMA2_FLAG_GL2                      ((uint32_t)0x10000010)</span>
<span class="cp">#define DMA2_FLAG_TC2                      ((uint32_t)0x10000020)</span>
<span class="cp">#define DMA2_FLAG_HT2                      ((uint32_t)0x10000040)</span>
<span class="cp">#define DMA2_FLAG_TE2                      ((uint32_t)0x10000080)</span>
<span class="cp">#define DMA2_FLAG_GL3                      ((uint32_t)0x10000100)</span>
<span class="cp">#define DMA2_FLAG_TC3                      ((uint32_t)0x10000200)</span>
<span class="cp">#define DMA2_FLAG_HT3                      ((uint32_t)0x10000400)</span>
<span class="cp">#define DMA2_FLAG_TE3                      ((uint32_t)0x10000800)</span>
<span class="cp">#define DMA2_FLAG_GL4                      ((uint32_t)0x10001000)</span>
<span class="cp">#define DMA2_FLAG_TC4                      ((uint32_t)0x10002000)</span>
<span class="cp">#define DMA2_FLAG_HT4                      ((uint32_t)0x10004000)</span>
<span class="cp">#define DMA2_FLAG_TE4                      ((uint32_t)0x10008000)</span>
<span class="cp">#define DMA2_FLAG_GL5                      ((uint32_t)0x10010000)</span>
<span class="cp">#define DMA2_FLAG_TC5                      ((uint32_t)0x10020000)</span>
<span class="cp">#define DMA2_FLAG_HT5                      ((uint32_t)0x10040000)</span>
<span class="cp">#define DMA2_FLAG_TE5                      ((uint32_t)0x10080000)</span>

<span class="cp">#define IS_DMA_CLEAR_FLAG(FLAG) (((((FLAG) &amp; 0xF0000000) == 0x00) || (((FLAG) &amp; 0xEFF00000) == 0x00)) &amp;&amp; ((FLAG) != 0x00))</span>

<span class="cp">#define IS_DMA_GET_FLAG(FLAG) (((FLAG) == DMA1_FLAG_GL1) || ((FLAG) == DMA1_FLAG_TC1) || \</span>
<span class="cp">                               ((FLAG) == DMA1_FLAG_HT1) || ((FLAG) == DMA1_FLAG_TE1) || \</span>
<span class="cp">                               ((FLAG) == DMA1_FLAG_GL2) || ((FLAG) == DMA1_FLAG_TC2) || \</span>
<span class="cp">                               ((FLAG) == DMA1_FLAG_HT2) || ((FLAG) == DMA1_FLAG_TE2) || \</span>
<span class="cp">                               ((FLAG) == DMA1_FLAG_GL3) || ((FLAG) == DMA1_FLAG_TC3) || \</span>
<span class="cp">                               ((FLAG) == DMA1_FLAG_HT3) || ((FLAG) == DMA1_FLAG_TE3) || \</span>
<span class="cp">                               ((FLAG) == DMA1_FLAG_GL4) || ((FLAG) == DMA1_FLAG_TC4) || \</span>
<span class="cp">                               ((FLAG) == DMA1_FLAG_HT4) || ((FLAG) == DMA1_FLAG_TE4) || \</span>
<span class="cp">                               ((FLAG) == DMA1_FLAG_GL5) || ((FLAG) == DMA1_FLAG_TC5) || \</span>
<span class="cp">                               ((FLAG) == DMA1_FLAG_HT5) || ((FLAG) == DMA1_FLAG_TE5) || \</span>
<span class="cp">                               ((FLAG) == DMA1_FLAG_GL6) || ((FLAG) == DMA1_FLAG_TC6) || \</span>
<span class="cp">                               ((FLAG) == DMA1_FLAG_HT6) || ((FLAG) == DMA1_FLAG_TE6) || \</span>
<span class="cp">                               ((FLAG) == DMA1_FLAG_GL7) || ((FLAG) == DMA1_FLAG_TC7) || \</span>
<span class="cp">                               ((FLAG) == DMA1_FLAG_HT7) || ((FLAG) == DMA1_FLAG_TE7) || \</span>
<span class="cp">                               ((FLAG) == DMA2_FLAG_GL1) || ((FLAG) == DMA2_FLAG_TC1) || \</span>
<span class="cp">                               ((FLAG) == DMA2_FLAG_HT1) || ((FLAG) == DMA2_FLAG_TE1) || \</span>
<span class="cp">                               ((FLAG) == DMA2_FLAG_GL2) || ((FLAG) == DMA2_FLAG_TC2) || \</span>
<span class="cp">                               ((FLAG) == DMA2_FLAG_HT2) || ((FLAG) == DMA2_FLAG_TE2) || \</span>
<span class="cp">                               ((FLAG) == DMA2_FLAG_GL3) || ((FLAG) == DMA2_FLAG_TC3) || \</span>
<span class="cp">                               ((FLAG) == DMA2_FLAG_HT3) || ((FLAG) == DMA2_FLAG_TE3) || \</span>
<span class="cp">                               ((FLAG) == DMA2_FLAG_GL4) || ((FLAG) == DMA2_FLAG_TC4) || \</span>
<span class="cp">                               ((FLAG) == DMA2_FLAG_HT4) || ((FLAG) == DMA2_FLAG_TE4) || \</span>
<span class="cp">                               ((FLAG) == DMA2_FLAG_GL5) || ((FLAG) == DMA2_FLAG_TC5) || \</span>
<span class="cp">                               ((FLAG) == DMA2_FLAG_HT5) || ((FLAG) == DMA2_FLAG_TE5))</span>
<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/** @defgroup DMA_Buffer_Size </span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>

<span class="cp">#define IS_DMA_BUFFER_SIZE(SIZE) (((SIZE) &gt;= 0x1) &amp;&amp; ((SIZE) &lt; 0x10000))</span>

<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/** @defgroup DMA_Exported_Macros</span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>

<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/** @defgroup DMA_Exported_Functions</span>
<span class="cm">  * @{</span>
<span class="cm">  */</span>

<span class="kt">void</span> <span class="nf">DMA_DeInit</span><span class="p">(</span><span class="n">DMA_Channel_TypeDef</span><span class="o">*</span> <span class="n">DMAy_Channelx</span><span class="p">);</span>
<span class="kt">void</span> <span class="nf">DMA_Init</span><span class="p">(</span><span class="n">DMA_Channel_TypeDef</span><span class="o">*</span> <span class="n">DMAy_Channelx</span><span class="p">,</span> <span class="n">DMA_InitTypeDef</span><span class="o">*</span> <span class="n">DMA_InitStruct</span><span class="p">);</span>
<span class="kt">void</span> <span class="nf">DMA_StructInit</span><span class="p">(</span><span class="n">DMA_InitTypeDef</span><span class="o">*</span> <span class="n">DMA_InitStruct</span><span class="p">);</span>
<span class="kt">void</span> <span class="nf">DMA_Cmd</span><span class="p">(</span><span class="n">DMA_Channel_TypeDef</span><span class="o">*</span> <span class="n">DMAy_Channelx</span><span class="p">,</span> <span class="n">FunctionalState</span> <span class="n">NewState</span><span class="p">);</span>
<span class="kt">void</span> <span class="nf">DMA_ITConfig</span><span class="p">(</span><span class="n">DMA_Channel_TypeDef</span><span class="o">*</span> <span class="n">DMAy_Channelx</span><span class="p">,</span> <span class="kt">uint32_t</span> <span class="n">DMA_IT</span><span class="p">,</span> <span class="n">FunctionalState</span> <span class="n">NewState</span><span class="p">);</span>
<span class="kt">uint16_t</span> <span class="nf">DMA_GetCurrDataCounter</span><span class="p">(</span><span class="n">DMA_Channel_TypeDef</span><span class="o">*</span> <span class="n">DMAy_Channelx</span><span class="p">);</span>
<span class="n">FlagStatus</span> <span class="nf">DMA_GetFlagStatus</span><span class="p">(</span><span class="kt">uint32_t</span> <span class="n">DMA_FLAG</span><span class="p">);</span>
<span class="kt">void</span> <span class="nf">DMA_ClearFlag</span><span class="p">(</span><span class="kt">uint32_t</span> <span class="n">DMA_FLAG</span><span class="p">);</span>
<span class="n">ITStatus</span> <span class="nf">DMA_GetITStatus</span><span class="p">(</span><span class="kt">uint32_t</span> <span class="n">DMA_IT</span><span class="p">);</span>
<span class="kt">void</span> <span class="nf">DMA_ClearITPendingBit</span><span class="p">(</span><span class="kt">uint32_t</span> <span class="n">DMA_IT</span><span class="p">);</span>

<span class="cp">#ifdef __cplusplus</span>
<span class="p">}</span>
<span class="cp">#endif</span>

<span class="cp">#endif </span><span class="cm">/*__STM32F10x_DMA_H */</span><span class="cp"></span>
<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/**</span>
<span class="cm">  * @}</span>
<span class="cm">  */</span>

<span class="cm">/******************* (C) COPYRIGHT 2009 STMicroelectronics *****END OF FILE****/</span>
</pre></div>
</code></pre></td></tr></table>
</div> <!-- class=content -->
<div class='footer'>generated by <a href='https://git.zx2c4.com/cgit/about/'>cgit v1.2.3</a> (<a href='https://git-scm.com/'>git 2.25.1</a>) at 2025-06-20 14:26:18 +0000</div>
</div> <!-- id=cgit -->
</body>
</html>