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>
36 #include <asm/reset.h>
40 /* Some prototypes. */
41 static void ap_scan_bus(struct work_struct *);
42 static void ap_poll_all(unsigned long);
43 static void ap_poll_timeout(unsigned long);
44 static int ap_poll_thread_start(void);
45 static void ap_poll_thread_stop(void);
50 MODULE_AUTHOR("IBM Corporation");
51 MODULE_DESCRIPTION("Adjunct Processor Bus driver, "
52 "Copyright 2006 IBM Corporation");
53 MODULE_LICENSE("GPL");
58 int ap_domain_index = -1; /* Adjunct Processor Domain Index */
59 module_param_named(domain, ap_domain_index, int, 0000);
60 MODULE_PARM_DESC(domain, "domain index for ap devices");
61 EXPORT_SYMBOL(ap_domain_index);
63 static int ap_thread_flag = 1;
64 module_param_named(poll_thread, ap_thread_flag, int, 0000);
65 MODULE_PARM_DESC(poll_thread, "Turn on/off poll thread, default is 1 (on).");
67 static struct device *ap_root_device = NULL;
68 static DEFINE_SPINLOCK(ap_device_lock);
69 static LIST_HEAD(ap_device_list);
72 * Workqueue & timer for bus rescan.
74 static struct workqueue_struct *ap_work_queue;
75 static struct timer_list ap_config_timer;
76 static int ap_config_time = AP_CONFIG_TIME;
77 static DECLARE_WORK(ap_config_work, ap_scan_bus);
80 * Tasklet & timer for AP request polling.
82 static struct timer_list ap_poll_timer = TIMER_INITIALIZER(ap_poll_timeout,0,0);
83 static DECLARE_TASKLET(ap_tasklet, ap_poll_all, 0);
84 static atomic_t ap_poll_requests = ATOMIC_INIT(0);
85 static DECLARE_WAIT_QUEUE_HEAD(ap_poll_wait);
86 static struct task_struct *ap_poll_kthread = NULL;
87 static DEFINE_MUTEX(ap_poll_thread_mutex);
90 * Test if ap instructions are available.
92 * Returns 0 if the ap instructions are installed.
94 static inline int ap_instructions_available(void)
96 register unsigned long reg0 asm ("0") = AP_MKQID(0,0);
97 register unsigned long reg1 asm ("1") = -ENODEV;
98 register unsigned long reg2 asm ("2") = 0UL;
101 " .long 0xb2af0000\n" /* PQAP(TAPQ) */
105 : "+d" (reg0), "+d" (reg1), "+d" (reg2) : : "cc" );
110 * Test adjunct processor queue.
111 * @qid: the ap queue number
112 * @queue_depth: pointer to queue depth value
113 * @device_type: pointer to device type value
115 * Returns ap queue status structure.
117 static inline struct ap_queue_status
118 ap_test_queue(ap_qid_t qid, int *queue_depth, int *device_type)
120 register unsigned long reg0 asm ("0") = qid;
121 register struct ap_queue_status reg1 asm ("1");
122 register unsigned long reg2 asm ("2") = 0UL;
124 asm volatile(".long 0xb2af0000" /* PQAP(TAPQ) */
125 : "+d" (reg0), "=d" (reg1), "+d" (reg2) : : "cc");
126 *device_type = (int) (reg2 >> 24);
127 *queue_depth = (int) (reg2 & 0xff);
132 * Reset adjunct processor queue.
133 * @qid: the ap queue number
135 * Returns ap queue status structure.
137 static inline struct ap_queue_status ap_reset_queue(ap_qid_t qid)
139 register unsigned long reg0 asm ("0") = qid | 0x01000000UL;
140 register struct ap_queue_status reg1 asm ("1");
141 register unsigned long reg2 asm ("2") = 0UL;
144 ".long 0xb2af0000" /* PQAP(RAPQ) */
145 : "+d" (reg0), "=d" (reg1), "+d" (reg2) : : "cc");
150 * Send message to adjunct processor queue.
151 * @qid: the ap queue number
152 * @psmid: the program supplied message identifier
153 * @msg: the message text
154 * @length: the message length
156 * Returns ap queue status structure.
158 * Condition code 1 on NQAP can't happen because the L bit is 1.
160 * Condition code 2 on NQAP also means the send is incomplete,
161 * because a segment boundary was reached. The NQAP is repeated.
163 static inline struct ap_queue_status
164 __ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length)
166 typedef struct { char _[length]; } msgblock;
167 register unsigned long reg0 asm ("0") = qid | 0x40000000UL;
168 register struct ap_queue_status reg1 asm ("1");
169 register unsigned long reg2 asm ("2") = (unsigned long) msg;
170 register unsigned long reg3 asm ("3") = (unsigned long) length;
171 register unsigned long reg4 asm ("4") = (unsigned int) (psmid >> 32);
172 register unsigned long reg5 asm ("5") = (unsigned int) psmid;
175 "0: .long 0xb2ad0042\n" /* DQAP */
177 : "+d" (reg0), "=d" (reg1), "+d" (reg2), "+d" (reg3)
178 : "d" (reg4), "d" (reg5), "m" (*(msgblock *) msg)
183 int ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length)
185 struct ap_queue_status status;
187 status = __ap_send(qid, psmid, msg, length);
188 switch (status.response_code) {
189 case AP_RESPONSE_NORMAL:
191 case AP_RESPONSE_Q_FULL:
193 default: /* Device is gone. */
197 EXPORT_SYMBOL(ap_send);
200 * Receive message from adjunct processor queue.
201 * @qid: the ap queue number
202 * @psmid: pointer to program supplied message identifier
203 * @msg: the message text
204 * @length: the message length
206 * Returns ap queue status structure.
208 * Condition code 1 on DQAP means the receive has taken place
209 * but only partially. The response is incomplete, hence the
212 * Condition code 2 on DQAP also means the receive is incomplete,
213 * this time because a segment boundary was reached. Again, the
216 * Note that gpr2 is used by the DQAP instruction to keep track of
217 * any 'residual' length, in case the instruction gets interrupted.
218 * Hence it gets zeroed before the instruction.
220 static inline struct ap_queue_status
221 __ap_recv(ap_qid_t qid, unsigned long long *psmid, void *msg, size_t length)
223 typedef struct { char _[length]; } msgblock;
224 register unsigned long reg0 asm("0") = qid | 0x80000000UL;
225 register struct ap_queue_status reg1 asm ("1");
226 register unsigned long reg2 asm("2") = 0UL;
227 register unsigned long reg4 asm("4") = (unsigned long) msg;
228 register unsigned long reg5 asm("5") = (unsigned long) length;
229 register unsigned long reg6 asm("6") = 0UL;
230 register unsigned long reg7 asm("7") = 0UL;
234 "0: .long 0xb2ae0064\n"
236 : "+d" (reg0), "=d" (reg1), "+d" (reg2),
237 "+d" (reg4), "+d" (reg5), "+d" (reg6), "+d" (reg7),
238 "=m" (*(msgblock *) msg) : : "cc" );
239 *psmid = (((unsigned long long) reg6) << 32) + reg7;
243 int ap_recv(ap_qid_t qid, unsigned long long *psmid, void *msg, size_t length)
245 struct ap_queue_status status;
247 status = __ap_recv(qid, psmid, msg, length);
248 switch (status.response_code) {
249 case AP_RESPONSE_NORMAL:
251 case AP_RESPONSE_NO_PENDING_REPLY:
252 if (status.queue_empty)
259 EXPORT_SYMBOL(ap_recv);
262 * Check if an AP queue is available. The test is repeated for
263 * AP_MAX_RESET times.
264 * @qid: the ap queue number
265 * @queue_depth: pointer to queue depth value
266 * @device_type: pointer to device type value
268 static int ap_query_queue(ap_qid_t qid, int *queue_depth, int *device_type)
270 struct ap_queue_status status;
271 int t_depth, t_device_type, rc, i;
274 for (i = 0; i < AP_MAX_RESET; i++) {
275 status = ap_test_queue(qid, &t_depth, &t_device_type);
276 switch (status.response_code) {
277 case AP_RESPONSE_NORMAL:
278 *queue_depth = t_depth + 1;
279 *device_type = t_device_type;
282 case AP_RESPONSE_Q_NOT_AVAIL:
285 case AP_RESPONSE_RESET_IN_PROGRESS:
287 case AP_RESPONSE_DECONFIGURED:
290 case AP_RESPONSE_CHECKSTOPPED:
293 case AP_RESPONSE_BUSY:
300 if (i < AP_MAX_RESET - 1)
307 * Reset an AP queue and wait for it to become available again.
308 * @qid: the ap queue number
310 static int ap_init_queue(ap_qid_t qid)
312 struct ap_queue_status status;
316 status = ap_reset_queue(qid);
317 for (i = 0; i < AP_MAX_RESET; i++) {
318 switch (status.response_code) {
319 case AP_RESPONSE_NORMAL:
320 if (status.queue_empty)
323 case AP_RESPONSE_Q_NOT_AVAIL:
324 case AP_RESPONSE_DECONFIGURED:
325 case AP_RESPONSE_CHECKSTOPPED:
326 i = AP_MAX_RESET; /* return with -ENODEV */
328 case AP_RESPONSE_RESET_IN_PROGRESS:
329 case AP_RESPONSE_BUSY:
335 if (i < AP_MAX_RESET - 1) {
337 status = ap_test_queue(qid, &dummy, &dummy);
344 * AP device related attributes.
346 static ssize_t ap_hwtype_show(struct device *dev,
347 struct device_attribute *attr, char *buf)
349 struct ap_device *ap_dev = to_ap_dev(dev);
350 return snprintf(buf, PAGE_SIZE, "%d\n", ap_dev->device_type);
352 static DEVICE_ATTR(hwtype, 0444, ap_hwtype_show, NULL);
354 static ssize_t ap_depth_show(struct device *dev, struct device_attribute *attr,
357 struct ap_device *ap_dev = to_ap_dev(dev);
358 return snprintf(buf, PAGE_SIZE, "%d\n", ap_dev->queue_depth);
360 static DEVICE_ATTR(depth, 0444, ap_depth_show, NULL);
362 static ssize_t ap_request_count_show(struct device *dev,
363 struct device_attribute *attr,
366 struct ap_device *ap_dev = to_ap_dev(dev);
369 spin_lock_bh(&ap_dev->lock);
370 rc = snprintf(buf, PAGE_SIZE, "%d\n", ap_dev->total_request_count);
371 spin_unlock_bh(&ap_dev->lock);
375 static DEVICE_ATTR(request_count, 0444, ap_request_count_show, NULL);
377 static ssize_t ap_modalias_show(struct device *dev,
378 struct device_attribute *attr, char *buf)
380 return sprintf(buf, "ap:t%02X", to_ap_dev(dev)->device_type);
383 static DEVICE_ATTR(modalias, 0444, ap_modalias_show, NULL);
385 static struct attribute *ap_dev_attrs[] = {
386 &dev_attr_hwtype.attr,
387 &dev_attr_depth.attr,
388 &dev_attr_request_count.attr,
389 &dev_attr_modalias.attr,
392 static struct attribute_group ap_dev_attr_group = {
393 .attrs = ap_dev_attrs
397 * AP bus driver registration/unregistration.
399 static int ap_bus_match(struct device *dev, struct device_driver *drv)
401 struct ap_device *ap_dev = to_ap_dev(dev);
402 struct ap_driver *ap_drv = to_ap_drv(drv);
403 struct ap_device_id *id;
406 * Compare device type of the device with the list of
407 * supported types of the device_driver.
409 for (id = ap_drv->ids; id->match_flags; id++) {
410 if ((id->match_flags & AP_DEVICE_ID_MATCH_DEVICE_TYPE) &&
411 (id->dev_type != ap_dev->device_type))
419 * uevent function for AP devices. It sets up a single environment
420 * variable DEV_TYPE which contains the hardware device type.
422 static int ap_uevent (struct device *dev, char **envp, int num_envp,
423 char *buffer, int buffer_size)
425 struct ap_device *ap_dev = to_ap_dev(dev);
431 /* Set up DEV_TYPE environment variable. */
433 length = scnprintf(buffer, buffer_size, "DEV_TYPE=%04X",
434 ap_dev->device_type);
435 if (buffer_size - length <= 0)
438 buffer_size -= length;
441 length = scnprintf(buffer, buffer_size, "MODALIAS=ap:t%02X",
442 ap_dev->device_type);
443 if (buffer_size - length <= 0)
449 static struct bus_type ap_bus_type = {
451 .match = &ap_bus_match,
452 .uevent = &ap_uevent,
455 static int ap_device_probe(struct device *dev)
457 struct ap_device *ap_dev = to_ap_dev(dev);
458 struct ap_driver *ap_drv = to_ap_drv(dev->driver);
461 ap_dev->drv = ap_drv;
462 spin_lock_bh(&ap_device_lock);
463 list_add(&ap_dev->list, &ap_device_list);
464 spin_unlock_bh(&ap_device_lock);
465 rc = ap_drv->probe ? ap_drv->probe(ap_dev) : -ENODEV;
470 * Flush all requests from the request/pending queue of an AP device.
471 * @ap_dev: pointer to the AP device.
473 static void __ap_flush_queue(struct ap_device *ap_dev)
475 struct ap_message *ap_msg, *next;
477 list_for_each_entry_safe(ap_msg, next, &ap_dev->pendingq, list) {
478 list_del_init(&ap_msg->list);
479 ap_dev->pendingq_count--;
480 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
482 list_for_each_entry_safe(ap_msg, next, &ap_dev->requestq, list) {
483 list_del_init(&ap_msg->list);
484 ap_dev->requestq_count--;
485 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
489 void ap_flush_queue(struct ap_device *ap_dev)
491 spin_lock_bh(&ap_dev->lock);
492 __ap_flush_queue(ap_dev);
493 spin_unlock_bh(&ap_dev->lock);
495 EXPORT_SYMBOL(ap_flush_queue);
497 static int ap_device_remove(struct device *dev)
499 struct ap_device *ap_dev = to_ap_dev(dev);
500 struct ap_driver *ap_drv = ap_dev->drv;
502 ap_flush_queue(ap_dev);
504 ap_drv->remove(ap_dev);
505 spin_lock_bh(&ap_device_lock);
506 list_del_init(&ap_dev->list);
507 spin_unlock_bh(&ap_device_lock);
511 int ap_driver_register(struct ap_driver *ap_drv, struct module *owner,
514 struct device_driver *drv = &ap_drv->driver;
516 drv->bus = &ap_bus_type;
517 drv->probe = ap_device_probe;
518 drv->remove = ap_device_remove;
521 return driver_register(drv);
523 EXPORT_SYMBOL(ap_driver_register);
525 void ap_driver_unregister(struct ap_driver *ap_drv)
527 driver_unregister(&ap_drv->driver);
529 EXPORT_SYMBOL(ap_driver_unregister);
534 static ssize_t ap_domain_show(struct bus_type *bus, char *buf)
536 return snprintf(buf, PAGE_SIZE, "%d\n", ap_domain_index);
539 static BUS_ATTR(ap_domain, 0444, ap_domain_show, NULL);
541 static ssize_t ap_config_time_show(struct bus_type *bus, char *buf)
543 return snprintf(buf, PAGE_SIZE, "%d\n", ap_config_time);
546 static ssize_t ap_config_time_store(struct bus_type *bus,
547 const char *buf, size_t count)
551 if (sscanf(buf, "%d\n", &time) != 1 || time < 5 || time > 120)
553 ap_config_time = time;
554 if (!timer_pending(&ap_config_timer) ||
555 !mod_timer(&ap_config_timer, jiffies + ap_config_time * HZ)) {
556 ap_config_timer.expires = jiffies + ap_config_time * HZ;
557 add_timer(&ap_config_timer);
562 static BUS_ATTR(config_time, 0644, ap_config_time_show, ap_config_time_store);
564 static ssize_t ap_poll_thread_show(struct bus_type *bus, char *buf)
566 return snprintf(buf, PAGE_SIZE, "%d\n", ap_poll_kthread ? 1 : 0);
569 static ssize_t ap_poll_thread_store(struct bus_type *bus,
570 const char *buf, size_t count)
574 if (sscanf(buf, "%d\n", &flag) != 1)
577 rc = ap_poll_thread_start();
582 ap_poll_thread_stop();
586 static BUS_ATTR(poll_thread, 0644, ap_poll_thread_show, ap_poll_thread_store);
588 static struct bus_attribute *const ap_bus_attrs[] = {
590 &bus_attr_config_time,
591 &bus_attr_poll_thread,
596 * Pick one of the 16 ap domains.
598 static int ap_select_domain(void)
600 int queue_depth, device_type, count, max_count, best_domain;
604 * We want to use a single domain. Either the one specified with
605 * the "domain=" parameter or the domain with the maximum number
608 if (ap_domain_index >= 0 && ap_domain_index < AP_DOMAINS)
609 /* Domain has already been selected. */
613 for (i = 0; i < AP_DOMAINS; i++) {
615 for (j = 0; j < AP_DEVICES; j++) {
616 ap_qid_t qid = AP_MKQID(j, i);
617 rc = ap_query_queue(qid, &queue_depth, &device_type);
622 if (count > max_count) {
627 if (best_domain >= 0){
628 ap_domain_index = best_domain;
635 * Find the device type if query queue returned a device type of 0.
636 * @ap_dev: pointer to the AP device.
638 static int ap_probe_device_type(struct ap_device *ap_dev)
640 static unsigned char msg[] = {
641 0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,
642 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
643 0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,
644 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
645 0x01,0x00,0x43,0x43,0x41,0x2d,0x41,0x50,
646 0x50,0x4c,0x20,0x20,0x20,0x01,0x01,0x01,
647 0x00,0x00,0x00,0x00,0x50,0x4b,0x00,0x00,
648 0x00,0x00,0x01,0x1c,0x00,0x00,0x00,0x00,
649 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
650 0x00,0x00,0x05,0xb8,0x00,0x00,0x00,0x00,
651 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
652 0x70,0x00,0x41,0x00,0x00,0x00,0x00,0x00,
653 0x00,0x00,0x54,0x32,0x01,0x00,0xa0,0x00,
654 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
655 0x00,0x00,0x00,0x00,0xb8,0x05,0x00,0x00,
656 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
657 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
658 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
659 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
660 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
661 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
662 0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,
663 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
664 0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,
665 0x49,0x43,0x53,0x46,0x20,0x20,0x20,0x20,
666 0x50,0x4b,0x0a,0x00,0x50,0x4b,0x43,0x53,
667 0x2d,0x31,0x2e,0x32,0x37,0x00,0x11,0x22,
668 0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00,
669 0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,
670 0x99,0x00,0x11,0x22,0x33,0x44,0x55,0x66,
671 0x77,0x88,0x99,0x00,0x11,0x22,0x33,0x44,
672 0x55,0x66,0x77,0x88,0x99,0x00,0x11,0x22,
673 0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00,
674 0x11,0x22,0x33,0x5d,0x00,0x5b,0x00,0x77,
675 0x88,0x1e,0x00,0x00,0x57,0x00,0x00,0x00,
676 0x00,0x04,0x00,0x00,0x4f,0x00,0x00,0x00,
677 0x03,0x02,0x00,0x00,0x40,0x01,0x00,0x01,
678 0xce,0x02,0x68,0x2d,0x5f,0xa9,0xde,0x0c,
679 0xf6,0xd2,0x7b,0x58,0x4b,0xf9,0x28,0x68,
680 0x3d,0xb4,0xf4,0xef,0x78,0xd5,0xbe,0x66,
681 0x63,0x42,0xef,0xf8,0xfd,0xa4,0xf8,0xb0,
682 0x8e,0x29,0xc2,0xc9,0x2e,0xd8,0x45,0xb8,
683 0x53,0x8c,0x6f,0x4e,0x72,0x8f,0x6c,0x04,
684 0x9c,0x88,0xfc,0x1e,0xc5,0x83,0x55,0x57,
685 0xf7,0xdd,0xfd,0x4f,0x11,0x36,0x95,0x5d,
687 struct ap_queue_status status;
688 unsigned long long psmid;
692 reply = (void *) get_zeroed_page(GFP_KERNEL);
698 status = __ap_send(ap_dev->qid, 0x0102030405060708ULL,
700 if (status.response_code != AP_RESPONSE_NORMAL) {
705 /* Wait for the test message to complete. */
706 for (i = 0; i < 6; i++) {
708 status = __ap_recv(ap_dev->qid, &psmid, reply, 4096);
709 if (status.response_code == AP_RESPONSE_NORMAL &&
710 psmid == 0x0102030405060708ULL)
715 if (reply[0] == 0x00 && reply[1] == 0x86)
716 ap_dev->device_type = AP_DEVICE_TYPE_PCICC;
718 ap_dev->device_type = AP_DEVICE_TYPE_PCICA;
724 free_page((unsigned long) reply);
730 * Scan the ap bus for new devices.
732 static int __ap_scan_bus(struct device *dev, void *data)
734 return to_ap_dev(dev)->qid == (ap_qid_t)(unsigned long) data;
737 static void ap_device_release(struct device *dev)
739 struct ap_device *ap_dev = to_ap_dev(dev);
744 static void ap_scan_bus(struct work_struct *unused)
746 struct ap_device *ap_dev;
749 int queue_depth, device_type;
752 if (ap_select_domain() != 0)
754 for (i = 0; i < AP_DEVICES; i++) {
755 qid = AP_MKQID(i, ap_domain_index);
756 dev = bus_find_device(&ap_bus_type, NULL,
757 (void *)(unsigned long)qid,
759 rc = ap_query_queue(qid, &queue_depth, &device_type);
761 ap_dev = to_ap_dev(dev);
762 spin_lock_bh(&ap_dev->lock);
763 if (rc || ap_dev->unregistered) {
764 spin_unlock_bh(&ap_dev->lock);
766 device_unregister(dev);
769 spin_unlock_bh(&ap_dev->lock);
777 rc = ap_init_queue(qid);
780 ap_dev = kzalloc(sizeof(*ap_dev), GFP_KERNEL);
784 ap_dev->queue_depth = queue_depth;
785 ap_dev->unregistered = 1;
786 spin_lock_init(&ap_dev->lock);
787 INIT_LIST_HEAD(&ap_dev->pendingq);
788 INIT_LIST_HEAD(&ap_dev->requestq);
789 INIT_LIST_HEAD(&ap_dev->list);
790 if (device_type == 0)
791 ap_probe_device_type(ap_dev);
793 ap_dev->device_type = device_type;
795 ap_dev->device.bus = &ap_bus_type;
796 ap_dev->device.parent = ap_root_device;
797 snprintf(ap_dev->device.bus_id, BUS_ID_SIZE, "card%02x",
798 AP_QID_DEVICE(ap_dev->qid));
799 ap_dev->device.release = ap_device_release;
800 rc = device_register(&ap_dev->device);
805 /* Add device attributes. */
806 rc = sysfs_create_group(&ap_dev->device.kobj,
809 spin_lock_bh(&ap_dev->lock);
810 ap_dev->unregistered = 0;
811 spin_unlock_bh(&ap_dev->lock);
814 device_unregister(&ap_dev->device);
819 ap_config_timeout(unsigned long ptr)
821 queue_work(ap_work_queue, &ap_config_work);
822 ap_config_timer.expires = jiffies + ap_config_time * HZ;
823 add_timer(&ap_config_timer);
827 * Set up the timer to run the poll tasklet
829 static inline void ap_schedule_poll_timer(void)
831 if (timer_pending(&ap_poll_timer))
833 mod_timer(&ap_poll_timer, jiffies + AP_POLL_TIME);
837 * Receive pending reply messages from an AP device.
838 * @ap_dev: pointer to the AP device
839 * @flags: pointer to control flags, bit 2^0 is set if another poll is
840 * required, bit 2^1 is set if the poll timer needs to get armed
841 * Returns 0 if the device is still present, -ENODEV if not.
843 static int ap_poll_read(struct ap_device *ap_dev, unsigned long *flags)
845 struct ap_queue_status status;
846 struct ap_message *ap_msg;
848 if (ap_dev->queue_count <= 0)
850 status = __ap_recv(ap_dev->qid, &ap_dev->reply->psmid,
851 ap_dev->reply->message, ap_dev->reply->length);
852 switch (status.response_code) {
853 case AP_RESPONSE_NORMAL:
854 atomic_dec(&ap_poll_requests);
855 ap_dev->queue_count--;
856 list_for_each_entry(ap_msg, &ap_dev->pendingq, list) {
857 if (ap_msg->psmid != ap_dev->reply->psmid)
859 list_del_init(&ap_msg->list);
860 ap_dev->pendingq_count--;
861 ap_dev->drv->receive(ap_dev, ap_msg, ap_dev->reply);
864 if (ap_dev->queue_count > 0)
867 case AP_RESPONSE_NO_PENDING_REPLY:
868 if (status.queue_empty) {
869 /* The card shouldn't forget requests but who knows. */
870 ap_dev->queue_count = 0;
871 list_splice_init(&ap_dev->pendingq, &ap_dev->requestq);
872 ap_dev->requestq_count += ap_dev->pendingq_count;
873 ap_dev->pendingq_count = 0;
884 * Send messages from the request queue to an AP device.
885 * @ap_dev: pointer to the AP device
886 * @flags: pointer to control flags, bit 2^0 is set if another poll is
887 * required, bit 2^1 is set if the poll timer needs to get armed
888 * Returns 0 if the device is still present, -ENODEV if not.
890 static int ap_poll_write(struct ap_device *ap_dev, unsigned long *flags)
892 struct ap_queue_status status;
893 struct ap_message *ap_msg;
895 if (ap_dev->requestq_count <= 0 ||
896 ap_dev->queue_count >= ap_dev->queue_depth)
898 /* Start the next request on the queue. */
899 ap_msg = list_entry(ap_dev->requestq.next, struct ap_message, list);
900 status = __ap_send(ap_dev->qid, ap_msg->psmid,
901 ap_msg->message, ap_msg->length);
902 switch (status.response_code) {
903 case AP_RESPONSE_NORMAL:
904 atomic_inc(&ap_poll_requests);
905 ap_dev->queue_count++;
906 list_move_tail(&ap_msg->list, &ap_dev->pendingq);
907 ap_dev->requestq_count--;
908 ap_dev->pendingq_count++;
909 if (ap_dev->queue_count < ap_dev->queue_depth &&
910 ap_dev->requestq_count > 0)
914 case AP_RESPONSE_Q_FULL:
917 case AP_RESPONSE_MESSAGE_TOO_BIG:
926 * Poll AP device for pending replies and send new messages. If either
927 * ap_poll_read or ap_poll_write returns -ENODEV unregister the device.
928 * @ap_dev: pointer to the bus device
929 * @flags: pointer to control flags, bit 2^0 is set if another poll is
930 * required, bit 2^1 is set if the poll timer needs to get armed
933 static inline int ap_poll_queue(struct ap_device *ap_dev, unsigned long *flags)
937 rc = ap_poll_read(ap_dev, flags);
940 return ap_poll_write(ap_dev, flags);
944 * Queue a message to a device.
945 * @ap_dev: pointer to the AP device
946 * @ap_msg: the message to be queued
948 static int __ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
950 struct ap_queue_status status;
952 if (list_empty(&ap_dev->requestq) &&
953 ap_dev->queue_count < ap_dev->queue_depth) {
954 status = __ap_send(ap_dev->qid, ap_msg->psmid,
955 ap_msg->message, ap_msg->length);
956 switch (status.response_code) {
957 case AP_RESPONSE_NORMAL:
958 list_add_tail(&ap_msg->list, &ap_dev->pendingq);
959 atomic_inc(&ap_poll_requests);
960 ap_dev->pendingq_count++;
961 ap_dev->queue_count++;
962 ap_dev->total_request_count++;
964 case AP_RESPONSE_Q_FULL:
965 list_add_tail(&ap_msg->list, &ap_dev->requestq);
966 ap_dev->requestq_count++;
967 ap_dev->total_request_count++;
969 case AP_RESPONSE_MESSAGE_TOO_BIG:
970 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-EINVAL));
972 default: /* Device is gone. */
973 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
977 list_add_tail(&ap_msg->list, &ap_dev->requestq);
978 ap_dev->requestq_count++;
979 ap_dev->total_request_count++;
982 ap_schedule_poll_timer();
986 void ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
991 spin_lock_bh(&ap_dev->lock);
992 if (!ap_dev->unregistered) {
993 /* Make room on the queue by polling for finished requests. */
994 rc = ap_poll_queue(ap_dev, &flags);
996 rc = __ap_queue_message(ap_dev, ap_msg);
998 wake_up(&ap_poll_wait);
1000 ap_dev->unregistered = 1;
1002 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
1005 spin_unlock_bh(&ap_dev->lock);
1007 device_unregister(&ap_dev->device);
1009 EXPORT_SYMBOL(ap_queue_message);
1012 * Cancel a crypto request. This is done by removing the request
1013 * from the devive pendingq or requestq queue. Note that the
1014 * request stays on the AP queue. When it finishes the message
1015 * reply will be discarded because the psmid can't be found.
1016 * @ap_dev: AP device that has the message queued
1017 * @ap_msg: the message that is to be removed
1019 void ap_cancel_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
1021 struct ap_message *tmp;
1023 spin_lock_bh(&ap_dev->lock);
1024 if (!list_empty(&ap_msg->list)) {
1025 list_for_each_entry(tmp, &ap_dev->pendingq, list)
1026 if (tmp->psmid == ap_msg->psmid) {
1027 ap_dev->pendingq_count--;
1030 ap_dev->requestq_count--;
1032 list_del_init(&ap_msg->list);
1034 spin_unlock_bh(&ap_dev->lock);
1036 EXPORT_SYMBOL(ap_cancel_message);
1039 * AP receive polling for finished AP requests
1041 static void ap_poll_timeout(unsigned long unused)
1043 tasklet_schedule(&ap_tasklet);
1047 * Poll all AP devices on the bus in a round robin fashion. Continue
1048 * polling until bit 2^0 of the control flags is not set. If bit 2^1
1049 * of the control flags has been set arm the poll timer.
1051 static int __ap_poll_all(struct ap_device *ap_dev, unsigned long *flags)
1053 spin_lock(&ap_dev->lock);
1054 if (!ap_dev->unregistered) {
1055 if (ap_poll_queue(ap_dev, flags))
1056 ap_dev->unregistered = 1;
1058 spin_unlock(&ap_dev->lock);
1062 static void ap_poll_all(unsigned long dummy)
1064 unsigned long flags;
1065 struct ap_device *ap_dev;
1069 spin_lock(&ap_device_lock);
1070 list_for_each_entry(ap_dev, &ap_device_list, list) {
1071 __ap_poll_all(ap_dev, &flags);
1073 spin_unlock(&ap_device_lock);
1074 } while (flags & 1);
1076 ap_schedule_poll_timer();
1080 * AP bus poll thread. The purpose of this thread is to poll for
1081 * finished requests in a loop if there is a "free" cpu - that is
1082 * a cpu that doesn't have anything better to do. The polling stops
1083 * as soon as there is another task or if all messages have been
1086 static int ap_poll_thread(void *data)
1088 DECLARE_WAITQUEUE(wait, current);
1089 unsigned long flags;
1091 struct ap_device *ap_dev;
1093 set_user_nice(current, 19);
1095 if (need_resched()) {
1099 add_wait_queue(&ap_poll_wait, &wait);
1100 set_current_state(TASK_INTERRUPTIBLE);
1101 if (kthread_should_stop())
1103 requests = atomic_read(&ap_poll_requests);
1106 set_current_state(TASK_RUNNING);
1107 remove_wait_queue(&ap_poll_wait, &wait);
1110 spin_lock_bh(&ap_device_lock);
1111 list_for_each_entry(ap_dev, &ap_device_list, list) {
1112 __ap_poll_all(ap_dev, &flags);
1114 spin_unlock_bh(&ap_device_lock);
1116 set_current_state(TASK_RUNNING);
1117 remove_wait_queue(&ap_poll_wait, &wait);
1121 static int ap_poll_thread_start(void)
1125 mutex_lock(&ap_poll_thread_mutex);
1126 if (!ap_poll_kthread) {
1127 ap_poll_kthread = kthread_run(ap_poll_thread, NULL, "appoll");
1128 rc = IS_ERR(ap_poll_kthread) ? PTR_ERR(ap_poll_kthread) : 0;
1130 ap_poll_kthread = NULL;
1134 mutex_unlock(&ap_poll_thread_mutex);
1138 static void ap_poll_thread_stop(void)
1140 mutex_lock(&ap_poll_thread_mutex);
1141 if (ap_poll_kthread) {
1142 kthread_stop(ap_poll_kthread);
1143 ap_poll_kthread = NULL;
1145 mutex_unlock(&ap_poll_thread_mutex);
1148 static void ap_reset_domain(void)
1152 for (i = 0; i < AP_DEVICES; i++)
1153 ap_reset_queue(AP_MKQID(i, ap_domain_index));
1156 static void ap_reset_all(void)
1160 for (i = 0; i < AP_DOMAINS; i++)
1161 for (j = 0; j < AP_DEVICES; j++)
1162 ap_reset_queue(AP_MKQID(j, i));
1165 static struct reset_call ap_reset_call = {
1170 * The module initialization code.
1172 int __init ap_module_init(void)
1176 if (ap_domain_index < -1 || ap_domain_index >= AP_DOMAINS) {
1177 printk(KERN_WARNING "Invalid param: domain = %d. "
1178 " Not loading.\n", ap_domain_index);
1181 if (ap_instructions_available() != 0) {
1182 printk(KERN_WARNING "AP instructions not installed.\n");
1185 register_reset_call(&ap_reset_call);
1187 /* Create /sys/bus/ap. */
1188 rc = bus_register(&ap_bus_type);
1191 for (i = 0; ap_bus_attrs[i]; i++) {
1192 rc = bus_create_file(&ap_bus_type, ap_bus_attrs[i]);
1197 /* Create /sys/devices/ap. */
1198 ap_root_device = s390_root_dev_register("ap");
1199 rc = IS_ERR(ap_root_device) ? PTR_ERR(ap_root_device) : 0;
1203 ap_work_queue = create_singlethread_workqueue("kapwork");
1204 if (!ap_work_queue) {
1209 if (ap_select_domain() == 0)
1212 /* Setup the ap bus rescan timer. */
1213 init_timer(&ap_config_timer);
1214 ap_config_timer.function = ap_config_timeout;
1215 ap_config_timer.data = 0;
1216 ap_config_timer.expires = jiffies + ap_config_time * HZ;
1217 add_timer(&ap_config_timer);
1219 /* Start the low priority AP bus poll thread. */
1220 if (ap_thread_flag) {
1221 rc = ap_poll_thread_start();
1229 del_timer_sync(&ap_config_timer);
1230 del_timer_sync(&ap_poll_timer);
1231 destroy_workqueue(ap_work_queue);
1233 s390_root_dev_unregister(ap_root_device);
1236 bus_remove_file(&ap_bus_type, ap_bus_attrs[i]);
1237 bus_unregister(&ap_bus_type);
1239 unregister_reset_call(&ap_reset_call);
1243 static int __ap_match_all(struct device *dev, void *data)
1249 * The module termination code
1251 void ap_module_exit(void)
1257 ap_poll_thread_stop();
1258 del_timer_sync(&ap_config_timer);
1259 del_timer_sync(&ap_poll_timer);
1260 destroy_workqueue(ap_work_queue);
1261 tasklet_kill(&ap_tasklet);
1262 s390_root_dev_unregister(ap_root_device);
1263 while ((dev = bus_find_device(&ap_bus_type, NULL, NULL,
1266 device_unregister(dev);
1269 for (i = 0; ap_bus_attrs[i]; i++)
1270 bus_remove_file(&ap_bus_type, ap_bus_attrs[i]);
1271 bus_unregister(&ap_bus_type);
1272 unregister_reset_call(&ap_reset_call);
1275 #ifndef CONFIG_ZCRYPT_MONOLITHIC
1276 module_init(ap_module_init);
1277 module_exit(ap_module_exit);