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>
8 * Felix Beck <felix.beck@de.ibm.com>
10 * Adjunct processor bus.
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2, or (at your option)
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #define KMSG_COMPONENT "ap"
28 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/delay.h>
33 #include <linux/err.h>
34 #include <linux/interrupt.h>
35 #include <linux/workqueue.h>
36 #include <linux/notifier.h>
37 #include <linux/kthread.h>
38 #include <linux/mutex.h>
39 #include <asm/reset.h>
41 #include <asm/atomic.h>
42 #include <asm/system.h>
44 #include <linux/hrtimer.h>
45 #include <linux/ktime.h>
49 /* Some prototypes. */
50 static void ap_scan_bus(struct work_struct *);
51 static void ap_poll_all(unsigned long);
52 static enum hrtimer_restart ap_poll_timeout(struct hrtimer *);
53 static int ap_poll_thread_start(void);
54 static void ap_poll_thread_stop(void);
55 static void ap_request_timeout(unsigned long);
56 static inline void ap_schedule_poll_timer(void);
57 static int __ap_poll_device(struct ap_device *ap_dev, unsigned long *flags);
58 static int ap_device_remove(struct device *dev);
59 static int ap_device_probe(struct device *dev);
60 static void ap_interrupt_handler(void *unused1, void *unused2);
61 static void ap_reset(struct ap_device *ap_dev);
62 static void ap_config_timeout(unsigned long ptr);
67 MODULE_AUTHOR("IBM Corporation");
68 MODULE_DESCRIPTION("Adjunct Processor Bus driver, "
69 "Copyright 2006 IBM Corporation");
70 MODULE_LICENSE("GPL");
75 int ap_domain_index = -1; /* Adjunct Processor Domain Index */
76 module_param_named(domain, ap_domain_index, int, 0000);
77 MODULE_PARM_DESC(domain, "domain index for ap devices");
78 EXPORT_SYMBOL(ap_domain_index);
80 static int ap_thread_flag = 0;
81 module_param_named(poll_thread, ap_thread_flag, int, 0000);
82 MODULE_PARM_DESC(poll_thread, "Turn on/off poll thread, default is 0 (off).");
84 static struct device *ap_root_device = NULL;
85 static DEFINE_SPINLOCK(ap_device_list_lock);
86 static LIST_HEAD(ap_device_list);
89 * Workqueue & timer for bus rescan.
91 static struct workqueue_struct *ap_work_queue;
92 static struct timer_list ap_config_timer;
93 static int ap_config_time = AP_CONFIG_TIME;
94 static DECLARE_WORK(ap_config_work, ap_scan_bus);
97 * Tasklet & timer for AP request polling and interrupts
99 static DECLARE_TASKLET(ap_tasklet, ap_poll_all, 0);
100 static atomic_t ap_poll_requests = ATOMIC_INIT(0);
101 static DECLARE_WAIT_QUEUE_HEAD(ap_poll_wait);
102 static struct task_struct *ap_poll_kthread = NULL;
103 static DEFINE_MUTEX(ap_poll_thread_mutex);
104 static void *ap_interrupt_indicator;
105 static struct hrtimer ap_poll_timer;
106 /* In LPAR poll with 4kHz frequency. Poll every 250000 nanoseconds.
107 * If z/VM change to 1500000 nanoseconds to adjust to z/VM polling.*/
108 static unsigned long long poll_timeout = 250000;
111 static int ap_suspend_flag;
112 static struct bus_type ap_bus_type;
115 * ap_using_interrupts() - Returns non-zero if interrupt support is
118 static inline int ap_using_interrupts(void)
120 return ap_interrupt_indicator != NULL;
124 * ap_intructions_available() - Test if AP instructions are available.
126 * Returns 0 if the AP instructions are installed.
128 static inline int ap_instructions_available(void)
130 register unsigned long reg0 asm ("0") = AP_MKQID(0,0);
131 register unsigned long reg1 asm ("1") = -ENODEV;
132 register unsigned long reg2 asm ("2") = 0UL;
135 " .long 0xb2af0000\n" /* PQAP(TAPQ) */
139 : "+d" (reg0), "+d" (reg1), "+d" (reg2) : : "cc" );
144 * ap_interrupts_available(): Test if AP interrupts are available.
146 * Returns 1 if AP interrupts are available.
148 static int ap_interrupts_available(void)
150 unsigned long long facility_bits[2];
152 if (stfle(facility_bits, 2) <= 1)
154 if (!(facility_bits[0] & (1ULL << 61)) ||
155 !(facility_bits[1] & (1ULL << 62)))
161 * ap_test_queue(): Test adjunct processor queue.
162 * @qid: The AP queue number
163 * @queue_depth: Pointer to queue depth value
164 * @device_type: Pointer to device type value
166 * Returns AP queue status structure.
168 static inline struct ap_queue_status
169 ap_test_queue(ap_qid_t qid, int *queue_depth, int *device_type)
171 register unsigned long reg0 asm ("0") = qid;
172 register struct ap_queue_status reg1 asm ("1");
173 register unsigned long reg2 asm ("2") = 0UL;
175 asm volatile(".long 0xb2af0000" /* PQAP(TAPQ) */
176 : "+d" (reg0), "=d" (reg1), "+d" (reg2) : : "cc");
177 *device_type = (int) (reg2 >> 24);
178 *queue_depth = (int) (reg2 & 0xff);
183 * ap_reset_queue(): Reset adjunct processor queue.
184 * @qid: The AP queue number
186 * Returns AP queue status structure.
188 static inline struct ap_queue_status ap_reset_queue(ap_qid_t qid)
190 register unsigned long reg0 asm ("0") = qid | 0x01000000UL;
191 register struct ap_queue_status reg1 asm ("1");
192 register unsigned long reg2 asm ("2") = 0UL;
195 ".long 0xb2af0000" /* PQAP(RAPQ) */
196 : "+d" (reg0), "=d" (reg1), "+d" (reg2) : : "cc");
202 * ap_queue_interruption_control(): Enable interruption for a specific AP.
203 * @qid: The AP queue number
204 * @ind: The notification indicator byte
206 * Returns AP queue status.
208 static inline struct ap_queue_status
209 ap_queue_interruption_control(ap_qid_t qid, void *ind)
211 register unsigned long reg0 asm ("0") = qid | 0x03000000UL;
212 register unsigned long reg1_in asm ("1") = 0x0000800000000000UL | AP_ISC;
213 register struct ap_queue_status reg1_out asm ("1");
214 register void *reg2 asm ("2") = ind;
216 ".long 0xb2af0000" /* PQAP(RAPQ) */
217 : "+d" (reg0), "+d" (reg1_in), "=d" (reg1_out), "+d" (reg2)
225 * ap_queue_enable_interruption(): Enable interruption on an AP.
226 * @qid: The AP queue number
227 * @ind: the notification indicator byte
229 * Enables interruption on AP queue via ap_queue_interruption_control(). Based
230 * on the return value it waits a while and tests the AP queue if interrupts
231 * have been switched on using ap_test_queue().
233 static int ap_queue_enable_interruption(ap_qid_t qid, void *ind)
236 struct ap_queue_status status;
237 int t_depth, t_device_type, rc, i;
240 status = ap_queue_interruption_control(qid, ind);
242 for (i = 0; i < AP_MAX_RESET; i++) {
243 switch (status.response_code) {
244 case AP_RESPONSE_NORMAL:
245 if (status.int_enabled)
248 case AP_RESPONSE_RESET_IN_PROGRESS:
249 case AP_RESPONSE_BUSY:
251 case AP_RESPONSE_Q_NOT_AVAIL:
252 case AP_RESPONSE_DECONFIGURED:
253 case AP_RESPONSE_CHECKSTOPPED:
254 case AP_RESPONSE_INVALID_ADDRESS:
256 case AP_RESPONSE_OTHERWISE_CHANGED:
257 if (status.int_enabled)
263 if (i < AP_MAX_RESET - 1) {
265 status = ap_test_queue(qid, &t_depth, &t_device_type);
275 * __ap_send(): Send message to adjunct processor queue.
276 * @qid: The AP queue number
277 * @psmid: The program supplied message identifier
278 * @msg: The message text
279 * @length: The message length
281 * Returns AP queue status structure.
282 * Condition code 1 on NQAP can't happen because the L bit is 1.
283 * Condition code 2 on NQAP also means the send is incomplete,
284 * because a segment boundary was reached. The NQAP is repeated.
286 static inline struct ap_queue_status
287 __ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length)
289 typedef struct { char _[length]; } msgblock;
290 register unsigned long reg0 asm ("0") = qid | 0x40000000UL;
291 register struct ap_queue_status reg1 asm ("1");
292 register unsigned long reg2 asm ("2") = (unsigned long) msg;
293 register unsigned long reg3 asm ("3") = (unsigned long) length;
294 register unsigned long reg4 asm ("4") = (unsigned int) (psmid >> 32);
295 register unsigned long reg5 asm ("5") = (unsigned int) psmid;
298 "0: .long 0xb2ad0042\n" /* DQAP */
300 : "+d" (reg0), "=d" (reg1), "+d" (reg2), "+d" (reg3)
301 : "d" (reg4), "d" (reg5), "m" (*(msgblock *) msg)
306 int ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length)
308 struct ap_queue_status status;
310 status = __ap_send(qid, psmid, msg, length);
311 switch (status.response_code) {
312 case AP_RESPONSE_NORMAL:
314 case AP_RESPONSE_Q_FULL:
315 case AP_RESPONSE_RESET_IN_PROGRESS:
317 default: /* Device is gone. */
321 EXPORT_SYMBOL(ap_send);
324 * __ap_recv(): Receive message from adjunct processor queue.
325 * @qid: The AP queue number
326 * @psmid: Pointer to program supplied message identifier
327 * @msg: The message text
328 * @length: The message length
330 * Returns AP queue status structure.
331 * Condition code 1 on DQAP means the receive has taken place
332 * but only partially. The response is incomplete, hence the
334 * Condition code 2 on DQAP also means the receive is incomplete,
335 * this time because a segment boundary was reached. Again, the
337 * Note that gpr2 is used by the DQAP instruction to keep track of
338 * any 'residual' length, in case the instruction gets interrupted.
339 * Hence it gets zeroed before the instruction.
341 static inline struct ap_queue_status
342 __ap_recv(ap_qid_t qid, unsigned long long *psmid, void *msg, size_t length)
344 typedef struct { char _[length]; } msgblock;
345 register unsigned long reg0 asm("0") = qid | 0x80000000UL;
346 register struct ap_queue_status reg1 asm ("1");
347 register unsigned long reg2 asm("2") = 0UL;
348 register unsigned long reg4 asm("4") = (unsigned long) msg;
349 register unsigned long reg5 asm("5") = (unsigned long) length;
350 register unsigned long reg6 asm("6") = 0UL;
351 register unsigned long reg7 asm("7") = 0UL;
355 "0: .long 0xb2ae0064\n"
357 : "+d" (reg0), "=d" (reg1), "+d" (reg2),
358 "+d" (reg4), "+d" (reg5), "+d" (reg6), "+d" (reg7),
359 "=m" (*(msgblock *) msg) : : "cc" );
360 *psmid = (((unsigned long long) reg6) << 32) + reg7;
364 int ap_recv(ap_qid_t qid, unsigned long long *psmid, void *msg, size_t length)
366 struct ap_queue_status status;
368 status = __ap_recv(qid, psmid, msg, length);
369 switch (status.response_code) {
370 case AP_RESPONSE_NORMAL:
372 case AP_RESPONSE_NO_PENDING_REPLY:
373 if (status.queue_empty)
376 case AP_RESPONSE_RESET_IN_PROGRESS:
382 EXPORT_SYMBOL(ap_recv);
385 * ap_query_queue(): Check if an AP queue is available.
386 * @qid: The AP queue number
387 * @queue_depth: Pointer to queue depth value
388 * @device_type: Pointer to device type value
390 * The test is repeated for AP_MAX_RESET times.
392 static int ap_query_queue(ap_qid_t qid, int *queue_depth, int *device_type)
394 struct ap_queue_status status;
395 int t_depth, t_device_type, rc, i;
398 for (i = 0; i < AP_MAX_RESET; i++) {
399 status = ap_test_queue(qid, &t_depth, &t_device_type);
400 switch (status.response_code) {
401 case AP_RESPONSE_NORMAL:
402 *queue_depth = t_depth + 1;
403 *device_type = t_device_type;
406 case AP_RESPONSE_Q_NOT_AVAIL:
409 case AP_RESPONSE_RESET_IN_PROGRESS:
411 case AP_RESPONSE_DECONFIGURED:
414 case AP_RESPONSE_CHECKSTOPPED:
417 case AP_RESPONSE_INVALID_ADDRESS:
420 case AP_RESPONSE_OTHERWISE_CHANGED:
422 case AP_RESPONSE_BUSY:
429 if (i < AP_MAX_RESET - 1)
436 * ap_init_queue(): Reset an AP queue.
437 * @qid: The AP queue number
439 * Reset an AP queue and wait for it to become available again.
441 static int ap_init_queue(ap_qid_t qid)
443 struct ap_queue_status status;
447 status = ap_reset_queue(qid);
448 for (i = 0; i < AP_MAX_RESET; i++) {
449 switch (status.response_code) {
450 case AP_RESPONSE_NORMAL:
451 if (status.queue_empty)
454 case AP_RESPONSE_Q_NOT_AVAIL:
455 case AP_RESPONSE_DECONFIGURED:
456 case AP_RESPONSE_CHECKSTOPPED:
457 i = AP_MAX_RESET; /* return with -ENODEV */
459 case AP_RESPONSE_RESET_IN_PROGRESS:
461 case AP_RESPONSE_BUSY:
465 if (rc != -ENODEV && rc != -EBUSY)
467 if (i < AP_MAX_RESET - 1) {
469 status = ap_test_queue(qid, &dummy, &dummy);
472 if (rc == 0 && ap_using_interrupts()) {
473 rc = ap_queue_enable_interruption(qid, ap_interrupt_indicator);
474 /* If interruption mode is supported by the machine,
475 * but an AP can not be enabled for interruption then
476 * the AP will be discarded. */
478 pr_err("Registering adapter interrupts for "
479 "AP %d failed\n", AP_QID_DEVICE(qid));
485 * ap_increase_queue_count(): Arm request timeout.
486 * @ap_dev: Pointer to an AP device.
488 * Arm request timeout if an AP device was idle and a new request is submitted.
490 static void ap_increase_queue_count(struct ap_device *ap_dev)
492 int timeout = ap_dev->drv->request_timeout;
494 ap_dev->queue_count++;
495 if (ap_dev->queue_count == 1) {
496 mod_timer(&ap_dev->timeout, jiffies + timeout);
497 ap_dev->reset = AP_RESET_ARMED;
502 * ap_decrease_queue_count(): Decrease queue count.
503 * @ap_dev: Pointer to an AP device.
505 * If AP device is still alive, re-schedule request timeout if there are still
508 static void ap_decrease_queue_count(struct ap_device *ap_dev)
510 int timeout = ap_dev->drv->request_timeout;
512 ap_dev->queue_count--;
513 if (ap_dev->queue_count > 0)
514 mod_timer(&ap_dev->timeout, jiffies + timeout);
517 * The timeout timer should to be disabled now - since
518 * del_timer_sync() is very expensive, we just tell via the
519 * reset flag to ignore the pending timeout timer.
521 ap_dev->reset = AP_RESET_IGNORE;
525 * AP device related attributes.
527 static ssize_t ap_hwtype_show(struct device *dev,
528 struct device_attribute *attr, char *buf)
530 struct ap_device *ap_dev = to_ap_dev(dev);
531 return snprintf(buf, PAGE_SIZE, "%d\n", ap_dev->device_type);
534 static DEVICE_ATTR(hwtype, 0444, ap_hwtype_show, NULL);
535 static ssize_t ap_depth_show(struct device *dev, struct device_attribute *attr,
538 struct ap_device *ap_dev = to_ap_dev(dev);
539 return snprintf(buf, PAGE_SIZE, "%d\n", ap_dev->queue_depth);
542 static DEVICE_ATTR(depth, 0444, ap_depth_show, NULL);
543 static ssize_t ap_request_count_show(struct device *dev,
544 struct device_attribute *attr,
547 struct ap_device *ap_dev = to_ap_dev(dev);
550 spin_lock_bh(&ap_dev->lock);
551 rc = snprintf(buf, PAGE_SIZE, "%d\n", ap_dev->total_request_count);
552 spin_unlock_bh(&ap_dev->lock);
556 static DEVICE_ATTR(request_count, 0444, ap_request_count_show, NULL);
558 static ssize_t ap_modalias_show(struct device *dev,
559 struct device_attribute *attr, char *buf)
561 return sprintf(buf, "ap:t%02X", to_ap_dev(dev)->device_type);
564 static DEVICE_ATTR(modalias, 0444, ap_modalias_show, NULL);
566 static struct attribute *ap_dev_attrs[] = {
567 &dev_attr_hwtype.attr,
568 &dev_attr_depth.attr,
569 &dev_attr_request_count.attr,
570 &dev_attr_modalias.attr,
573 static struct attribute_group ap_dev_attr_group = {
574 .attrs = ap_dev_attrs
579 * @dev: Pointer to device
580 * @drv: Pointer to device_driver
582 * AP bus driver registration/unregistration.
584 static int ap_bus_match(struct device *dev, struct device_driver *drv)
586 struct ap_device *ap_dev = to_ap_dev(dev);
587 struct ap_driver *ap_drv = to_ap_drv(drv);
588 struct ap_device_id *id;
591 * Compare device type of the device with the list of
592 * supported types of the device_driver.
594 for (id = ap_drv->ids; id->match_flags; id++) {
595 if ((id->match_flags & AP_DEVICE_ID_MATCH_DEVICE_TYPE) &&
596 (id->dev_type != ap_dev->device_type))
604 * ap_uevent(): Uevent function for AP devices.
605 * @dev: Pointer to device
606 * @env: Pointer to kobj_uevent_env
608 * It sets up a single environment variable DEV_TYPE which contains the
609 * hardware device type.
611 static int ap_uevent (struct device *dev, struct kobj_uevent_env *env)
613 struct ap_device *ap_dev = to_ap_dev(dev);
619 /* Set up DEV_TYPE environment variable. */
620 retval = add_uevent_var(env, "DEV_TYPE=%04X", ap_dev->device_type);
625 retval = add_uevent_var(env, "MODALIAS=ap:t%02X", ap_dev->device_type);
630 static int ap_bus_suspend(struct device *dev, pm_message_t state)
632 struct ap_device *ap_dev = to_ap_dev(dev);
635 if (!ap_suspend_flag) {
638 /* Disable scanning for devices, thus we do not want to scan
639 * for them after removing.
641 del_timer_sync(&ap_config_timer);
642 if (ap_work_queue != NULL) {
643 destroy_workqueue(ap_work_queue);
644 ap_work_queue = NULL;
646 tasklet_disable(&ap_tasklet);
648 /* Poll on the device until all requests are finished. */
651 __ap_poll_device(ap_dev, &flags);
652 } while ((flags & 1) || (flags & 2));
654 ap_device_remove(dev);
658 static int ap_bus_resume(struct device *dev)
661 struct ap_device *ap_dev = to_ap_dev(dev);
663 if (ap_suspend_flag) {
665 if (!ap_interrupts_available())
666 ap_interrupt_indicator = NULL;
667 ap_device_probe(dev);
669 setup_timer(&ap_dev->timeout, ap_request_timeout,
670 (unsigned long) ap_dev);
672 init_timer(&ap_config_timer);
673 ap_config_timer.function = ap_config_timeout;
674 ap_config_timer.data = 0;
675 ap_config_timer.expires = jiffies + ap_config_time * HZ;
676 add_timer(&ap_config_timer);
677 ap_work_queue = create_singlethread_workqueue("kapwork");
680 tasklet_enable(&ap_tasklet);
681 if (!ap_using_interrupts())
682 ap_schedule_poll_timer();
684 tasklet_schedule(&ap_tasklet);
686 rc = ap_poll_thread_start();
688 ap_device_probe(dev);
690 setup_timer(&ap_dev->timeout, ap_request_timeout,
691 (unsigned long) ap_dev);
697 static struct bus_type ap_bus_type = {
699 .match = &ap_bus_match,
700 .uevent = &ap_uevent,
701 .suspend = ap_bus_suspend,
702 .resume = ap_bus_resume
705 static int ap_device_probe(struct device *dev)
707 struct ap_device *ap_dev = to_ap_dev(dev);
708 struct ap_driver *ap_drv = to_ap_drv(dev->driver);
711 ap_dev->drv = ap_drv;
712 rc = ap_drv->probe ? ap_drv->probe(ap_dev) : -ENODEV;
714 spin_lock_bh(&ap_device_list_lock);
715 list_add(&ap_dev->list, &ap_device_list);
716 spin_unlock_bh(&ap_device_list_lock);
722 * __ap_flush_queue(): Flush requests.
723 * @ap_dev: Pointer to the AP device
725 * Flush all requests from the request/pending queue of an AP device.
727 static void __ap_flush_queue(struct ap_device *ap_dev)
729 struct ap_message *ap_msg, *next;
731 list_for_each_entry_safe(ap_msg, next, &ap_dev->pendingq, list) {
732 list_del_init(&ap_msg->list);
733 ap_dev->pendingq_count--;
734 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
736 list_for_each_entry_safe(ap_msg, next, &ap_dev->requestq, list) {
737 list_del_init(&ap_msg->list);
738 ap_dev->requestq_count--;
739 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
743 void ap_flush_queue(struct ap_device *ap_dev)
745 spin_lock_bh(&ap_dev->lock);
746 __ap_flush_queue(ap_dev);
747 spin_unlock_bh(&ap_dev->lock);
749 EXPORT_SYMBOL(ap_flush_queue);
751 static int ap_device_remove(struct device *dev)
753 struct ap_device *ap_dev = to_ap_dev(dev);
754 struct ap_driver *ap_drv = ap_dev->drv;
756 ap_flush_queue(ap_dev);
757 del_timer_sync(&ap_dev->timeout);
758 spin_lock_bh(&ap_device_list_lock);
759 list_del_init(&ap_dev->list);
760 spin_unlock_bh(&ap_device_list_lock);
762 ap_drv->remove(ap_dev);
763 spin_lock_bh(&ap_dev->lock);
764 atomic_sub(ap_dev->queue_count, &ap_poll_requests);
765 spin_unlock_bh(&ap_dev->lock);
769 int ap_driver_register(struct ap_driver *ap_drv, struct module *owner,
772 struct device_driver *drv = &ap_drv->driver;
774 drv->bus = &ap_bus_type;
775 drv->probe = ap_device_probe;
776 drv->remove = ap_device_remove;
779 return driver_register(drv);
781 EXPORT_SYMBOL(ap_driver_register);
783 void ap_driver_unregister(struct ap_driver *ap_drv)
785 driver_unregister(&ap_drv->driver);
787 EXPORT_SYMBOL(ap_driver_unregister);
792 static ssize_t ap_domain_show(struct bus_type *bus, char *buf)
794 return snprintf(buf, PAGE_SIZE, "%d\n", ap_domain_index);
797 static BUS_ATTR(ap_domain, 0444, ap_domain_show, NULL);
799 static ssize_t ap_config_time_show(struct bus_type *bus, char *buf)
801 return snprintf(buf, PAGE_SIZE, "%d\n", ap_config_time);
804 static ssize_t ap_interrupts_show(struct bus_type *bus, char *buf)
806 return snprintf(buf, PAGE_SIZE, "%d\n",
807 ap_using_interrupts() ? 1 : 0);
810 static BUS_ATTR(ap_interrupts, 0444, ap_interrupts_show, NULL);
812 static ssize_t ap_config_time_store(struct bus_type *bus,
813 const char *buf, size_t count)
817 if (sscanf(buf, "%d\n", &time) != 1 || time < 5 || time > 120)
819 ap_config_time = time;
820 if (!timer_pending(&ap_config_timer) ||
821 !mod_timer(&ap_config_timer, jiffies + ap_config_time * HZ)) {
822 ap_config_timer.expires = jiffies + ap_config_time * HZ;
823 add_timer(&ap_config_timer);
828 static BUS_ATTR(config_time, 0644, ap_config_time_show, ap_config_time_store);
830 static ssize_t ap_poll_thread_show(struct bus_type *bus, char *buf)
832 return snprintf(buf, PAGE_SIZE, "%d\n", ap_poll_kthread ? 1 : 0);
835 static ssize_t ap_poll_thread_store(struct bus_type *bus,
836 const char *buf, size_t count)
840 if (sscanf(buf, "%d\n", &flag) != 1)
843 rc = ap_poll_thread_start();
848 ap_poll_thread_stop();
852 static BUS_ATTR(poll_thread, 0644, ap_poll_thread_show, ap_poll_thread_store);
854 static ssize_t poll_timeout_show(struct bus_type *bus, char *buf)
856 return snprintf(buf, PAGE_SIZE, "%llu\n", poll_timeout);
859 static ssize_t poll_timeout_store(struct bus_type *bus, const char *buf,
862 unsigned long long time;
865 /* 120 seconds = maximum poll interval */
866 if (sscanf(buf, "%llu\n", &time) != 1 || time < 1 ||
867 time > 120000000000ULL)
870 hr_time = ktime_set(0, poll_timeout);
872 if (!hrtimer_is_queued(&ap_poll_timer) ||
873 !hrtimer_forward(&ap_poll_timer, hrtimer_get_expires(&ap_poll_timer), hr_time)) {
874 hrtimer_set_expires(&ap_poll_timer, hr_time);
875 hrtimer_start_expires(&ap_poll_timer, HRTIMER_MODE_ABS);
880 static BUS_ATTR(poll_timeout, 0644, poll_timeout_show, poll_timeout_store);
882 static struct bus_attribute *const ap_bus_attrs[] = {
884 &bus_attr_config_time,
885 &bus_attr_poll_thread,
886 &bus_attr_ap_interrupts,
887 &bus_attr_poll_timeout,
892 * ap_select_domain(): Select an AP domain.
894 * Pick one of the 16 AP domains.
896 static int ap_select_domain(void)
898 int queue_depth, device_type, count, max_count, best_domain;
902 * We want to use a single domain. Either the one specified with
903 * the "domain=" parameter or the domain with the maximum number
906 if (ap_domain_index >= 0 && ap_domain_index < AP_DOMAINS)
907 /* Domain has already been selected. */
911 for (i = 0; i < AP_DOMAINS; i++) {
913 for (j = 0; j < AP_DEVICES; j++) {
914 ap_qid_t qid = AP_MKQID(j, i);
915 rc = ap_query_queue(qid, &queue_depth, &device_type);
920 if (count > max_count) {
925 if (best_domain >= 0){
926 ap_domain_index = best_domain;
933 * ap_probe_device_type(): Find the device type of an AP.
934 * @ap_dev: pointer to the AP device.
936 * Find the device type if query queue returned a device type of 0.
938 static int ap_probe_device_type(struct ap_device *ap_dev)
940 static unsigned char msg[] = {
941 0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,
942 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
943 0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,
944 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
945 0x01,0x00,0x43,0x43,0x41,0x2d,0x41,0x50,
946 0x50,0x4c,0x20,0x20,0x20,0x01,0x01,0x01,
947 0x00,0x00,0x00,0x00,0x50,0x4b,0x00,0x00,
948 0x00,0x00,0x01,0x1c,0x00,0x00,0x00,0x00,
949 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
950 0x00,0x00,0x05,0xb8,0x00,0x00,0x00,0x00,
951 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
952 0x70,0x00,0x41,0x00,0x00,0x00,0x00,0x00,
953 0x00,0x00,0x54,0x32,0x01,0x00,0xa0,0x00,
954 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
955 0x00,0x00,0x00,0x00,0xb8,0x05,0x00,0x00,
956 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
957 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
958 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
959 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
960 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
961 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
962 0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,
963 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
964 0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,
965 0x49,0x43,0x53,0x46,0x20,0x20,0x20,0x20,
966 0x50,0x4b,0x0a,0x00,0x50,0x4b,0x43,0x53,
967 0x2d,0x31,0x2e,0x32,0x37,0x00,0x11,0x22,
968 0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00,
969 0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,
970 0x99,0x00,0x11,0x22,0x33,0x44,0x55,0x66,
971 0x77,0x88,0x99,0x00,0x11,0x22,0x33,0x44,
972 0x55,0x66,0x77,0x88,0x99,0x00,0x11,0x22,
973 0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00,
974 0x11,0x22,0x33,0x5d,0x00,0x5b,0x00,0x77,
975 0x88,0x1e,0x00,0x00,0x57,0x00,0x00,0x00,
976 0x00,0x04,0x00,0x00,0x4f,0x00,0x00,0x00,
977 0x03,0x02,0x00,0x00,0x40,0x01,0x00,0x01,
978 0xce,0x02,0x68,0x2d,0x5f,0xa9,0xde,0x0c,
979 0xf6,0xd2,0x7b,0x58,0x4b,0xf9,0x28,0x68,
980 0x3d,0xb4,0xf4,0xef,0x78,0xd5,0xbe,0x66,
981 0x63,0x42,0xef,0xf8,0xfd,0xa4,0xf8,0xb0,
982 0x8e,0x29,0xc2,0xc9,0x2e,0xd8,0x45,0xb8,
983 0x53,0x8c,0x6f,0x4e,0x72,0x8f,0x6c,0x04,
984 0x9c,0x88,0xfc,0x1e,0xc5,0x83,0x55,0x57,
985 0xf7,0xdd,0xfd,0x4f,0x11,0x36,0x95,0x5d,
987 struct ap_queue_status status;
988 unsigned long long psmid;
992 reply = (void *) get_zeroed_page(GFP_KERNEL);
998 status = __ap_send(ap_dev->qid, 0x0102030405060708ULL,
1000 if (status.response_code != AP_RESPONSE_NORMAL) {
1005 /* Wait for the test message to complete. */
1006 for (i = 0; i < 6; i++) {
1008 status = __ap_recv(ap_dev->qid, &psmid, reply, 4096);
1009 if (status.response_code == AP_RESPONSE_NORMAL &&
1010 psmid == 0x0102030405060708ULL)
1014 /* Got an answer. */
1015 if (reply[0] == 0x00 && reply[1] == 0x86)
1016 ap_dev->device_type = AP_DEVICE_TYPE_PCICC;
1018 ap_dev->device_type = AP_DEVICE_TYPE_PCICA;
1024 free_page((unsigned long) reply);
1029 static void ap_interrupt_handler(void *unused1, void *unused2)
1031 tasklet_schedule(&ap_tasklet);
1035 * __ap_scan_bus(): Scan the AP bus.
1036 * @dev: Pointer to device
1037 * @data: Pointer to data
1039 * Scan the AP bus for new devices.
1041 static int __ap_scan_bus(struct device *dev, void *data)
1043 return to_ap_dev(dev)->qid == (ap_qid_t)(unsigned long) data;
1046 static void ap_device_release(struct device *dev)
1048 struct ap_device *ap_dev = to_ap_dev(dev);
1053 static void ap_scan_bus(struct work_struct *unused)
1055 struct ap_device *ap_dev;
1058 int queue_depth, device_type;
1061 if (ap_select_domain() != 0)
1063 for (i = 0; i < AP_DEVICES; i++) {
1064 qid = AP_MKQID(i, ap_domain_index);
1065 dev = bus_find_device(&ap_bus_type, NULL,
1066 (void *)(unsigned long)qid,
1068 rc = ap_query_queue(qid, &queue_depth, &device_type);
1071 set_current_state(TASK_UNINTERRUPTIBLE);
1072 schedule_timeout(AP_RESET_TIMEOUT);
1073 rc = ap_query_queue(qid, &queue_depth,
1076 ap_dev = to_ap_dev(dev);
1077 spin_lock_bh(&ap_dev->lock);
1078 if (rc || ap_dev->unregistered) {
1079 spin_unlock_bh(&ap_dev->lock);
1080 device_unregister(dev);
1084 spin_unlock_bh(&ap_dev->lock);
1090 rc = ap_init_queue(qid);
1093 ap_dev = kzalloc(sizeof(*ap_dev), GFP_KERNEL);
1097 ap_dev->queue_depth = queue_depth;
1098 ap_dev->unregistered = 1;
1099 spin_lock_init(&ap_dev->lock);
1100 INIT_LIST_HEAD(&ap_dev->pendingq);
1101 INIT_LIST_HEAD(&ap_dev->requestq);
1102 INIT_LIST_HEAD(&ap_dev->list);
1103 setup_timer(&ap_dev->timeout, ap_request_timeout,
1104 (unsigned long) ap_dev);
1105 if (device_type == 0)
1106 ap_probe_device_type(ap_dev);
1108 ap_dev->device_type = device_type;
1110 ap_dev->device.bus = &ap_bus_type;
1111 ap_dev->device.parent = ap_root_device;
1112 dev_set_name(&ap_dev->device, "card%02x",
1113 AP_QID_DEVICE(ap_dev->qid));
1114 ap_dev->device.release = ap_device_release;
1115 rc = device_register(&ap_dev->device);
1117 put_device(&ap_dev->device);
1120 /* Add device attributes. */
1121 rc = sysfs_create_group(&ap_dev->device.kobj,
1122 &ap_dev_attr_group);
1124 spin_lock_bh(&ap_dev->lock);
1125 ap_dev->unregistered = 0;
1126 spin_unlock_bh(&ap_dev->lock);
1129 device_unregister(&ap_dev->device);
1134 ap_config_timeout(unsigned long ptr)
1136 queue_work(ap_work_queue, &ap_config_work);
1137 ap_config_timer.expires = jiffies + ap_config_time * HZ;
1138 add_timer(&ap_config_timer);
1142 * ap_schedule_poll_timer(): Schedule poll timer.
1144 * Set up the timer to run the poll tasklet
1146 static inline void ap_schedule_poll_timer(void)
1149 if (ap_using_interrupts() || ap_suspend_flag)
1151 if (hrtimer_is_queued(&ap_poll_timer))
1153 if (ktime_to_ns(hrtimer_expires_remaining(&ap_poll_timer)) <= 0) {
1154 hr_time = ktime_set(0, poll_timeout);
1155 hrtimer_forward_now(&ap_poll_timer, hr_time);
1156 hrtimer_restart(&ap_poll_timer);
1162 * ap_poll_read(): Receive pending reply messages from an AP device.
1163 * @ap_dev: pointer to the AP device
1164 * @flags: pointer to control flags, bit 2^0 is set if another poll is
1165 * required, bit 2^1 is set if the poll timer needs to get armed
1167 * Returns 0 if the device is still present, -ENODEV if not.
1169 static int ap_poll_read(struct ap_device *ap_dev, unsigned long *flags)
1171 struct ap_queue_status status;
1172 struct ap_message *ap_msg;
1174 if (ap_dev->queue_count <= 0)
1176 status = __ap_recv(ap_dev->qid, &ap_dev->reply->psmid,
1177 ap_dev->reply->message, ap_dev->reply->length);
1178 switch (status.response_code) {
1179 case AP_RESPONSE_NORMAL:
1180 atomic_dec(&ap_poll_requests);
1181 ap_decrease_queue_count(ap_dev);
1182 list_for_each_entry(ap_msg, &ap_dev->pendingq, list) {
1183 if (ap_msg->psmid != ap_dev->reply->psmid)
1185 list_del_init(&ap_msg->list);
1186 ap_dev->pendingq_count--;
1187 ap_dev->drv->receive(ap_dev, ap_msg, ap_dev->reply);
1190 if (ap_dev->queue_count > 0)
1193 case AP_RESPONSE_NO_PENDING_REPLY:
1194 if (status.queue_empty) {
1195 /* The card shouldn't forget requests but who knows. */
1196 atomic_sub(ap_dev->queue_count, &ap_poll_requests);
1197 ap_dev->queue_count = 0;
1198 list_splice_init(&ap_dev->pendingq, &ap_dev->requestq);
1199 ap_dev->requestq_count += ap_dev->pendingq_count;
1200 ap_dev->pendingq_count = 0;
1211 * ap_poll_write(): Send messages from the request queue to an AP device.
1212 * @ap_dev: pointer to the AP device
1213 * @flags: pointer to control flags, bit 2^0 is set if another poll is
1214 * required, bit 2^1 is set if the poll timer needs to get armed
1216 * Returns 0 if the device is still present, -ENODEV if not.
1218 static int ap_poll_write(struct ap_device *ap_dev, unsigned long *flags)
1220 struct ap_queue_status status;
1221 struct ap_message *ap_msg;
1223 if (ap_dev->requestq_count <= 0 ||
1224 ap_dev->queue_count >= ap_dev->queue_depth)
1226 /* Start the next request on the queue. */
1227 ap_msg = list_entry(ap_dev->requestq.next, struct ap_message, list);
1228 status = __ap_send(ap_dev->qid, ap_msg->psmid,
1229 ap_msg->message, ap_msg->length);
1230 switch (status.response_code) {
1231 case AP_RESPONSE_NORMAL:
1232 atomic_inc(&ap_poll_requests);
1233 ap_increase_queue_count(ap_dev);
1234 list_move_tail(&ap_msg->list, &ap_dev->pendingq);
1235 ap_dev->requestq_count--;
1236 ap_dev->pendingq_count++;
1237 if (ap_dev->queue_count < ap_dev->queue_depth &&
1238 ap_dev->requestq_count > 0)
1242 case AP_RESPONSE_Q_FULL:
1243 case AP_RESPONSE_RESET_IN_PROGRESS:
1246 case AP_RESPONSE_MESSAGE_TOO_BIG:
1255 * ap_poll_queue(): Poll AP device for pending replies and send new messages.
1256 * @ap_dev: pointer to the bus device
1257 * @flags: pointer to control flags, bit 2^0 is set if another poll is
1258 * required, bit 2^1 is set if the poll timer needs to get armed
1260 * Poll AP device for pending replies and send new messages. If either
1261 * ap_poll_read or ap_poll_write returns -ENODEV unregister the device.
1264 static inline int ap_poll_queue(struct ap_device *ap_dev, unsigned long *flags)
1268 rc = ap_poll_read(ap_dev, flags);
1271 return ap_poll_write(ap_dev, flags);
1275 * __ap_queue_message(): Queue a message to a device.
1276 * @ap_dev: pointer to the AP device
1277 * @ap_msg: the message to be queued
1279 * Queue a message to a device. Returns 0 if successful.
1281 static int __ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
1283 struct ap_queue_status status;
1285 if (list_empty(&ap_dev->requestq) &&
1286 ap_dev->queue_count < ap_dev->queue_depth) {
1287 status = __ap_send(ap_dev->qid, ap_msg->psmid,
1288 ap_msg->message, ap_msg->length);
1289 switch (status.response_code) {
1290 case AP_RESPONSE_NORMAL:
1291 list_add_tail(&ap_msg->list, &ap_dev->pendingq);
1292 atomic_inc(&ap_poll_requests);
1293 ap_dev->pendingq_count++;
1294 ap_increase_queue_count(ap_dev);
1295 ap_dev->total_request_count++;
1297 case AP_RESPONSE_Q_FULL:
1298 case AP_RESPONSE_RESET_IN_PROGRESS:
1299 list_add_tail(&ap_msg->list, &ap_dev->requestq);
1300 ap_dev->requestq_count++;
1301 ap_dev->total_request_count++;
1303 case AP_RESPONSE_MESSAGE_TOO_BIG:
1304 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-EINVAL));
1306 default: /* Device is gone. */
1307 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
1311 list_add_tail(&ap_msg->list, &ap_dev->requestq);
1312 ap_dev->requestq_count++;
1313 ap_dev->total_request_count++;
1316 ap_schedule_poll_timer();
1320 void ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
1322 unsigned long flags;
1325 spin_lock_bh(&ap_dev->lock);
1326 if (!ap_dev->unregistered) {
1327 /* Make room on the queue by polling for finished requests. */
1328 rc = ap_poll_queue(ap_dev, &flags);
1330 rc = __ap_queue_message(ap_dev, ap_msg);
1332 wake_up(&ap_poll_wait);
1334 ap_dev->unregistered = 1;
1336 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
1339 spin_unlock_bh(&ap_dev->lock);
1341 device_unregister(&ap_dev->device);
1343 EXPORT_SYMBOL(ap_queue_message);
1346 * ap_cancel_message(): Cancel a crypto request.
1347 * @ap_dev: The AP device that has the message queued
1348 * @ap_msg: The message that is to be removed
1350 * Cancel a crypto request. This is done by removing the request
1351 * from the device pending or request queue. Note that the
1352 * request stays on the AP queue. When it finishes the message
1353 * reply will be discarded because the psmid can't be found.
1355 void ap_cancel_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
1357 struct ap_message *tmp;
1359 spin_lock_bh(&ap_dev->lock);
1360 if (!list_empty(&ap_msg->list)) {
1361 list_for_each_entry(tmp, &ap_dev->pendingq, list)
1362 if (tmp->psmid == ap_msg->psmid) {
1363 ap_dev->pendingq_count--;
1366 ap_dev->requestq_count--;
1368 list_del_init(&ap_msg->list);
1370 spin_unlock_bh(&ap_dev->lock);
1372 EXPORT_SYMBOL(ap_cancel_message);
1375 * ap_poll_timeout(): AP receive polling for finished AP requests.
1376 * @unused: Unused pointer.
1378 * Schedules the AP tasklet using a high resolution timer.
1380 static enum hrtimer_restart ap_poll_timeout(struct hrtimer *unused)
1382 tasklet_schedule(&ap_tasklet);
1383 return HRTIMER_NORESTART;
1387 * ap_reset(): Reset a not responding AP device.
1388 * @ap_dev: Pointer to the AP device
1390 * Reset a not responding AP device and move all requests from the
1391 * pending queue to the request queue.
1393 static void ap_reset(struct ap_device *ap_dev)
1397 ap_dev->reset = AP_RESET_IGNORE;
1398 atomic_sub(ap_dev->queue_count, &ap_poll_requests);
1399 ap_dev->queue_count = 0;
1400 list_splice_init(&ap_dev->pendingq, &ap_dev->requestq);
1401 ap_dev->requestq_count += ap_dev->pendingq_count;
1402 ap_dev->pendingq_count = 0;
1403 rc = ap_init_queue(ap_dev->qid);
1405 ap_dev->unregistered = 1;
1408 static int __ap_poll_device(struct ap_device *ap_dev, unsigned long *flags)
1410 spin_lock(&ap_dev->lock);
1411 if (!ap_dev->unregistered) {
1412 if (ap_poll_queue(ap_dev, flags))
1413 ap_dev->unregistered = 1;
1414 if (ap_dev->reset == AP_RESET_DO)
1417 spin_unlock(&ap_dev->lock);
1422 * ap_poll_all(): Poll all AP devices.
1423 * @dummy: Unused variable
1425 * Poll all AP devices on the bus in a round robin fashion. Continue
1426 * polling until bit 2^0 of the control flags is not set. If bit 2^1
1427 * of the control flags has been set arm the poll timer.
1429 static void ap_poll_all(unsigned long dummy)
1431 unsigned long flags;
1432 struct ap_device *ap_dev;
1434 /* Reset the indicator if interrupts are used. Thus new interrupts can
1435 * be received. Doing it in the beginning of the tasklet is therefor
1436 * important that no requests on any AP get lost.
1438 if (ap_using_interrupts())
1439 xchg((u8 *)ap_interrupt_indicator, 0);
1442 spin_lock(&ap_device_list_lock);
1443 list_for_each_entry(ap_dev, &ap_device_list, list) {
1444 __ap_poll_device(ap_dev, &flags);
1446 spin_unlock(&ap_device_list_lock);
1447 } while (flags & 1);
1449 ap_schedule_poll_timer();
1453 * ap_poll_thread(): Thread that polls for finished requests.
1454 * @data: Unused pointer
1456 * AP bus poll thread. The purpose of this thread is to poll for
1457 * finished requests in a loop if there is a "free" cpu - that is
1458 * a cpu that doesn't have anything better to do. The polling stops
1459 * as soon as there is another task or if all messages have been
1462 static int ap_poll_thread(void *data)
1464 DECLARE_WAITQUEUE(wait, current);
1465 unsigned long flags;
1467 struct ap_device *ap_dev;
1469 set_user_nice(current, 19);
1471 if (ap_suspend_flag)
1473 if (need_resched()) {
1477 add_wait_queue(&ap_poll_wait, &wait);
1478 set_current_state(TASK_INTERRUPTIBLE);
1479 if (kthread_should_stop())
1481 requests = atomic_read(&ap_poll_requests);
1484 set_current_state(TASK_RUNNING);
1485 remove_wait_queue(&ap_poll_wait, &wait);
1488 spin_lock_bh(&ap_device_list_lock);
1489 list_for_each_entry(ap_dev, &ap_device_list, list) {
1490 __ap_poll_device(ap_dev, &flags);
1492 spin_unlock_bh(&ap_device_list_lock);
1494 set_current_state(TASK_RUNNING);
1495 remove_wait_queue(&ap_poll_wait, &wait);
1499 static int ap_poll_thread_start(void)
1503 if (ap_using_interrupts() || ap_suspend_flag)
1505 mutex_lock(&ap_poll_thread_mutex);
1506 if (!ap_poll_kthread) {
1507 ap_poll_kthread = kthread_run(ap_poll_thread, NULL, "appoll");
1508 rc = IS_ERR(ap_poll_kthread) ? PTR_ERR(ap_poll_kthread) : 0;
1510 ap_poll_kthread = NULL;
1514 mutex_unlock(&ap_poll_thread_mutex);
1518 static void ap_poll_thread_stop(void)
1520 mutex_lock(&ap_poll_thread_mutex);
1521 if (ap_poll_kthread) {
1522 kthread_stop(ap_poll_kthread);
1523 ap_poll_kthread = NULL;
1525 mutex_unlock(&ap_poll_thread_mutex);
1529 * ap_request_timeout(): Handling of request timeouts
1530 * @data: Holds the AP device.
1532 * Handles request timeouts.
1534 static void ap_request_timeout(unsigned long data)
1536 struct ap_device *ap_dev = (struct ap_device *) data;
1538 if (ap_dev->reset == AP_RESET_ARMED) {
1539 ap_dev->reset = AP_RESET_DO;
1541 if (ap_using_interrupts())
1542 tasklet_schedule(&ap_tasklet);
1546 static void ap_reset_domain(void)
1550 if (ap_domain_index != -1)
1551 for (i = 0; i < AP_DEVICES; i++)
1552 ap_reset_queue(AP_MKQID(i, ap_domain_index));
1555 static void ap_reset_all(void)
1559 for (i = 0; i < AP_DOMAINS; i++)
1560 for (j = 0; j < AP_DEVICES; j++)
1561 ap_reset_queue(AP_MKQID(j, i));
1564 static struct reset_call ap_reset_call = {
1569 * ap_module_init(): The module initialization code.
1571 * Initializes the module.
1573 int __init ap_module_init(void)
1577 if (ap_domain_index < -1 || ap_domain_index >= AP_DOMAINS) {
1578 pr_warning("%d is not a valid cryptographic domain\n",
1582 if (ap_instructions_available() != 0) {
1583 pr_warning("The hardware system does not support "
1584 "AP instructions\n");
1587 if (ap_interrupts_available()) {
1588 isc_register(AP_ISC);
1589 ap_interrupt_indicator = s390_register_adapter_interrupt(
1590 &ap_interrupt_handler, NULL, AP_ISC);
1591 if (IS_ERR(ap_interrupt_indicator)) {
1592 ap_interrupt_indicator = NULL;
1593 isc_unregister(AP_ISC);
1597 register_reset_call(&ap_reset_call);
1599 /* Create /sys/bus/ap. */
1600 rc = bus_register(&ap_bus_type);
1603 for (i = 0; ap_bus_attrs[i]; i++) {
1604 rc = bus_create_file(&ap_bus_type, ap_bus_attrs[i]);
1609 /* Create /sys/devices/ap. */
1610 ap_root_device = root_device_register("ap");
1611 rc = IS_ERR(ap_root_device) ? PTR_ERR(ap_root_device) : 0;
1615 ap_work_queue = create_singlethread_workqueue("kapwork");
1616 if (!ap_work_queue) {
1621 if (ap_select_domain() == 0)
1624 /* Setup the AP bus rescan timer. */
1625 init_timer(&ap_config_timer);
1626 ap_config_timer.function = ap_config_timeout;
1627 ap_config_timer.data = 0;
1628 ap_config_timer.expires = jiffies + ap_config_time * HZ;
1629 add_timer(&ap_config_timer);
1631 /* Setup the high resultion poll timer.
1632 * If we are running under z/VM adjust polling to z/VM polling rate.
1635 poll_timeout = 1500000;
1636 hrtimer_init(&ap_poll_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
1637 ap_poll_timer.function = ap_poll_timeout;
1639 /* Start the low priority AP bus poll thread. */
1640 if (ap_thread_flag) {
1641 rc = ap_poll_thread_start();
1649 del_timer_sync(&ap_config_timer);
1650 hrtimer_cancel(&ap_poll_timer);
1651 destroy_workqueue(ap_work_queue);
1653 root_device_unregister(ap_root_device);
1656 bus_remove_file(&ap_bus_type, ap_bus_attrs[i]);
1657 bus_unregister(&ap_bus_type);
1659 unregister_reset_call(&ap_reset_call);
1660 if (ap_using_interrupts()) {
1661 s390_unregister_adapter_interrupt(ap_interrupt_indicator, AP_ISC);
1662 isc_unregister(AP_ISC);
1667 static int __ap_match_all(struct device *dev, void *data)
1673 * ap_modules_exit(): The module termination code
1675 * Terminates the module.
1677 void ap_module_exit(void)
1683 ap_poll_thread_stop();
1684 del_timer_sync(&ap_config_timer);
1685 hrtimer_cancel(&ap_poll_timer);
1686 destroy_workqueue(ap_work_queue);
1687 tasklet_kill(&ap_tasklet);
1688 root_device_unregister(ap_root_device);
1689 while ((dev = bus_find_device(&ap_bus_type, NULL, NULL,
1692 device_unregister(dev);
1695 for (i = 0; ap_bus_attrs[i]; i++)
1696 bus_remove_file(&ap_bus_type, ap_bus_attrs[i]);
1697 bus_unregister(&ap_bus_type);
1698 unregister_reset_call(&ap_reset_call);
1699 if (ap_using_interrupts()) {
1700 s390_unregister_adapter_interrupt(ap_interrupt_indicator, AP_ISC);
1701 isc_unregister(AP_ISC);
1705 #ifndef CONFIG_ZCRYPT_MONOLITHIC
1706 module_init(ap_module_init);
1707 module_exit(ap_module_exit);