s390/airq: introduce adapter interrupt vector helper

The PCI code is the first user of adapter interrupts vectors.
Add a set of helpers to airq.c to separate the adatper interrupt
code from the PCI bits. The helpers allow for adapter interrupt
vectors of any size.

Reviewed-by: Sebastian Ott <sebott@linux.vnet.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

diff --git a/arch/s390/include/asm/airq.h b/arch/s390/include/asm/airq.h
index 4066cee0c2d2635e32a59fecb0eaf2e05c565776..4057acba67c4a67f9b071f776833d34264d0b483 100644 (file)
--- a/arch/s390/include/asm/airq.h
+++ b/arch/s390/include/asm/airq.h
@@ -23,4 +23,41 @@ struct airq_struct {
 int register_adapter_interrupt(struct airq_struct *airq);
 void unregister_adapter_interrupt(struct airq_struct *airq);
 
+/* Adapter interrupt bit vector */
+struct airq_iv {
+       unsigned long *vector;  /* Adapter interrupt bit vector */
+       unsigned long *avail;   /* Allocation bit mask for the bit vector */
+       unsigned int *data;     /* 32 bit value associated with each bit */
+       unsigned long bits;     /* Number of bits in the vector */
+       unsigned long end;      /* Number of highest allocated bit + 1 */
+       spinlock_t lock;        /* Lock to protect alloc & free */
+};
+
+#define AIRQ_IV_ALLOC  1       /* Use an allocation bit mask */
+#define AIRQ_IV_DATA   2       /* Allocate the data array */
+
+struct airq_iv *airq_iv_create(unsigned long bits, unsigned long flags);
+void airq_iv_release(struct airq_iv *iv);
+unsigned long airq_iv_alloc_bit(struct airq_iv *iv);
+void airq_iv_free_bit(struct airq_iv *iv, unsigned long bit);
+unsigned long airq_iv_scan(struct airq_iv *iv, unsigned long start,
+                          unsigned long end);
+
+static inline unsigned long airq_iv_end(struct airq_iv *iv)
+{
+       return iv->end;
+}
+
+static inline void airq_iv_set_data(struct airq_iv *iv, unsigned long bit,
+                                   unsigned int data)
+{
+       iv->data[bit] = data;
+}
+
+static inline unsigned int airq_iv_get_data(struct airq_iv *iv,
+                                           unsigned long bit)
+{
+       return iv->data[bit];
+}
+
 #endif /* _ASM_S390_AIRQ_H */

diff --git a/drivers/s390/cio/airq.c b/drivers/s390/cio/airq.c
index 91edbd7ee80640d7d624280722843cbfb69093a8..c7ffb790a24da0c4f6f1bfd2258fd020fdb76c1f 100644 (file)
--- a/drivers/s390/cio/airq.c
+++ b/drivers/s390/cio/airq.c
@@ -93,3 +93,143 @@ void do_adapter_IO(u8 isc)
                        airq->handler(airq);
        rcu_read_unlock();
 }
+
+/**
+ * airq_iv_create - create an interrupt vector
+ * @bits: number of bits in the interrupt vector
+ * @flags: allocation flags
+ *
+ * Returns a pointer to an interrupt vector structure
+ */
+struct airq_iv *airq_iv_create(unsigned long bits, unsigned long flags)
+{
+       struct airq_iv *iv;
+       unsigned long size;
+
+       iv = kzalloc(sizeof(*iv), GFP_KERNEL);
+       if (!iv)
+               goto out;
+       iv->bits = bits;
+       size = BITS_TO_LONGS(bits) * sizeof(unsigned long);
+       iv->vector = kzalloc(size, GFP_KERNEL);
+       if (!iv->vector)
+               goto out_iv;
+       if (flags & AIRQ_IV_ALLOC) {
+               iv->avail = kmalloc(size, GFP_KERNEL);
+               if (!iv->avail)
+                       goto out_vector;
+               memset(iv->avail, 0xff, size);
+               iv->end = 0;
+       } else
+               iv->end = bits;
+       if (flags & AIRQ_IV_DATA) {
+               size = bits * sizeof(unsigned int);
+               iv->data = kzalloc(size, GFP_KERNEL);
+               if (!iv->data)
+                       goto out_alloc;
+       }
+       spin_lock_init(&iv->lock);
+       return iv;
+
+out_alloc:
+       kfree(iv->avail);
+out_vector:
+       kfree(iv->vector);
+out_iv:
+       kfree(iv);
+out:
+       return NULL;
+}
+EXPORT_SYMBOL(airq_iv_create);
+
+/**
+ * airq_iv_release - release an interrupt vector
+ * @iv: pointer to interrupt vector structure
+ */
+void airq_iv_release(struct airq_iv *iv)
+{
+       kfree(iv->data);
+       kfree(iv->vector);
+       kfree(iv->avail);
+       kfree(iv);
+}
+EXPORT_SYMBOL(airq_iv_release);
+
+/**
+ * airq_iv_alloc_bit - allocate an irq bit from an interrupt vector
+ * @iv: pointer to an interrupt vector structure
+ *
+ * Returns the bit number of the allocated irq, or -1UL if no bit
+ * is available or the AIRQ_IV_ALLOC flag has not been specified
+ */
+unsigned long airq_iv_alloc_bit(struct airq_iv *iv)
+{
+       const unsigned long be_to_le = BITS_PER_LONG - 1;
+       unsigned long bit;
+
+       if (!iv->avail)
+               return -1UL;
+       spin_lock(&iv->lock);
+       bit = find_first_bit_left(iv->avail, iv->bits);
+       if (bit < iv->bits) {
+               clear_bit(bit ^ be_to_le, iv->avail);
+               if (bit >= iv->end)
+                       iv->end = bit + 1;
+       } else
+               bit = -1UL;
+       spin_unlock(&iv->lock);
+       return bit;
+
+}
+EXPORT_SYMBOL(airq_iv_alloc_bit);
+
+/**
+ * airq_iv_free_bit - free an irq bit of an interrupt vector
+ * @iv: pointer to interrupt vector structure
+ * @bit: number of the irq bit to free
+ */
+void airq_iv_free_bit(struct airq_iv *iv, unsigned long bit)
+{
+       const unsigned long be_to_le = BITS_PER_LONG - 1;
+
+       if (!iv->avail)
+               return;
+       spin_lock(&iv->lock);
+       /* Clear (possibly left over) interrupt bit */
+       clear_bit(bit ^ be_to_le, iv->vector);
+       /* Make the bit position available again */
+       set_bit(bit ^ be_to_le, iv->avail);
+       if (bit == iv->end - 1) {
+               /* Find new end of bit-field */
+               while (--iv->end > 0)
+                       if (!test_bit((iv->end - 1) ^ be_to_le, iv->avail))
+                               break;
+       }
+       spin_unlock(&iv->lock);
+}
+EXPORT_SYMBOL(airq_iv_free_bit);
+
+/**
+ * airq_iv_scan - scan interrupt vector for non-zero bits
+ * @iv: pointer to interrupt vector structure
+ * @start: bit number to start the search
+ * @end: bit number to end the search
+ *
+ * Returns the bit number of the next non-zero interrupt bit, or
+ * -1UL if the scan completed without finding any more any non-zero bits.
+ */
+unsigned long airq_iv_scan(struct airq_iv *iv, unsigned long start,
+                          unsigned long end)
+{
+       const unsigned long be_to_le = BITS_PER_LONG - 1;
+       unsigned long bit;
+
+       /* Find non-zero bit starting from 'ivs->next'. */
+       bit = find_next_bit_left(iv->vector, end, start);
+       if (bit >= end)
+               return -1UL;
+       /* Clear interrupt bit (find left uses big-endian bit numbers) */
+       clear_bit(bit ^ be_to_le, iv->vector);
+       return bit;
+}
+EXPORT_SYMBOL(airq_iv_scan);