1 // SPDX-License-Identifier: GPL-2.0
3 * qdio queue initialization
5 * Copyright IBM Corp. 2008
6 * Author(s): Jan Glauber <jang@linux.vnet.ibm.com>
8 #include <linux/kernel.h>
9 #include <linux/slab.h>
10 #include <linux/export.h>
13 #include <asm/ebcdic.h>
22 #include "qdio_debug.h"
24 #define QBUFF_PER_PAGE (PAGE_SIZE / sizeof(struct qdio_buffer))
26 static struct kmem_cache
*qdio_q_cache
;
27 static struct kmem_cache
*qdio_aob_cache
;
29 struct qaob
*qdio_allocate_aob(void)
31 return kmem_cache_zalloc(qdio_aob_cache
, GFP_ATOMIC
);
33 EXPORT_SYMBOL_GPL(qdio_allocate_aob
);
35 void qdio_release_aob(struct qaob
*aob
)
37 kmem_cache_free(qdio_aob_cache
, aob
);
39 EXPORT_SYMBOL_GPL(qdio_release_aob
);
42 * qdio_free_buffers() - free qdio buffers
43 * @buf: array of pointers to qdio buffers
44 * @count: number of qdio buffers to free
46 void qdio_free_buffers(struct qdio_buffer
**buf
, unsigned int count
)
50 for (pos
= 0; pos
< count
; pos
+= QBUFF_PER_PAGE
)
51 free_page((unsigned long) buf
[pos
]);
53 EXPORT_SYMBOL_GPL(qdio_free_buffers
);
56 * qdio_alloc_buffers() - allocate qdio buffers
57 * @buf: array of pointers to qdio buffers
58 * @count: number of qdio buffers to allocate
60 int qdio_alloc_buffers(struct qdio_buffer
**buf
, unsigned int count
)
64 for (pos
= 0; pos
< count
; pos
+= QBUFF_PER_PAGE
) {
65 buf
[pos
] = (void *) get_zeroed_page(GFP_KERNEL
);
67 qdio_free_buffers(buf
, count
);
71 for (pos
= 0; pos
< count
; pos
++)
72 if (pos
% QBUFF_PER_PAGE
)
73 buf
[pos
] = buf
[pos
- 1] + 1;
76 EXPORT_SYMBOL_GPL(qdio_alloc_buffers
);
79 * qdio_reset_buffers() - reset qdio buffers
80 * @buf: array of pointers to qdio buffers
81 * @count: number of qdio buffers that will be zeroed
83 void qdio_reset_buffers(struct qdio_buffer
**buf
, unsigned int count
)
87 for (pos
= 0; pos
< count
; pos
++)
88 memset(buf
[pos
], 0, sizeof(struct qdio_buffer
));
90 EXPORT_SYMBOL_GPL(qdio_reset_buffers
);
92 static void __qdio_free_queues(struct qdio_q
**queues
, unsigned int count
)
97 for (i
= 0; i
< count
; i
++) {
99 free_page((unsigned long) q
->slib
);
100 kmem_cache_free(qdio_q_cache
, q
);
104 void qdio_free_queues(struct qdio_irq
*irq_ptr
)
106 __qdio_free_queues(irq_ptr
->input_qs
, irq_ptr
->max_input_qs
);
107 irq_ptr
->max_input_qs
= 0;
109 __qdio_free_queues(irq_ptr
->output_qs
, irq_ptr
->max_output_qs
);
110 irq_ptr
->max_output_qs
= 0;
113 static int __qdio_allocate_qs(struct qdio_q
**irq_ptr_qs
, int nr_queues
)
118 for (i
= 0; i
< nr_queues
; i
++) {
119 q
= kmem_cache_zalloc(qdio_q_cache
, GFP_KERNEL
);
121 __qdio_free_queues(irq_ptr_qs
, i
);
125 q
->slib
= (struct slib
*) __get_free_page(GFP_KERNEL
);
127 kmem_cache_free(qdio_q_cache
, q
);
128 __qdio_free_queues(irq_ptr_qs
, i
);
136 int qdio_allocate_qs(struct qdio_irq
*irq_ptr
, int nr_input_qs
, int nr_output_qs
)
140 rc
= __qdio_allocate_qs(irq_ptr
->input_qs
, nr_input_qs
);
144 rc
= __qdio_allocate_qs(irq_ptr
->output_qs
, nr_output_qs
);
146 __qdio_free_queues(irq_ptr
->input_qs
, nr_input_qs
);
150 irq_ptr
->max_input_qs
= nr_input_qs
;
151 irq_ptr
->max_output_qs
= nr_output_qs
;
155 static void setup_queues_misc(struct qdio_q
*q
, struct qdio_irq
*irq_ptr
,
156 qdio_handler_t
*handler
, int i
)
158 struct slib
*slib
= q
->slib
;
160 /* queue must be cleared for qdio_establish */
161 memset(q
, 0, sizeof(*q
));
162 memset(slib
, 0, PAGE_SIZE
);
164 q
->irq_ptr
= irq_ptr
;
165 q
->mask
= 1 << (31 - i
);
167 q
->handler
= handler
;
170 static void setup_storage_lists(struct qdio_q
*q
, struct qdio_irq
*irq_ptr
,
171 struct qdio_buffer
**sbals_array
, int i
)
176 DBF_HEX(&q
, sizeof(void *));
177 q
->sl
= (struct sl
*)((char *)q
->slib
+ PAGE_SIZE
/ 2);
180 for (j
= 0; j
< QDIO_MAX_BUFFERS_PER_Q
; j
++)
181 q
->sbal
[j
] = *sbals_array
++;
185 prev
= (q
->is_input_q
) ? irq_ptr
->input_qs
[i
- 1]
186 : irq_ptr
->output_qs
[i
- 1];
187 prev
->slib
->nsliba
= (unsigned long)q
->slib
;
190 q
->slib
->sla
= (unsigned long)q
->sl
;
191 q
->slib
->slsba
= (unsigned long)&q
->slsb
.val
[0];
194 for (j
= 0; j
< QDIO_MAX_BUFFERS_PER_Q
; j
++)
195 q
->sl
->element
[j
].sbal
= virt_to_phys(q
->sbal
[j
]);
198 static void setup_queues(struct qdio_irq
*irq_ptr
,
199 struct qdio_initialize
*qdio_init
)
204 for_each_input_queue(irq_ptr
, q
, i
) {
205 DBF_EVENT("inq:%1d", i
);
206 setup_queues_misc(q
, irq_ptr
, qdio_init
->input_handler
, i
);
210 setup_storage_lists(q
, irq_ptr
,
211 qdio_init
->input_sbal_addr_array
[i
], i
);
214 for_each_output_queue(irq_ptr
, q
, i
) {
215 DBF_EVENT("outq:%1d", i
);
216 setup_queues_misc(q
, irq_ptr
, qdio_init
->output_handler
, i
);
219 setup_storage_lists(q
, irq_ptr
,
220 qdio_init
->output_sbal_addr_array
[i
], i
);
224 static void check_and_setup_qebsm(struct qdio_irq
*irq_ptr
,
225 unsigned char qdioac
, unsigned long token
)
227 if (!(irq_ptr
->qib
.rflags
& QIB_RFLAGS_ENABLE_QEBSM
))
229 if (!(qdioac
& AC1_SC_QEBSM_AVAILABLE
) ||
230 (!(qdioac
& AC1_SC_QEBSM_ENABLED
)))
233 irq_ptr
->sch_token
= token
;
236 DBF_EVENT("%8lx", irq_ptr
->sch_token
);
240 irq_ptr
->sch_token
= 0;
241 irq_ptr
->qib
.rflags
&= ~QIB_RFLAGS_ENABLE_QEBSM
;
246 * If there is a qdio_irq we use the chsc_page and store the information
247 * in the qdio_irq, otherwise we copy it to the specified structure.
249 int qdio_setup_get_ssqd(struct qdio_irq
*irq_ptr
,
250 struct subchannel_id
*schid
,
251 struct qdio_ssqd_desc
*data
)
253 struct chsc_ssqd_area
*ssqd
;
256 DBF_EVENT("getssqd:%4x", schid
->sch_no
);
258 ssqd
= (struct chsc_ssqd_area
*)__get_free_page(GFP_KERNEL
);
262 ssqd
= (struct chsc_ssqd_area
*)irq_ptr
->chsc_page
;
265 rc
= chsc_ssqd(*schid
, ssqd
);
269 if (!(ssqd
->qdio_ssqd
.flags
& CHSC_FLAG_QDIO_CAPABILITY
) ||
270 !(ssqd
->qdio_ssqd
.flags
& CHSC_FLAG_VALIDITY
) ||
271 (ssqd
->qdio_ssqd
.sch
!= schid
->sch_no
))
275 memcpy(data
, &ssqd
->qdio_ssqd
, sizeof(*data
));
279 free_page((unsigned long)ssqd
);
284 void qdio_setup_ssqd_info(struct qdio_irq
*irq_ptr
)
286 unsigned char qdioac
;
289 rc
= qdio_setup_get_ssqd(irq_ptr
, &irq_ptr
->schid
, &irq_ptr
->ssqd_desc
);
291 DBF_ERROR("%4x ssqd ERR", irq_ptr
->schid
.sch_no
);
292 DBF_ERROR("rc:%x", rc
);
293 /* all flags set, worst case */
294 qdioac
= AC1_SIGA_INPUT_NEEDED
| AC1_SIGA_OUTPUT_NEEDED
|
295 AC1_SIGA_SYNC_NEEDED
;
297 qdioac
= irq_ptr
->ssqd_desc
.qdioac1
;
299 check_and_setup_qebsm(irq_ptr
, qdioac
, irq_ptr
->ssqd_desc
.sch_token
);
300 irq_ptr
->qdioac1
= qdioac
;
301 DBF_EVENT("ac 1:%2x 2:%4x", qdioac
, irq_ptr
->ssqd_desc
.qdioac2
);
302 DBF_EVENT("3:%4x qib:%4x", irq_ptr
->ssqd_desc
.qdioac3
, irq_ptr
->qib
.ac
);
305 static void qdio_fill_qdr_desc(struct qdesfmt0
*desc
, struct qdio_q
*queue
)
307 desc
->sliba
= virt_to_phys(queue
->slib
);
308 desc
->sla
= virt_to_phys(queue
->sl
);
309 desc
->slsba
= virt_to_phys(&queue
->slsb
);
311 desc
->akey
= PAGE_DEFAULT_KEY
>> 4;
312 desc
->bkey
= PAGE_DEFAULT_KEY
>> 4;
313 desc
->ckey
= PAGE_DEFAULT_KEY
>> 4;
314 desc
->dkey
= PAGE_DEFAULT_KEY
>> 4;
317 static void setup_qdr(struct qdio_irq
*irq_ptr
,
318 struct qdio_initialize
*qdio_init
)
320 struct qdesfmt0
*desc
= &irq_ptr
->qdr
->qdf0
[0];
323 memset(irq_ptr
->qdr
, 0, sizeof(struct qdr
));
325 irq_ptr
->qdr
->qfmt
= qdio_init
->q_format
;
326 irq_ptr
->qdr
->ac
= qdio_init
->qdr_ac
;
327 irq_ptr
->qdr
->iqdcnt
= qdio_init
->no_input_qs
;
328 irq_ptr
->qdr
->oqdcnt
= qdio_init
->no_output_qs
;
329 irq_ptr
->qdr
->iqdsz
= sizeof(struct qdesfmt0
) / 4; /* size in words */
330 irq_ptr
->qdr
->oqdsz
= sizeof(struct qdesfmt0
) / 4;
331 irq_ptr
->qdr
->qiba
= virt_to_phys(&irq_ptr
->qib
);
332 irq_ptr
->qdr
->qkey
= PAGE_DEFAULT_KEY
>> 4;
334 for (i
= 0; i
< qdio_init
->no_input_qs
; i
++)
335 qdio_fill_qdr_desc(desc
++, irq_ptr
->input_qs
[i
]);
337 for (i
= 0; i
< qdio_init
->no_output_qs
; i
++)
338 qdio_fill_qdr_desc(desc
++, irq_ptr
->output_qs
[i
]);
341 static void setup_qib(struct qdio_irq
*irq_ptr
,
342 struct qdio_initialize
*init_data
)
344 memset(&irq_ptr
->qib
, 0, sizeof(irq_ptr
->qib
));
346 irq_ptr
->qib
.qfmt
= init_data
->q_format
;
347 irq_ptr
->qib
.pfmt
= init_data
->qib_param_field_format
;
349 irq_ptr
->qib
.rflags
= init_data
->qib_rflags
;
350 if (css_general_characteristics
.qebsm
)
351 irq_ptr
->qib
.rflags
|= QIB_RFLAGS_ENABLE_QEBSM
;
353 if (init_data
->no_input_qs
)
354 irq_ptr
->qib
.isliba
=
355 (unsigned long)(irq_ptr
->input_qs
[0]->slib
);
356 if (init_data
->no_output_qs
)
357 irq_ptr
->qib
.osliba
=
358 (unsigned long)(irq_ptr
->output_qs
[0]->slib
);
359 memcpy(irq_ptr
->qib
.ebcnam
, dev_name(&irq_ptr
->cdev
->dev
), 8);
360 ASCEBC(irq_ptr
->qib
.ebcnam
, 8);
362 if (init_data
->qib_param_field
)
363 memcpy(irq_ptr
->qib
.parm
, init_data
->qib_param_field
,
364 sizeof(irq_ptr
->qib
.parm
));
367 int qdio_setup_irq(struct qdio_irq
*irq_ptr
, struct qdio_initialize
*init_data
)
369 struct ccw_device
*cdev
= irq_ptr
->cdev
;
372 irq_ptr
->qdioac1
= 0;
373 memset(&irq_ptr
->ccw
, 0, sizeof(irq_ptr
->ccw
));
374 memset(&irq_ptr
->ssqd_desc
, 0, sizeof(irq_ptr
->ssqd_desc
));
375 memset(&irq_ptr
->perf_stat
, 0, sizeof(irq_ptr
->perf_stat
));
377 irq_ptr
->debugfs_dev
= NULL
;
378 irq_ptr
->sch_token
= irq_ptr
->perf_stat_enabled
= 0;
379 irq_ptr
->state
= QDIO_IRQ_STATE_INACTIVE
;
381 irq_ptr
->int_parm
= init_data
->int_parm
;
382 irq_ptr
->nr_input_qs
= init_data
->no_input_qs
;
383 irq_ptr
->nr_output_qs
= init_data
->no_output_qs
;
384 ccw_device_get_schid(cdev
, &irq_ptr
->schid
);
385 setup_queues(irq_ptr
, init_data
);
387 irq_ptr
->irq_poll
= init_data
->irq_poll
;
388 set_bit(QDIO_IRQ_DISABLED
, &irq_ptr
->poll_state
);
390 setup_qib(irq_ptr
, init_data
);
392 /* fill input and output descriptors */
393 setup_qdr(irq_ptr
, init_data
);
395 /* qdr, qib, sls, slsbs, slibs, sbales are filled now */
397 /* set our IRQ handler */
398 spin_lock_irq(get_ccwdev_lock(cdev
));
399 irq_ptr
->orig_handler
= cdev
->handler
;
400 cdev
->handler
= qdio_int_handler
;
401 spin_unlock_irq(get_ccwdev_lock(cdev
));
403 /* get qdio commands */
404 ciw
= ccw_device_get_ciw(cdev
, CIW_TYPE_EQUEUE
);
406 DBF_ERROR("%4x NO EQ", irq_ptr
->schid
.sch_no
);
409 irq_ptr
->equeue
= *ciw
;
411 ciw
= ccw_device_get_ciw(cdev
, CIW_TYPE_AQUEUE
);
413 DBF_ERROR("%4x NO AQ", irq_ptr
->schid
.sch_no
);
416 irq_ptr
->aqueue
= *ciw
;
421 void qdio_shutdown_irq(struct qdio_irq
*irq
)
423 struct ccw_device
*cdev
= irq
->cdev
;
425 /* restore IRQ handler */
426 spin_lock_irq(get_ccwdev_lock(cdev
));
427 cdev
->handler
= irq
->orig_handler
;
428 cdev
->private->intparm
= 0;
429 spin_unlock_irq(get_ccwdev_lock(cdev
));
432 void qdio_print_subchannel_info(struct qdio_irq
*irq_ptr
)
434 dev_info(&irq_ptr
->cdev
->dev
,
435 "qdio: %s on SC %x using AI:%d QEBSM:%d PRI:%d TDD:%d SIGA:%s%s%s\n",
436 (irq_ptr
->qib
.qfmt
== QDIO_QETH_QFMT
) ? "OSA" :
437 ((irq_ptr
->qib
.qfmt
== QDIO_ZFCP_QFMT
) ? "ZFCP" : "HS"),
438 irq_ptr
->schid
.sch_no
,
439 is_thinint_irq(irq_ptr
),
440 (irq_ptr
->sch_token
) ? 1 : 0,
441 pci_out_supported(irq_ptr
) ? 1 : 0,
442 css_general_characteristics
.aif_tdd
,
443 qdio_need_siga_in(irq_ptr
) ? "R" : " ",
444 qdio_need_siga_out(irq_ptr
) ? "W" : " ",
445 qdio_need_siga_sync(irq_ptr
) ? "S" : " ");
448 int __init
qdio_setup_init(void)
452 qdio_q_cache
= kmem_cache_create("qdio_q", sizeof(struct qdio_q
),
457 qdio_aob_cache
= kmem_cache_create("qdio_aob",
462 if (!qdio_aob_cache
) {
464 goto free_qdio_q_cache
;
467 /* Check for OSA/FCP thin interrupts (bit 67). */
468 DBF_EVENT("thinint:%1d",
469 (css_general_characteristics
.aif_osa
) ? 1 : 0);
471 /* Check for QEBSM support in general (bit 58). */
472 DBF_EVENT("cssQEBSM:%1d", css_general_characteristics
.qebsm
);
477 kmem_cache_destroy(qdio_q_cache
);
481 void qdio_setup_exit(void)
483 kmem_cache_destroy(qdio_aob_cache
);
484 kmem_cache_destroy(qdio_q_cache
);