git.oblomov.eu Git - linux-2.6/blob - drivers/s390/cio/airq.c

   1 /*
   2  *  drivers/s390/cio/airq.c
   3  *    Support for adapter interruptions
   4  *
   5  *    Copyright IBM Corp. 1999,2007
   6  *    Author(s): Ingo Adlung <adlung@de.ibm.com>
   7  *               Cornelia Huck <cornelia.huck@de.ibm.com>
   8  *               Arnd Bergmann <arndb@de.ibm.com>
   9  *               Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
  10  */
  11
  12 #include <linux/init.h>
  13 #include <linux/module.h>
  14 #include <linux/slab.h>
  15 #include <linux/rcupdate.h>
  16
  17 #include <asm/airq.h>
  18 #include <asm/isc.h>
  19
  20 #include "cio.h"
  21 #include "cio_debug.h"
  22
  23 #define NR_AIRQS                32
  24 #define NR_AIRQS_PER_WORD       sizeof(unsigned long)
  25 #define NR_AIRQ_WORDS           (NR_AIRQS / NR_AIRQS_PER_WORD)
  26
  27 union indicator_t {
  28         unsigned long word[NR_AIRQ_WORDS];
  29         unsigned char byte[NR_AIRQS];
  30 } __attribute__((packed));
  31
  32 struct airq_t {
  33         adapter_int_handler_t handler;
  34         void *drv_data;
  35 };
  36
  37 static union indicator_t indicators[MAX_ISC+1];
  38 static struct airq_t *airqs[MAX_ISC+1][NR_AIRQS];
  39
  40 static int register_airq(struct airq_t *airq, u8 isc)
  41 {
  42         int i;
  43
  44         for (i = 0; i < NR_AIRQS; i++)
  45                 if (!cmpxchg(&airqs[isc][i], NULL, airq))
  46                         return i;
  47         return -ENOMEM;
  48 }
  49
  50 /**
  51  * s390_register_adapter_interrupt() - register adapter interrupt handler
  52  * @handler: adapter handler to be registered
  53  * @drv_data: driver data passed with each call to the handler
  54  * @isc: isc for which the handler should be called
  55  *
  56  * Returns:
  57  *  Pointer to the indicator to be used on success
  58  *  ERR_PTR() if registration failed
  59  */
  60 void *s390_register_adapter_interrupt(adapter_int_handler_t handler,
  61                                       void *drv_data, u8 isc)
  62 {
  63         struct airq_t *airq;
  64         char dbf_txt[16];
  65         int ret;
  66
  67         if (isc > MAX_ISC)
  68                 return ERR_PTR(-EINVAL);
  69         airq = kmalloc(sizeof(struct airq_t), GFP_KERNEL);
  70         if (!airq) {
  71                 ret = -ENOMEM;
  72                 goto out;
  73         }
  74         airq->handler = handler;
  75         airq->drv_data = drv_data;
  76
  77         ret = register_airq(airq, isc);
  78 out:
  79         snprintf(dbf_txt, sizeof(dbf_txt), "rairq:%d", ret);
  80         CIO_TRACE_EVENT(4, dbf_txt);
  81         if (ret < 0) {
  82                 kfree(airq);
  83                 return ERR_PTR(ret);
  84         } else
  85                 return &indicators[isc].byte[ret];
  86 }
  87 EXPORT_SYMBOL(s390_register_adapter_interrupt);
  88
  89 /**
  90  * s390_unregister_adapter_interrupt - unregister adapter interrupt handler
  91  * @ind: indicator for which the handler is to be unregistered
  92  * @isc: interruption subclass
  93  */
  94 void s390_unregister_adapter_interrupt(void *ind, u8 isc)
  95 {
  96         struct airq_t *airq;
  97         char dbf_txt[16];
  98         int i;
  99
 100         i = (int) ((addr_t) ind) - ((addr_t) &indicators[isc].byte[0]);
 101         snprintf(dbf_txt, sizeof(dbf_txt), "urairq:%d", i);
 102         CIO_TRACE_EVENT(4, dbf_txt);
 103         indicators[isc].byte[i] = 0;
 104         airq = xchg(&airqs[isc][i], NULL);
 105         /*
 106          * Allow interrupts to complete. This will ensure that the airq handle
 107          * is no longer referenced by any interrupt handler.
 108          */
 109         synchronize_sched();
 110         kfree(airq);
 111 }
 112 EXPORT_SYMBOL(s390_unregister_adapter_interrupt);
 113
 114 #define INDICATOR_MASK  (0xffUL << ((NR_AIRQS_PER_WORD - 1) * 8))
 115
 116 void do_adapter_IO(u8 isc)
 117 {
 118         int w;
 119         int i;
 120         unsigned long word;
 121         struct airq_t *airq;
 122
 123         /*
 124          * Access indicator array in word-sized chunks to minimize storage
 125          * fetch operations.
 126          */
 127         for (w = 0; w < NR_AIRQ_WORDS; w++) {
 128                 word = indicators[isc].word[w];
 129                 i = w * NR_AIRQS_PER_WORD;
 130                 /*
 131                  * Check bytes within word for active indicators.
 132                  */
 133                 while (word) {
 134                         if (word & INDICATOR_MASK) {
 135                                 airq = airqs[isc][i];
 136                                 /* Make sure gcc reads from airqs only once. */
 137                                 barrier();
 138                                 if (likely(airq))
 139                                         airq->handler(&indicators[isc].byte[i],
 140                                                       airq->drv_data);
 141                                 else
 142                                         /*
 143                                          * Reset ill-behaved indicator.
 144                                          */
 145                                         indicators[isc].byte[i] = 0;
 146                         }
 147                         word <<= 8;
 148                         i++;
 149                 }
 150         }
 151 }