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);
762 device_unregister(dev);
771 rc = ap_init_queue(qid);
774 ap_dev = kzalloc(sizeof(*ap_dev), GFP_KERNEL);
778 ap_dev->queue_depth = queue_depth;
779 ap_dev->unregistered = 1;
780 spin_lock_init(&ap_dev->lock);
781 INIT_LIST_HEAD(&ap_dev->pendingq);
782 INIT_LIST_HEAD(&ap_dev->requestq);
783 INIT_LIST_HEAD(&ap_dev->list);
784 if (device_type == 0)
785 ap_probe_device_type(ap_dev);
787 ap_dev->device_type = device_type;
789 ap_dev->device.bus = &ap_bus_type;
790 ap_dev->device.parent = ap_root_device;
791 snprintf(ap_dev->device.bus_id, BUS_ID_SIZE, "card%02x",
792 AP_QID_DEVICE(ap_dev->qid));
793 ap_dev->device.release = ap_device_release;
794 rc = device_register(&ap_dev->device);
799 /* Add device attributes. */
800 rc = sysfs_create_group(&ap_dev->device.kobj,
803 spin_lock_bh(&ap_dev->lock);
804 ap_dev->unregistered = 0;
805 spin_unlock_bh(&ap_dev->lock);
808 device_unregister(&ap_dev->device);
813 ap_config_timeout(unsigned long ptr)
815 queue_work(ap_work_queue, &ap_config_work);
816 ap_config_timer.expires = jiffies + ap_config_time * HZ;
817 add_timer(&ap_config_timer);
821 * Set up the timer to run the poll tasklet
823 static inline void ap_schedule_poll_timer(void)
825 if (timer_pending(&ap_poll_timer))
827 mod_timer(&ap_poll_timer, jiffies + AP_POLL_TIME);
831 * Receive pending reply messages from an AP device.
832 * @ap_dev: pointer to the AP device
833 * @flags: pointer to control flags, bit 2^0 is set if another poll is
834 * required, bit 2^1 is set if the poll timer needs to get armed
835 * Returns 0 if the device is still present, -ENODEV if not.
837 static int ap_poll_read(struct ap_device *ap_dev, unsigned long *flags)
839 struct ap_queue_status status;
840 struct ap_message *ap_msg;
842 if (ap_dev->queue_count <= 0)
844 status = __ap_recv(ap_dev->qid, &ap_dev->reply->psmid,
845 ap_dev->reply->message, ap_dev->reply->length);
846 switch (status.response_code) {
847 case AP_RESPONSE_NORMAL:
848 atomic_dec(&ap_poll_requests);
849 ap_dev->queue_count--;
850 list_for_each_entry(ap_msg, &ap_dev->pendingq, list) {
851 if (ap_msg->psmid != ap_dev->reply->psmid)
853 list_del_init(&ap_msg->list);
854 ap_dev->pendingq_count--;
855 ap_dev->drv->receive(ap_dev, ap_msg, ap_dev->reply);
858 if (ap_dev->queue_count > 0)
861 case AP_RESPONSE_NO_PENDING_REPLY:
862 if (status.queue_empty) {
863 /* The card shouldn't forget requests but who knows. */
864 ap_dev->queue_count = 0;
865 list_splice_init(&ap_dev->pendingq, &ap_dev->requestq);
866 ap_dev->requestq_count += ap_dev->pendingq_count;
867 ap_dev->pendingq_count = 0;
878 * Send messages from the request queue to an AP device.
879 * @ap_dev: pointer to the AP device
880 * @flags: pointer to control flags, bit 2^0 is set if another poll is
881 * required, bit 2^1 is set if the poll timer needs to get armed
882 * Returns 0 if the device is still present, -ENODEV if not.
884 static int ap_poll_write(struct ap_device *ap_dev, unsigned long *flags)
886 struct ap_queue_status status;
887 struct ap_message *ap_msg;
889 if (ap_dev->requestq_count <= 0 ||
890 ap_dev->queue_count >= ap_dev->queue_depth)
892 /* Start the next request on the queue. */
893 ap_msg = list_entry(ap_dev->requestq.next, struct ap_message, list);
894 status = __ap_send(ap_dev->qid, ap_msg->psmid,
895 ap_msg->message, ap_msg->length);
896 switch (status.response_code) {
897 case AP_RESPONSE_NORMAL:
898 atomic_inc(&ap_poll_requests);
899 ap_dev->queue_count++;
900 list_move_tail(&ap_msg->list, &ap_dev->pendingq);
901 ap_dev->requestq_count--;
902 ap_dev->pendingq_count++;
903 if (ap_dev->queue_count < ap_dev->queue_depth &&
904 ap_dev->requestq_count > 0)
908 case AP_RESPONSE_Q_FULL:
911 case AP_RESPONSE_MESSAGE_TOO_BIG:
920 * Poll AP device for pending replies and send new messages. If either
921 * ap_poll_read or ap_poll_write returns -ENODEV unregister the device.
922 * @ap_dev: pointer to the bus device
923 * @flags: pointer to control flags, bit 2^0 is set if another poll is
924 * required, bit 2^1 is set if the poll timer needs to get armed
927 static inline int ap_poll_queue(struct ap_device *ap_dev, unsigned long *flags)
931 rc = ap_poll_read(ap_dev, flags);
934 return ap_poll_write(ap_dev, flags);
938 * Queue a message to a device.
939 * @ap_dev: pointer to the AP device
940 * @ap_msg: the message to be queued
942 static int __ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
944 struct ap_queue_status status;
946 if (list_empty(&ap_dev->requestq) &&
947 ap_dev->queue_count < ap_dev->queue_depth) {
948 status = __ap_send(ap_dev->qid, ap_msg->psmid,
949 ap_msg->message, ap_msg->length);
950 switch (status.response_code) {
951 case AP_RESPONSE_NORMAL:
952 list_add_tail(&ap_msg->list, &ap_dev->pendingq);
953 atomic_inc(&ap_poll_requests);
954 ap_dev->pendingq_count++;
955 ap_dev->queue_count++;
956 ap_dev->total_request_count++;
958 case AP_RESPONSE_Q_FULL:
959 list_add_tail(&ap_msg->list, &ap_dev->requestq);
960 ap_dev->requestq_count++;
961 ap_dev->total_request_count++;
963 case AP_RESPONSE_MESSAGE_TOO_BIG:
964 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-EINVAL));
966 default: /* Device is gone. */
967 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
971 list_add_tail(&ap_msg->list, &ap_dev->requestq);
972 ap_dev->requestq_count++;
973 ap_dev->total_request_count++;
976 ap_schedule_poll_timer();
980 void ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
985 spin_lock_bh(&ap_dev->lock);
986 if (!ap_dev->unregistered) {
987 /* Make room on the queue by polling for finished requests. */
988 rc = ap_poll_queue(ap_dev, &flags);
990 rc = __ap_queue_message(ap_dev, ap_msg);
992 wake_up(&ap_poll_wait);
994 ap_dev->unregistered = 1;
996 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
999 spin_unlock_bh(&ap_dev->lock);
1001 device_unregister(&ap_dev->device);
1003 EXPORT_SYMBOL(ap_queue_message);
1006 * Cancel a crypto request. This is done by removing the request
1007 * from the devive pendingq or requestq queue. Note that the
1008 * request stays on the AP queue. When it finishes the message
1009 * reply will be discarded because the psmid can't be found.
1010 * @ap_dev: AP device that has the message queued
1011 * @ap_msg: the message that is to be removed
1013 void ap_cancel_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
1015 struct ap_message *tmp;
1017 spin_lock_bh(&ap_dev->lock);
1018 if (!list_empty(&ap_msg->list)) {
1019 list_for_each_entry(tmp, &ap_dev->pendingq, list)
1020 if (tmp->psmid == ap_msg->psmid) {
1021 ap_dev->pendingq_count--;
1024 ap_dev->requestq_count--;
1026 list_del_init(&ap_msg->list);
1028 spin_unlock_bh(&ap_dev->lock);
1030 EXPORT_SYMBOL(ap_cancel_message);
1033 * AP receive polling for finished AP requests
1035 static void ap_poll_timeout(unsigned long unused)
1037 tasklet_schedule(&ap_tasklet);
1041 * Poll all AP devices on the bus in a round robin fashion. Continue
1042 * polling until bit 2^0 of the control flags is not set. If bit 2^1
1043 * of the control flags has been set arm the poll timer.
1045 static int __ap_poll_all(struct ap_device *ap_dev, unsigned long *flags)
1049 spin_lock(&ap_dev->lock);
1050 if (!ap_dev->unregistered) {
1051 rc = ap_poll_queue(ap_dev, flags);
1053 ap_dev->unregistered = 1;
1056 spin_unlock(&ap_dev->lock);
1058 device_unregister(&ap_dev->device);
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);