Commit | Line | Data |
---|---|---|
779e6e1c JG |
1 | /* |
2 | * linux/drivers/s390/cio/thinint_qdio.c | |
3 | * | |
4 | * thin interrupt support for qdio | |
5 | * | |
6 | * Copyright 2000-2008 IBM Corp. | |
7 | * Author(s): Utz Bacher <utz.bacher@de.ibm.com> | |
8 | * Cornelia Huck <cornelia.huck@de.ibm.com> | |
9 | * Jan Glauber <jang@linux.vnet.ibm.com> | |
10 | */ | |
11 | #include <linux/io.h> | |
12 | #include <asm/atomic.h> | |
13 | #include <asm/debug.h> | |
14 | #include <asm/qdio.h> | |
15 | #include <asm/airq.h> | |
16 | #include <asm/isc.h> | |
17 | ||
18 | #include "cio.h" | |
19 | #include "ioasm.h" | |
20 | #include "qdio.h" | |
21 | #include "qdio_debug.h" | |
22 | #include "qdio_perf.h" | |
23 | ||
24 | /* | |
25 | * Restriction: only 63 iqdio subchannels would have its own indicator, | |
26 | * after that, subsequent subchannels share one indicator | |
27 | */ | |
28 | #define TIQDIO_NR_NONSHARED_IND 63 | |
29 | #define TIQDIO_NR_INDICATORS (TIQDIO_NR_NONSHARED_IND + 1) | |
30 | #define TIQDIO_SHARED_IND 63 | |
31 | ||
32 | /* list of thin interrupt input queues */ | |
33 | static LIST_HEAD(tiq_list); | |
34 | ||
35 | /* adapter local summary indicator */ | |
36 | static unsigned char *tiqdio_alsi; | |
37 | ||
38 | /* device state change indicators */ | |
39 | struct indicator_t { | |
40 | u32 ind; /* u32 because of compare-and-swap performance */ | |
41 | atomic_t count; /* use count, 0 or 1 for non-shared indicators */ | |
42 | }; | |
43 | static struct indicator_t *q_indicators; | |
44 | ||
45 | static void tiqdio_tasklet_fn(unsigned long data); | |
46 | static DECLARE_TASKLET(tiqdio_tasklet, tiqdio_tasklet_fn, 0); | |
47 | ||
48 | static int css_qdio_omit_svs; | |
49 | ||
50 | static inline unsigned long do_clear_global_summary(void) | |
51 | { | |
52 | register unsigned long __fn asm("1") = 3; | |
53 | register unsigned long __tmp asm("2"); | |
54 | register unsigned long __time asm("3"); | |
55 | ||
56 | asm volatile( | |
57 | " .insn rre,0xb2650000,2,0" | |
58 | : "+d" (__fn), "=d" (__tmp), "=d" (__time)); | |
59 | return __time; | |
60 | } | |
61 | ||
62 | /* returns addr for the device state change indicator */ | |
63 | static u32 *get_indicator(void) | |
64 | { | |
65 | int i; | |
66 | ||
67 | for (i = 0; i < TIQDIO_NR_NONSHARED_IND; i++) | |
68 | if (!atomic_read(&q_indicators[i].count)) { | |
69 | atomic_set(&q_indicators[i].count, 1); | |
70 | return &q_indicators[i].ind; | |
71 | } | |
72 | ||
73 | /* use the shared indicator */ | |
74 | atomic_inc(&q_indicators[TIQDIO_SHARED_IND].count); | |
75 | return &q_indicators[TIQDIO_SHARED_IND].ind; | |
76 | } | |
77 | ||
78 | static void put_indicator(u32 *addr) | |
79 | { | |
80 | int i; | |
81 | ||
82 | if (!addr) | |
83 | return; | |
84 | i = ((unsigned long)addr - (unsigned long)q_indicators) / | |
85 | sizeof(struct indicator_t); | |
86 | atomic_dec(&q_indicators[i].count); | |
87 | } | |
88 | ||
89 | void tiqdio_add_input_queues(struct qdio_irq *irq_ptr) | |
90 | { | |
91 | struct qdio_q *q; | |
92 | int i; | |
93 | ||
94 | /* No TDD facility? If we must use SIGA-s we can also omit SVS. */ | |
95 | if (!css_qdio_omit_svs && irq_ptr->siga_flag.sync) | |
96 | css_qdio_omit_svs = 1; | |
97 | ||
98 | for_each_input_queue(irq_ptr, q, i) { | |
99 | list_add_rcu(&q->entry, &tiq_list); | |
100 | synchronize_rcu(); | |
101 | } | |
102 | xchg(irq_ptr->dsci, 1); | |
103 | tasklet_schedule(&tiqdio_tasklet); | |
104 | } | |
105 | ||
106 | /* | |
107 | * we cannot stop the tiqdio tasklet here since it is for all | |
108 | * thinint qdio devices and it must run as long as there is a | |
109 | * thinint device left | |
110 | */ | |
111 | void tiqdio_remove_input_queues(struct qdio_irq *irq_ptr) | |
112 | { | |
113 | struct qdio_q *q; | |
114 | int i; | |
115 | ||
53b41ba7 JG |
116 | for (i = 0; i < irq_ptr->nr_input_qs; i++) { |
117 | q = irq_ptr->input_qs[i]; | |
118 | /* if establish triggered an error */ | |
119 | if (!q || !q->entry.prev || !q->entry.next) | |
120 | continue; | |
779e6e1c JG |
121 | list_del_rcu(&q->entry); |
122 | synchronize_rcu(); | |
123 | } | |
124 | } | |
125 | ||
126 | static inline int tiqdio_inbound_q_done(struct qdio_q *q) | |
127 | { | |
9a1ce28a | 128 | unsigned char state = 0; |
779e6e1c JG |
129 | |
130 | if (!atomic_read(&q->nr_buf_used)) | |
131 | return 1; | |
132 | ||
133 | qdio_siga_sync_q(q); | |
50f769df | 134 | get_buf_state(q, q->first_to_check, &state, 0); |
779e6e1c JG |
135 | |
136 | if (state == SLSB_P_INPUT_PRIMED) | |
137 | /* more work coming */ | |
138 | return 0; | |
139 | return 1; | |
140 | } | |
141 | ||
142 | static inline int shared_ind(struct qdio_irq *irq_ptr) | |
143 | { | |
144 | return irq_ptr->dsci == &q_indicators[TIQDIO_SHARED_IND].ind; | |
145 | } | |
146 | ||
147 | static void __tiqdio_inbound_processing(struct qdio_q *q) | |
148 | { | |
149 | qdio_perf_stat_inc(&perf_stats.thinint_inbound); | |
150 | qdio_sync_after_thinint(q); | |
151 | ||
152 | /* | |
153 | * Maybe we have work on our outbound queues... at least | |
154 | * we have to check the PCI capable queues. | |
155 | */ | |
156 | qdio_check_outbound_after_thinint(q); | |
157 | ||
158 | again: | |
159 | if (!qdio_inbound_q_moved(q)) | |
160 | return; | |
161 | ||
162 | qdio_kick_inbound_handler(q); | |
163 | ||
164 | if (!tiqdio_inbound_q_done(q)) { | |
165 | qdio_perf_stat_inc(&perf_stats.thinint_inbound_loop); | |
166 | goto again; | |
167 | } | |
168 | ||
169 | qdio_stop_polling(q); | |
170 | /* | |
171 | * We need to check again to not lose initiative after | |
172 | * resetting the ACK state. | |
173 | */ | |
174 | if (!tiqdio_inbound_q_done(q)) { | |
175 | qdio_perf_stat_inc(&perf_stats.thinint_inbound_loop2); | |
176 | goto again; | |
177 | } | |
178 | } | |
179 | ||
180 | void tiqdio_inbound_processing(unsigned long data) | |
181 | { | |
182 | struct qdio_q *q = (struct qdio_q *)data; | |
183 | ||
184 | __tiqdio_inbound_processing(q); | |
185 | } | |
186 | ||
187 | /* check for work on all inbound thinint queues */ | |
188 | static void tiqdio_tasklet_fn(unsigned long data) | |
189 | { | |
190 | struct qdio_q *q; | |
191 | ||
192 | qdio_perf_stat_inc(&perf_stats.tasklet_thinint); | |
193 | again: | |
194 | ||
195 | /* protect tiq_list entries, only changed in activate or shutdown */ | |
196 | rcu_read_lock(); | |
197 | ||
198 | list_for_each_entry_rcu(q, &tiq_list, entry) | |
199 | /* only process queues from changed sets */ | |
200 | if (*q->irq_ptr->dsci) { | |
201 | ||
202 | /* only clear it if the indicator is non-shared */ | |
203 | if (!shared_ind(q->irq_ptr)) | |
204 | xchg(q->irq_ptr->dsci, 0); | |
205 | /* | |
206 | * don't call inbound processing directly since | |
207 | * that could starve other thinint queues | |
208 | */ | |
209 | tasklet_schedule(&q->tasklet); | |
210 | } | |
211 | ||
212 | rcu_read_unlock(); | |
213 | ||
214 | /* | |
215 | * if we used the shared indicator clear it now after all queues | |
216 | * were processed | |
217 | */ | |
218 | if (atomic_read(&q_indicators[TIQDIO_SHARED_IND].count)) { | |
219 | xchg(&q_indicators[TIQDIO_SHARED_IND].ind, 0); | |
220 | ||
221 | /* prevent racing */ | |
222 | if (*tiqdio_alsi) | |
223 | xchg(&q_indicators[TIQDIO_SHARED_IND].ind, 1); | |
224 | } | |
225 | ||
226 | /* check for more work */ | |
227 | if (*tiqdio_alsi) { | |
228 | xchg(tiqdio_alsi, 0); | |
229 | qdio_perf_stat_inc(&perf_stats.tasklet_thinint_loop); | |
230 | goto again; | |
231 | } | |
232 | } | |
233 | ||
234 | /** | |
235 | * tiqdio_thinint_handler - thin interrupt handler for qdio | |
236 | * @ind: pointer to adapter local summary indicator | |
237 | * @drv_data: NULL | |
238 | */ | |
239 | static void tiqdio_thinint_handler(void *ind, void *drv_data) | |
240 | { | |
241 | qdio_perf_stat_inc(&perf_stats.thin_int); | |
242 | ||
243 | /* | |
244 | * SVS only when needed: issue SVS to benefit from iqdio interrupt | |
245 | * avoidance (SVS clears adapter interrupt suppression overwrite) | |
246 | */ | |
247 | if (!css_qdio_omit_svs) | |
248 | do_clear_global_summary(); | |
249 | ||
250 | /* | |
251 | * reset local summary indicator (tiqdio_alsi) to stop adapter | |
252 | * interrupts for now, the tasklet will clean all dsci's | |
253 | */ | |
254 | xchg((u8 *)ind, 0); | |
255 | tasklet_hi_schedule(&tiqdio_tasklet); | |
256 | } | |
257 | ||
258 | static int set_subchannel_ind(struct qdio_irq *irq_ptr, int reset) | |
259 | { | |
260 | struct scssc_area *scssc_area; | |
779e6e1c JG |
261 | int rc; |
262 | ||
263 | scssc_area = (struct scssc_area *)irq_ptr->chsc_page; | |
264 | memset(scssc_area, 0, PAGE_SIZE); | |
265 | ||
266 | if (reset) { | |
267 | scssc_area->summary_indicator_addr = 0; | |
268 | scssc_area->subchannel_indicator_addr = 0; | |
269 | } else { | |
270 | scssc_area->summary_indicator_addr = virt_to_phys(tiqdio_alsi); | |
271 | scssc_area->subchannel_indicator_addr = | |
272 | virt_to_phys(irq_ptr->dsci); | |
273 | } | |
274 | ||
275 | scssc_area->request = (struct chsc_header) { | |
276 | .length = 0x0fe0, | |
277 | .code = 0x0021, | |
278 | }; | |
279 | scssc_area->operation_code = 0; | |
280 | scssc_area->ks = PAGE_DEFAULT_KEY; | |
281 | scssc_area->kc = PAGE_DEFAULT_KEY; | |
282 | scssc_area->isc = QDIO_AIRQ_ISC; | |
283 | scssc_area->schid = irq_ptr->schid; | |
284 | ||
285 | /* enable the time delay disablement facility */ | |
286 | if (css_general_characteristics.aif_tdd) | |
287 | scssc_area->word_with_d_bit = 0x10000000; | |
288 | ||
289 | rc = chsc(scssc_area); | |
290 | if (rc) | |
291 | return -EIO; | |
292 | ||
293 | rc = chsc_error_from_response(scssc_area->response.code); | |
294 | if (rc) { | |
22f99347 JG |
295 | DBF_ERROR("%4x SSI r:%4x", irq_ptr->schid.sch_no, |
296 | scssc_area->response.code); | |
297 | DBF_ERROR_HEX(&scssc_area->response, sizeof(void *)); | |
779e6e1c JG |
298 | return rc; |
299 | } | |
300 | ||
22f99347 JG |
301 | DBF_EVENT("setscind"); |
302 | DBF_HEX(&scssc_area->summary_indicator_addr, sizeof(unsigned long)); | |
303 | DBF_HEX(&scssc_area->subchannel_indicator_addr, sizeof(unsigned long)); | |
779e6e1c JG |
304 | return 0; |
305 | } | |
306 | ||
307 | /* allocate non-shared indicators and shared indicator */ | |
308 | int __init tiqdio_allocate_memory(void) | |
309 | { | |
310 | q_indicators = kzalloc(sizeof(struct indicator_t) * TIQDIO_NR_INDICATORS, | |
311 | GFP_KERNEL); | |
312 | if (!q_indicators) | |
313 | return -ENOMEM; | |
314 | return 0; | |
315 | } | |
316 | ||
317 | void tiqdio_free_memory(void) | |
318 | { | |
319 | kfree(q_indicators); | |
320 | } | |
321 | ||
322 | int __init tiqdio_register_thinints(void) | |
323 | { | |
779e6e1c JG |
324 | isc_register(QDIO_AIRQ_ISC); |
325 | tiqdio_alsi = s390_register_adapter_interrupt(&tiqdio_thinint_handler, | |
326 | NULL, QDIO_AIRQ_ISC); | |
327 | if (IS_ERR(tiqdio_alsi)) { | |
22f99347 | 328 | DBF_EVENT("RTI:%lx", PTR_ERR(tiqdio_alsi)); |
779e6e1c JG |
329 | tiqdio_alsi = NULL; |
330 | isc_unregister(QDIO_AIRQ_ISC); | |
331 | return -ENOMEM; | |
332 | } | |
333 | return 0; | |
334 | } | |
335 | ||
336 | int qdio_establish_thinint(struct qdio_irq *irq_ptr) | |
337 | { | |
338 | if (!is_thinint_irq(irq_ptr)) | |
339 | return 0; | |
340 | ||
341 | /* Check for aif time delay disablement. If installed, | |
342 | * omit SVS even under LPAR | |
343 | */ | |
344 | if (css_general_characteristics.aif_tdd) | |
345 | css_qdio_omit_svs = 1; | |
346 | return set_subchannel_ind(irq_ptr, 0); | |
347 | } | |
348 | ||
349 | void qdio_setup_thinint(struct qdio_irq *irq_ptr) | |
350 | { | |
351 | if (!is_thinint_irq(irq_ptr)) | |
352 | return; | |
353 | irq_ptr->dsci = get_indicator(); | |
22f99347 | 354 | DBF_HEX(&irq_ptr->dsci, sizeof(void *)); |
779e6e1c JG |
355 | } |
356 | ||
357 | void qdio_shutdown_thinint(struct qdio_irq *irq_ptr) | |
358 | { | |
359 | if (!is_thinint_irq(irq_ptr)) | |
360 | return; | |
361 | ||
362 | /* reset adapter interrupt indicators */ | |
363 | put_indicator(irq_ptr->dsci); | |
364 | set_subchannel_ind(irq_ptr, 1); | |
365 | } | |
366 | ||
367 | void __exit tiqdio_unregister_thinints(void) | |
368 | { | |
369 | tasklet_disable(&tiqdio_tasklet); | |
370 | ||
371 | if (tiqdio_alsi) { | |
372 | s390_unregister_adapter_interrupt(tiqdio_alsi, QDIO_AIRQ_ISC); | |
373 | isc_unregister(QDIO_AIRQ_ISC); | |
374 | } | |
375 | } |