В этой статье приведен перевод раздела "Interrupt Manager" документации VisualDSP++ 5.0 Device Drivers and System Services Manual for Blackfin® Processors [1]. Описывается менеджер прерываний VDK процессора Blackfin, который управляет прерываниями (событиями) и осуществляет их обслуживание. Рассматриваются следующие вопросы:

• Инициализация Менеджера Прерываний
• Завершение работы Менеджера Прерываний
• Функции контроллера событий ядра (CEC)
• Функции системного контроллера прерываний (SIC)
• Защита критических регионов кода
• Модификация IMASK
• Файловая структура
• Документация по API Interrupt Manager

Примечание: менеджер прерываний можно использовать не только в приложениях VDK, но и в обычных программах (не RTOS). Выигрыш в том, что упрощается управление над всеми прерываниями в программе, и их обработка унифицируется, что благоприятно сказывается на читаемости и портируемости кода.

Процессор Blackfin использует двухярусный механизм управления прерываниями и событиями. Прерывания системного уровня управляются системным контроллером прерываний (system interrupt controller, SIC). Все сигналы прерываний периферийных устройства перенаправляются через SIC, после чего, в зависимости от настроек SIC, перенаправляются контролеру событий ядра (core event controller, CEC). CEC обрабатывает эти события, и в зависимости от настроек CEC, запускает на выполнение векторы обработки прерываний процессора [2].

Менеджер Прерываний (Interrupt Manager, далее этот термин оставлен в тексте без перевода) предоставляет функции, позволяющие приложению управлять всеми аспектами SIC и CEC. Он делает это таким образом, что события и прерывания управляются и обрабатываются эффективным и в то же время кооперативным способом.

Процессор Blackfin предоставляет 16 уровней прерываний и событий. Эти уровни, которые называются группами векторов прерываний (interrupt vector groups, IVG), пронумерованы от 0 до 15, и самый малый номер соответствует самому высокому приоритету. Некоторые уровни IVG выделены на заранее определенные события, такие как emulation, reset, non-maskable interrupt (NMI) и т. д. Другие уровни IVG, от 7 до 15, считаются событиями общего назначения (general-purpose events), и они обычно используются для прерываний системного уровня (от периферийных устройств), или как программные прерывания (software interrupts).

Вся обработка IVG осуществляется в CEC. Когда срабатывает определенный IVG (если предположить, что событие разрешено), CEC просматривает подходящую запись в таблице векторов событий (event vector table, EVT), и запускает на выполнение вектор по адресу из таблицы, туда где обрабатывается событие.

Все прерывания периферийных устройств сначала попадают в SIC. Если предположить, что SIC был запрограммирован (соотвествующие прерывания разрешены установкой бит в регистрах SIC_IMASK0 и SIC_IMASK1), прерывания периферии затем перенаправляются для обработки в CEC. SIC предоставляет богатую функциональность для обработки и поддержки прерываний от периферийных устройств. В дополнение к разрешению/запрету маршрутизации прерываний от периферийных устройств в CEC, контроллер SIC позволяет привязывать прерывания периферийных устройств к любому из уровней general-purpose IVG контроллера CEC, и управлять выходом процессора из режима ожидания при поступлении этих прерываний.

В системах, которые применяют процессоры Blackfin, часто имеется большее количество потенциальных источников прерывания, чем уровней IVG. Как указывалось выше, некоторые события (такие как NMI) привязываются один-к-одному на уровень IVG. Другие события, обычно события, обычно случающиеся не очень часто, такие как прервания ошибок периферийных устройств, часто сопрягаются на одном уровне IVG.

Interrupt Manager позволяет приложению получить полный контроль на тем, как прерывания должны быть обработаны, должны ли они быть замаскированы или демаскированы, должны ли обрабатываться индивидуальным уровнем IVG или совмещать несколько прерываний на одном уровне IVG, должен ли процессор пробуждаться от прерывания и т. д. Interrupt Manager также позволяет создавать цепочки обработчиков прерываний (interrupt handler chains). Обработчик прерывания это вызываемая на языке C функция (внимание, это не ISR), которая предоставлена приложением для обработки прерывания. Через Interrupt Manager приложение может прицепить любое количество обработчиков к одному уровню IVG. Когда несколько событий совмещено на одном уровне IVG, это позволяет каждому обработчику быть разработанному независимо от любого другого, и позволяет приложению обработать эти прерывания прямым и понятным способом.

Кроме того, Interrupt Manager обрабатывает только те уровни IVG и системные прерывания, которые приложение направляет для управления к Interrupt Manager. Это дает разработчику приложения получить полный и беспрепятственный доступ к любому уровню IVG или системному прерыванию, чтобы вручную управлять прерываниями.

Многоядерным процессоры Blackfin расширяют эту возможность подключением одного SIC и одного CEC для каждого ядра. Это предоставляет максимум гибкости, и дает разработчикам самим решать, как привязать прерывания к определенному ядру, нескольким ядрам, и т. д. Когда используются многоядерные процессоры Blackfin, обычно используется по одному Interrupt Manager-у на каждое ядро. Поскольку нет никаких причин предоставлять несколько Interrupt Manager для одноядерных процессоров, эта служба на них не поддерживается. Разработчики не должны пытаться инстанцировать больше чем один Interrupt Manager на ядро.

Следуя конвенции всех Системных Служб, Interrupt Manager использует уникальное и однозначное именование, чтобы защититься от конфликтов. Все перечисляемые значения, операторы и макросы Interrupt Manager используют префикс ADI_INT_, в то время как все функции Interrupt Manager используют префикс adi_int_.

Все функции Interrupt Manager API возвращают код типа ADI_INT_RESULT. Список кодов возврата см. в файле adi_int.h. Наподобие всех Системных Служб, код возврата, который сигнализирует об успешном завершении, для Interrupt Manager определен как 0 (или ADI_INT_RESULT_SUCCESS). Это позволяет приложениям быстро и просто определить, была ли какая-либо ошибка в обработке.

[Инициализация Менеджера Прерываний]

Чтобы использовать Interrupt Manager, функция должна его инициализировать. Функция, которая инициализирует Interrupt Manager, называется adi_int_Init. Приложение, которое вызывает adi_int_Init, передает в неё аргумент, который определяет память, которую Interrupt Manager использует для своей работы.

Объем предоставленной памяти зависит от количества вторичных обработчиков, используемых приложением. Когда используется соединение в цепочку обработчиков (interrupt handler chaining), Interrupt Manager считает первый подцепленный на уровень IVG обработчик прерывания как первичный (primary interrupt handler). Любые дополнительные обработчики, которые привязываются к тому же самому уровню IVG, считаются вторичными (secondary handlers). Без любой дополнительной памяти от приложения Interrupt Manager может поддерживать только один первичный обработчик на каждый уровень IVG. Если приложение никогда не использует больше одного обработчика на каждый уровень IVG (т. е. есть только один первичный обработчик и нет вторичных обработчиков), то приложению не нужно предоставлять дополнительную память для Interrupt Manager в аргументе функции инициализации.

Имеется макрос ADI_INT_SECONDARY_MEMORY, который применяется для получения размера памяти (в байтах), требуемого для одного вторичного обработчика. Таким образом, приложение должно предоставить функции инициализации n порций ADI_INT_SECONDARY_MEMORY, где n это количество поддерживаемых вторичных обработчиков.

Другой параметр, который передается функции инициализации, это параметр, который Interrupt Manager передает функции adi_int_EnterCriticalRegion(). Это значение зависит от рабочего окружения приложения. См. описание функции adi_int_EnterCriticalRegion для дополнительной информации.

Будучи вызванной, функция инициализации инициализирует внутренние структуры данных и делает возврат. Во время инициализации не делается никаких изменений с контроллерами CEC или SIC. После инициализации может быть вызвана любая другая функция Interrupt Manager API.

[Завершение работы Менеджера Прерываний]

Когда больше не требуется функциональность Interrupt Manager, приложение может вызвать функцию завершения (termination) для Interrupt Manager, adi_int_Terminate(). Множество приложений работает в бесконечном цикле, и никогда не вызывают эту функцию завершения.

Будучи вызванной, функция завершения отцепляет все обработчики прерывания и запрещает все прерывания, которыми управлял Interrupt Manager. После вызова функции завершения любая память, предоставленная функцией инициализации, может быть использована приложением для других целей (эта память освобождена). После завершения не будет вызвана ни одна функция Interrupt Manager. Если нужны службы Interrupt Manager после вызова функции завершения, приложение должно опять инициализировать службы Interrupt Manager повторным вызовом функции adi_init_Init.

[Функции контроллера событий ядра (CEC)]

Нужны только 2 функции для управления контроллером событий ядра (core event controller, CEC): adi_int_CECHook() и adi_int_CECUnhook(), как описано ниже.

adi_int_CECHook(). Функция adi_int_CECHook() используется для прикрепления (hook) обработчиков прерывания к цепочке обработчиков для уровня IVG. При вызове этой функции приложение передает номер обслуживаемого IVG, адрес обработчика, параметр, который Interrupt Manager автоматически передает обратно в обработчик, когда он вызывается, и флаг, показывающий, разрешается или нет вложенность прерываний для этого уровня IVG.

Сама по себе функция обработчика это обычная функция, вызываемая в стиле языка C, которая удовлетворяет типу ADI_INT_HANDLER_FN. Обработчик прерывания это не ISR, а стандартная функция C. Когда срабатывает уровень IVG, Interrupt Manager вызывает обработчик прерывания для обработки события. Interrupt Manager передает в обработчик прерывания аргумент клиента, который  был ранее передан в Interrupt Manager через функцию adi_int_CECHook(). Обработчик прерывания предпринимает любые действия по обработке события прерывания, после чего делает возврат либо значения ADI_INT_RESULT_PROCESSED, либо ADI_INT_RESULT_NOT_PROCESSED.

Обработчики прерываний должны быть написаны так, что они быстро опрашивают систему, чтобы определить, должно ли событие, вызвавшее прерывание, быть обработано обработчиком прерывания. Если событие, вызвавшее прерывание, не то, которое ожидает этот обработчик, то он должен немедленно сделать возврат с кодом ADI_INT_RESULT_NOT_PROCESSED. Тогда Interrupt Manager автоматически вызовет следующий обработчик прерывания, подцепленный к одному уровню IVG (если он имеется в цепочке обработчиков). Если событие, вызвавшее прерывание, ожидается обработчиков, то он выполнит его обработку и при этом должен вернуть код ADI_INT_RESULT_PROCESSED.

Параметр вложенности имеет значение только когда вызывается первый обработчик, подцепленный к цепочке обработчиков IVG. Первый обработчик прерывания, подцепленный к цепочке IVG, называется первичным (primary handler). Любые дополнительные обработчики, подцепленные к цепочке на тот же самый уровень IVG, называются вторичными (secondary handlers). Когда первичный обработчик подцеплен к цепочке, Interrupt Manager загружает ISR в соответствующую запись таблицы векторов событий (event vector table, EVT). Если флаг вложенности установлен, то ISR, который Interrupt Manager загрузил для обработки цепочки обработчиков, будет поддерживания вложенность прерываний (interrupt nesting). Если флаг вложенности очищен, то ISR, который Interrupt Manager загрузил, не будет поддерживать вложенность прерываний. Когда вторичные обработчики подцеплены в цепочку IVG, параметр флага вложенности игнорируется.

И наконец, функция adi_int_CECHook() демаскирует соответствующий бит регистра IMASK контроллера CEC, разрешая тем самым обработку прерывания.

В большинстве приложений пользователи уделяют большое внимание оптимизации обработки, которая происходит для самого ответственного прерывания, которое происходит с высокой частотой и требует минимальной задержки для обработки. В таком случае чаще всего такое "высокочастотное" ли низколатентное прерывание назначается на свой собственный уровень IVG, и другие прерывания, вызываемые не так часто, и не такие критичные к сроку обработки (как например обработка ошибки) объединяются в цепочку и вешаются на один (другой) уровень IVG.

Interrupt Manager поддерживает эту методику, и он оптимизирован так, чтобы позволить экстремально эффективно обработать первичные обработчики прерываний. Несмотря на то, что вторичные обработчики обрабатываются также эффективно, они вызываются все же позже первичного обработчика прерываний. Вторичные обработчики прицепляются в цепочку IVG так, что они будут обработаны по принципу последним пришел, первым вышел (last-in, first-out, LIFO). Это означает, что когда сработало событие, после вызова первичного обработчика (если предположить, что первичный обработчик не вернул код ADI_INT_RESULT_PROCESSED), Interrupt Manager вызовет вторичный обработчик из цепочки, который был прицеплен последним в цепочку, за ним предпоследний, и т. д.

Чтобы гарантировать оптимальное быстродействие, разработчик приложения должен обслужить прерывания с учетом, какой обработчик прицепить следующим за первичным, а какой последним, т. е. в каком порядке обработчики собираются в цепочку IVG.

adi_int_CECUnhook(). Функция adi_int_CECUnhook() используется для отцепления обработчика от цепочки обработчиков определенного уровня IVG. При вызове этой функции приложение передает в неё номер IVG и адрес функции обработчика, которая должна быть исключена из цепочки.

Функция удаляет обработчик прерывания из цепочки обработчиков для указанного уровня IVG. Если удаляется первичный обработчик, то последний подцепленный в цепочку обработчик становится первичным вместо него. Если после удаления обработчика из IVG-цепочки больше в ней не осталось обработчиков, то функция adi_int_CECUnhook() маскирует соответствующий бит в регистре IMASK контроллера CEC, запрещая тем самым это прерывание.

Обработчики прерываний (Interrupt Handlers; внимание, не путать обработчики прерываний с ISR!). Поскольку обработчики регистрируются с помощью Interrupt Manager, и вовлекаются в обработку из встроенной процедуры ISR для определенного уровня IVG (и здесь может быть несколько прерываний, ожидающих своей обработки на одном и том же уровне IVG), отдельные обработчики прерывания не должны использовать инструкцию RTI при своем завершении. Вместо этого они должны делать обычный возврат, как функция, используя инструкцию RTS. Фактически обработчики прерывания это ни что другое, как простая подпрограмма на языке C. Таким образом, каждый обработчик прерывания периферийного устройства должен удовлетворять следующему шаблону:

ADI_INT_HANDLER(mjk_SPORT_RX_handler)
{
   ... ... // код пользователя
}

Здесь ADI_INT_HANDLER это макрос, определенный так:

#define ADI_INT_HANDLER(NAME) \

   void (*NAME)(void *ClientArg)

[Функции системного контроллера прерываний (SIC)]

VDK предоставляет следующие функции, которыми приложение может получить полный контроль над системным контроллером прерываний (system interrupt controller, SIC):

adi_int_SICEnable – разрешает передачу в CEC прерывания от периферийного устройства.

adi_int_SICDisable – запрещает передачу в CEC прерывания от периферийного устройства.

adi_int_SICSetIVG – устанавливает уровень IVG, с которым будет обрабатываться прерывание периферийного устройства.

adi_int_SICGetIVG – определяет уровень IVG, к которому привязано прерывание от периферийного устройства.

adi_int_SICWakeup – задает, должно ли прерывание от периферийного устройства пробуждать процессор (вызывать его выход из состояния ожидания idle).

adi_int_SICInterruptAsserted – определяет, было ли выставлено прерывание от периферийного устройства.

adi_int_SICGlobalWakeup – запрещает всем прерываниям выводить из сна процессор, или восстанавливает все пробуждения в предыдущее состояние.

За исключением функции глобального запрета/разрешения пробуждения, все эти функции SIC получают как параметр значение из перечисления (enum), которое уникально идентифицирует прерывание от периферийного устройства. Перечисление ADI_INT_PERIPHERAL_ID идентифицирует каждый возможный источник прерывания для процессора. Это перечисление определено в файле adi_int.h (см. содержимое этого файла для получения полного списка значений для каждого поддерживаемого процессора Blackfin).

adi_int_SICDisable. Функция adi_int_SICDisable() используется для запрета передачи прерывания периферийного устройства в контроллер CEC. Будучи вызванной, функция программирует соответствующий регистр IMASK контроллера SIC, чтобы запретить прерывание от периферийного устройства.

adi_int_SICEnable. Функция adi_int_SICEnable() используется для разрешения передачи прерывания периферийного устройства в контроллер CEC. Будучи вызванной, функция программирует соответствующий регистр IMASK контроллера SIC, чтобы разрешить прерывание от периферийного устройства.

adi_int_SICGetIVG. Функция adi_int_SICGetIVG() используется для определения, к какому уровню IVG привязано прерывание периферийного устройства.

В дополнение к параметру ADI_INT_PERIPHERAL_ID, в эту функцию передается информация, указывающая на место в памяти для результата. Функция опрашивает надлежащее поле в соответствующем регистре назначения прерывания (SIC interrupt assignment register) и сохраняет уровень IVG (от 0 до 15), на который привязано прерывание периферийного устройства.

adi_int_SICInterruptAsserted. Функция adi_int_SICInterruptAsserted() используется, чтобы определить, было ли выставлено прерывание от периферийного устройства. Хотя эта функция может быть вызвана в любое время, она предназначена для того, чтобы быть вызванной в самом начале обработчика прерывания приложения, чтобы определить, нужно ли этому обработчику обслуживать выставленное прерывание периферийного устройства.

Вместо обычного использования кода возврата ADI_INT_RESULT_SUCCESS эта функция возвращает код ADI_INT_RESULT_ASSERTED или ADI_INT_RESULT_NOT_ASSERTED после успешного завершения. Если в параметрах вызова были ошибки, то эта функция может возвратить код ошибки.

adi_int_SICSetIVG. Функция adi_int_SICSetIVG() используется, чтобы установить уровень IVG, к которому будет привязано прерывание от периферийного устройства. При включении питания процессор Blackfin вовлекает привязку прерываний периферийных устройств по умолчанию к уровням IVG. Эта функция изменяет привязку по умолчанию. В дополнение к параметру ADI_INT_PERIPHERAL_ID, этой функции передается уровень IVG (от 0 до 15), к которому должно быть привязано прерывание от периферийного устройства. Функция модифицирует подходящее поле в соответствующем регистре назначения прерываний контроллера SIC (SIC interrupt assignment register), чтобы обеспечить новую привязку.

adi_int_SICWakeup. Функция adi_int_SICWakeup() используется для разрешения или запрета пробуждения процессора от прерывания периферийного устройства, когда сработало прерывание, и процессор находится в состоянии ожидания (idle state). В дополнение к параметру ADI_INT_PERIPHERAL_ID, этой функции передается флаг TRUE/FALSE. Если флаг в значении TRUE, то регистр пробуждения от прерывания контроллера SIC (SIC interrupt wakeup register) программируется так, что указанное прерывание от периферийного устройства будет пробуждать процессор при срабатывании прерывания. Если флаг в состоянии FALSE, то SIC interrupt wakeup register программируется для запрета пробуждения ядра процессора при срабатывании прерывания от этого периферийного устройства.

Обратите внимание, что эта функция не разрешает и не запрещает обработку прерывания. Также имейте в виду, что можно сконфигурировать контроллер SIC так, что прерывание периферийного устройства будет выводить процессор из режима ожидания, но это событие не приведет к обработке прерывания.

adi_int_SICGlobalWakeup. Регистр пробуждения от прерывания контроллера SIC (SIC interrupt wakeup register) содержит биты, которые соответствуют каждому периферийному устройству, и они задают, может или нет периферийное устройство выводить процессор из режима ожидания. По умолчанию все биты в SIC interrupt wakeup register установлены.

Функция adi_int_SICGlobalWakeup() используется для того, чтобы глобально запретить пробуждение от прерываний всех периферийных устройств путем сброса в 0 всех бит SIC interrupt wakeup register. Эта функция также используется для восстановления SIC interrupt wakeup register в предыдущее состояние. В эту функцию передается флаг TRUE/FALSE и указатель на структуру ADI_INT_WAKEUP_REGISTER, в которую сохраняются значения регистра пробуждения, когда глобально запрещается пробуждение от всех прерываний, или откуда берутся данные, когда снова разрешается (точнее восстанавливается предыдущее) состояние пробуждения.

Если в флаг передано FALSE, то эта функция обрабатывает поля в SIC interrupt wakeup register, и сохраняет их значения в соответствующие поля структуры ADI_INT_WAKEUP_REGISTER, на которую указывает аргумент функции. SIC interrupt wakeup register программируется так, что ни для одного прерывания не разрешается разбудить ядро.

Если в флаг передано TRUE, то эта функция программирует SIC wakeup register значениями полей из структуры ADI_INT_WAKEUP_REGISTER, на которую ссылается параметр указателя функции. Предполагается, что эти значения были получены предыдущем вызовом функции adi_int_SICGlobalWakeup.

Например, эта функция может быть использована, чтобы переключиться в режим пониженного энергопотребления, когда оставлены разрешенными только выбранные источники пробуждения.

/* Декларируется структура для сохранения состояния регистра настройки

   пробуждения от прерываний (SIC interrupt wakeup register) */
ADI_INT_WAKEUP_REGISTER RegIWR;

/* Глобально запрещаются прерывания, при этом структура RegIWR

   заполняется значением SIC interrupt wakeup register */
adi_init_SICGlobalWakeup(FALSE, &RegIWR);

/* Разрешить пробуждение от PLL, чтобы изменить режимы энергопотребления */
adi_int_SICWakeup(ADI_INT_PLL_WAKEUP, 1);

/* Разрешаются любые другие пробуждения, которые должны выводить из сна процессор */
...

/* Перевод процессора в режим сна */
adi_pwr_SetPowerMode(ADI_PWR_MODE_SLEEP);

/* При пробуждении восстановление состояния пробуждения в предыдущие настройки */
adi_int_SICGlobalWakeup(TRUE, &RegIWR);

[Защита критических регионов кода]

Во встраиваемых системах часто необходимо защитить определенные критические участки выполняемого кода. Это часто необходимо, когда какая-то логическая последовательность команд обновляет или модифицирует некоторую часть данных (происходит атомарная операция). В таких случаях другой логической последовательности команд, находящаяся в коде обработчика прерывания (или другом потоке системы RTOS), запрещено вмешиваться в процесс обновления критических данных.

С этой целью Interrupt Manager предоставляет 2 функции, которые можно использовать как обрамление критического региона кода: adi_int_EnterCriticalRegion() и adi_int_ExitCriticalRegion(). Приложение вызывает функцию adi_int_EnterCriticalRegion() в начале критического региона кода, и затем вызывает adi_int_ExitCriticalRegion() в конце этого критического региона кода. Эти функции всегда должны использоваться парно.

Реальная реализация этих функций может меняться в зависимости от имеющегося рабочего окружения, в котором работает код. Например, в обычной системе (где не используется RTOS наподобие VDK или FreeRTOS), действия в этих функциях могут отличаться от действий в системе, основанной на RTOS. Однако принцип использования остается одинаковым, независимо от реализации. Таким образом, код приложения всегда работает одинаково, и не требует изменения в зависимости от рабочего окружения.

Функции adi_int_EnterCriticalRegion() передается аргумент типа void *, и она возвращает тип void *. Значение, возвращенное из функции adi_int_EnterCriticalRegion(), всегда должно быть передано соответствующей (парной) функции adi_int_ExitCriticalRegion(). Вот пример такой последовательности кода:

...
Value = adi_int_EnterCriticalRegion(pArg);
...               // критическая область кода
adi_int_ExitCriticalRegion(Value);
...

Значение, возвращенное из adi_int_EnterCriticalRegion(), должно быть передано соответствующей функции adi_int_ExitCriticalRegion(). Хотя разрешены вложенные вызовы этой функции, разработчик приложение минимизирует использование этих функций только для критических секций кода, и понимает, что процессор был помещен в некоторое измененное состояние. При использовании критических секций их код может повлиять на общую производительность системы.

Например, может случиться так, что в критическом регионе кода отключены прерывания. Обычно разработчику нельзя допустить, чтобы прерывания были отключены на продолжительное время. Так что эти функции должны использоваться экономно и рассудительно.

Разрешено вложение вызовов этих функций (т. е. критические области кода могут быть вложены друг в друга). Для примера, рассмотрим последовательность кода, которая делает вызов функции Foo() в критическом регионе кода. При этом функция Foo() также внутри себя имеет критический регион кода.

...
Value = adi_int_EnterCriticalRegion(pArg);
...               // критическая область кода
Foo();            // вызов функции Foo()
adi_int_ExitCriticalRegion(Value);
...

void Foo(void)
{
   void *Value;
   ...
   Value = adi_int_EnterCriticalRegion(pArg);
   ...            // критическая область кода
   adi_int_ExitCriticalRegion(Value);
   ...
}

Такая практика разрешена, однако она довольно бессмысленна. Следует также иметь в виду, что злоупотребление вызовами этих функций может негативно сказаться на производительности системы.

Значение pArg, переданное в функцию adi_int_EnterCriticalRegion(), зависит от реальной реализации для имеющегося рабочего окружения. В некоторых операционных системах это значение не используется и может быть равно NULL. Для дополнительной информации по параметру pArg просмотрите исходный файл для определенного рабочего окружения adi_int_xxx.c в каталоге Blackfin/lib/src/services, где xxx указывает на предназначенное рабочее окружение.

Все Системные Службы и Драйверы Устройств используют эти функции исключительно для того, чтобы защитить критические регионы кода. Программа приложения также должна использовать эти функции исключительно чтобы защитить критические регионы кода приложения.

[Модификация IMASK]

Приложениям редко требуется модифицировать регистр IMASK процессора, Interrupt Manager сам модифицирует значение регистра IMASK для корректного управления контроллером CEC. В некоторых рабочих окружениях, основанных на RTOS, сама система RTOS плотно управляет содержимым регистра IMASK, и предоставляет также функции, которые позволяют манипулировать содержимым IMASK.

Однако чтобы обеспечить совместимость между всеми рабочими окружениями, Interrupt Manager предоставляет функции, которые позволяют очищать или устанавливать биты регистра IMASK. В зависимости от используемого рабочего окружения эти функции могут модифицировать значение IMASK напрямую, либо использовать для этого предоставляемые RTOS функции для манипулирования содержимым IMASK. Независимо от того, как будет изменено значение IMASK, Interrupt Manager API для этой цели предоставляет универсальный и целостный механизм.

Предоставлены 2 зависящие от рабочего окружения функции, чтобы можно было устанавливать и сбрасывать биты регистра IMASK: adi_int_SetIMASKBits и adi_int_ClearIMASKBits. Эти функции получают в качестве параметров значение, которое соответствует регистру IMASK целевого процессора. Когда вызывается функция adi_int_SetIMASKBits(), то она устанавливает в лог. 1 те биты регистра IMASK, у которых в соответствующей позиции бит переданного значения имеется лог. 1. Когда вызывается adi_int_ClearIMASKBits() функция, то она сбрасывает те биты регистра IMASK, в позиции которых переданного в функцию значения имеется лог. 1.

Рассмотрим следующий пример кода. Предполагается, что IMASK это 32-битное значение, и оно содержит 0x00000000 на входе в этот код:

...
...               // IMASK === 0x00000000
ReturnCode = adi_int_SetIMASKBits(0x00000003);
...               // IMASK == 0x00000003
ReturnCode = adi_int_ClearIMASKBits(0x00000001);
...               // IMASK == 0x00000002
ReturnCode = adi_int_ClearIMASKBits(0x00000002);
...               // IMASK == 0x00000000

В то время как весьма маловероятно, что приложению когда-либо понадобится напрямую менять значения отдельных бит IMASK, Interrupt Manager использует эти функции для управления контроллером CEC.

Примеры. Вместе с VisualDSP++ поставляются примеры, демонстрирующие использование Interrupt Manager. Их можно найти в подкаталогах папки Blackfin/EZ-Kits.

[Файловая структура]

API для Interrupt Manager определен в заголовочном файле adi_int.h. Этот файл находится в подкаталоге Blackfin/include/services, и автоматически подключается в файле services.h, находящемся в том же подкаталоге. Так что в код приложения нужно подключать только заголовочный файл services.h.

Приложения должны быть слинкованы с одним из библиотечных файлов Системных Служб (system services). Эти файлы находятся в каталоге Blackfin/lib. См. раздел "DMA Manager" в даташите [1], чтобы правильно выбрать библиотечный файл.

Для удобства весь исходный код Interrupt Manager размещен в каталоге Blackfin/lib/src/services. Весь код, зависящий от рабочего окружения, находится в файле adi_int_xxx.c, где xxx указывает на целевое рабочее окружение. Эти файлы никогда не должны присоединяться к проекту, потому что соответствующая библиотека Системных Служб уже содержит требуемый объектный код.

[Документация по API Interrupt Manager]

В этом разделе приведены описания функций модуля Interrupt Manager, формирующие его интерфейс программирования (application programming interface, API).

ADI_INT_RESULT adi_int_Init(void *pMemory,
                            const size_t MemorySize,
                            u32 *pMaxEntries,
                            void *pEnterCriticalArg);

ADI_INT_RESULT adi_int_Terminate(void);

ADI_INT_RESULT adi_int_CECHook(u32 IVG,
                               ADI_INT_HANDLER_FN Handler,
                               void *ClientArg,
                               u32 NestingFlag);

ADI_INT_RESULT adi_int_CECUnhook(u32 IVG,
                                 ADI_INT_HANDLER_FN Handler,
                                 void *ClientArg);

void adi_int_ClearIMASKBits(ADI_INT_IMASK BitsToClear);

void *adi_int_EnterCriticalRegion(void *pArg);

void adi_int_ExitCriticalRegion(void *pArg);

ADI_INT_RESULT adi_int_GetCurrentIVGLevel(u32 *pIVG);

ADI_INT_RESULT adi_int_GetLibraryDetails(ADI_INT_LIBRARY_DETAILS *pLibraryDetails);

ADI_INT_RESULT adi_int_SICDisable(const ADI_INT_PERIPHERAL_ID PeripheralID);

ADI_INT_RESULT adi_int_SICEnable(const ADI_INT_PERIPHERAL_ID PeripheralID);

ADI_INT_RESULT adi_int_SICGetIVG(const ADI_INT_PERIPHERAL_ID PeripheralID,
                                 u32 *pIVG);

ADI_INT_RESULT adi_int_SICInterruptAsserted(const ADI_INT_PERIPHERAL_ID PeripheralID);

ADI_INT_RESULT adi_int_SICSetIVG(const ADI_INT_PERIPHERAL_ID PeripheralID,
                                 const u32 IVG);

void adi_int_SetIMASKBits(ADI_INT_IMASK BitsToSet);

ADI_INT_RESULT adi_int_SICWakeup(const ADI_INT_PERIPHERAL_ID PeripheralID,
                                 u32 WakeupFlag);

ADI_INT_RESULT adi_int_SICGlobalWakeup(u32 WakeupFlag,
                                       pADI_INT_WAKEUP_REGISTER SaveIWR);

[Ссылки]

1. VisualDSP++ 5.0 Device Drivers and System Services Manual for Blackfin® Processors site:analog.com.
2. ADSP-BF538: обработка событий (прерывания, исключения).
3. VDK: обработчики прерываний (ISR).