Embedded Linux, SPI, GPIO

[Ruben (Gast)]

Hallo,

folgende Ausgangssituation: Ich möchte von einem Linux-System 
(Pandaboard) über die SPI-Schnittstelle Daten von einem AD-Wandler 
(ADS1255 von Texas Instruments) lesen.

Der AD-Wandler hat einen DATA-READY Ausgang, der kurzzeitig high wird 
wenn eine Wandlung fertig ist.

Nun möchte ich auf dem Pandaboard folgende Schritte durchführen:
- Interrupt an GPIO-Pin um DATA-READY Signal auszuwerten (bei steigender 
Flanke)
- anschließend Daten auslesen mit spidev-Treiber (kommt später dran)

Der zugehörige GPIO-Pin ist unter /sys/class/gpio/gpioXX als input 
konfiguriert. Unter edge habe ich "rising" eingetragen.

Wie kann ich in einem Linux-System einen Interrupt einrichten? Muss ich 
dazu einen eigenen Treiber schreiben? Bzw. ist mein GPIO-Pin so 
ausreichend konfiguriert?

Ich hoffe ich habe mich einigermaßen verständlich ausgedrückt.

Grüße
Ruben

[Guenter B. (gooofy)]

ob es der einzige Weg ist, weiss ich nicht, aber es geht auf jeden Fall 
sehr elegant mit einem Kernel-Modul. Hier kann man z.B. in der 
init-Funktion GPIOs auf Interrupts mappen und dann einen entsprechenden 
Callback hinterlegen:

static int __init hirc_modinit(void)
{
  int result;
  int i, nlow, nhigh;

  printk(KERN_INFO PFX "init starts\n");

  /* Init read buffer. */
  result = lirc_buffer_init(&rbuf, sizeof(int), RBUF_LEN);
  if (result < 0)
    return -ENOMEM;

  result = gpio_request (HIRC_GPIO, "hirc");

  if (result) {
    printk (KERN_ERR PFX "failed to request GPIO %d: %d\n", HIRC_GPIO, result);
    return result;
  }

  gpio_direction_input (HIRC_GPIO);

  irq = gpio_to_irq (HIRC_GPIO);

  if (irq < 0) {
    printk (KERN_ERR PFX "failed to map GPIO %d to interrupt: %d\n", HIRC_GPIO, irq);

    gpio_free (HIRC_GPIO);

    return irq;

  }

  printk (KERN_INFO PFX "GPIO %d mapped to IRQ %d\n", HIRC_GPIO, irq);

  //set_irq_type(irq, IRQ_TYPE_EDGE_RISING);

  result = request_irq(irq, irq_handler,
      //0,
      IRQF_DISABLED | IRQF_TRIGGER_RISING ,
      //     IRQF_DISABLED | IRQF_TRIGGER_RISING ,
      HIRC_DRIVER_NAME, irq_id);

  switch (result) {
    case -EBUSY:
      printk(KERN_ERR PFX "irq %d busy\n", irq);
      gpio_free (HIRC_GPIO);
      return -EBUSY;
    case -EINVAL:
      printk(KERN_ERR PFX
          "bad irq number or handler\n");
      gpio_free (HIRC_GPIO);
      return -EINVAL;
    default:
      printk(KERN_INFO PFX "irq %d, gpio %d obtained\n", irq, HIRC_GPIO);
      break;
  }

(Beispiel stammt aus einem Treiber fuer einen Infrarot-Empfaenger, der 
an einem GPIO haengt - allerdings handelt es sich um einen kleinen 
Router, nicht um ein Pandaboard).

der Interrupt-Handler kann dann mit gpio_get_value den Pin lesen:

static irqreturn_t irq_handler(int i, void *blah)
{
  struct timeval tv;
  int dcd;
  long deltv;
  int data;
  static int last_dcd = -1;

  while (1) {
    dcd = gpio_get_value(HIRC_GPIO);

    if (dcd == last_dcd) {
      return IRQ_HANDLED;
    }

    /* get current time */
    do_gettimeofday(&tv);

    deltv = tv.tv_sec-lasttv.tv_sec;
    if (tv.tv_sec < lasttv.tv_sec ||
        (tv.tv_sec == lasttv.tv_sec &&
         tv.tv_usec < lasttv.tv_usec)) {
      printk(KERN_WARNING PFX "AIEEEE: your clock just jumped backwards\n");
      printk(KERN_WARNING PFX
          "%d %d %lx %lx %lx %lx\n",
          dcd, sense,
          tv.tv_sec, lasttv.tv_sec,
          tv.tv_usec, lasttv.tv_usec);
      data = PULSE_MASK;
    } else if (deltv > 15) {
      data = PULSE_MASK; /* really long time */
#if 0
      printk (KERN_WARNING PFX "really long time: %ld\n", deltv);
#endif
    } else
      data = (int) (deltv*1000000 +
          tv.tv_usec -
          lasttv.tv_usec);
    rbwrite(dcd^sense ? data : (data|PULSE_BIT));
    lasttv = tv;
    last_dcd = dcd;
    wake_up_interruptible(&rbuf.wait_poll);
  }

  return IRQ_HANDLED;
}

[Ruben (Gast)]

Danke für die Antwort. Ich werde das mal ausprobieren.

Grüße
Ruben

[Ruben (Gast)]

Hallo,

ich habe den Vorschlag von Günter umgesetzt und das geht auch 
grundsätzlich. Allerdings tritt der Interrupt nur einmal auf.

Meinem Verständnis nach muss ich im Interrupt-Handler den Interrupt 
wieder frei schalten.

Hat da jemand einen Tipp für mich?

Vielen Dank im voraus.
Ruben

[leohome (Gast)]

IRQF_DISABLED | IRQF_TRIGGER_RISING Flag könnte Falsch sein

setze mal statt desse eine 0 rein.

[Bernd B. (behbeh)]

Hallo,
sowas habe ich versucht mit einem Linux FOX Board. Sollte dann ja auch 
möglich sein damit.
Ein Tip zum DRDY Signal. Bei richtiger Behandlung, also wenn man die 
Daten ausliest, müsste das DRDY Signal mit der ersten Clk-Flanke wieder 
auf High gehen, also muss man den ISR auf negative Flanke stellen, dann 
kann man im Wandlertakt( z.B. 1000Hz ADS1281) die 3 bzw 4 Bytes 
auslesen. Klappt prima bei mir, leider nicht mit Linux.
Bernd

[Mario G. (mario)]

Hallo,

sorry das ich den alten Thread nochmal ausgrabe aber ich habe ein 
ähnliches Problem: ich möchte einen GPIO als Interrupt nutzen und beim 
eintreten des Interrupts eine Aktion auslösen.

Das Programmieren das Kernelmoduls ist kein Problem, ABER:
Weiß jemand ob es möglich ist aus dem Interrupt-Handler heraus ein 
Aktion im Userspace aufzurufen, z.B. ein Programm starten?