LXR linux/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
  27union indicator_t {
  28        unsigned long word[NR_AIRQ_WORDS];
  29        unsigned char byte[NR_AIRQS];
  30} __attribute__((packed));
  31
  32struct airq_t {
  33        adapter_int_handler_t handler;
  34        void *drv_data;
  35};
  36
  37static union indicator_t indicators[MAX_ISC+1];
  38static struct airq_t *airqs[MAX_ISC+1][NR_AIRQS];
  39
  40static 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 */
  60void *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);
  78out:
  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}
  87EXPORT_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 */
  94void 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}
 112EXPORT_SYMBOL(s390_unregister_adapter_interrupt);
 113
 114#define INDICATOR_MASK  (0xffUL << ((NR_AIRQS_PER_WORD - 1) * 8))
 115
 116void 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}
 152