]>
Commit | Line | Data |
---|---|---|
779e6e1c JG |
1 | /* |
2 | * linux/drivers/s390/cio/thinint_qdio.c | |
3 | * | |
6486cda6 | 4 | * Copyright 2000,2009 IBM Corp. |
779e6e1c JG |
5 | * Author(s): Utz Bacher <utz.bacher@de.ibm.com> |
6 | * Cornelia Huck <cornelia.huck@de.ibm.com> | |
7 | * Jan Glauber <jang@linux.vnet.ibm.com> | |
8 | */ | |
9 | #include <linux/io.h> | |
5a0e3ad6 | 10 | #include <linux/slab.h> |
779e6e1c JG |
11 | #include <asm/atomic.h> |
12 | #include <asm/debug.h> | |
13 | #include <asm/qdio.h> | |
14 | #include <asm/airq.h> | |
15 | #include <asm/isc.h> | |
16 | ||
17 | #include "cio.h" | |
18 | #include "ioasm.h" | |
19 | #include "qdio.h" | |
20 | #include "qdio_debug.h" | |
779e6e1c JG |
21 | |
22 | /* | |
23 | * Restriction: only 63 iqdio subchannels would have its own indicator, | |
24 | * after that, subsequent subchannels share one indicator | |
25 | */ | |
26 | #define TIQDIO_NR_NONSHARED_IND 63 | |
27 | #define TIQDIO_NR_INDICATORS (TIQDIO_NR_NONSHARED_IND + 1) | |
779e6e1c JG |
28 | |
29 | /* list of thin interrupt input queues */ | |
30 | static LIST_HEAD(tiq_list); | |
b4547402 | 31 | DEFINE_MUTEX(tiq_list_lock); |
779e6e1c JG |
32 | |
33 | /* adapter local summary indicator */ | |
d36deae7 | 34 | static u8 *tiqdio_alsi; |
779e6e1c | 35 | |
d36deae7 | 36 | struct indicator_t *q_indicators; |
779e6e1c | 37 | |
779e6e1c JG |
38 | static int css_qdio_omit_svs; |
39 | ||
d36deae7 JG |
40 | static u64 last_ai_time; |
41 | ||
779e6e1c JG |
42 | static inline unsigned long do_clear_global_summary(void) |
43 | { | |
44 | register unsigned long __fn asm("1") = 3; | |
45 | register unsigned long __tmp asm("2"); | |
46 | register unsigned long __time asm("3"); | |
47 | ||
48 | asm volatile( | |
49 | " .insn rre,0xb2650000,2,0" | |
50 | : "+d" (__fn), "=d" (__tmp), "=d" (__time)); | |
51 | return __time; | |
52 | } | |
53 | ||
54 | /* returns addr for the device state change indicator */ | |
55 | static u32 *get_indicator(void) | |
56 | { | |
57 | int i; | |
58 | ||
59 | for (i = 0; i < TIQDIO_NR_NONSHARED_IND; i++) | |
60 | if (!atomic_read(&q_indicators[i].count)) { | |
61 | atomic_set(&q_indicators[i].count, 1); | |
62 | return &q_indicators[i].ind; | |
63 | } | |
64 | ||
65 | /* use the shared indicator */ | |
66 | atomic_inc(&q_indicators[TIQDIO_SHARED_IND].count); | |
67 | return &q_indicators[TIQDIO_SHARED_IND].ind; | |
68 | } | |
69 | ||
70 | static void put_indicator(u32 *addr) | |
71 | { | |
72 | int i; | |
73 | ||
74 | if (!addr) | |
75 | return; | |
76 | i = ((unsigned long)addr - (unsigned long)q_indicators) / | |
77 | sizeof(struct indicator_t); | |
78 | atomic_dec(&q_indicators[i].count); | |
79 | } | |
80 | ||
81 | void tiqdio_add_input_queues(struct qdio_irq *irq_ptr) | |
82 | { | |
83 | struct qdio_q *q; | |
84 | int i; | |
85 | ||
86 | /* No TDD facility? If we must use SIGA-s we can also omit SVS. */ | |
87 | if (!css_qdio_omit_svs && irq_ptr->siga_flag.sync) | |
88 | css_qdio_omit_svs = 1; | |
89 | ||
b4547402 JG |
90 | mutex_lock(&tiq_list_lock); |
91 | for_each_input_queue(irq_ptr, q, i) | |
779e6e1c | 92 | list_add_rcu(&q->entry, &tiq_list); |
b4547402 | 93 | mutex_unlock(&tiq_list_lock); |
d0c9d4a8 | 94 | xchg(irq_ptr->dsci, 1 << 7); |
779e6e1c JG |
95 | } |
96 | ||
779e6e1c JG |
97 | void tiqdio_remove_input_queues(struct qdio_irq *irq_ptr) |
98 | { | |
99 | struct qdio_q *q; | |
100 | int i; | |
101 | ||
53b41ba7 JG |
102 | for (i = 0; i < irq_ptr->nr_input_qs; i++) { |
103 | q = irq_ptr->input_qs[i]; | |
104 | /* if establish triggered an error */ | |
105 | if (!q || !q->entry.prev || !q->entry.next) | |
106 | continue; | |
b4547402 JG |
107 | |
108 | mutex_lock(&tiq_list_lock); | |
779e6e1c | 109 | list_del_rcu(&q->entry); |
b4547402 | 110 | mutex_unlock(&tiq_list_lock); |
779e6e1c JG |
111 | synchronize_rcu(); |
112 | } | |
113 | } | |
114 | ||
d36deae7 | 115 | static inline int shared_ind_used(void) |
779e6e1c | 116 | { |
d36deae7 | 117 | return atomic_read(&q_indicators[TIQDIO_SHARED_IND].count); |
779e6e1c JG |
118 | } |
119 | ||
cf9a031c JG |
120 | /** |
121 | * tiqdio_thinint_handler - thin interrupt handler for qdio | |
d36deae7 JG |
122 | * @alsi: pointer to adapter local summary indicator |
123 | * @data: NULL | |
cf9a031c | 124 | */ |
d36deae7 | 125 | static void tiqdio_thinint_handler(void *alsi, void *data) |
779e6e1c JG |
126 | { |
127 | struct qdio_q *q; | |
128 | ||
d36deae7 JG |
129 | last_ai_time = S390_lowcore.int_clock; |
130 | ||
cf9a031c JG |
131 | /* |
132 | * SVS only when needed: issue SVS to benefit from iqdio interrupt | |
d36deae7 | 133 | * avoidance (SVS clears adapter interrupt suppression overwrite). |
cf9a031c JG |
134 | */ |
135 | if (!css_qdio_omit_svs) | |
136 | do_clear_global_summary(); | |
137 | ||
d36deae7 JG |
138 | /* reset local summary indicator */ |
139 | if (shared_ind_used()) | |
140 | xchg(tiqdio_alsi, 0); | |
779e6e1c JG |
141 | |
142 | /* protect tiq_list entries, only changed in activate or shutdown */ | |
143 | rcu_read_lock(); | |
144 | ||
cf9a031c | 145 | /* check for work on all inbound thinint queues */ |
d36deae7 JG |
146 | list_for_each_entry_rcu(q, &tiq_list, entry) { |
147 | ||
779e6e1c | 148 | /* only process queues from changed sets */ |
d36deae7 JG |
149 | if (!*q->irq_ptr->dsci) |
150 | continue; | |
779e6e1c | 151 | |
d36deae7 JG |
152 | if (q->u.in.queue_start_poll) { |
153 | /* skip if polling is enabled or already in work */ | |
154 | if (test_and_set_bit(QDIO_QUEUE_IRQS_DISABLED, | |
155 | &q->u.in.queue_irq_state)) { | |
156 | qperf_inc(q, int_discarded); | |
157 | continue; | |
158 | } | |
159 | ||
160 | /* avoid dsci clear here, done after processing */ | |
161 | q->u.in.queue_start_poll(q->irq_ptr->cdev, q->nr, | |
162 | q->irq_ptr->int_parm); | |
163 | } else { | |
779e6e1c JG |
164 | /* only clear it if the indicator is non-shared */ |
165 | if (!shared_ind(q->irq_ptr)) | |
166 | xchg(q->irq_ptr->dsci, 0); | |
167 | /* | |
d36deae7 JG |
168 | * Call inbound processing but not directly |
169 | * since that could starve other thinint queues. | |
779e6e1c JG |
170 | */ |
171 | tasklet_schedule(&q->tasklet); | |
172 | } | |
d36deae7 JG |
173 | qperf_inc(q, adapter_int); |
174 | } | |
779e6e1c JG |
175 | rcu_read_unlock(); |
176 | ||
177 | /* | |
d36deae7 JG |
178 | * If the shared indicator was used clear it now after all queues |
179 | * were processed. | |
779e6e1c | 180 | */ |
d36deae7 | 181 | if (shared_ind_used()) { |
779e6e1c JG |
182 | xchg(&q_indicators[TIQDIO_SHARED_IND].ind, 0); |
183 | ||
184 | /* prevent racing */ | |
185 | if (*tiqdio_alsi) | |
d0c9d4a8 | 186 | xchg(&q_indicators[TIQDIO_SHARED_IND].ind, 1 << 7); |
779e6e1c | 187 | } |
779e6e1c JG |
188 | } |
189 | ||
190 | static int set_subchannel_ind(struct qdio_irq *irq_ptr, int reset) | |
191 | { | |
192 | struct scssc_area *scssc_area; | |
779e6e1c JG |
193 | int rc; |
194 | ||
195 | scssc_area = (struct scssc_area *)irq_ptr->chsc_page; | |
196 | memset(scssc_area, 0, PAGE_SIZE); | |
197 | ||
198 | if (reset) { | |
199 | scssc_area->summary_indicator_addr = 0; | |
200 | scssc_area->subchannel_indicator_addr = 0; | |
201 | } else { | |
202 | scssc_area->summary_indicator_addr = virt_to_phys(tiqdio_alsi); | |
203 | scssc_area->subchannel_indicator_addr = | |
204 | virt_to_phys(irq_ptr->dsci); | |
205 | } | |
206 | ||
207 | scssc_area->request = (struct chsc_header) { | |
208 | .length = 0x0fe0, | |
209 | .code = 0x0021, | |
210 | }; | |
211 | scssc_area->operation_code = 0; | |
d1bf8590 HC |
212 | scssc_area->ks = PAGE_DEFAULT_KEY >> 4; |
213 | scssc_area->kc = PAGE_DEFAULT_KEY >> 4; | |
779e6e1c JG |
214 | scssc_area->isc = QDIO_AIRQ_ISC; |
215 | scssc_area->schid = irq_ptr->schid; | |
216 | ||
217 | /* enable the time delay disablement facility */ | |
218 | if (css_general_characteristics.aif_tdd) | |
219 | scssc_area->word_with_d_bit = 0x10000000; | |
220 | ||
221 | rc = chsc(scssc_area); | |
222 | if (rc) | |
223 | return -EIO; | |
224 | ||
225 | rc = chsc_error_from_response(scssc_area->response.code); | |
226 | if (rc) { | |
22f99347 JG |
227 | DBF_ERROR("%4x SSI r:%4x", irq_ptr->schid.sch_no, |
228 | scssc_area->response.code); | |
229 | DBF_ERROR_HEX(&scssc_area->response, sizeof(void *)); | |
779e6e1c JG |
230 | return rc; |
231 | } | |
232 | ||
22f99347 JG |
233 | DBF_EVENT("setscind"); |
234 | DBF_HEX(&scssc_area->summary_indicator_addr, sizeof(unsigned long)); | |
235 | DBF_HEX(&scssc_area->subchannel_indicator_addr, sizeof(unsigned long)); | |
779e6e1c JG |
236 | return 0; |
237 | } | |
238 | ||
239 | /* allocate non-shared indicators and shared indicator */ | |
240 | int __init tiqdio_allocate_memory(void) | |
241 | { | |
242 | q_indicators = kzalloc(sizeof(struct indicator_t) * TIQDIO_NR_INDICATORS, | |
243 | GFP_KERNEL); | |
244 | if (!q_indicators) | |
245 | return -ENOMEM; | |
246 | return 0; | |
247 | } | |
248 | ||
249 | void tiqdio_free_memory(void) | |
250 | { | |
251 | kfree(q_indicators); | |
252 | } | |
253 | ||
254 | int __init tiqdio_register_thinints(void) | |
255 | { | |
779e6e1c JG |
256 | isc_register(QDIO_AIRQ_ISC); |
257 | tiqdio_alsi = s390_register_adapter_interrupt(&tiqdio_thinint_handler, | |
258 | NULL, QDIO_AIRQ_ISC); | |
259 | if (IS_ERR(tiqdio_alsi)) { | |
22f99347 | 260 | DBF_EVENT("RTI:%lx", PTR_ERR(tiqdio_alsi)); |
779e6e1c JG |
261 | tiqdio_alsi = NULL; |
262 | isc_unregister(QDIO_AIRQ_ISC); | |
263 | return -ENOMEM; | |
264 | } | |
265 | return 0; | |
266 | } | |
267 | ||
268 | int qdio_establish_thinint(struct qdio_irq *irq_ptr) | |
269 | { | |
270 | if (!is_thinint_irq(irq_ptr)) | |
271 | return 0; | |
272 | ||
273 | /* Check for aif time delay disablement. If installed, | |
274 | * omit SVS even under LPAR | |
275 | */ | |
276 | if (css_general_characteristics.aif_tdd) | |
277 | css_qdio_omit_svs = 1; | |
278 | return set_subchannel_ind(irq_ptr, 0); | |
279 | } | |
280 | ||
281 | void qdio_setup_thinint(struct qdio_irq *irq_ptr) | |
282 | { | |
283 | if (!is_thinint_irq(irq_ptr)) | |
284 | return; | |
285 | irq_ptr->dsci = get_indicator(); | |
22f99347 | 286 | DBF_HEX(&irq_ptr->dsci, sizeof(void *)); |
779e6e1c JG |
287 | } |
288 | ||
289 | void qdio_shutdown_thinint(struct qdio_irq *irq_ptr) | |
290 | { | |
291 | if (!is_thinint_irq(irq_ptr)) | |
292 | return; | |
293 | ||
294 | /* reset adapter interrupt indicators */ | |
295 | put_indicator(irq_ptr->dsci); | |
296 | set_subchannel_ind(irq_ptr, 1); | |
297 | } | |
298 | ||
299 | void __exit tiqdio_unregister_thinints(void) | |
300 | { | |
9e890ad8 | 301 | WARN_ON(!list_empty(&tiq_list)); |
779e6e1c JG |
302 | |
303 | if (tiqdio_alsi) { | |
304 | s390_unregister_adapter_interrupt(tiqdio_alsi, QDIO_AIRQ_ISC); | |
305 | isc_unregister(QDIO_AIRQ_ISC); | |
306 | } | |
307 | } |