Melhor padrão para WFI (espera por interrupção) nos microcontroladores Cortex (ARM)

Estou pensando em desenvolver software alimentado por bateria usando os controladores EFM Gekko (http://energymicro.com/) e gostaria que o controlador estivesse dormindo sempre que não houvesse nada útil para ele fazer. A instrução WFI (Wait For Interrupt) é usada para esse fim; colocará o processador em suspensão até que ocorra uma interrupção.

Se o sono estivesse comprometido armazenando algo em algum lugar, seria possível usar operações de carregamento exclusivo / armazenamento exclusivo para fazer algo como:

  // dont_sleep é carregado com 2 sempre que algo acontece
  // deve forçar o loop principal a alternar pelo menos uma vez. Se uma interrupção
  // ocorre que faz com que seja redefinido para 2 durante a seguinte instrução,
  // o comportamento será como se a interrupção tivesse acontecido depois dele.

  loja_exclusiva (carga_exclusiva (não dorme) >> 1);

  while (! dont_sleep)
  {
    // Se ocorrer uma interrupção entre a próxima instrução e store_exclusive, não durma
    load_exclusive (SLEEP_TRIGGER);
    if (! dont_sleep)             
      loja_exclusiva (SLEEP_TRIGGER);
  }

Se uma interrupção ocorrer entre as operações load_exclusive e store_exclusive, o efeito seria pular a store_exclusive, fazendo com que o sistema execute o loop mais uma vez (para ver se a interrupção havia definido dont_sleep). Infelizmente, o Gekko usa uma instrução WFI em vez de um endereço de gravação para acionar o modo de suspensão; escrevendo código como

  if (! dont_sleep)
    WFI ();

correria o risco de que uma interrupção pudesse ocorrer entre o 'if' e o 'wfi' e definir dont_sleep, mas o wfi iria em frente e seria executado de qualquer maneira. Qual é o melhor padrão para evitar isso? Defina PRIMASK como 1 para impedir que as interrupções interrompam o processador antes de executar o WFI e limpe-o imediatamente depois? Ou existe algum truque melhor?

EDITAR

Eu estou pensando sobre o bit Event. Pela descrição geral, ele gostaria que fosse destinado ao suporte a vários processadores, mas estava se perguntando se algo como o seguinte poderia funcionar:

  if (não dorme)
    SEV (); / * Tornará o seguinte sinalizador de evento claro do WFE, mas não será interrompido * /
  WFE ();

Cada interrupção que define não_sleep também deve executar uma instrução SEV; portanto, se a interrupção ocorrer após o teste "se", o WFE limpará o sinalizador de evento, mas não entrará no modo de suspensão. Isso soa como um bom paradigma?

Eu não entendi completamente a dont_sleepcoisa, mas uma coisa que você pode tentar é fazer o "trabalho principal" no manipulador PendSV, definido com a menor prioridade. Em seguida, agende um PendSV de outros manipuladores sempre que precisar de algo. Veja aqui como fazê-lo (é para M1, mas M3 não é muito diferente).

Outra coisa que você pode usar (talvez em conjunto com a abordagem anterior) é o recurso de suspensão na saída. Se você ativá-lo, o processador entrará em suspensão após sair do último manipulador ISR, sem que você precise chamar o WFI. Veja alguns exemplos aqui .

Coloque-o dentro de uma seção crítica. Os ISRs não serão executados, portanto você não corre o risco de alterar o dont_sleep antes do WFI, mas eles ainda ativam o processador e os ISRs serão executados assim que a seção crítica terminar.

uint8 interruptStatus;
interruptStatus = EnterCriticalSection();
if (!dont_sleep)
  WFI();
ExitCriticalSection(interruptStatus);

Seu ambiente de desenvolvimento provavelmente possui funções críticas de seção, mas é mais ou menos assim:

EnterCriticalSection é:

MRS r0, PRIMASK /* Save interrupt state. */
CPSID i /* Turn off interrupts. */
BX lr /* Return. */

ExitCriticalSection é:

MSR PRIMASK, r0 /* Restore interrupt states. */
BX lr /* Return. */

Sua ideia é boa, é exatamente isso que o Linux implementa. Veja aqui .

Citação útil do tópico de discussão acima mencionado para esclarecer por que o WFI funciona mesmo com as interrupções desabilitadas:

Se você pretende ficar ocioso até a próxima interrupção, precisa fazer alguma preparação. Durante essa preparação, uma interrupção pode se tornar ativa. Essa interrupção pode ser um evento de ativação que você está procurando.

Não importa o quão bom seja o seu código, se você não desativar as interrupções, você sempre terá uma corrida entre preparar-se para dormir e realmente dormir, o que resulta em perda de eventos de despertar.

É por isso que todas as CPUs ARM que eu conheço serão ativadas mesmo se estiverem mascaradas na CPU principal (bit CPSR I).

Qualquer outra coisa e você deve esquecer de usar o modo ocioso.

Assumindo que:

1. O encadeamento principal executa tarefas em segundo plano
2. As interrupções executam apenas tarefas de alta prioridade e nenhuma tarefa em segundo plano
3. O thread principal pode ser interrompido a qualquer momento (normalmente não mascara interrupções)

A solução é usar o PRIMASK para bloquear interrupções entre a validação do sinalizador e o WFI:

mask_interrupts();
if (!dont_sleep)
    wfi();
unmask_interrupts();

E o modo de suspensão ao sair? Isso entra automaticamente no modo de suspensão sempre que um manipulador de IRQ sai, portanto não há realmente nenhum "modo normal" em execução após a configuração. Um IRQ acontece, ele acorda e executa o manipulador e volta a dormir. Não é necessário WFI.