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 } 152