Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright IBM Corp. 2016
4 * Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>
5 *
6 * Adjunct processor bus, queue related code.
7 */
8
9#define KMSG_COMPONENT "ap"
10#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11
12#include <linux/init.h>
13#include <linux/slab.h>
14#include <asm/facility.h>
15
16#include "ap_bus.h"
17#include "ap_debug.h"
18
19static void __ap_flush_queue(struct ap_queue *aq);
20
21/**
22 * ap_queue_enable_interruption(): Enable interruption on an AP queue.
23 * @qid: The AP queue number
24 * @ind: the notification indicator byte
25 *
26 * Enables interruption on AP queue via ap_aqic(). Based on the return
27 * value it waits a while and tests the AP queue if interrupts
28 * have been switched on using ap_test_queue().
29 */
30static int ap_queue_enable_interruption(struct ap_queue *aq, void *ind)
31{
32 struct ap_queue_status status;
33 struct ap_qirq_ctrl qirqctrl = { 0 };
34
35 qirqctrl.ir = 1;
36 qirqctrl.isc = AP_ISC;
37 status = ap_aqic(aq->qid, qirqctrl, ind);
38 switch (status.response_code) {
39 case AP_RESPONSE_NORMAL:
40 case AP_RESPONSE_OTHERWISE_CHANGED:
41 return 0;
42 case AP_RESPONSE_Q_NOT_AVAIL:
43 case AP_RESPONSE_DECONFIGURED:
44 case AP_RESPONSE_CHECKSTOPPED:
45 case AP_RESPONSE_INVALID_ADDRESS:
46 pr_err("Registering adapter interrupts for AP device %02x.%04x failed\n",
47 AP_QID_CARD(aq->qid),
48 AP_QID_QUEUE(aq->qid));
49 return -EOPNOTSUPP;
50 case AP_RESPONSE_RESET_IN_PROGRESS:
51 case AP_RESPONSE_BUSY:
52 default:
53 return -EBUSY;
54 }
55}
56
57/**
58 * __ap_send(): Send message to adjunct processor queue.
59 * @qid: The AP queue number
60 * @psmid: The program supplied message identifier
61 * @msg: The message text
62 * @length: The message length
63 * @special: Special Bit
64 *
65 * Returns AP queue status structure.
66 * Condition code 1 on NQAP can't happen because the L bit is 1.
67 * Condition code 2 on NQAP also means the send is incomplete,
68 * because a segment boundary was reached. The NQAP is repeated.
69 */
70static inline struct ap_queue_status
71__ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length,
72 int special)
73{
74 if (special)
75 qid |= 0x400000UL;
76 return ap_nqap(qid, psmid, msg, length);
77}
78
79int ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length)
80{
81 struct ap_queue_status status;
82
83 status = __ap_send(qid, psmid, msg, length, 0);
84 switch (status.response_code) {
85 case AP_RESPONSE_NORMAL:
86 return 0;
87 case AP_RESPONSE_Q_FULL:
88 case AP_RESPONSE_RESET_IN_PROGRESS:
89 return -EBUSY;
90 case AP_RESPONSE_REQ_FAC_NOT_INST:
91 return -EINVAL;
92 default: /* Device is gone. */
93 return -ENODEV;
94 }
95}
96EXPORT_SYMBOL(ap_send);
97
98int ap_recv(ap_qid_t qid, unsigned long long *psmid, void *msg, size_t length)
99{
100 struct ap_queue_status status;
101
102 if (msg == NULL)
103 return -EINVAL;
104 status = ap_dqap(qid, psmid, msg, length);
105 switch (status.response_code) {
106 case AP_RESPONSE_NORMAL:
107 return 0;
108 case AP_RESPONSE_NO_PENDING_REPLY:
109 if (status.queue_empty)
110 return -ENOENT;
111 return -EBUSY;
112 case AP_RESPONSE_RESET_IN_PROGRESS:
113 return -EBUSY;
114 default:
115 return -ENODEV;
116 }
117}
118EXPORT_SYMBOL(ap_recv);
119
120/* State machine definitions and helpers */
121
122static enum ap_sm_wait ap_sm_nop(struct ap_queue *aq)
123{
124 return AP_SM_WAIT_NONE;
125}
126
127/**
128 * ap_sm_recv(): Receive pending reply messages from an AP queue but do
129 * not change the state of the device.
130 * @aq: pointer to the AP queue
131 *
132 * Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT
133 */
134static struct ap_queue_status ap_sm_recv(struct ap_queue *aq)
135{
136 struct ap_queue_status status;
137 struct ap_message *ap_msg;
138
139 status = ap_dqap(aq->qid, &aq->reply->psmid,
140 aq->reply->msg, aq->reply->len);
141 switch (status.response_code) {
142 case AP_RESPONSE_NORMAL:
143 aq->queue_count--;
144 if (aq->queue_count > 0)
145 mod_timer(&aq->timeout,
146 jiffies + aq->request_timeout);
147 list_for_each_entry(ap_msg, &aq->pendingq, list) {
148 if (ap_msg->psmid != aq->reply->psmid)
149 continue;
150 list_del_init(&ap_msg->list);
151 aq->pendingq_count--;
152 ap_msg->receive(aq, ap_msg, aq->reply);
153 break;
154 }
155 fallthrough;
156 case AP_RESPONSE_NO_PENDING_REPLY:
157 if (!status.queue_empty || aq->queue_count <= 0)
158 break;
159 /* The card shouldn't forget requests but who knows. */
160 aq->queue_count = 0;
161 list_splice_init(&aq->pendingq, &aq->requestq);
162 aq->requestq_count += aq->pendingq_count;
163 aq->pendingq_count = 0;
164 break;
165 default:
166 break;
167 }
168 return status;
169}
170
171/**
172 * ap_sm_read(): Receive pending reply messages from an AP queue.
173 * @aq: pointer to the AP queue
174 *
175 * Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT
176 */
177static enum ap_sm_wait ap_sm_read(struct ap_queue *aq)
178{
179 struct ap_queue_status status;
180
181 if (!aq->reply)
182 return AP_SM_WAIT_NONE;
183 status = ap_sm_recv(aq);
184 switch (status.response_code) {
185 case AP_RESPONSE_NORMAL:
186 if (aq->queue_count > 0) {
187 aq->sm_state = AP_SM_STATE_WORKING;
188 return AP_SM_WAIT_AGAIN;
189 }
190 aq->sm_state = AP_SM_STATE_IDLE;
191 return AP_SM_WAIT_NONE;
192 case AP_RESPONSE_NO_PENDING_REPLY:
193 if (aq->queue_count > 0)
194 return AP_SM_WAIT_INTERRUPT;
195 aq->sm_state = AP_SM_STATE_IDLE;
196 return AP_SM_WAIT_NONE;
197 default:
198 aq->sm_state = AP_SM_STATE_BORKED;
199 return AP_SM_WAIT_NONE;
200 }
201}
202
203/**
204 * ap_sm_write(): Send messages from the request queue to an AP queue.
205 * @aq: pointer to the AP queue
206 *
207 * Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT
208 */
209static enum ap_sm_wait ap_sm_write(struct ap_queue *aq)
210{
211 struct ap_queue_status status;
212 struct ap_message *ap_msg;
213
214 if (aq->requestq_count <= 0)
215 return AP_SM_WAIT_NONE;
216 /* Start the next request on the queue. */
217 ap_msg = list_entry(aq->requestq.next, struct ap_message, list);
218 status = __ap_send(aq->qid, ap_msg->psmid,
219 ap_msg->msg, ap_msg->len,
220 ap_msg->flags & AP_MSG_FLAG_SPECIAL);
221 switch (status.response_code) {
222 case AP_RESPONSE_NORMAL:
223 aq->queue_count++;
224 if (aq->queue_count == 1)
225 mod_timer(&aq->timeout, jiffies + aq->request_timeout);
226 list_move_tail(&ap_msg->list, &aq->pendingq);
227 aq->requestq_count--;
228 aq->pendingq_count++;
229 if (aq->queue_count < aq->card->queue_depth) {
230 aq->sm_state = AP_SM_STATE_WORKING;
231 return AP_SM_WAIT_AGAIN;
232 }
233 fallthrough;
234 case AP_RESPONSE_Q_FULL:
235 aq->sm_state = AP_SM_STATE_QUEUE_FULL;
236 return AP_SM_WAIT_INTERRUPT;
237 case AP_RESPONSE_RESET_IN_PROGRESS:
238 aq->sm_state = AP_SM_STATE_RESET_WAIT;
239 return AP_SM_WAIT_TIMEOUT;
240 case AP_RESPONSE_MESSAGE_TOO_BIG:
241 case AP_RESPONSE_REQ_FAC_NOT_INST:
242 list_del_init(&ap_msg->list);
243 aq->requestq_count--;
244 ap_msg->rc = -EINVAL;
245 ap_msg->receive(aq, ap_msg, NULL);
246 return AP_SM_WAIT_AGAIN;
247 default:
248 aq->sm_state = AP_SM_STATE_BORKED;
249 return AP_SM_WAIT_NONE;
250 }
251}
252
253/**
254 * ap_sm_read_write(): Send and receive messages to/from an AP queue.
255 * @aq: pointer to the AP queue
256 *
257 * Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT
258 */
259static enum ap_sm_wait ap_sm_read_write(struct ap_queue *aq)
260{
261 return min(ap_sm_read(aq), ap_sm_write(aq));
262}
263
264/**
265 * ap_sm_reset(): Reset an AP queue.
266 * @qid: The AP queue number
267 *
268 * Submit the Reset command to an AP queue.
269 */
270static enum ap_sm_wait ap_sm_reset(struct ap_queue *aq)
271{
272 struct ap_queue_status status;
273
274 status = ap_rapq(aq->qid);
275 switch (status.response_code) {
276 case AP_RESPONSE_NORMAL:
277 case AP_RESPONSE_RESET_IN_PROGRESS:
278 aq->sm_state = AP_SM_STATE_RESET_WAIT;
279 aq->interrupt = AP_INTR_DISABLED;
280 return AP_SM_WAIT_TIMEOUT;
281 case AP_RESPONSE_BUSY:
282 return AP_SM_WAIT_TIMEOUT;
283 case AP_RESPONSE_Q_NOT_AVAIL:
284 case AP_RESPONSE_DECONFIGURED:
285 case AP_RESPONSE_CHECKSTOPPED:
286 default:
287 aq->sm_state = AP_SM_STATE_BORKED;
288 return AP_SM_WAIT_NONE;
289 }
290}
291
292/**
293 * ap_sm_reset_wait(): Test queue for completion of the reset operation
294 * @aq: pointer to the AP queue
295 *
296 * Returns AP_POLL_IMMEDIATELY, AP_POLL_AFTER_TIMEROUT or 0.
297 */
298static enum ap_sm_wait ap_sm_reset_wait(struct ap_queue *aq)
299{
300 struct ap_queue_status status;
301 void *lsi_ptr;
302
303 if (aq->queue_count > 0 && aq->reply)
304 /* Try to read a completed message and get the status */
305 status = ap_sm_recv(aq);
306 else
307 /* Get the status with TAPQ */
308 status = ap_tapq(aq->qid, NULL);
309
310 switch (status.response_code) {
311 case AP_RESPONSE_NORMAL:
312 lsi_ptr = ap_airq_ptr();
313 if (lsi_ptr && ap_queue_enable_interruption(aq, lsi_ptr) == 0)
314 aq->sm_state = AP_SM_STATE_SETIRQ_WAIT;
315 else
316 aq->sm_state = (aq->queue_count > 0) ?
317 AP_SM_STATE_WORKING : AP_SM_STATE_IDLE;
318 return AP_SM_WAIT_AGAIN;
319 case AP_RESPONSE_BUSY:
320 case AP_RESPONSE_RESET_IN_PROGRESS:
321 return AP_SM_WAIT_TIMEOUT;
322 case AP_RESPONSE_Q_NOT_AVAIL:
323 case AP_RESPONSE_DECONFIGURED:
324 case AP_RESPONSE_CHECKSTOPPED:
325 default:
326 aq->sm_state = AP_SM_STATE_BORKED;
327 return AP_SM_WAIT_NONE;
328 }
329}
330
331/**
332 * ap_sm_setirq_wait(): Test queue for completion of the irq enablement
333 * @aq: pointer to the AP queue
334 *
335 * Returns AP_POLL_IMMEDIATELY, AP_POLL_AFTER_TIMEROUT or 0.
336 */
337static enum ap_sm_wait ap_sm_setirq_wait(struct ap_queue *aq)
338{
339 struct ap_queue_status status;
340
341 if (aq->queue_count > 0 && aq->reply)
342 /* Try to read a completed message and get the status */
343 status = ap_sm_recv(aq);
344 else
345 /* Get the status with TAPQ */
346 status = ap_tapq(aq->qid, NULL);
347
348 if (status.irq_enabled == 1) {
349 /* Irqs are now enabled */
350 aq->interrupt = AP_INTR_ENABLED;
351 aq->sm_state = (aq->queue_count > 0) ?
352 AP_SM_STATE_WORKING : AP_SM_STATE_IDLE;
353 }
354
355 switch (status.response_code) {
356 case AP_RESPONSE_NORMAL:
357 if (aq->queue_count > 0)
358 return AP_SM_WAIT_AGAIN;
359 fallthrough;
360 case AP_RESPONSE_NO_PENDING_REPLY:
361 return AP_SM_WAIT_TIMEOUT;
362 default:
363 aq->sm_state = AP_SM_STATE_BORKED;
364 return AP_SM_WAIT_NONE;
365 }
366}
367
368/*
369 * AP state machine jump table
370 */
371static ap_func_t *ap_jumptable[NR_AP_SM_STATES][NR_AP_SM_EVENTS] = {
372 [AP_SM_STATE_RESET_START] = {
373 [AP_SM_EVENT_POLL] = ap_sm_reset,
374 [AP_SM_EVENT_TIMEOUT] = ap_sm_nop,
375 },
376 [AP_SM_STATE_RESET_WAIT] = {
377 [AP_SM_EVENT_POLL] = ap_sm_reset_wait,
378 [AP_SM_EVENT_TIMEOUT] = ap_sm_nop,
379 },
380 [AP_SM_STATE_SETIRQ_WAIT] = {
381 [AP_SM_EVENT_POLL] = ap_sm_setirq_wait,
382 [AP_SM_EVENT_TIMEOUT] = ap_sm_nop,
383 },
384 [AP_SM_STATE_IDLE] = {
385 [AP_SM_EVENT_POLL] = ap_sm_write,
386 [AP_SM_EVENT_TIMEOUT] = ap_sm_nop,
387 },
388 [AP_SM_STATE_WORKING] = {
389 [AP_SM_EVENT_POLL] = ap_sm_read_write,
390 [AP_SM_EVENT_TIMEOUT] = ap_sm_reset,
391 },
392 [AP_SM_STATE_QUEUE_FULL] = {
393 [AP_SM_EVENT_POLL] = ap_sm_read,
394 [AP_SM_EVENT_TIMEOUT] = ap_sm_reset,
395 },
396 [AP_SM_STATE_REMOVE] = {
397 [AP_SM_EVENT_POLL] = ap_sm_nop,
398 [AP_SM_EVENT_TIMEOUT] = ap_sm_nop,
399 },
400 [AP_SM_STATE_UNBOUND] = {
401 [AP_SM_EVENT_POLL] = ap_sm_nop,
402 [AP_SM_EVENT_TIMEOUT] = ap_sm_nop,
403 },
404 [AP_SM_STATE_BORKED] = {
405 [AP_SM_EVENT_POLL] = ap_sm_nop,
406 [AP_SM_EVENT_TIMEOUT] = ap_sm_nop,
407 },
408};
409
410enum ap_sm_wait ap_sm_event(struct ap_queue *aq, enum ap_sm_event event)
411{
412 return ap_jumptable[aq->sm_state][event](aq);
413}
414
415enum ap_sm_wait ap_sm_event_loop(struct ap_queue *aq, enum ap_sm_event event)
416{
417 enum ap_sm_wait wait;
418
419 while ((wait = ap_sm_event(aq, event)) == AP_SM_WAIT_AGAIN)
420 ;
421 return wait;
422}
423
424/*
425 * AP queue related attributes.
426 */
427static ssize_t request_count_show(struct device *dev,
428 struct device_attribute *attr,
429 char *buf)
430{
431 struct ap_queue *aq = to_ap_queue(dev);
432 u64 req_cnt;
433
434 spin_lock_bh(&aq->lock);
435 req_cnt = aq->total_request_count;
436 spin_unlock_bh(&aq->lock);
437 return scnprintf(buf, PAGE_SIZE, "%llu\n", req_cnt);
438}
439
440static ssize_t request_count_store(struct device *dev,
441 struct device_attribute *attr,
442 const char *buf, size_t count)
443{
444 struct ap_queue *aq = to_ap_queue(dev);
445
446 spin_lock_bh(&aq->lock);
447 aq->total_request_count = 0;
448 spin_unlock_bh(&aq->lock);
449
450 return count;
451}
452
453static DEVICE_ATTR_RW(request_count);
454
455static ssize_t requestq_count_show(struct device *dev,
456 struct device_attribute *attr, char *buf)
457{
458 struct ap_queue *aq = to_ap_queue(dev);
459 unsigned int reqq_cnt = 0;
460
461 spin_lock_bh(&aq->lock);
462 reqq_cnt = aq->requestq_count;
463 spin_unlock_bh(&aq->lock);
464 return scnprintf(buf, PAGE_SIZE, "%d\n", reqq_cnt);
465}
466
467static DEVICE_ATTR_RO(requestq_count);
468
469static ssize_t pendingq_count_show(struct device *dev,
470 struct device_attribute *attr, char *buf)
471{
472 struct ap_queue *aq = to_ap_queue(dev);
473 unsigned int penq_cnt = 0;
474
475 spin_lock_bh(&aq->lock);
476 penq_cnt = aq->pendingq_count;
477 spin_unlock_bh(&aq->lock);
478 return scnprintf(buf, PAGE_SIZE, "%d\n", penq_cnt);
479}
480
481static DEVICE_ATTR_RO(pendingq_count);
482
483static ssize_t reset_show(struct device *dev,
484 struct device_attribute *attr, char *buf)
485{
486 struct ap_queue *aq = to_ap_queue(dev);
487 int rc = 0;
488
489 spin_lock_bh(&aq->lock);
490 switch (aq->sm_state) {
491 case AP_SM_STATE_RESET_START:
492 case AP_SM_STATE_RESET_WAIT:
493 rc = scnprintf(buf, PAGE_SIZE, "Reset in progress.\n");
494 break;
495 case AP_SM_STATE_WORKING:
496 case AP_SM_STATE_QUEUE_FULL:
497 rc = scnprintf(buf, PAGE_SIZE, "Reset Timer armed.\n");
498 break;
499 default:
500 rc = scnprintf(buf, PAGE_SIZE, "No Reset Timer set.\n");
501 }
502 spin_unlock_bh(&aq->lock);
503 return rc;
504}
505
506static ssize_t reset_store(struct device *dev,
507 struct device_attribute *attr,
508 const char *buf, size_t count)
509{
510 struct ap_queue *aq = to_ap_queue(dev);
511
512 spin_lock_bh(&aq->lock);
513 __ap_flush_queue(aq);
514 aq->sm_state = AP_SM_STATE_RESET_START;
515 ap_wait(ap_sm_event(aq, AP_SM_EVENT_POLL));
516 spin_unlock_bh(&aq->lock);
517
518 AP_DBF(DBF_INFO, "reset queue=%02x.%04x triggered by user\n",
519 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid));
520
521 return count;
522}
523
524static DEVICE_ATTR_RW(reset);
525
526static ssize_t interrupt_show(struct device *dev,
527 struct device_attribute *attr, char *buf)
528{
529 struct ap_queue *aq = to_ap_queue(dev);
530 int rc = 0;
531
532 spin_lock_bh(&aq->lock);
533 if (aq->sm_state == AP_SM_STATE_SETIRQ_WAIT)
534 rc = scnprintf(buf, PAGE_SIZE, "Enable Interrupt pending.\n");
535 else if (aq->interrupt == AP_INTR_ENABLED)
536 rc = scnprintf(buf, PAGE_SIZE, "Interrupts enabled.\n");
537 else
538 rc = scnprintf(buf, PAGE_SIZE, "Interrupts disabled.\n");
539 spin_unlock_bh(&aq->lock);
540 return rc;
541}
542
543static DEVICE_ATTR_RO(interrupt);
544
545static struct attribute *ap_queue_dev_attrs[] = {
546 &dev_attr_request_count.attr,
547 &dev_attr_requestq_count.attr,
548 &dev_attr_pendingq_count.attr,
549 &dev_attr_reset.attr,
550 &dev_attr_interrupt.attr,
551 NULL
552};
553
554static struct attribute_group ap_queue_dev_attr_group = {
555 .attrs = ap_queue_dev_attrs
556};
557
558static const struct attribute_group *ap_queue_dev_attr_groups[] = {
559 &ap_queue_dev_attr_group,
560 NULL
561};
562
563static struct device_type ap_queue_type = {
564 .name = "ap_queue",
565 .groups = ap_queue_dev_attr_groups,
566};
567
568static void ap_queue_device_release(struct device *dev)
569{
570 struct ap_queue *aq = to_ap_queue(dev);
571
572 spin_lock_bh(&ap_queues_lock);
573 hash_del(&aq->hnode);
574 spin_unlock_bh(&ap_queues_lock);
575
576 kfree(aq);
577}
578
579struct ap_queue *ap_queue_create(ap_qid_t qid, int device_type)
580{
581 struct ap_queue *aq;
582
583 aq = kzalloc(sizeof(*aq), GFP_KERNEL);
584 if (!aq)
585 return NULL;
586 aq->ap_dev.device.release = ap_queue_device_release;
587 aq->ap_dev.device.type = &ap_queue_type;
588 aq->ap_dev.device_type = device_type;
589 aq->qid = qid;
590 aq->sm_state = AP_SM_STATE_UNBOUND;
591 aq->interrupt = AP_INTR_DISABLED;
592 spin_lock_init(&aq->lock);
593 INIT_LIST_HEAD(&aq->pendingq);
594 INIT_LIST_HEAD(&aq->requestq);
595 timer_setup(&aq->timeout, ap_request_timeout, 0);
596
597 return aq;
598}
599
600void ap_queue_init_reply(struct ap_queue *aq, struct ap_message *reply)
601{
602 aq->reply = reply;
603
604 spin_lock_bh(&aq->lock);
605 ap_wait(ap_sm_event(aq, AP_SM_EVENT_POLL));
606 spin_unlock_bh(&aq->lock);
607}
608EXPORT_SYMBOL(ap_queue_init_reply);
609
610/**
611 * ap_queue_message(): Queue a request to an AP device.
612 * @aq: The AP device to queue the message to
613 * @ap_msg: The message that is to be added
614 */
615void ap_queue_message(struct ap_queue *aq, struct ap_message *ap_msg)
616{
617 /* For asynchronous message handling a valid receive-callback
618 * is required.
619 */
620 BUG_ON(!ap_msg->receive);
621
622 spin_lock_bh(&aq->lock);
623 /* Queue the message. */
624 list_add_tail(&ap_msg->list, &aq->requestq);
625 aq->requestq_count++;
626 aq->total_request_count++;
627 atomic64_inc(&aq->card->total_request_count);
628 /* Send/receive as many request from the queue as possible. */
629 ap_wait(ap_sm_event_loop(aq, AP_SM_EVENT_POLL));
630 spin_unlock_bh(&aq->lock);
631}
632EXPORT_SYMBOL(ap_queue_message);
633
634/**
635 * ap_cancel_message(): Cancel a crypto request.
636 * @aq: The AP device that has the message queued
637 * @ap_msg: The message that is to be removed
638 *
639 * Cancel a crypto request. This is done by removing the request
640 * from the device pending or request queue. Note that the
641 * request stays on the AP queue. When it finishes the message
642 * reply will be discarded because the psmid can't be found.
643 */
644void ap_cancel_message(struct ap_queue *aq, struct ap_message *ap_msg)
645{
646 struct ap_message *tmp;
647
648 spin_lock_bh(&aq->lock);
649 if (!list_empty(&ap_msg->list)) {
650 list_for_each_entry(tmp, &aq->pendingq, list)
651 if (tmp->psmid == ap_msg->psmid) {
652 aq->pendingq_count--;
653 goto found;
654 }
655 aq->requestq_count--;
656found:
657 list_del_init(&ap_msg->list);
658 }
659 spin_unlock_bh(&aq->lock);
660}
661EXPORT_SYMBOL(ap_cancel_message);
662
663/**
664 * __ap_flush_queue(): Flush requests.
665 * @aq: Pointer to the AP queue
666 *
667 * Flush all requests from the request/pending queue of an AP device.
668 */
669static void __ap_flush_queue(struct ap_queue *aq)
670{
671 struct ap_message *ap_msg, *next;
672
673 list_for_each_entry_safe(ap_msg, next, &aq->pendingq, list) {
674 list_del_init(&ap_msg->list);
675 aq->pendingq_count--;
676 ap_msg->rc = -EAGAIN;
677 ap_msg->receive(aq, ap_msg, NULL);
678 }
679 list_for_each_entry_safe(ap_msg, next, &aq->requestq, list) {
680 list_del_init(&ap_msg->list);
681 aq->requestq_count--;
682 ap_msg->rc = -EAGAIN;
683 ap_msg->receive(aq, ap_msg, NULL);
684 }
685 aq->queue_count = 0;
686}
687
688void ap_flush_queue(struct ap_queue *aq)
689{
690 spin_lock_bh(&aq->lock);
691 __ap_flush_queue(aq);
692 spin_unlock_bh(&aq->lock);
693}
694EXPORT_SYMBOL(ap_flush_queue);
695
696void ap_queue_prepare_remove(struct ap_queue *aq)
697{
698 spin_lock_bh(&aq->lock);
699 /* flush queue */
700 __ap_flush_queue(aq);
701 /* set REMOVE state to prevent new messages are queued in */
702 aq->sm_state = AP_SM_STATE_REMOVE;
703 spin_unlock_bh(&aq->lock);
704 del_timer_sync(&aq->timeout);
705}
706
707void ap_queue_remove(struct ap_queue *aq)
708{
709 /*
710 * all messages have been flushed and the state is
711 * AP_SM_STATE_REMOVE. Now reset with zero which also
712 * clears the irq registration and move the state
713 * to AP_SM_STATE_UNBOUND to signal that this queue
714 * is not used by any driver currently.
715 */
716 spin_lock_bh(&aq->lock);
717 ap_zapq(aq->qid);
718 aq->sm_state = AP_SM_STATE_UNBOUND;
719 spin_unlock_bh(&aq->lock);
720}
721
722void ap_queue_init_state(struct ap_queue *aq)
723{
724 spin_lock_bh(&aq->lock);
725 aq->sm_state = AP_SM_STATE_RESET_START;
726 ap_wait(ap_sm_event(aq, AP_SM_EVENT_POLL));
727 spin_unlock_bh(&aq->lock);
728}
729EXPORT_SYMBOL(ap_queue_init_state);