2 * linux/drivers/s390/crypto/ap_bus.c
4 * Copyright (C) 2006 IBM Corporation
5 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
6 * Martin Schwidefsky <schwidefsky@de.ibm.com>
7 * Ralph Wuerthner <rwuerthn@de.ibm.com>
9 * Adjunct processor bus.
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2, or (at your option)
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 #include <linux/module.h>
27 #include <linux/init.h>
28 #include <linux/delay.h>
29 #include <linux/err.h>
30 #include <linux/interrupt.h>
31 #include <linux/workqueue.h>
32 #include <linux/notifier.h>
33 #include <linux/kthread.h>
34 #include <linux/mutex.h>
35 #include <asm/s390_rdev.h>
39 /* Some prototypes. */
40 static void ap_scan_bus(void *);
41 static void ap_poll_all(unsigned long);
42 static void ap_poll_timeout(unsigned long);
43 static int ap_poll_thread_start(void);
44 static void ap_poll_thread_stop(void);
49 MODULE_AUTHOR("IBM Corporation");
50 MODULE_DESCRIPTION("Adjunct Processor Bus driver, "
51 "Copyright 2006 IBM Corporation");
52 MODULE_LICENSE("GPL");
57 int ap_domain_index = -1; /* Adjunct Processor Domain Index */
58 module_param_named(domain, ap_domain_index, int, 0000);
59 MODULE_PARM_DESC(domain, "domain index for ap devices");
60 EXPORT_SYMBOL(ap_domain_index);
62 static int ap_thread_flag = 1;
63 module_param_named(poll_thread, ap_thread_flag, int, 0000);
64 MODULE_PARM_DESC(poll_thread, "Turn on/off poll thread, default is 1 (on).");
66 static struct device *ap_root_device = NULL;
69 * Workqueue & timer for bus rescan.
71 static struct workqueue_struct *ap_work_queue;
72 static struct timer_list ap_config_timer;
73 static int ap_config_time = AP_CONFIG_TIME;
74 static DECLARE_WORK(ap_config_work, ap_scan_bus, NULL);
77 * Tasklet & timer for AP request polling.
79 static struct timer_list ap_poll_timer = TIMER_INITIALIZER(ap_poll_timeout,0,0);
80 static DECLARE_TASKLET(ap_tasklet, ap_poll_all, 0);
81 static atomic_t ap_poll_requests = ATOMIC_INIT(0);
82 static DECLARE_WAIT_QUEUE_HEAD(ap_poll_wait);
83 static struct task_struct *ap_poll_kthread = NULL;
84 static DEFINE_MUTEX(ap_poll_thread_mutex);
87 * Test if ap instructions are available.
89 * Returns 0 if the ap instructions are installed.
91 static inline int ap_instructions_available(void)
93 register unsigned long reg0 asm ("0") = AP_MKQID(0,0);
94 register unsigned long reg1 asm ("1") = -ENODEV;
95 register unsigned long reg2 asm ("2") = 0UL;
98 " .long 0xb2af0000\n" /* PQAP(TAPQ) */
102 : "+d" (reg0), "+d" (reg1), "+d" (reg2) : : "cc" );
107 * Test adjunct processor queue.
108 * @qid: the ap queue number
109 * @queue_depth: pointer to queue depth value
110 * @device_type: pointer to device type value
112 * Returns ap queue status structure.
114 static inline struct ap_queue_status
115 ap_test_queue(ap_qid_t qid, int *queue_depth, int *device_type)
117 register unsigned long reg0 asm ("0") = qid;
118 register struct ap_queue_status reg1 asm ("1");
119 register unsigned long reg2 asm ("2") = 0UL;
121 asm volatile(".long 0xb2af0000" /* PQAP(TAPQ) */
122 : "+d" (reg0), "=d" (reg1), "+d" (reg2) : : "cc");
123 *device_type = (int) (reg2 >> 24);
124 *queue_depth = (int) (reg2 & 0xff);
129 * Reset adjunct processor queue.
130 * @qid: the ap queue number
132 * Returns ap queue status structure.
134 static inline struct ap_queue_status ap_reset_queue(ap_qid_t qid)
136 register unsigned long reg0 asm ("0") = qid | 0x01000000UL;
137 register struct ap_queue_status reg1 asm ("1");
138 register unsigned long reg2 asm ("2") = 0UL;
141 ".long 0xb2af0000" /* PQAP(RAPQ) */
142 : "+d" (reg0), "=d" (reg1), "+d" (reg2) : : "cc");
147 * Send message to adjunct processor queue.
148 * @qid: the ap queue number
149 * @psmid: the program supplied message identifier
150 * @msg: the message text
151 * @length: the message length
153 * Returns ap queue status structure.
155 * Condition code 1 on NQAP can't happen because the L bit is 1.
157 * Condition code 2 on NQAP also means the send is incomplete,
158 * because a segment boundary was reached. The NQAP is repeated.
160 static inline struct ap_queue_status
161 __ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length)
163 typedef struct { char _[length]; } msgblock;
164 register unsigned long reg0 asm ("0") = qid | 0x40000000UL;
165 register struct ap_queue_status reg1 asm ("1");
166 register unsigned long reg2 asm ("2") = (unsigned long) msg;
167 register unsigned long reg3 asm ("3") = (unsigned long) length;
168 register unsigned long reg4 asm ("4") = (unsigned int) (psmid >> 32);
169 register unsigned long reg5 asm ("5") = (unsigned int) psmid;
172 "0: .long 0xb2ad0042\n" /* DQAP */
174 : "+d" (reg0), "=d" (reg1), "+d" (reg2), "+d" (reg3)
175 : "d" (reg4), "d" (reg5), "m" (*(msgblock *) msg)
180 int ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length)
182 struct ap_queue_status status;
184 status = __ap_send(qid, psmid, msg, length);
185 switch (status.response_code) {
186 case AP_RESPONSE_NORMAL:
188 case AP_RESPONSE_Q_FULL:
190 default: /* Device is gone. */
194 EXPORT_SYMBOL(ap_send);
197 * Receive message from adjunct processor queue.
198 * @qid: the ap queue number
199 * @psmid: pointer to program supplied message identifier
200 * @msg: the message text
201 * @length: the message length
203 * Returns ap queue status structure.
205 * Condition code 1 on DQAP means the receive has taken place
206 * but only partially. The response is incomplete, hence the
209 * Condition code 2 on DQAP also means the receive is incomplete,
210 * this time because a segment boundary was reached. Again, the
213 * Note that gpr2 is used by the DQAP instruction to keep track of
214 * any 'residual' length, in case the instruction gets interrupted.
215 * Hence it gets zeroed before the instruction.
217 static inline struct ap_queue_status
218 __ap_recv(ap_qid_t qid, unsigned long long *psmid, void *msg, size_t length)
220 typedef struct { char _[length]; } msgblock;
221 register unsigned long reg0 asm("0") = qid | 0x80000000UL;
222 register struct ap_queue_status reg1 asm ("1");
223 register unsigned long reg2 asm("2") = 0UL;
224 register unsigned long reg4 asm("4") = (unsigned long) msg;
225 register unsigned long reg5 asm("5") = (unsigned long) length;
226 register unsigned long reg6 asm("6") = 0UL;
227 register unsigned long reg7 asm("7") = 0UL;
231 "0: .long 0xb2ae0064\n"
233 : "+d" (reg0), "=d" (reg1), "+d" (reg2),
234 "+d" (reg4), "+d" (reg5), "+d" (reg6), "+d" (reg7),
235 "=m" (*(msgblock *) msg) : : "cc" );
236 *psmid = (((unsigned long long) reg6) << 32) + reg7;
240 int ap_recv(ap_qid_t qid, unsigned long long *psmid, void *msg, size_t length)
242 struct ap_queue_status status;
244 status = __ap_recv(qid, psmid, msg, length);
245 switch (status.response_code) {
246 case AP_RESPONSE_NORMAL:
248 case AP_RESPONSE_NO_PENDING_REPLY:
249 if (status.queue_empty)
256 EXPORT_SYMBOL(ap_recv);
259 * Check if an AP queue is available. The test is repeated for
260 * AP_MAX_RESET times.
261 * @qid: the ap queue number
262 * @queue_depth: pointer to queue depth value
263 * @device_type: pointer to device type value
265 static int ap_query_queue(ap_qid_t qid, int *queue_depth, int *device_type)
267 struct ap_queue_status status;
268 int t_depth, t_device_type, rc, i;
271 for (i = 0; i < AP_MAX_RESET; i++) {
272 status = ap_test_queue(qid, &t_depth, &t_device_type);
273 switch (status.response_code) {
274 case AP_RESPONSE_NORMAL:
275 *queue_depth = t_depth + 1;
276 *device_type = t_device_type;
279 case AP_RESPONSE_Q_NOT_AVAIL:
282 case AP_RESPONSE_RESET_IN_PROGRESS:
284 case AP_RESPONSE_DECONFIGURED:
287 case AP_RESPONSE_CHECKSTOPPED:
290 case AP_RESPONSE_BUSY:
297 if (i < AP_MAX_RESET - 1)
304 * Reset an AP queue and wait for it to become available again.
305 * @qid: the ap queue number
307 static int ap_init_queue(ap_qid_t qid)
309 struct ap_queue_status status;
313 status = ap_reset_queue(qid);
314 for (i = 0; i < AP_MAX_RESET; i++) {
315 switch (status.response_code) {
316 case AP_RESPONSE_NORMAL:
317 if (status.queue_empty)
320 case AP_RESPONSE_Q_NOT_AVAIL:
321 case AP_RESPONSE_DECONFIGURED:
322 case AP_RESPONSE_CHECKSTOPPED:
323 i = AP_MAX_RESET; /* return with -ENODEV */
325 case AP_RESPONSE_RESET_IN_PROGRESS:
326 case AP_RESPONSE_BUSY:
332 if (i < AP_MAX_RESET - 1) {
334 status = ap_test_queue(qid, &dummy, &dummy);
341 * AP device related attributes.
343 static ssize_t ap_hwtype_show(struct device *dev,
344 struct device_attribute *attr, char *buf)
346 struct ap_device *ap_dev = to_ap_dev(dev);
347 return snprintf(buf, PAGE_SIZE, "%d\n", ap_dev->device_type);
349 static DEVICE_ATTR(hwtype, 0444, ap_hwtype_show, NULL);
351 static ssize_t ap_depth_show(struct device *dev, struct device_attribute *attr,
354 struct ap_device *ap_dev = to_ap_dev(dev);
355 return snprintf(buf, PAGE_SIZE, "%d\n", ap_dev->queue_depth);
357 static DEVICE_ATTR(depth, 0444, ap_depth_show, NULL);
359 static ssize_t ap_request_count_show(struct device *dev,
360 struct device_attribute *attr,
363 struct ap_device *ap_dev = to_ap_dev(dev);
366 spin_lock_bh(&ap_dev->lock);
367 rc = snprintf(buf, PAGE_SIZE, "%d\n", ap_dev->total_request_count);
368 spin_unlock_bh(&ap_dev->lock);
372 static DEVICE_ATTR(request_count, 0444, ap_request_count_show, NULL);
374 static ssize_t ap_modalias_show(struct device *dev,
375 struct device_attribute *attr, char *buf)
377 return sprintf(buf, "ap:t%02X", to_ap_dev(dev)->device_type);
380 static DEVICE_ATTR(modalias, 0444, ap_modalias_show, NULL);
382 static struct attribute *ap_dev_attrs[] = {
383 &dev_attr_hwtype.attr,
384 &dev_attr_depth.attr,
385 &dev_attr_request_count.attr,
386 &dev_attr_modalias.attr,
389 static struct attribute_group ap_dev_attr_group = {
390 .attrs = ap_dev_attrs
394 * AP bus driver registration/unregistration.
396 static int ap_bus_match(struct device *dev, struct device_driver *drv)
398 struct ap_device *ap_dev = to_ap_dev(dev);
399 struct ap_driver *ap_drv = to_ap_drv(drv);
400 struct ap_device_id *id;
403 * Compare device type of the device with the list of
404 * supported types of the device_driver.
406 for (id = ap_drv->ids; id->match_flags; id++) {
407 if ((id->match_flags & AP_DEVICE_ID_MATCH_DEVICE_TYPE) &&
408 (id->dev_type != ap_dev->device_type))
416 * uevent function for AP devices. It sets up a single environment
417 * variable DEV_TYPE which contains the hardware device type.
419 static int ap_uevent (struct device *dev, char **envp, int num_envp,
420 char *buffer, int buffer_size)
422 struct ap_device *ap_dev = to_ap_dev(dev);
428 /* Set up DEV_TYPE environment variable. */
430 length = scnprintf(buffer, buffer_size, "DEV_TYPE=%04X",
431 ap_dev->device_type);
432 if (buffer_size - length <= 0)
438 static struct bus_type ap_bus_type = {
440 .match = &ap_bus_match,
441 .uevent = &ap_uevent,
444 static int ap_device_probe(struct device *dev)
446 struct ap_device *ap_dev = to_ap_dev(dev);
447 struct ap_driver *ap_drv = to_ap_drv(dev->driver);
450 ap_dev->drv = ap_drv;
451 rc = ap_drv->probe ? ap_drv->probe(ap_dev) : -ENODEV;
453 ap_dev->unregistered = 1;
458 * Flush all requests from the request/pending queue of an AP device.
459 * @ap_dev: pointer to the AP device.
461 static inline void __ap_flush_queue(struct ap_device *ap_dev)
463 struct ap_message *ap_msg, *next;
465 list_for_each_entry_safe(ap_msg, next, &ap_dev->pendingq, list) {
466 list_del_init(&ap_msg->list);
467 ap_dev->pendingq_count--;
468 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
470 list_for_each_entry_safe(ap_msg, next, &ap_dev->requestq, list) {
471 list_del_init(&ap_msg->list);
472 ap_dev->requestq_count--;
473 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
477 void ap_flush_queue(struct ap_device *ap_dev)
479 spin_lock_bh(&ap_dev->lock);
480 __ap_flush_queue(ap_dev);
481 spin_unlock_bh(&ap_dev->lock);
483 EXPORT_SYMBOL(ap_flush_queue);
485 static int ap_device_remove(struct device *dev)
487 struct ap_device *ap_dev = to_ap_dev(dev);
488 struct ap_driver *ap_drv = ap_dev->drv;
490 spin_lock_bh(&ap_dev->lock);
491 __ap_flush_queue(ap_dev);
493 * set ->unregistered to 1 while holding the lock. This prevents
494 * new messages to be put on the queue from now on.
496 ap_dev->unregistered = 1;
497 spin_unlock_bh(&ap_dev->lock);
499 ap_drv->remove(ap_dev);
503 int ap_driver_register(struct ap_driver *ap_drv, struct module *owner,
506 struct device_driver *drv = &ap_drv->driver;
508 drv->bus = &ap_bus_type;
509 drv->probe = ap_device_probe;
510 drv->remove = ap_device_remove;
513 return driver_register(drv);
515 EXPORT_SYMBOL(ap_driver_register);
517 void ap_driver_unregister(struct ap_driver *ap_drv)
519 driver_unregister(&ap_drv->driver);
521 EXPORT_SYMBOL(ap_driver_unregister);
526 static ssize_t ap_domain_show(struct bus_type *bus, char *buf)
528 return snprintf(buf, PAGE_SIZE, "%d\n", ap_domain_index);
531 static BUS_ATTR(ap_domain, 0444, ap_domain_show, NULL);
533 static ssize_t ap_config_time_show(struct bus_type *bus, char *buf)
535 return snprintf(buf, PAGE_SIZE, "%d\n", ap_config_time);
538 static ssize_t ap_config_time_store(struct bus_type *bus,
539 const char *buf, size_t count)
543 if (sscanf(buf, "%d\n", &time) != 1 || time < 5 || time > 120)
545 ap_config_time = time;
546 if (!timer_pending(&ap_config_timer) ||
547 !mod_timer(&ap_config_timer, jiffies + ap_config_time * HZ)) {
548 ap_config_timer.expires = jiffies + ap_config_time * HZ;
549 add_timer(&ap_config_timer);
554 static BUS_ATTR(config_time, 0644, ap_config_time_show, ap_config_time_store);
556 static ssize_t ap_poll_thread_show(struct bus_type *bus, char *buf)
558 return snprintf(buf, PAGE_SIZE, "%d\n", ap_poll_kthread ? 1 : 0);
561 static ssize_t ap_poll_thread_store(struct bus_type *bus,
562 const char *buf, size_t count)
566 if (sscanf(buf, "%d\n", &flag) != 1)
569 rc = ap_poll_thread_start();
574 ap_poll_thread_stop();
578 static BUS_ATTR(poll_thread, 0644, ap_poll_thread_show, ap_poll_thread_store);
580 static struct bus_attribute *const ap_bus_attrs[] = {
582 &bus_attr_config_time,
583 &bus_attr_poll_thread,
588 * Pick one of the 16 ap domains.
590 static inline int ap_select_domain(void)
592 int queue_depth, device_type, count, max_count, best_domain;
596 * We want to use a single domain. Either the one specified with
597 * the "domain=" parameter or the domain with the maximum number
600 if (ap_domain_index >= 0 && ap_domain_index < AP_DOMAINS)
601 /* Domain has already been selected. */
605 for (i = 0; i < AP_DOMAINS; i++) {
607 for (j = 0; j < AP_DEVICES; j++) {
608 ap_qid_t qid = AP_MKQID(j, i);
609 rc = ap_query_queue(qid, &queue_depth, &device_type);
614 if (count > max_count) {
619 if (best_domain >= 0){
620 ap_domain_index = best_domain;
627 * Find the device type if query queue returned a device type of 0.
628 * @ap_dev: pointer to the AP device.
630 static int ap_probe_device_type(struct ap_device *ap_dev)
632 static unsigned char msg[] = {
633 0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,
634 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
635 0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,
636 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
637 0x01,0x00,0x43,0x43,0x41,0x2d,0x41,0x50,
638 0x50,0x4c,0x20,0x20,0x20,0x01,0x01,0x01,
639 0x00,0x00,0x00,0x00,0x50,0x4b,0x00,0x00,
640 0x00,0x00,0x01,0x1c,0x00,0x00,0x00,0x00,
641 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
642 0x00,0x00,0x05,0xb8,0x00,0x00,0x00,0x00,
643 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
644 0x70,0x00,0x41,0x00,0x00,0x00,0x00,0x00,
645 0x00,0x00,0x54,0x32,0x01,0x00,0xa0,0x00,
646 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
647 0x00,0x00,0x00,0x00,0xb8,0x05,0x00,0x00,
648 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
649 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
650 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
651 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
652 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
653 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
654 0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,
655 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
656 0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,
657 0x49,0x43,0x53,0x46,0x20,0x20,0x20,0x20,
658 0x50,0x4b,0x0a,0x00,0x50,0x4b,0x43,0x53,
659 0x2d,0x31,0x2e,0x32,0x37,0x00,0x11,0x22,
660 0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00,
661 0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,
662 0x99,0x00,0x11,0x22,0x33,0x44,0x55,0x66,
663 0x77,0x88,0x99,0x00,0x11,0x22,0x33,0x44,
664 0x55,0x66,0x77,0x88,0x99,0x00,0x11,0x22,
665 0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00,
666 0x11,0x22,0x33,0x5d,0x00,0x5b,0x00,0x77,
667 0x88,0x1e,0x00,0x00,0x57,0x00,0x00,0x00,
668 0x00,0x04,0x00,0x00,0x4f,0x00,0x00,0x00,
669 0x03,0x02,0x00,0x00,0x40,0x01,0x00,0x01,
670 0xce,0x02,0x68,0x2d,0x5f,0xa9,0xde,0x0c,
671 0xf6,0xd2,0x7b,0x58,0x4b,0xf9,0x28,0x68,
672 0x3d,0xb4,0xf4,0xef,0x78,0xd5,0xbe,0x66,
673 0x63,0x42,0xef,0xf8,0xfd,0xa4,0xf8,0xb0,
674 0x8e,0x29,0xc2,0xc9,0x2e,0xd8,0x45,0xb8,
675 0x53,0x8c,0x6f,0x4e,0x72,0x8f,0x6c,0x04,
676 0x9c,0x88,0xfc,0x1e,0xc5,0x83,0x55,0x57,
677 0xf7,0xdd,0xfd,0x4f,0x11,0x36,0x95,0x5d,
679 struct ap_queue_status status;
680 unsigned long long psmid;
684 reply = (void *) get_zeroed_page(GFP_KERNEL);
690 status = __ap_send(ap_dev->qid, 0x0102030405060708ULL,
692 if (status.response_code != AP_RESPONSE_NORMAL) {
697 /* Wait for the test message to complete. */
698 for (i = 0; i < 6; i++) {
700 status = __ap_recv(ap_dev->qid, &psmid, reply, 4096);
701 if (status.response_code == AP_RESPONSE_NORMAL &&
702 psmid == 0x0102030405060708ULL)
707 if (reply[0] == 0x00 && reply[1] == 0x86)
708 ap_dev->device_type = AP_DEVICE_TYPE_PCICC;
710 ap_dev->device_type = AP_DEVICE_TYPE_PCICA;
716 free_page((unsigned long) reply);
722 * Scan the ap bus for new devices.
724 static int __ap_scan_bus(struct device *dev, void *data)
726 return to_ap_dev(dev)->qid == (ap_qid_t)(unsigned long) data;
729 static void ap_device_release(struct device *dev)
731 struct ap_device *ap_dev = to_ap_dev(dev);
736 static void ap_scan_bus(void *data)
738 struct ap_device *ap_dev;
741 int queue_depth, device_type;
744 if (ap_select_domain() != 0)
746 for (i = 0; i < AP_DEVICES; i++) {
747 qid = AP_MKQID(i, ap_domain_index);
748 dev = bus_find_device(&ap_bus_type, NULL,
749 (void *)(unsigned long)qid,
755 rc = ap_query_queue(qid, &queue_depth, &device_type);
758 rc = ap_init_queue(qid);
761 ap_dev = kzalloc(sizeof(*ap_dev), GFP_KERNEL);
765 ap_dev->queue_depth = queue_depth;
766 spin_lock_init(&ap_dev->lock);
767 INIT_LIST_HEAD(&ap_dev->pendingq);
768 INIT_LIST_HEAD(&ap_dev->requestq);
769 if (device_type == 0)
770 ap_probe_device_type(ap_dev);
772 ap_dev->device_type = device_type;
774 ap_dev->device.bus = &ap_bus_type;
775 ap_dev->device.parent = ap_root_device;
776 snprintf(ap_dev->device.bus_id, BUS_ID_SIZE, "card%02x",
777 AP_QID_DEVICE(ap_dev->qid));
778 ap_dev->device.release = ap_device_release;
779 rc = device_register(&ap_dev->device);
784 /* Add device attributes. */
785 rc = sysfs_create_group(&ap_dev->device.kobj,
788 device_unregister(&ap_dev->device);
793 ap_config_timeout(unsigned long ptr)
795 queue_work(ap_work_queue, &ap_config_work);
796 ap_config_timer.expires = jiffies + ap_config_time * HZ;
797 add_timer(&ap_config_timer);
801 * Set up the timer to run the poll tasklet
803 static inline void ap_schedule_poll_timer(void)
805 if (timer_pending(&ap_poll_timer))
807 mod_timer(&ap_poll_timer, jiffies + AP_POLL_TIME);
811 * Receive pending reply messages from an AP device.
812 * @ap_dev: pointer to the AP device
813 * @flags: pointer to control flags, bit 2^0 is set if another poll is
814 * required, bit 2^1 is set if the poll timer needs to get armed
815 * Returns 0 if the device is still present, -ENODEV if not.
817 static inline int ap_poll_read(struct ap_device *ap_dev, unsigned long *flags)
819 struct ap_queue_status status;
820 struct ap_message *ap_msg;
822 if (ap_dev->queue_count <= 0)
824 status = __ap_recv(ap_dev->qid, &ap_dev->reply->psmid,
825 ap_dev->reply->message, ap_dev->reply->length);
826 switch (status.response_code) {
827 case AP_RESPONSE_NORMAL:
828 atomic_dec(&ap_poll_requests);
829 ap_dev->queue_count--;
830 list_for_each_entry(ap_msg, &ap_dev->pendingq, list) {
831 if (ap_msg->psmid != ap_dev->reply->psmid)
833 list_del_init(&ap_msg->list);
834 ap_dev->pendingq_count--;
835 ap_dev->drv->receive(ap_dev, ap_msg, ap_dev->reply);
838 if (ap_dev->queue_count > 0)
841 case AP_RESPONSE_NO_PENDING_REPLY:
842 if (status.queue_empty) {
843 /* The card shouldn't forget requests but who knows. */
844 ap_dev->queue_count = 0;
845 list_splice_init(&ap_dev->pendingq, &ap_dev->requestq);
846 ap_dev->requestq_count += ap_dev->pendingq_count;
847 ap_dev->pendingq_count = 0;
858 * Send messages from the request queue to an AP device.
859 * @ap_dev: pointer to the AP device
860 * @flags: pointer to control flags, bit 2^0 is set if another poll is
861 * required, bit 2^1 is set if the poll timer needs to get armed
862 * Returns 0 if the device is still present, -ENODEV if not.
864 static inline int ap_poll_write(struct ap_device *ap_dev, unsigned long *flags)
866 struct ap_queue_status status;
867 struct ap_message *ap_msg;
869 if (ap_dev->requestq_count <= 0 ||
870 ap_dev->queue_count >= ap_dev->queue_depth)
872 /* Start the next request on the queue. */
873 ap_msg = list_entry(ap_dev->requestq.next, struct ap_message, list);
874 status = __ap_send(ap_dev->qid, ap_msg->psmid,
875 ap_msg->message, ap_msg->length);
876 switch (status.response_code) {
877 case AP_RESPONSE_NORMAL:
878 atomic_inc(&ap_poll_requests);
879 ap_dev->queue_count++;
880 list_move_tail(&ap_msg->list, &ap_dev->pendingq);
881 ap_dev->requestq_count--;
882 ap_dev->pendingq_count++;
883 if (ap_dev->queue_count < ap_dev->queue_depth &&
884 ap_dev->requestq_count > 0)
888 case AP_RESPONSE_Q_FULL:
891 case AP_RESPONSE_MESSAGE_TOO_BIG:
900 * Poll AP device for pending replies and send new messages. If either
901 * ap_poll_read or ap_poll_write returns -ENODEV unregister the device.
902 * @ap_dev: pointer to the bus device
903 * @flags: pointer to control flags, bit 2^0 is set if another poll is
904 * required, bit 2^1 is set if the poll timer needs to get armed
907 static inline int ap_poll_queue(struct ap_device *ap_dev, unsigned long *flags)
911 rc = ap_poll_read(ap_dev, flags);
914 return ap_poll_write(ap_dev, flags);
918 * Queue a message to a device.
919 * @ap_dev: pointer to the AP device
920 * @ap_msg: the message to be queued
922 static int __ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
924 struct ap_queue_status status;
926 if (list_empty(&ap_dev->requestq) &&
927 ap_dev->queue_count < ap_dev->queue_depth) {
928 status = __ap_send(ap_dev->qid, ap_msg->psmid,
929 ap_msg->message, ap_msg->length);
930 switch (status.response_code) {
931 case AP_RESPONSE_NORMAL:
932 list_add_tail(&ap_msg->list, &ap_dev->pendingq);
933 atomic_inc(&ap_poll_requests);
934 ap_dev->pendingq_count++;
935 ap_dev->queue_count++;
936 ap_dev->total_request_count++;
938 case AP_RESPONSE_Q_FULL:
939 list_add_tail(&ap_msg->list, &ap_dev->requestq);
940 ap_dev->requestq_count++;
941 ap_dev->total_request_count++;
943 case AP_RESPONSE_MESSAGE_TOO_BIG:
944 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-EINVAL));
946 default: /* Device is gone. */
947 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
951 list_add_tail(&ap_msg->list, &ap_dev->requestq);
952 ap_dev->requestq_count++;
953 ap_dev->total_request_count++;
956 ap_schedule_poll_timer();
960 void ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
965 spin_lock_bh(&ap_dev->lock);
966 if (!ap_dev->unregistered) {
967 /* Make room on the queue by polling for finished requests. */
968 rc = ap_poll_queue(ap_dev, &flags);
970 rc = __ap_queue_message(ap_dev, ap_msg);
972 wake_up(&ap_poll_wait);
974 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
977 spin_unlock_bh(&ap_dev->lock);
979 device_unregister(&ap_dev->device);
981 EXPORT_SYMBOL(ap_queue_message);
984 * Cancel a crypto request. This is done by removing the request
985 * from the devive pendingq or requestq queue. Note that the
986 * request stays on the AP queue. When it finishes the message
987 * reply will be discarded because the psmid can't be found.
988 * @ap_dev: AP device that has the message queued
989 * @ap_msg: the message that is to be removed
991 void ap_cancel_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
993 struct ap_message *tmp;
995 spin_lock_bh(&ap_dev->lock);
996 if (!list_empty(&ap_msg->list)) {
997 list_for_each_entry(tmp, &ap_dev->pendingq, list)
998 if (tmp->psmid == ap_msg->psmid) {
999 ap_dev->pendingq_count--;
1002 ap_dev->requestq_count--;
1004 list_del_init(&ap_msg->list);
1006 spin_unlock_bh(&ap_dev->lock);
1008 EXPORT_SYMBOL(ap_cancel_message);
1011 * AP receive polling for finished AP requests
1013 static void ap_poll_timeout(unsigned long unused)
1015 tasklet_schedule(&ap_tasklet);
1019 * Poll all AP devices on the bus in a round robin fashion. Continue
1020 * polling until bit 2^0 of the control flags is not set. If bit 2^1
1021 * of the control flags has been set arm the poll timer.
1023 static int __ap_poll_all(struct device *dev, void *data)
1025 struct ap_device *ap_dev = to_ap_dev(dev);
1028 spin_lock(&ap_dev->lock);
1029 if (!ap_dev->unregistered) {
1030 rc = ap_poll_queue(to_ap_dev(dev), (unsigned long *) data);
1033 spin_unlock(&ap_dev->lock);
1035 device_unregister(&ap_dev->device);
1039 static void ap_poll_all(unsigned long dummy)
1041 unsigned long flags;
1045 bus_for_each_dev(&ap_bus_type, NULL, &flags, __ap_poll_all);
1046 } while (flags & 1);
1048 ap_schedule_poll_timer();
1052 * AP bus poll thread. The purpose of this thread is to poll for
1053 * finished requests in a loop if there is a "free" cpu - that is
1054 * a cpu that doesn't have anything better to do. The polling stops
1055 * as soon as there is another task or if all messages have been
1058 static int ap_poll_thread(void *data)
1060 DECLARE_WAITQUEUE(wait, current);
1061 unsigned long flags;
1064 set_user_nice(current, -20);
1066 if (need_resched()) {
1070 add_wait_queue(&ap_poll_wait, &wait);
1071 set_current_state(TASK_INTERRUPTIBLE);
1072 if (kthread_should_stop())
1074 requests = atomic_read(&ap_poll_requests);
1077 set_current_state(TASK_RUNNING);
1078 remove_wait_queue(&ap_poll_wait, &wait);
1082 bus_for_each_dev(&ap_bus_type, NULL, &flags, __ap_poll_all);
1085 set_current_state(TASK_RUNNING);
1086 remove_wait_queue(&ap_poll_wait, &wait);
1090 static int ap_poll_thread_start(void)
1094 mutex_lock(&ap_poll_thread_mutex);
1095 if (!ap_poll_kthread) {
1096 ap_poll_kthread = kthread_run(ap_poll_thread, NULL, "appoll");
1097 rc = IS_ERR(ap_poll_kthread) ? PTR_ERR(ap_poll_kthread) : 0;
1099 ap_poll_kthread = NULL;
1103 mutex_unlock(&ap_poll_thread_mutex);
1107 static void ap_poll_thread_stop(void)
1109 mutex_lock(&ap_poll_thread_mutex);
1110 if (ap_poll_kthread) {
1111 kthread_stop(ap_poll_kthread);
1112 ap_poll_kthread = NULL;
1114 mutex_unlock(&ap_poll_thread_mutex);
1118 * The module initialization code.
1120 int __init ap_module_init(void)
1124 if (ap_domain_index < -1 || ap_domain_index >= AP_DOMAINS) {
1125 printk(KERN_WARNING "Invalid param: domain = %d. "
1126 " Not loading.\n", ap_domain_index);
1129 if (ap_instructions_available() != 0) {
1130 printk(KERN_WARNING "AP instructions not installed.\n");
1134 /* Create /sys/bus/ap. */
1135 rc = bus_register(&ap_bus_type);
1138 for (i = 0; ap_bus_attrs[i]; i++) {
1139 rc = bus_create_file(&ap_bus_type, ap_bus_attrs[i]);
1144 /* Create /sys/devices/ap. */
1145 ap_root_device = s390_root_dev_register("ap");
1146 rc = IS_ERR(ap_root_device) ? PTR_ERR(ap_root_device) : 0;
1150 ap_work_queue = create_singlethread_workqueue("kapwork");
1151 if (!ap_work_queue) {
1156 if (ap_select_domain() == 0)
1159 /* Setup the ap bus rescan timer. */
1160 init_timer(&ap_config_timer);
1161 ap_config_timer.function = ap_config_timeout;
1162 ap_config_timer.data = 0;
1163 ap_config_timer.expires = jiffies + ap_config_time * HZ;
1164 add_timer(&ap_config_timer);
1166 /* Start the low priority AP bus poll thread. */
1167 if (ap_thread_flag) {
1168 rc = ap_poll_thread_start();
1176 del_timer_sync(&ap_config_timer);
1177 del_timer_sync(&ap_poll_timer);
1178 destroy_workqueue(ap_work_queue);
1180 s390_root_dev_unregister(ap_root_device);
1183 bus_remove_file(&ap_bus_type, ap_bus_attrs[i]);
1184 bus_unregister(&ap_bus_type);
1189 static int __ap_match_all(struct device *dev, void *data)
1195 * The module termination code
1197 void ap_module_exit(void)
1202 ap_poll_thread_stop();
1203 del_timer_sync(&ap_config_timer);
1204 del_timer_sync(&ap_poll_timer);
1205 destroy_workqueue(ap_work_queue);
1206 s390_root_dev_unregister(ap_root_device);
1207 while ((dev = bus_find_device(&ap_bus_type, NULL, NULL,
1210 device_unregister(dev);
1213 for (i = 0; ap_bus_attrs[i]; i++)
1214 bus_remove_file(&ap_bus_type, ap_bus_attrs[i]);
1215 bus_unregister(&ap_bus_type);
1218 #ifndef CONFIG_ZCRYPT_MONOLITHIC
1219 module_init(ap_module_init);
1220 module_exit(ap_module_exit);