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>
19 #include "qdio_debug.h"
21 #define QBUFF_PER_PAGE (PAGE_SIZE / sizeof(struct qdio_buffer))
23 static struct kmem_cache
*qdio_q_cache
;
24 static struct kmem_cache
*qdio_aob_cache
;
26 struct qaob
*qdio_allocate_aob(void)
28 return kmem_cache_zalloc(qdio_aob_cache
, GFP_ATOMIC
);
31 void qdio_release_aob(struct qaob
*aob
)
33 kmem_cache_free(qdio_aob_cache
, aob
);
35 EXPORT_SYMBOL_GPL(qdio_release_aob
);
38 * qdio_free_buffers() - free qdio buffers
39 * @buf: array of pointers to qdio buffers
40 * @count: number of qdio buffers to free
42 void qdio_free_buffers(struct qdio_buffer
**buf
, unsigned int count
)
46 for (pos
= 0; pos
< count
; pos
+= QBUFF_PER_PAGE
)
47 free_page((unsigned long) buf
[pos
]);
49 EXPORT_SYMBOL_GPL(qdio_free_buffers
);
52 * qdio_alloc_buffers() - allocate qdio buffers
53 * @buf: array of pointers to qdio buffers
54 * @count: number of qdio buffers to allocate
56 int qdio_alloc_buffers(struct qdio_buffer
**buf
, unsigned int count
)
60 for (pos
= 0; pos
< count
; pos
+= QBUFF_PER_PAGE
) {
61 buf
[pos
] = (void *) get_zeroed_page(GFP_KERNEL
);
63 qdio_free_buffers(buf
, count
);
67 for (pos
= 0; pos
< count
; pos
++)
68 if (pos
% QBUFF_PER_PAGE
)
69 buf
[pos
] = buf
[pos
- 1] + 1;
72 EXPORT_SYMBOL_GPL(qdio_alloc_buffers
);
75 * qdio_reset_buffers() - reset qdio buffers
76 * @buf: array of pointers to qdio buffers
77 * @count: number of qdio buffers that will be zeroed
79 void qdio_reset_buffers(struct qdio_buffer
**buf
, unsigned int count
)
83 for (pos
= 0; pos
< count
; pos
++)
84 memset(buf
[pos
], 0, sizeof(struct qdio_buffer
));
86 EXPORT_SYMBOL_GPL(qdio_reset_buffers
);
89 * qebsm is only available under 64bit but the adapter sets the feature
90 * flag anyway, so we manually override it.
92 static inline int qebsm_possible(void)
94 return css_general_characteristics
.qebsm
;
98 * qib_param_field: pointer to 128 bytes or NULL, if no param field
99 * nr_input_qs: pointer to nr_queues*128 words of data or NULL
101 static void set_impl_params(struct qdio_irq
*irq_ptr
,
102 unsigned int qib_param_field_format
,
103 unsigned char *qib_param_field
,
104 unsigned long *input_slib_elements
,
105 unsigned long *output_slib_elements
)
113 irq_ptr
->qib
.pfmt
= qib_param_field_format
;
115 memcpy(irq_ptr
->qib
.parm
, qib_param_field
,
116 QDIO_MAX_BUFFERS_PER_Q
);
118 if (!input_slib_elements
)
121 for_each_input_queue(irq_ptr
, q
, i
) {
122 for (j
= 0; j
< QDIO_MAX_BUFFERS_PER_Q
; j
++)
123 q
->slib
->slibe
[j
].parms
=
124 input_slib_elements
[i
* QDIO_MAX_BUFFERS_PER_Q
+ j
];
127 if (!output_slib_elements
)
130 for_each_output_queue(irq_ptr
, q
, i
) {
131 for (j
= 0; j
< QDIO_MAX_BUFFERS_PER_Q
; j
++)
132 q
->slib
->slibe
[j
].parms
=
133 output_slib_elements
[i
* QDIO_MAX_BUFFERS_PER_Q
+ j
];
137 static int __qdio_allocate_qs(struct qdio_q
**irq_ptr_qs
, int nr_queues
)
142 for (i
= 0; i
< nr_queues
; i
++) {
143 q
= kmem_cache_zalloc(qdio_q_cache
, GFP_KERNEL
);
147 q
->slib
= (struct slib
*) __get_free_page(GFP_KERNEL
);
149 kmem_cache_free(qdio_q_cache
, q
);
157 int qdio_allocate_qs(struct qdio_irq
*irq_ptr
, int nr_input_qs
, int nr_output_qs
)
161 rc
= __qdio_allocate_qs(irq_ptr
->input_qs
, nr_input_qs
);
164 rc
= __qdio_allocate_qs(irq_ptr
->output_qs
, nr_output_qs
);
168 static void setup_queues_misc(struct qdio_q
*q
, struct qdio_irq
*irq_ptr
,
169 qdio_handler_t
*handler
, int i
)
171 struct slib
*slib
= q
->slib
;
173 /* queue must be cleared for qdio_establish */
174 memset(q
, 0, sizeof(*q
));
175 memset(slib
, 0, PAGE_SIZE
);
177 q
->irq_ptr
= irq_ptr
;
178 q
->mask
= 1 << (31 - i
);
180 q
->handler
= handler
;
183 static void setup_storage_lists(struct qdio_q
*q
, struct qdio_irq
*irq_ptr
,
184 struct qdio_buffer
**sbals_array
, int i
)
189 DBF_HEX(&q
, sizeof(void *));
190 q
->sl
= (struct sl
*)((char *)q
->slib
+ PAGE_SIZE
/ 2);
193 for (j
= 0; j
< QDIO_MAX_BUFFERS_PER_Q
; j
++)
194 q
->sbal
[j
] = *sbals_array
++;
198 prev
= (q
->is_input_q
) ? irq_ptr
->input_qs
[i
- 1]
199 : irq_ptr
->output_qs
[i
- 1];
200 prev
->slib
->nsliba
= (unsigned long)q
->slib
;
203 q
->slib
->sla
= (unsigned long)q
->sl
;
204 q
->slib
->slsba
= (unsigned long)&q
->slsb
.val
[0];
207 for (j
= 0; j
< QDIO_MAX_BUFFERS_PER_Q
; j
++)
208 q
->sl
->element
[j
].sbal
= (unsigned long)q
->sbal
[j
];
211 static void setup_queues(struct qdio_irq
*irq_ptr
,
212 struct qdio_initialize
*qdio_init
)
215 struct qdio_buffer
**input_sbal_array
= qdio_init
->input_sbal_addr_array
;
216 struct qdio_buffer
**output_sbal_array
= qdio_init
->output_sbal_addr_array
;
217 struct qdio_outbuf_state
*output_sbal_state_array
=
218 qdio_init
->output_sbal_state_array
;
221 for_each_input_queue(irq_ptr
, q
, i
) {
222 DBF_EVENT("inq:%1d", i
);
223 setup_queues_misc(q
, irq_ptr
, qdio_init
->input_handler
, i
);
226 q
->u
.in
.queue_start_poll
= qdio_init
->queue_start_poll_array
?
227 qdio_init
->queue_start_poll_array
[i
] : NULL
;
229 setup_storage_lists(q
, irq_ptr
, input_sbal_array
, i
);
230 input_sbal_array
+= QDIO_MAX_BUFFERS_PER_Q
;
232 if (is_thinint_irq(irq_ptr
)) {
233 tasklet_init(&q
->tasklet
, tiqdio_inbound_processing
,
236 tasklet_init(&q
->tasklet
, qdio_inbound_processing
,
241 for_each_output_queue(irq_ptr
, q
, i
) {
242 DBF_EVENT("outq:%1d", i
);
243 setup_queues_misc(q
, irq_ptr
, qdio_init
->output_handler
, i
);
245 q
->u
.out
.sbal_state
= output_sbal_state_array
;
246 output_sbal_state_array
+= QDIO_MAX_BUFFERS_PER_Q
;
249 q
->u
.out
.scan_threshold
= qdio_init
->scan_threshold
;
250 setup_storage_lists(q
, irq_ptr
, output_sbal_array
, i
);
251 output_sbal_array
+= QDIO_MAX_BUFFERS_PER_Q
;
253 tasklet_init(&q
->tasklet
, qdio_outbound_processing
,
255 timer_setup(&q
->u
.out
.timer
, qdio_outbound_timer
, 0);
259 static void process_ac_flags(struct qdio_irq
*irq_ptr
, unsigned char qdioac
)
261 if (qdioac
& AC1_SIGA_INPUT_NEEDED
)
262 irq_ptr
->siga_flag
.input
= 1;
263 if (qdioac
& AC1_SIGA_OUTPUT_NEEDED
)
264 irq_ptr
->siga_flag
.output
= 1;
265 if (qdioac
& AC1_SIGA_SYNC_NEEDED
)
266 irq_ptr
->siga_flag
.sync
= 1;
267 if (!(qdioac
& AC1_AUTOMATIC_SYNC_ON_THININT
))
268 irq_ptr
->siga_flag
.sync_after_ai
= 1;
269 if (!(qdioac
& AC1_AUTOMATIC_SYNC_ON_OUT_PCI
))
270 irq_ptr
->siga_flag
.sync_out_after_pci
= 1;
273 static void check_and_setup_qebsm(struct qdio_irq
*irq_ptr
,
274 unsigned char qdioac
, unsigned long token
)
276 if (!(irq_ptr
->qib
.rflags
& QIB_RFLAGS_ENABLE_QEBSM
))
278 if (!(qdioac
& AC1_SC_QEBSM_AVAILABLE
) ||
279 (!(qdioac
& AC1_SC_QEBSM_ENABLED
)))
282 irq_ptr
->sch_token
= token
;
285 DBF_EVENT("%8lx", irq_ptr
->sch_token
);
289 irq_ptr
->sch_token
= 0;
290 irq_ptr
->qib
.rflags
&= ~QIB_RFLAGS_ENABLE_QEBSM
;
295 * If there is a qdio_irq we use the chsc_page and store the information
296 * in the qdio_irq, otherwise we copy it to the specified structure.
298 int qdio_setup_get_ssqd(struct qdio_irq
*irq_ptr
,
299 struct subchannel_id
*schid
,
300 struct qdio_ssqd_desc
*data
)
302 struct chsc_ssqd_area
*ssqd
;
305 DBF_EVENT("getssqd:%4x", schid
->sch_no
);
307 ssqd
= (struct chsc_ssqd_area
*)__get_free_page(GFP_KERNEL
);
311 ssqd
= (struct chsc_ssqd_area
*)irq_ptr
->chsc_page
;
314 rc
= chsc_ssqd(*schid
, ssqd
);
318 if (!(ssqd
->qdio_ssqd
.flags
& CHSC_FLAG_QDIO_CAPABILITY
) ||
319 !(ssqd
->qdio_ssqd
.flags
& CHSC_FLAG_VALIDITY
) ||
320 (ssqd
->qdio_ssqd
.sch
!= schid
->sch_no
))
324 memcpy(data
, &ssqd
->qdio_ssqd
, sizeof(*data
));
328 free_page((unsigned long)ssqd
);
333 void qdio_setup_ssqd_info(struct qdio_irq
*irq_ptr
)
335 unsigned char qdioac
;
338 rc
= qdio_setup_get_ssqd(irq_ptr
, &irq_ptr
->schid
, &irq_ptr
->ssqd_desc
);
340 DBF_ERROR("%4x ssqd ERR", irq_ptr
->schid
.sch_no
);
341 DBF_ERROR("rc:%x", rc
);
342 /* all flags set, worst case */
343 qdioac
= AC1_SIGA_INPUT_NEEDED
| AC1_SIGA_OUTPUT_NEEDED
|
344 AC1_SIGA_SYNC_NEEDED
;
346 qdioac
= irq_ptr
->ssqd_desc
.qdioac1
;
348 check_and_setup_qebsm(irq_ptr
, qdioac
, irq_ptr
->ssqd_desc
.sch_token
);
349 process_ac_flags(irq_ptr
, qdioac
);
350 DBF_EVENT("ac 1:%2x 2:%4x", qdioac
, irq_ptr
->ssqd_desc
.qdioac2
);
351 DBF_EVENT("3:%4x qib:%4x", irq_ptr
->ssqd_desc
.qdioac3
, irq_ptr
->qib
.ac
);
354 void qdio_release_memory(struct qdio_irq
*irq_ptr
)
360 * Must check queue array manually since irq_ptr->nr_input_queues /
361 * irq_ptr->nr_input_queues may not yet be set.
363 for (i
= 0; i
< QDIO_MAX_QUEUES_PER_IRQ
; i
++) {
364 q
= irq_ptr
->input_qs
[i
];
366 free_page((unsigned long) q
->slib
);
367 kmem_cache_free(qdio_q_cache
, q
);
370 for (i
= 0; i
< QDIO_MAX_QUEUES_PER_IRQ
; i
++) {
371 q
= irq_ptr
->output_qs
[i
];
373 if (q
->u
.out
.use_cq
) {
376 for (n
= 0; n
< QDIO_MAX_BUFFERS_PER_Q
; ++n
) {
377 struct qaob
*aob
= q
->u
.out
.aobs
[n
];
379 qdio_release_aob(aob
);
380 q
->u
.out
.aobs
[n
] = NULL
;
384 qdio_disable_async_operation(&q
->u
.out
);
386 free_page((unsigned long) q
->slib
);
387 kmem_cache_free(qdio_q_cache
, q
);
390 free_page((unsigned long) irq_ptr
->qdr
);
391 free_page(irq_ptr
->chsc_page
);
392 free_page((unsigned long) irq_ptr
);
395 static void __qdio_allocate_fill_qdr(struct qdio_irq
*irq_ptr
,
396 struct qdio_q
**irq_ptr_qs
,
399 irq_ptr
->qdr
->qdf0
[i
+ nr
].sliba
=
400 (unsigned long)irq_ptr_qs
[i
]->slib
;
402 irq_ptr
->qdr
->qdf0
[i
+ nr
].sla
=
403 (unsigned long)irq_ptr_qs
[i
]->sl
;
405 irq_ptr
->qdr
->qdf0
[i
+ nr
].slsba
=
406 (unsigned long)&irq_ptr_qs
[i
]->slsb
.val
[0];
408 irq_ptr
->qdr
->qdf0
[i
+ nr
].akey
= PAGE_DEFAULT_KEY
>> 4;
409 irq_ptr
->qdr
->qdf0
[i
+ nr
].bkey
= PAGE_DEFAULT_KEY
>> 4;
410 irq_ptr
->qdr
->qdf0
[i
+ nr
].ckey
= PAGE_DEFAULT_KEY
>> 4;
411 irq_ptr
->qdr
->qdf0
[i
+ nr
].dkey
= PAGE_DEFAULT_KEY
>> 4;
414 static void setup_qdr(struct qdio_irq
*irq_ptr
,
415 struct qdio_initialize
*qdio_init
)
419 irq_ptr
->qdr
->qfmt
= qdio_init
->q_format
;
420 irq_ptr
->qdr
->ac
= qdio_init
->qdr_ac
;
421 irq_ptr
->qdr
->iqdcnt
= qdio_init
->no_input_qs
;
422 irq_ptr
->qdr
->oqdcnt
= qdio_init
->no_output_qs
;
423 irq_ptr
->qdr
->iqdsz
= sizeof(struct qdesfmt0
) / 4; /* size in words */
424 irq_ptr
->qdr
->oqdsz
= sizeof(struct qdesfmt0
) / 4;
425 irq_ptr
->qdr
->qiba
= (unsigned long)&irq_ptr
->qib
;
426 irq_ptr
->qdr
->qkey
= PAGE_DEFAULT_KEY
>> 4;
428 for (i
= 0; i
< qdio_init
->no_input_qs
; i
++)
429 __qdio_allocate_fill_qdr(irq_ptr
, irq_ptr
->input_qs
, i
, 0);
431 for (i
= 0; i
< qdio_init
->no_output_qs
; i
++)
432 __qdio_allocate_fill_qdr(irq_ptr
, irq_ptr
->output_qs
, i
,
433 qdio_init
->no_input_qs
);
436 static void setup_qib(struct qdio_irq
*irq_ptr
,
437 struct qdio_initialize
*init_data
)
439 if (qebsm_possible())
440 irq_ptr
->qib
.rflags
|= QIB_RFLAGS_ENABLE_QEBSM
;
442 irq_ptr
->qib
.rflags
|= init_data
->qib_rflags
;
444 irq_ptr
->qib
.qfmt
= init_data
->q_format
;
445 if (init_data
->no_input_qs
)
446 irq_ptr
->qib
.isliba
=
447 (unsigned long)(irq_ptr
->input_qs
[0]->slib
);
448 if (init_data
->no_output_qs
)
449 irq_ptr
->qib
.osliba
=
450 (unsigned long)(irq_ptr
->output_qs
[0]->slib
);
451 memcpy(irq_ptr
->qib
.ebcnam
, init_data
->adapter_name
, 8);
454 int qdio_setup_irq(struct qdio_initialize
*init_data
)
457 struct qdio_irq
*irq_ptr
= init_data
->cdev
->private->qdio_data
;
459 memset(&irq_ptr
->qib
, 0, sizeof(irq_ptr
->qib
));
460 memset(&irq_ptr
->siga_flag
, 0, sizeof(irq_ptr
->siga_flag
));
461 memset(&irq_ptr
->ccw
, 0, sizeof(irq_ptr
->ccw
));
462 memset(&irq_ptr
->ssqd_desc
, 0, sizeof(irq_ptr
->ssqd_desc
));
463 memset(&irq_ptr
->perf_stat
, 0, sizeof(irq_ptr
->perf_stat
));
465 irq_ptr
->debugfs_dev
= irq_ptr
->debugfs_perf
= NULL
;
466 irq_ptr
->sch_token
= irq_ptr
->state
= irq_ptr
->perf_stat_enabled
= 0;
468 /* wipes qib.ac, required by ar7063 */
469 memset(irq_ptr
->qdr
, 0, sizeof(struct qdr
));
471 irq_ptr
->int_parm
= init_data
->int_parm
;
472 irq_ptr
->nr_input_qs
= init_data
->no_input_qs
;
473 irq_ptr
->nr_output_qs
= init_data
->no_output_qs
;
474 irq_ptr
->cdev
= init_data
->cdev
;
475 ccw_device_get_schid(irq_ptr
->cdev
, &irq_ptr
->schid
);
476 setup_queues(irq_ptr
, init_data
);
478 setup_qib(irq_ptr
, init_data
);
479 qdio_setup_thinint(irq_ptr
);
480 set_impl_params(irq_ptr
, init_data
->qib_param_field_format
,
481 init_data
->qib_param_field
,
482 init_data
->input_slib_elements
,
483 init_data
->output_slib_elements
);
485 /* fill input and output descriptors */
486 setup_qdr(irq_ptr
, init_data
);
488 /* qdr, qib, sls, slsbs, slibs, sbales are filled now */
490 /* get qdio commands */
491 ciw
= ccw_device_get_ciw(init_data
->cdev
, CIW_TYPE_EQUEUE
);
493 DBF_ERROR("%4x NO EQ", irq_ptr
->schid
.sch_no
);
496 irq_ptr
->equeue
= *ciw
;
498 ciw
= ccw_device_get_ciw(init_data
->cdev
, CIW_TYPE_AQUEUE
);
500 DBF_ERROR("%4x NO AQ", irq_ptr
->schid
.sch_no
);
503 irq_ptr
->aqueue
= *ciw
;
505 /* set new interrupt handler */
506 spin_lock_irq(get_ccwdev_lock(irq_ptr
->cdev
));
507 irq_ptr
->orig_handler
= init_data
->cdev
->handler
;
508 init_data
->cdev
->handler
= qdio_int_handler
;
509 spin_unlock_irq(get_ccwdev_lock(irq_ptr
->cdev
));
513 void qdio_print_subchannel_info(struct qdio_irq
*irq_ptr
,
514 struct ccw_device
*cdev
)
518 snprintf(s
, 80, "qdio: %s %s on SC %x using "
519 "AI:%d QEBSM:%d PRI:%d TDD:%d SIGA:%s%s%s%s%s\n",
520 dev_name(&cdev
->dev
),
521 (irq_ptr
->qib
.qfmt
== QDIO_QETH_QFMT
) ? "OSA" :
522 ((irq_ptr
->qib
.qfmt
== QDIO_ZFCP_QFMT
) ? "ZFCP" : "HS"),
523 irq_ptr
->schid
.sch_no
,
524 is_thinint_irq(irq_ptr
),
525 (irq_ptr
->sch_token
) ? 1 : 0,
526 (irq_ptr
->qib
.ac
& QIB_AC_OUTBOUND_PCI_SUPPORTED
) ? 1 : 0,
527 css_general_characteristics
.aif_tdd
,
528 (irq_ptr
->siga_flag
.input
) ? "R" : " ",
529 (irq_ptr
->siga_flag
.output
) ? "W" : " ",
530 (irq_ptr
->siga_flag
.sync
) ? "S" : " ",
531 (irq_ptr
->siga_flag
.sync_after_ai
) ? "A" : " ",
532 (irq_ptr
->siga_flag
.sync_out_after_pci
) ? "P" : " ");
533 printk(KERN_INFO
"%s", s
);
536 int qdio_enable_async_operation(struct qdio_output_q
*outq
)
538 outq
->aobs
= kcalloc(QDIO_MAX_BUFFERS_PER_Q
, sizeof(struct qaob
*),
548 void qdio_disable_async_operation(struct qdio_output_q
*q
)
555 int __init
qdio_setup_init(void)
559 qdio_q_cache
= kmem_cache_create("qdio_q", sizeof(struct qdio_q
),
564 qdio_aob_cache
= kmem_cache_create("qdio_aob",
569 if (!qdio_aob_cache
) {
571 goto free_qdio_q_cache
;
574 /* Check for OSA/FCP thin interrupts (bit 67). */
575 DBF_EVENT("thinint:%1d",
576 (css_general_characteristics
.aif_osa
) ? 1 : 0);
578 /* Check for QEBSM support in general (bit 58). */
579 DBF_EVENT("cssQEBSM:%1d", (qebsm_possible()) ? 1 : 0);
584 kmem_cache_destroy(qdio_q_cache
);
588 void qdio_setup_exit(void)
590 kmem_cache_destroy(qdio_aob_cache
);
591 kmem_cache_destroy(qdio_q_cache
);