xref: /linux/drivers/s390/crypto/ap_bus.c (revision 25aee3debe0464f6c680173041fa3de30ec9ff54)
1 /*
2  * Copyright IBM Corp. 2006
3  * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
4  *	      Martin Schwidefsky <schwidefsky@de.ibm.com>
5  *	      Ralph Wuerthner <rwuerthn@de.ibm.com>
6  *	      Felix Beck <felix.beck@de.ibm.com>
7  *	      Holger Dengler <hd@linux.vnet.ibm.com>
8  *
9  * Adjunct processor bus.
10  *
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)
14  * any later version.
15  *
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.
20  *
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.
24  */
25 
26 #define KMSG_COMPONENT "ap"
27 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
28 
29 #include <linux/kernel_stat.h>
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/slab.h>
37 #include <linux/notifier.h>
38 #include <linux/kthread.h>
39 #include <linux/mutex.h>
40 #include <asm/reset.h>
41 #include <asm/airq.h>
42 #include <linux/atomic.h>
43 #include <asm/isc.h>
44 #include <linux/hrtimer.h>
45 #include <linux/ktime.h>
46 #include <asm/facility.h>
47 
48 #include "ap_bus.h"
49 
50 /* Some prototypes. */
51 static void ap_scan_bus(struct work_struct *);
52 static void ap_poll_all(unsigned long);
53 static enum hrtimer_restart ap_poll_timeout(struct hrtimer *);
54 static int ap_poll_thread_start(void);
55 static void ap_poll_thread_stop(void);
56 static void ap_request_timeout(unsigned long);
57 static inline void ap_schedule_poll_timer(void);
58 static int __ap_poll_device(struct ap_device *ap_dev, unsigned long *flags);
59 static int ap_device_remove(struct device *dev);
60 static int ap_device_probe(struct device *dev);
61 static void ap_interrupt_handler(void *unused1, void *unused2);
62 static void ap_reset(struct ap_device *ap_dev);
63 static void ap_config_timeout(unsigned long ptr);
64 static int ap_select_domain(void);
65 
66 /*
67  * Module description.
68  */
69 MODULE_AUTHOR("IBM Corporation");
70 MODULE_DESCRIPTION("Adjunct Processor Bus driver, "
71 		   "Copyright IBM Corp. 2006");
72 MODULE_LICENSE("GPL");
73 
74 /*
75  * Module parameter
76  */
77 int ap_domain_index = -1;	/* Adjunct Processor Domain Index */
78 module_param_named(domain, ap_domain_index, int, 0000);
79 MODULE_PARM_DESC(domain, "domain index for ap devices");
80 EXPORT_SYMBOL(ap_domain_index);
81 
82 static int ap_thread_flag = 0;
83 module_param_named(poll_thread, ap_thread_flag, int, 0000);
84 MODULE_PARM_DESC(poll_thread, "Turn on/off poll thread, default is 0 (off).");
85 
86 static struct device *ap_root_device = NULL;
87 static DEFINE_SPINLOCK(ap_device_list_lock);
88 static LIST_HEAD(ap_device_list);
89 
90 /*
91  * Workqueue & timer for bus rescan.
92  */
93 static struct workqueue_struct *ap_work_queue;
94 static struct timer_list ap_config_timer;
95 static int ap_config_time = AP_CONFIG_TIME;
96 static DECLARE_WORK(ap_config_work, ap_scan_bus);
97 
98 /*
99  * Tasklet & timer for AP request polling and interrupts
100  */
101 static DECLARE_TASKLET(ap_tasklet, ap_poll_all, 0);
102 static atomic_t ap_poll_requests = ATOMIC_INIT(0);
103 static DECLARE_WAIT_QUEUE_HEAD(ap_poll_wait);
104 static struct task_struct *ap_poll_kthread = NULL;
105 static DEFINE_MUTEX(ap_poll_thread_mutex);
106 static DEFINE_SPINLOCK(ap_poll_timer_lock);
107 static void *ap_interrupt_indicator;
108 static struct hrtimer ap_poll_timer;
109 /* In LPAR poll with 4kHz frequency. Poll every 250000 nanoseconds.
110  * If z/VM change to 1500000 nanoseconds to adjust to z/VM polling.*/
111 static unsigned long long poll_timeout = 250000;
112 
113 /* Suspend flag */
114 static int ap_suspend_flag;
115 /* Flag to check if domain was set through module parameter domain=. This is
116  * important when supsend and resume is done in a z/VM environment where the
117  * domain might change. */
118 static int user_set_domain = 0;
119 static struct bus_type ap_bus_type;
120 
121 /**
122  * ap_using_interrupts() - Returns non-zero if interrupt support is
123  * available.
124  */
125 static inline int ap_using_interrupts(void)
126 {
127 	return ap_interrupt_indicator != NULL;
128 }
129 
130 /**
131  * ap_intructions_available() - Test if AP instructions are available.
132  *
133  * Returns 0 if the AP instructions are installed.
134  */
135 static inline int ap_instructions_available(void)
136 {
137 	register unsigned long reg0 asm ("0") = AP_MKQID(0,0);
138 	register unsigned long reg1 asm ("1") = -ENODEV;
139 	register unsigned long reg2 asm ("2") = 0UL;
140 
141 	asm volatile(
142 		"   .long 0xb2af0000\n"		/* PQAP(TAPQ) */
143 		"0: la    %1,0\n"
144 		"1:\n"
145 		EX_TABLE(0b, 1b)
146 		: "+d" (reg0), "+d" (reg1), "+d" (reg2) : : "cc" );
147 	return reg1;
148 }
149 
150 /**
151  * ap_interrupts_available(): Test if AP interrupts are available.
152  *
153  * Returns 1 if AP interrupts are available.
154  */
155 static int ap_interrupts_available(void)
156 {
157 	return test_facility(2) && test_facility(65);
158 }
159 
160 /**
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
165  *
166  * Returns AP queue status structure.
167  */
168 static inline struct ap_queue_status
169 ap_test_queue(ap_qid_t qid, int *queue_depth, int *device_type)
170 {
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;
174 
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);
179 	return reg1;
180 }
181 
182 /**
183  * ap_reset_queue(): Reset adjunct processor queue.
184  * @qid: The AP queue number
185  *
186  * Returns AP queue status structure.
187  */
188 static inline struct ap_queue_status ap_reset_queue(ap_qid_t qid)
189 {
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;
193 
194 	asm volatile(
195 		".long 0xb2af0000"		/* PQAP(RAPQ) */
196 		: "+d" (reg0), "=d" (reg1), "+d" (reg2) : : "cc");
197 	return reg1;
198 }
199 
200 #ifdef CONFIG_64BIT
201 /**
202  * ap_queue_interruption_control(): Enable interruption for a specific AP.
203  * @qid: The AP queue number
204  * @ind: The notification indicator byte
205  *
206  * Returns AP queue status.
207  */
208 static inline struct ap_queue_status
209 ap_queue_interruption_control(ap_qid_t qid, void *ind)
210 {
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;
215 	asm volatile(
216 		".long 0xb2af0000"		/* PQAP(AQIC) */
217 		: "+d" (reg0), "+d" (reg1_in), "=d" (reg1_out), "+d" (reg2)
218 		:
219 		: "cc" );
220 	return reg1_out;
221 }
222 #endif
223 
224 #ifdef CONFIG_64BIT
225 static inline struct ap_queue_status
226 __ap_query_functions(ap_qid_t qid, unsigned int *functions)
227 {
228 	register unsigned long reg0 asm ("0") = 0UL | qid | (1UL << 23);
229 	register struct ap_queue_status reg1 asm ("1") = AP_QUEUE_STATUS_INVALID;
230 	register unsigned long reg2 asm ("2");
231 
232 	asm volatile(
233 		".long 0xb2af0000\n"		/* PQAP(TAPQ) */
234 		"0:\n"
235 		EX_TABLE(0b, 0b)
236 		: "+d" (reg0), "+d" (reg1), "=d" (reg2)
237 		:
238 		: "cc");
239 
240 	*functions = (unsigned int)(reg2 >> 32);
241 	return reg1;
242 }
243 #endif
244 
245 /**
246  * ap_query_functions(): Query supported functions.
247  * @qid: The AP queue number
248  * @functions: Pointer to functions field.
249  *
250  * Returns
251  *   0	     on success.
252  *   -ENODEV  if queue not valid.
253  *   -EBUSY   if device busy.
254  *   -EINVAL  if query function is not supported
255  */
256 static int ap_query_functions(ap_qid_t qid, unsigned int *functions)
257 {
258 #ifdef CONFIG_64BIT
259 	struct ap_queue_status status;
260 	int i;
261 	status = __ap_query_functions(qid, functions);
262 
263 	for (i = 0; i < AP_MAX_RESET; i++) {
264 		if (ap_queue_status_invalid_test(&status))
265 			return -ENODEV;
266 
267 		switch (status.response_code) {
268 		case AP_RESPONSE_NORMAL:
269 			return 0;
270 		case AP_RESPONSE_RESET_IN_PROGRESS:
271 		case AP_RESPONSE_BUSY:
272 			break;
273 		case AP_RESPONSE_Q_NOT_AVAIL:
274 		case AP_RESPONSE_DECONFIGURED:
275 		case AP_RESPONSE_CHECKSTOPPED:
276 		case AP_RESPONSE_INVALID_ADDRESS:
277 			return -ENODEV;
278 		case AP_RESPONSE_OTHERWISE_CHANGED:
279 			break;
280 		default:
281 			break;
282 		}
283 		if (i < AP_MAX_RESET - 1) {
284 			udelay(5);
285 			status = __ap_query_functions(qid, functions);
286 		}
287 	}
288 	return -EBUSY;
289 #else
290 	return -EINVAL;
291 #endif
292 }
293 
294 /**
295  * ap_4096_commands_availablen(): Check for availability of 4096 bit RSA
296  * support.
297  * @qid: The AP queue number
298  *
299  * Returns 1 if 4096 bit RSA keys are support fo the AP, returns 0 if not.
300  */
301 int ap_4096_commands_available(ap_qid_t qid)
302 {
303 	unsigned int functions;
304 
305 	if (ap_query_functions(qid, &functions))
306 		return 0;
307 
308 	return test_ap_facility(functions, 1) &&
309 	       test_ap_facility(functions, 2);
310 }
311 EXPORT_SYMBOL(ap_4096_commands_available);
312 
313 /**
314  * ap_queue_enable_interruption(): Enable interruption on an AP.
315  * @qid: The AP queue number
316  * @ind: the notification indicator byte
317  *
318  * Enables interruption on AP queue via ap_queue_interruption_control(). Based
319  * on the return value it waits a while and tests the AP queue if interrupts
320  * have been switched on using ap_test_queue().
321  */
322 static int ap_queue_enable_interruption(ap_qid_t qid, void *ind)
323 {
324 #ifdef CONFIG_64BIT
325 	struct ap_queue_status status;
326 	int t_depth, t_device_type, rc, i;
327 
328 	rc = -EBUSY;
329 	status = ap_queue_interruption_control(qid, ind);
330 
331 	for (i = 0; i < AP_MAX_RESET; i++) {
332 		switch (status.response_code) {
333 		case AP_RESPONSE_NORMAL:
334 			if (status.int_enabled)
335 				return 0;
336 			break;
337 		case AP_RESPONSE_RESET_IN_PROGRESS:
338 		case AP_RESPONSE_BUSY:
339 			if (i < AP_MAX_RESET - 1) {
340 				udelay(5);
341 				status = ap_queue_interruption_control(qid,
342 								       ind);
343 				continue;
344 			}
345 			break;
346 		case AP_RESPONSE_Q_NOT_AVAIL:
347 		case AP_RESPONSE_DECONFIGURED:
348 		case AP_RESPONSE_CHECKSTOPPED:
349 		case AP_RESPONSE_INVALID_ADDRESS:
350 			return -ENODEV;
351 		case AP_RESPONSE_OTHERWISE_CHANGED:
352 			if (status.int_enabled)
353 				return 0;
354 			break;
355 		default:
356 			break;
357 		}
358 		if (i < AP_MAX_RESET - 1) {
359 			udelay(5);
360 			status = ap_test_queue(qid, &t_depth, &t_device_type);
361 		}
362 	}
363 	return rc;
364 #else
365 	return -EINVAL;
366 #endif
367 }
368 
369 /**
370  * __ap_send(): Send message to adjunct processor queue.
371  * @qid: The AP queue number
372  * @psmid: The program supplied message identifier
373  * @msg: The message text
374  * @length: The message length
375  * @special: Special Bit
376  *
377  * Returns AP queue status structure.
378  * Condition code 1 on NQAP can't happen because the L bit is 1.
379  * Condition code 2 on NQAP also means the send is incomplete,
380  * because a segment boundary was reached. The NQAP is repeated.
381  */
382 static inline struct ap_queue_status
383 __ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length,
384 	  unsigned int special)
385 {
386 	typedef struct { char _[length]; } msgblock;
387 	register unsigned long reg0 asm ("0") = qid | 0x40000000UL;
388 	register struct ap_queue_status reg1 asm ("1");
389 	register unsigned long reg2 asm ("2") = (unsigned long) msg;
390 	register unsigned long reg3 asm ("3") = (unsigned long) length;
391 	register unsigned long reg4 asm ("4") = (unsigned int) (psmid >> 32);
392 	register unsigned long reg5 asm ("5") = (unsigned int) psmid;
393 
394 	if (special == 1)
395 		reg0 |= 0x400000UL;
396 
397 	asm volatile (
398 		"0: .long 0xb2ad0042\n"		/* NQAP */
399 		"   brc   2,0b"
400 		: "+d" (reg0), "=d" (reg1), "+d" (reg2), "+d" (reg3)
401 		: "d" (reg4), "d" (reg5), "m" (*(msgblock *) msg)
402 		: "cc" );
403 	return reg1;
404 }
405 
406 int ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length)
407 {
408 	struct ap_queue_status status;
409 
410 	status = __ap_send(qid, psmid, msg, length, 0);
411 	switch (status.response_code) {
412 	case AP_RESPONSE_NORMAL:
413 		return 0;
414 	case AP_RESPONSE_Q_FULL:
415 	case AP_RESPONSE_RESET_IN_PROGRESS:
416 		return -EBUSY;
417 	case AP_RESPONSE_REQ_FAC_NOT_INST:
418 		return -EINVAL;
419 	default:	/* Device is gone. */
420 		return -ENODEV;
421 	}
422 }
423 EXPORT_SYMBOL(ap_send);
424 
425 /**
426  * __ap_recv(): Receive message from adjunct processor queue.
427  * @qid: The AP queue number
428  * @psmid: Pointer to program supplied message identifier
429  * @msg: The message text
430  * @length: The message length
431  *
432  * Returns AP queue status structure.
433  * Condition code 1 on DQAP means the receive has taken place
434  * but only partially.	The response is incomplete, hence the
435  * DQAP is repeated.
436  * Condition code 2 on DQAP also means the receive is incomplete,
437  * this time because a segment boundary was reached. Again, the
438  * DQAP is repeated.
439  * Note that gpr2 is used by the DQAP instruction to keep track of
440  * any 'residual' length, in case the instruction gets interrupted.
441  * Hence it gets zeroed before the instruction.
442  */
443 static inline struct ap_queue_status
444 __ap_recv(ap_qid_t qid, unsigned long long *psmid, void *msg, size_t length)
445 {
446 	typedef struct { char _[length]; } msgblock;
447 	register unsigned long reg0 asm("0") = qid | 0x80000000UL;
448 	register struct ap_queue_status reg1 asm ("1");
449 	register unsigned long reg2 asm("2") = 0UL;
450 	register unsigned long reg4 asm("4") = (unsigned long) msg;
451 	register unsigned long reg5 asm("5") = (unsigned long) length;
452 	register unsigned long reg6 asm("6") = 0UL;
453 	register unsigned long reg7 asm("7") = 0UL;
454 
455 
456 	asm volatile(
457 		"0: .long 0xb2ae0064\n"		/* DQAP */
458 		"   brc   6,0b\n"
459 		: "+d" (reg0), "=d" (reg1), "+d" (reg2),
460 		"+d" (reg4), "+d" (reg5), "+d" (reg6), "+d" (reg7),
461 		"=m" (*(msgblock *) msg) : : "cc" );
462 	*psmid = (((unsigned long long) reg6) << 32) + reg7;
463 	return reg1;
464 }
465 
466 int ap_recv(ap_qid_t qid, unsigned long long *psmid, void *msg, size_t length)
467 {
468 	struct ap_queue_status status;
469 
470 	status = __ap_recv(qid, psmid, msg, length);
471 	switch (status.response_code) {
472 	case AP_RESPONSE_NORMAL:
473 		return 0;
474 	case AP_RESPONSE_NO_PENDING_REPLY:
475 		if (status.queue_empty)
476 			return -ENOENT;
477 		return -EBUSY;
478 	case AP_RESPONSE_RESET_IN_PROGRESS:
479 		return -EBUSY;
480 	default:
481 		return -ENODEV;
482 	}
483 }
484 EXPORT_SYMBOL(ap_recv);
485 
486 /**
487  * ap_query_queue(): Check if an AP queue is available.
488  * @qid: The AP queue number
489  * @queue_depth: Pointer to queue depth value
490  * @device_type: Pointer to device type value
491  *
492  * The test is repeated for AP_MAX_RESET times.
493  */
494 static int ap_query_queue(ap_qid_t qid, int *queue_depth, int *device_type)
495 {
496 	struct ap_queue_status status;
497 	int t_depth, t_device_type, rc, i;
498 
499 	rc = -EBUSY;
500 	for (i = 0; i < AP_MAX_RESET; i++) {
501 		status = ap_test_queue(qid, &t_depth, &t_device_type);
502 		switch (status.response_code) {
503 		case AP_RESPONSE_NORMAL:
504 			*queue_depth = t_depth + 1;
505 			*device_type = t_device_type;
506 			rc = 0;
507 			break;
508 		case AP_RESPONSE_Q_NOT_AVAIL:
509 			rc = -ENODEV;
510 			break;
511 		case AP_RESPONSE_RESET_IN_PROGRESS:
512 			break;
513 		case AP_RESPONSE_DECONFIGURED:
514 			rc = -ENODEV;
515 			break;
516 		case AP_RESPONSE_CHECKSTOPPED:
517 			rc = -ENODEV;
518 			break;
519 		case AP_RESPONSE_INVALID_ADDRESS:
520 			rc = -ENODEV;
521 			break;
522 		case AP_RESPONSE_OTHERWISE_CHANGED:
523 			break;
524 		case AP_RESPONSE_BUSY:
525 			break;
526 		default:
527 			BUG();
528 		}
529 		if (rc != -EBUSY)
530 			break;
531 		if (i < AP_MAX_RESET - 1)
532 			udelay(5);
533 	}
534 	return rc;
535 }
536 
537 /**
538  * ap_init_queue(): Reset an AP queue.
539  * @qid: The AP queue number
540  *
541  * Reset an AP queue and wait for it to become available again.
542  */
543 static int ap_init_queue(ap_qid_t qid)
544 {
545 	struct ap_queue_status status;
546 	int rc, dummy, i;
547 
548 	rc = -ENODEV;
549 	status = ap_reset_queue(qid);
550 	for (i = 0; i < AP_MAX_RESET; i++) {
551 		switch (status.response_code) {
552 		case AP_RESPONSE_NORMAL:
553 			if (status.queue_empty)
554 				rc = 0;
555 			break;
556 		case AP_RESPONSE_Q_NOT_AVAIL:
557 		case AP_RESPONSE_DECONFIGURED:
558 		case AP_RESPONSE_CHECKSTOPPED:
559 			i = AP_MAX_RESET;	/* return with -ENODEV */
560 			break;
561 		case AP_RESPONSE_RESET_IN_PROGRESS:
562 			rc = -EBUSY;
563 		case AP_RESPONSE_BUSY:
564 		default:
565 			break;
566 		}
567 		if (rc != -ENODEV && rc != -EBUSY)
568 			break;
569 		if (i < AP_MAX_RESET - 1) {
570 			udelay(5);
571 			status = ap_test_queue(qid, &dummy, &dummy);
572 		}
573 	}
574 	if (rc == 0 && ap_using_interrupts()) {
575 		rc = ap_queue_enable_interruption(qid, ap_interrupt_indicator);
576 		/* If interruption mode is supported by the machine,
577 		* but an AP can not be enabled for interruption then
578 		* the AP will be discarded.    */
579 		if (rc)
580 			pr_err("Registering adapter interrupts for "
581 			       "AP %d failed\n", AP_QID_DEVICE(qid));
582 	}
583 	return rc;
584 }
585 
586 /**
587  * ap_increase_queue_count(): Arm request timeout.
588  * @ap_dev: Pointer to an AP device.
589  *
590  * Arm request timeout if an AP device was idle and a new request is submitted.
591  */
592 static void ap_increase_queue_count(struct ap_device *ap_dev)
593 {
594 	int timeout = ap_dev->drv->request_timeout;
595 
596 	ap_dev->queue_count++;
597 	if (ap_dev->queue_count == 1) {
598 		mod_timer(&ap_dev->timeout, jiffies + timeout);
599 		ap_dev->reset = AP_RESET_ARMED;
600 	}
601 }
602 
603 /**
604  * ap_decrease_queue_count(): Decrease queue count.
605  * @ap_dev: Pointer to an AP device.
606  *
607  * If AP device is still alive, re-schedule request timeout if there are still
608  * pending requests.
609  */
610 static void ap_decrease_queue_count(struct ap_device *ap_dev)
611 {
612 	int timeout = ap_dev->drv->request_timeout;
613 
614 	ap_dev->queue_count--;
615 	if (ap_dev->queue_count > 0)
616 		mod_timer(&ap_dev->timeout, jiffies + timeout);
617 	else
618 		/*
619 		 * The timeout timer should to be disabled now - since
620 		 * del_timer_sync() is very expensive, we just tell via the
621 		 * reset flag to ignore the pending timeout timer.
622 		 */
623 		ap_dev->reset = AP_RESET_IGNORE;
624 }
625 
626 /*
627  * AP device related attributes.
628  */
629 static ssize_t ap_hwtype_show(struct device *dev,
630 			      struct device_attribute *attr, char *buf)
631 {
632 	struct ap_device *ap_dev = to_ap_dev(dev);
633 	return snprintf(buf, PAGE_SIZE, "%d\n", ap_dev->device_type);
634 }
635 
636 static DEVICE_ATTR(hwtype, 0444, ap_hwtype_show, NULL);
637 static ssize_t ap_depth_show(struct device *dev, struct device_attribute *attr,
638 			     char *buf)
639 {
640 	struct ap_device *ap_dev = to_ap_dev(dev);
641 	return snprintf(buf, PAGE_SIZE, "%d\n", ap_dev->queue_depth);
642 }
643 
644 static DEVICE_ATTR(depth, 0444, ap_depth_show, NULL);
645 static ssize_t ap_request_count_show(struct device *dev,
646 				     struct device_attribute *attr,
647 				     char *buf)
648 {
649 	struct ap_device *ap_dev = to_ap_dev(dev);
650 	int rc;
651 
652 	spin_lock_bh(&ap_dev->lock);
653 	rc = snprintf(buf, PAGE_SIZE, "%d\n", ap_dev->total_request_count);
654 	spin_unlock_bh(&ap_dev->lock);
655 	return rc;
656 }
657 
658 static DEVICE_ATTR(request_count, 0444, ap_request_count_show, NULL);
659 
660 static ssize_t ap_modalias_show(struct device *dev,
661 				struct device_attribute *attr, char *buf)
662 {
663 	return sprintf(buf, "ap:t%02X", to_ap_dev(dev)->device_type);
664 }
665 
666 static DEVICE_ATTR(modalias, 0444, ap_modalias_show, NULL);
667 
668 static struct attribute *ap_dev_attrs[] = {
669 	&dev_attr_hwtype.attr,
670 	&dev_attr_depth.attr,
671 	&dev_attr_request_count.attr,
672 	&dev_attr_modalias.attr,
673 	NULL
674 };
675 static struct attribute_group ap_dev_attr_group = {
676 	.attrs = ap_dev_attrs
677 };
678 
679 /**
680  * ap_bus_match()
681  * @dev: Pointer to device
682  * @drv: Pointer to device_driver
683  *
684  * AP bus driver registration/unregistration.
685  */
686 static int ap_bus_match(struct device *dev, struct device_driver *drv)
687 {
688 	struct ap_device *ap_dev = to_ap_dev(dev);
689 	struct ap_driver *ap_drv = to_ap_drv(drv);
690 	struct ap_device_id *id;
691 
692 	/*
693 	 * Compare device type of the device with the list of
694 	 * supported types of the device_driver.
695 	 */
696 	for (id = ap_drv->ids; id->match_flags; id++) {
697 		if ((id->match_flags & AP_DEVICE_ID_MATCH_DEVICE_TYPE) &&
698 		    (id->dev_type != ap_dev->device_type))
699 			continue;
700 		return 1;
701 	}
702 	return 0;
703 }
704 
705 /**
706  * ap_uevent(): Uevent function for AP devices.
707  * @dev: Pointer to device
708  * @env: Pointer to kobj_uevent_env
709  *
710  * It sets up a single environment variable DEV_TYPE which contains the
711  * hardware device type.
712  */
713 static int ap_uevent (struct device *dev, struct kobj_uevent_env *env)
714 {
715 	struct ap_device *ap_dev = to_ap_dev(dev);
716 	int retval = 0;
717 
718 	if (!ap_dev)
719 		return -ENODEV;
720 
721 	/* Set up DEV_TYPE environment variable. */
722 	retval = add_uevent_var(env, "DEV_TYPE=%04X", ap_dev->device_type);
723 	if (retval)
724 		return retval;
725 
726 	/* Add MODALIAS= */
727 	retval = add_uevent_var(env, "MODALIAS=ap:t%02X", ap_dev->device_type);
728 
729 	return retval;
730 }
731 
732 static int ap_bus_suspend(struct device *dev, pm_message_t state)
733 {
734 	struct ap_device *ap_dev = to_ap_dev(dev);
735 	unsigned long flags;
736 
737 	if (!ap_suspend_flag) {
738 		ap_suspend_flag = 1;
739 
740 		/* Disable scanning for devices, thus we do not want to scan
741 		 * for them after removing.
742 		 */
743 		del_timer_sync(&ap_config_timer);
744 		if (ap_work_queue != NULL) {
745 			destroy_workqueue(ap_work_queue);
746 			ap_work_queue = NULL;
747 		}
748 
749 		tasklet_disable(&ap_tasklet);
750 	}
751 	/* Poll on the device until all requests are finished. */
752 	do {
753 		flags = 0;
754 		spin_lock_bh(&ap_dev->lock);
755 		__ap_poll_device(ap_dev, &flags);
756 		spin_unlock_bh(&ap_dev->lock);
757 	} while ((flags & 1) || (flags & 2));
758 
759 	spin_lock_bh(&ap_dev->lock);
760 	ap_dev->unregistered = 1;
761 	spin_unlock_bh(&ap_dev->lock);
762 
763 	return 0;
764 }
765 
766 static int ap_bus_resume(struct device *dev)
767 {
768 	int rc = 0;
769 	struct ap_device *ap_dev = to_ap_dev(dev);
770 
771 	if (ap_suspend_flag) {
772 		ap_suspend_flag = 0;
773 		if (!ap_interrupts_available())
774 			ap_interrupt_indicator = NULL;
775 		if (!user_set_domain) {
776 			ap_domain_index = -1;
777 			ap_select_domain();
778 		}
779 		init_timer(&ap_config_timer);
780 		ap_config_timer.function = ap_config_timeout;
781 		ap_config_timer.data = 0;
782 		ap_config_timer.expires = jiffies + ap_config_time * HZ;
783 		add_timer(&ap_config_timer);
784 		ap_work_queue = create_singlethread_workqueue("kapwork");
785 		if (!ap_work_queue)
786 			return -ENOMEM;
787 		tasklet_enable(&ap_tasklet);
788 		if (!ap_using_interrupts())
789 			ap_schedule_poll_timer();
790 		else
791 			tasklet_schedule(&ap_tasklet);
792 		if (ap_thread_flag)
793 			rc = ap_poll_thread_start();
794 	}
795 	if (AP_QID_QUEUE(ap_dev->qid) != ap_domain_index) {
796 		spin_lock_bh(&ap_dev->lock);
797 		ap_dev->qid = AP_MKQID(AP_QID_DEVICE(ap_dev->qid),
798 				       ap_domain_index);
799 		spin_unlock_bh(&ap_dev->lock);
800 	}
801 	queue_work(ap_work_queue, &ap_config_work);
802 
803 	return rc;
804 }
805 
806 static struct bus_type ap_bus_type = {
807 	.name = "ap",
808 	.match = &ap_bus_match,
809 	.uevent = &ap_uevent,
810 	.suspend = ap_bus_suspend,
811 	.resume = ap_bus_resume
812 };
813 
814 static int ap_device_probe(struct device *dev)
815 {
816 	struct ap_device *ap_dev = to_ap_dev(dev);
817 	struct ap_driver *ap_drv = to_ap_drv(dev->driver);
818 	int rc;
819 
820 	ap_dev->drv = ap_drv;
821 	rc = ap_drv->probe ? ap_drv->probe(ap_dev) : -ENODEV;
822 	if (!rc) {
823 		spin_lock_bh(&ap_device_list_lock);
824 		list_add(&ap_dev->list, &ap_device_list);
825 		spin_unlock_bh(&ap_device_list_lock);
826 	}
827 	return rc;
828 }
829 
830 /**
831  * __ap_flush_queue(): Flush requests.
832  * @ap_dev: Pointer to the AP device
833  *
834  * Flush all requests from the request/pending queue of an AP device.
835  */
836 static void __ap_flush_queue(struct ap_device *ap_dev)
837 {
838 	struct ap_message *ap_msg, *next;
839 
840 	list_for_each_entry_safe(ap_msg, next, &ap_dev->pendingq, list) {
841 		list_del_init(&ap_msg->list);
842 		ap_dev->pendingq_count--;
843 		ap_msg->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
844 	}
845 	list_for_each_entry_safe(ap_msg, next, &ap_dev->requestq, list) {
846 		list_del_init(&ap_msg->list);
847 		ap_dev->requestq_count--;
848 		ap_msg->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
849 	}
850 }
851 
852 void ap_flush_queue(struct ap_device *ap_dev)
853 {
854 	spin_lock_bh(&ap_dev->lock);
855 	__ap_flush_queue(ap_dev);
856 	spin_unlock_bh(&ap_dev->lock);
857 }
858 EXPORT_SYMBOL(ap_flush_queue);
859 
860 static int ap_device_remove(struct device *dev)
861 {
862 	struct ap_device *ap_dev = to_ap_dev(dev);
863 	struct ap_driver *ap_drv = ap_dev->drv;
864 
865 	ap_flush_queue(ap_dev);
866 	del_timer_sync(&ap_dev->timeout);
867 	spin_lock_bh(&ap_device_list_lock);
868 	list_del_init(&ap_dev->list);
869 	spin_unlock_bh(&ap_device_list_lock);
870 	if (ap_drv->remove)
871 		ap_drv->remove(ap_dev);
872 	spin_lock_bh(&ap_dev->lock);
873 	atomic_sub(ap_dev->queue_count, &ap_poll_requests);
874 	spin_unlock_bh(&ap_dev->lock);
875 	return 0;
876 }
877 
878 int ap_driver_register(struct ap_driver *ap_drv, struct module *owner,
879 		       char *name)
880 {
881 	struct device_driver *drv = &ap_drv->driver;
882 
883 	drv->bus = &ap_bus_type;
884 	drv->probe = ap_device_probe;
885 	drv->remove = ap_device_remove;
886 	drv->owner = owner;
887 	drv->name = name;
888 	return driver_register(drv);
889 }
890 EXPORT_SYMBOL(ap_driver_register);
891 
892 void ap_driver_unregister(struct ap_driver *ap_drv)
893 {
894 	driver_unregister(&ap_drv->driver);
895 }
896 EXPORT_SYMBOL(ap_driver_unregister);
897 
898 /*
899  * AP bus attributes.
900  */
901 static ssize_t ap_domain_show(struct bus_type *bus, char *buf)
902 {
903 	return snprintf(buf, PAGE_SIZE, "%d\n", ap_domain_index);
904 }
905 
906 static BUS_ATTR(ap_domain, 0444, ap_domain_show, NULL);
907 
908 static ssize_t ap_config_time_show(struct bus_type *bus, char *buf)
909 {
910 	return snprintf(buf, PAGE_SIZE, "%d\n", ap_config_time);
911 }
912 
913 static ssize_t ap_interrupts_show(struct bus_type *bus, char *buf)
914 {
915 	return snprintf(buf, PAGE_SIZE, "%d\n",
916 			ap_using_interrupts() ? 1 : 0);
917 }
918 
919 static BUS_ATTR(ap_interrupts, 0444, ap_interrupts_show, NULL);
920 
921 static ssize_t ap_config_time_store(struct bus_type *bus,
922 				    const char *buf, size_t count)
923 {
924 	int time;
925 
926 	if (sscanf(buf, "%d\n", &time) != 1 || time < 5 || time > 120)
927 		return -EINVAL;
928 	ap_config_time = time;
929 	if (!timer_pending(&ap_config_timer) ||
930 	    !mod_timer(&ap_config_timer, jiffies + ap_config_time * HZ)) {
931 		ap_config_timer.expires = jiffies + ap_config_time * HZ;
932 		add_timer(&ap_config_timer);
933 	}
934 	return count;
935 }
936 
937 static BUS_ATTR(config_time, 0644, ap_config_time_show, ap_config_time_store);
938 
939 static ssize_t ap_poll_thread_show(struct bus_type *bus, char *buf)
940 {
941 	return snprintf(buf, PAGE_SIZE, "%d\n", ap_poll_kthread ? 1 : 0);
942 }
943 
944 static ssize_t ap_poll_thread_store(struct bus_type *bus,
945 				    const char *buf, size_t count)
946 {
947 	int flag, rc;
948 
949 	if (sscanf(buf, "%d\n", &flag) != 1)
950 		return -EINVAL;
951 	if (flag) {
952 		rc = ap_poll_thread_start();
953 		if (rc)
954 			return rc;
955 	}
956 	else
957 		ap_poll_thread_stop();
958 	return count;
959 }
960 
961 static BUS_ATTR(poll_thread, 0644, ap_poll_thread_show, ap_poll_thread_store);
962 
963 static ssize_t poll_timeout_show(struct bus_type *bus, char *buf)
964 {
965 	return snprintf(buf, PAGE_SIZE, "%llu\n", poll_timeout);
966 }
967 
968 static ssize_t poll_timeout_store(struct bus_type *bus, const char *buf,
969 				  size_t count)
970 {
971 	unsigned long long time;
972 	ktime_t hr_time;
973 
974 	/* 120 seconds = maximum poll interval */
975 	if (sscanf(buf, "%llu\n", &time) != 1 || time < 1 ||
976 	    time > 120000000000ULL)
977 		return -EINVAL;
978 	poll_timeout = time;
979 	hr_time = ktime_set(0, poll_timeout);
980 
981 	if (!hrtimer_is_queued(&ap_poll_timer) ||
982 	    !hrtimer_forward(&ap_poll_timer, hrtimer_get_expires(&ap_poll_timer), hr_time)) {
983 		hrtimer_set_expires(&ap_poll_timer, hr_time);
984 		hrtimer_start_expires(&ap_poll_timer, HRTIMER_MODE_ABS);
985 	}
986 	return count;
987 }
988 
989 static BUS_ATTR(poll_timeout, 0644, poll_timeout_show, poll_timeout_store);
990 
991 static struct bus_attribute *const ap_bus_attrs[] = {
992 	&bus_attr_ap_domain,
993 	&bus_attr_config_time,
994 	&bus_attr_poll_thread,
995 	&bus_attr_ap_interrupts,
996 	&bus_attr_poll_timeout,
997 	NULL,
998 };
999 
1000 /**
1001  * ap_select_domain(): Select an AP domain.
1002  *
1003  * Pick one of the 16 AP domains.
1004  */
1005 static int ap_select_domain(void)
1006 {
1007 	int queue_depth, device_type, count, max_count, best_domain;
1008 	int rc, i, j;
1009 
1010 	/*
1011 	 * We want to use a single domain. Either the one specified with
1012 	 * the "domain=" parameter or the domain with the maximum number
1013 	 * of devices.
1014 	 */
1015 	if (ap_domain_index >= 0 && ap_domain_index < AP_DOMAINS)
1016 		/* Domain has already been selected. */
1017 		return 0;
1018 	best_domain = -1;
1019 	max_count = 0;
1020 	for (i = 0; i < AP_DOMAINS; i++) {
1021 		count = 0;
1022 		for (j = 0; j < AP_DEVICES; j++) {
1023 			ap_qid_t qid = AP_MKQID(j, i);
1024 			rc = ap_query_queue(qid, &queue_depth, &device_type);
1025 			if (rc)
1026 				continue;
1027 			count++;
1028 		}
1029 		if (count > max_count) {
1030 			max_count = count;
1031 			best_domain = i;
1032 		}
1033 	}
1034 	if (best_domain >= 0){
1035 		ap_domain_index = best_domain;
1036 		return 0;
1037 	}
1038 	return -ENODEV;
1039 }
1040 
1041 /**
1042  * ap_probe_device_type(): Find the device type of an AP.
1043  * @ap_dev: pointer to the AP device.
1044  *
1045  * Find the device type if query queue returned a device type of 0.
1046  */
1047 static int ap_probe_device_type(struct ap_device *ap_dev)
1048 {
1049 	static unsigned char msg[] = {
1050 		0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,
1051 		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1052 		0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,
1053 		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1054 		0x01,0x00,0x43,0x43,0x41,0x2d,0x41,0x50,
1055 		0x50,0x4c,0x20,0x20,0x20,0x01,0x01,0x01,
1056 		0x00,0x00,0x00,0x00,0x50,0x4b,0x00,0x00,
1057 		0x00,0x00,0x01,0x1c,0x00,0x00,0x00,0x00,
1058 		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1059 		0x00,0x00,0x05,0xb8,0x00,0x00,0x00,0x00,
1060 		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1061 		0x70,0x00,0x41,0x00,0x00,0x00,0x00,0x00,
1062 		0x00,0x00,0x54,0x32,0x01,0x00,0xa0,0x00,
1063 		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1064 		0x00,0x00,0x00,0x00,0xb8,0x05,0x00,0x00,
1065 		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1066 		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1067 		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1068 		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1069 		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1070 		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1071 		0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,
1072 		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1073 		0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,
1074 		0x49,0x43,0x53,0x46,0x20,0x20,0x20,0x20,
1075 		0x50,0x4b,0x0a,0x00,0x50,0x4b,0x43,0x53,
1076 		0x2d,0x31,0x2e,0x32,0x37,0x00,0x11,0x22,
1077 		0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00,
1078 		0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,
1079 		0x99,0x00,0x11,0x22,0x33,0x44,0x55,0x66,
1080 		0x77,0x88,0x99,0x00,0x11,0x22,0x33,0x44,
1081 		0x55,0x66,0x77,0x88,0x99,0x00,0x11,0x22,
1082 		0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00,
1083 		0x11,0x22,0x33,0x5d,0x00,0x5b,0x00,0x77,
1084 		0x88,0x1e,0x00,0x00,0x57,0x00,0x00,0x00,
1085 		0x00,0x04,0x00,0x00,0x4f,0x00,0x00,0x00,
1086 		0x03,0x02,0x00,0x00,0x40,0x01,0x00,0x01,
1087 		0xce,0x02,0x68,0x2d,0x5f,0xa9,0xde,0x0c,
1088 		0xf6,0xd2,0x7b,0x58,0x4b,0xf9,0x28,0x68,
1089 		0x3d,0xb4,0xf4,0xef,0x78,0xd5,0xbe,0x66,
1090 		0x63,0x42,0xef,0xf8,0xfd,0xa4,0xf8,0xb0,
1091 		0x8e,0x29,0xc2,0xc9,0x2e,0xd8,0x45,0xb8,
1092 		0x53,0x8c,0x6f,0x4e,0x72,0x8f,0x6c,0x04,
1093 		0x9c,0x88,0xfc,0x1e,0xc5,0x83,0x55,0x57,
1094 		0xf7,0xdd,0xfd,0x4f,0x11,0x36,0x95,0x5d,
1095 	};
1096 	struct ap_queue_status status;
1097 	unsigned long long psmid;
1098 	char *reply;
1099 	int rc, i;
1100 
1101 	reply = (void *) get_zeroed_page(GFP_KERNEL);
1102 	if (!reply) {
1103 		rc = -ENOMEM;
1104 		goto out;
1105 	}
1106 
1107 	status = __ap_send(ap_dev->qid, 0x0102030405060708ULL,
1108 			   msg, sizeof(msg), 0);
1109 	if (status.response_code != AP_RESPONSE_NORMAL) {
1110 		rc = -ENODEV;
1111 		goto out_free;
1112 	}
1113 
1114 	/* Wait for the test message to complete. */
1115 	for (i = 0; i < 6; i++) {
1116 		mdelay(300);
1117 		status = __ap_recv(ap_dev->qid, &psmid, reply, 4096);
1118 		if (status.response_code == AP_RESPONSE_NORMAL &&
1119 		    psmid == 0x0102030405060708ULL)
1120 			break;
1121 	}
1122 	if (i < 6) {
1123 		/* Got an answer. */
1124 		if (reply[0] == 0x00 && reply[1] == 0x86)
1125 			ap_dev->device_type = AP_DEVICE_TYPE_PCICC;
1126 		else
1127 			ap_dev->device_type = AP_DEVICE_TYPE_PCICA;
1128 		rc = 0;
1129 	} else
1130 		rc = -ENODEV;
1131 
1132 out_free:
1133 	free_page((unsigned long) reply);
1134 out:
1135 	return rc;
1136 }
1137 
1138 static void ap_interrupt_handler(void *unused1, void *unused2)
1139 {
1140 	kstat_cpu(smp_processor_id()).irqs[IOINT_APB]++;
1141 	tasklet_schedule(&ap_tasklet);
1142 }
1143 
1144 /**
1145  * __ap_scan_bus(): Scan the AP bus.
1146  * @dev: Pointer to device
1147  * @data: Pointer to data
1148  *
1149  * Scan the AP bus for new devices.
1150  */
1151 static int __ap_scan_bus(struct device *dev, void *data)
1152 {
1153 	return to_ap_dev(dev)->qid == (ap_qid_t)(unsigned long) data;
1154 }
1155 
1156 static void ap_device_release(struct device *dev)
1157 {
1158 	struct ap_device *ap_dev = to_ap_dev(dev);
1159 
1160 	kfree(ap_dev);
1161 }
1162 
1163 static void ap_scan_bus(struct work_struct *unused)
1164 {
1165 	struct ap_device *ap_dev;
1166 	struct device *dev;
1167 	ap_qid_t qid;
1168 	int queue_depth, device_type;
1169 	unsigned int device_functions;
1170 	int rc, i;
1171 
1172 	if (ap_select_domain() != 0)
1173 		return;
1174 	for (i = 0; i < AP_DEVICES; i++) {
1175 		qid = AP_MKQID(i, ap_domain_index);
1176 		dev = bus_find_device(&ap_bus_type, NULL,
1177 				      (void *)(unsigned long)qid,
1178 				      __ap_scan_bus);
1179 		rc = ap_query_queue(qid, &queue_depth, &device_type);
1180 		if (dev) {
1181 			if (rc == -EBUSY) {
1182 				set_current_state(TASK_UNINTERRUPTIBLE);
1183 				schedule_timeout(AP_RESET_TIMEOUT);
1184 				rc = ap_query_queue(qid, &queue_depth,
1185 						    &device_type);
1186 			}
1187 			ap_dev = to_ap_dev(dev);
1188 			spin_lock_bh(&ap_dev->lock);
1189 			if (rc || ap_dev->unregistered) {
1190 				spin_unlock_bh(&ap_dev->lock);
1191 				if (ap_dev->unregistered)
1192 					i--;
1193 				device_unregister(dev);
1194 				put_device(dev);
1195 				continue;
1196 			}
1197 			spin_unlock_bh(&ap_dev->lock);
1198 			put_device(dev);
1199 			continue;
1200 		}
1201 		if (rc)
1202 			continue;
1203 		rc = ap_init_queue(qid);
1204 		if (rc)
1205 			continue;
1206 		ap_dev = kzalloc(sizeof(*ap_dev), GFP_KERNEL);
1207 		if (!ap_dev)
1208 			break;
1209 		ap_dev->qid = qid;
1210 		ap_dev->queue_depth = queue_depth;
1211 		ap_dev->unregistered = 1;
1212 		spin_lock_init(&ap_dev->lock);
1213 		INIT_LIST_HEAD(&ap_dev->pendingq);
1214 		INIT_LIST_HEAD(&ap_dev->requestq);
1215 		INIT_LIST_HEAD(&ap_dev->list);
1216 		setup_timer(&ap_dev->timeout, ap_request_timeout,
1217 			    (unsigned long) ap_dev);
1218 		switch (device_type) {
1219 		case 0:
1220 			if (ap_probe_device_type(ap_dev)) {
1221 				kfree(ap_dev);
1222 				continue;
1223 			}
1224 			break;
1225 		case 10:
1226 			if (ap_query_functions(qid, &device_functions)) {
1227 				kfree(ap_dev);
1228 				continue;
1229 			}
1230 			if (test_ap_facility(device_functions, 3))
1231 				ap_dev->device_type = AP_DEVICE_TYPE_CEX3C;
1232 			else if (test_ap_facility(device_functions, 4))
1233 				ap_dev->device_type = AP_DEVICE_TYPE_CEX3A;
1234 			else {
1235 				kfree(ap_dev);
1236 				continue;
1237 			}
1238 			break;
1239 		default:
1240 			ap_dev->device_type = device_type;
1241 		}
1242 
1243 		ap_dev->device.bus = &ap_bus_type;
1244 		ap_dev->device.parent = ap_root_device;
1245 		if (dev_set_name(&ap_dev->device, "card%02x",
1246 				 AP_QID_DEVICE(ap_dev->qid))) {
1247 			kfree(ap_dev);
1248 			continue;
1249 		}
1250 		ap_dev->device.release = ap_device_release;
1251 		rc = device_register(&ap_dev->device);
1252 		if (rc) {
1253 			put_device(&ap_dev->device);
1254 			continue;
1255 		}
1256 		/* Add device attributes. */
1257 		rc = sysfs_create_group(&ap_dev->device.kobj,
1258 					&ap_dev_attr_group);
1259 		if (!rc) {
1260 			spin_lock_bh(&ap_dev->lock);
1261 			ap_dev->unregistered = 0;
1262 			spin_unlock_bh(&ap_dev->lock);
1263 		}
1264 		else
1265 			device_unregister(&ap_dev->device);
1266 	}
1267 }
1268 
1269 static void
1270 ap_config_timeout(unsigned long ptr)
1271 {
1272 	queue_work(ap_work_queue, &ap_config_work);
1273 	ap_config_timer.expires = jiffies + ap_config_time * HZ;
1274 	add_timer(&ap_config_timer);
1275 }
1276 
1277 /**
1278  * __ap_schedule_poll_timer(): Schedule poll timer.
1279  *
1280  * Set up the timer to run the poll tasklet
1281  */
1282 static inline void __ap_schedule_poll_timer(void)
1283 {
1284 	ktime_t hr_time;
1285 
1286 	spin_lock_bh(&ap_poll_timer_lock);
1287 	if (hrtimer_is_queued(&ap_poll_timer) || ap_suspend_flag)
1288 		goto out;
1289 	if (ktime_to_ns(hrtimer_expires_remaining(&ap_poll_timer)) <= 0) {
1290 		hr_time = ktime_set(0, poll_timeout);
1291 		hrtimer_forward_now(&ap_poll_timer, hr_time);
1292 		hrtimer_restart(&ap_poll_timer);
1293 	}
1294 out:
1295 	spin_unlock_bh(&ap_poll_timer_lock);
1296 }
1297 
1298 /**
1299  * ap_schedule_poll_timer(): Schedule poll timer.
1300  *
1301  * Set up the timer to run the poll tasklet
1302  */
1303 static inline void ap_schedule_poll_timer(void)
1304 {
1305 	if (ap_using_interrupts())
1306 		return;
1307 	__ap_schedule_poll_timer();
1308 }
1309 
1310 /**
1311  * ap_poll_read(): Receive pending reply messages from an AP device.
1312  * @ap_dev: pointer to the AP device
1313  * @flags: pointer to control flags, bit 2^0 is set if another poll is
1314  *	   required, bit 2^1 is set if the poll timer needs to get armed
1315  *
1316  * Returns 0 if the device is still present, -ENODEV if not.
1317  */
1318 static int ap_poll_read(struct ap_device *ap_dev, unsigned long *flags)
1319 {
1320 	struct ap_queue_status status;
1321 	struct ap_message *ap_msg;
1322 
1323 	if (ap_dev->queue_count <= 0)
1324 		return 0;
1325 	status = __ap_recv(ap_dev->qid, &ap_dev->reply->psmid,
1326 			   ap_dev->reply->message, ap_dev->reply->length);
1327 	switch (status.response_code) {
1328 	case AP_RESPONSE_NORMAL:
1329 		atomic_dec(&ap_poll_requests);
1330 		ap_decrease_queue_count(ap_dev);
1331 		list_for_each_entry(ap_msg, &ap_dev->pendingq, list) {
1332 			if (ap_msg->psmid != ap_dev->reply->psmid)
1333 				continue;
1334 			list_del_init(&ap_msg->list);
1335 			ap_dev->pendingq_count--;
1336 			ap_msg->receive(ap_dev, ap_msg, ap_dev->reply);
1337 			break;
1338 		}
1339 		if (ap_dev->queue_count > 0)
1340 			*flags |= 1;
1341 		break;
1342 	case AP_RESPONSE_NO_PENDING_REPLY:
1343 		if (status.queue_empty) {
1344 			/* The card shouldn't forget requests but who knows. */
1345 			atomic_sub(ap_dev->queue_count, &ap_poll_requests);
1346 			ap_dev->queue_count = 0;
1347 			list_splice_init(&ap_dev->pendingq, &ap_dev->requestq);
1348 			ap_dev->requestq_count += ap_dev->pendingq_count;
1349 			ap_dev->pendingq_count = 0;
1350 		} else
1351 			*flags |= 2;
1352 		break;
1353 	default:
1354 		return -ENODEV;
1355 	}
1356 	return 0;
1357 }
1358 
1359 /**
1360  * ap_poll_write(): Send messages from the request queue to an AP device.
1361  * @ap_dev: pointer to the AP device
1362  * @flags: pointer to control flags, bit 2^0 is set if another poll is
1363  *	   required, bit 2^1 is set if the poll timer needs to get armed
1364  *
1365  * Returns 0 if the device is still present, -ENODEV if not.
1366  */
1367 static int ap_poll_write(struct ap_device *ap_dev, unsigned long *flags)
1368 {
1369 	struct ap_queue_status status;
1370 	struct ap_message *ap_msg;
1371 
1372 	if (ap_dev->requestq_count <= 0 ||
1373 	    ap_dev->queue_count >= ap_dev->queue_depth)
1374 		return 0;
1375 	/* Start the next request on the queue. */
1376 	ap_msg = list_entry(ap_dev->requestq.next, struct ap_message, list);
1377 	status = __ap_send(ap_dev->qid, ap_msg->psmid,
1378 			   ap_msg->message, ap_msg->length, ap_msg->special);
1379 	switch (status.response_code) {
1380 	case AP_RESPONSE_NORMAL:
1381 		atomic_inc(&ap_poll_requests);
1382 		ap_increase_queue_count(ap_dev);
1383 		list_move_tail(&ap_msg->list, &ap_dev->pendingq);
1384 		ap_dev->requestq_count--;
1385 		ap_dev->pendingq_count++;
1386 		if (ap_dev->queue_count < ap_dev->queue_depth &&
1387 		    ap_dev->requestq_count > 0)
1388 			*flags |= 1;
1389 		*flags |= 2;
1390 		break;
1391 	case AP_RESPONSE_RESET_IN_PROGRESS:
1392 		__ap_schedule_poll_timer();
1393 	case AP_RESPONSE_Q_FULL:
1394 		*flags |= 2;
1395 		break;
1396 	case AP_RESPONSE_MESSAGE_TOO_BIG:
1397 	case AP_RESPONSE_REQ_FAC_NOT_INST:
1398 		return -EINVAL;
1399 	default:
1400 		return -ENODEV;
1401 	}
1402 	return 0;
1403 }
1404 
1405 /**
1406  * ap_poll_queue(): Poll AP device for pending replies and send new messages.
1407  * @ap_dev: pointer to the bus device
1408  * @flags: pointer to control flags, bit 2^0 is set if another poll is
1409  *	   required, bit 2^1 is set if the poll timer needs to get armed
1410  *
1411  * Poll AP device for pending replies and send new messages. If either
1412  * ap_poll_read or ap_poll_write returns -ENODEV unregister the device.
1413  * Returns 0.
1414  */
1415 static inline int ap_poll_queue(struct ap_device *ap_dev, unsigned long *flags)
1416 {
1417 	int rc;
1418 
1419 	rc = ap_poll_read(ap_dev, flags);
1420 	if (rc)
1421 		return rc;
1422 	return ap_poll_write(ap_dev, flags);
1423 }
1424 
1425 /**
1426  * __ap_queue_message(): Queue a message to a device.
1427  * @ap_dev: pointer to the AP device
1428  * @ap_msg: the message to be queued
1429  *
1430  * Queue a message to a device. Returns 0 if successful.
1431  */
1432 static int __ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
1433 {
1434 	struct ap_queue_status status;
1435 
1436 	if (list_empty(&ap_dev->requestq) &&
1437 	    ap_dev->queue_count < ap_dev->queue_depth) {
1438 		status = __ap_send(ap_dev->qid, ap_msg->psmid,
1439 				   ap_msg->message, ap_msg->length,
1440 				   ap_msg->special);
1441 		switch (status.response_code) {
1442 		case AP_RESPONSE_NORMAL:
1443 			list_add_tail(&ap_msg->list, &ap_dev->pendingq);
1444 			atomic_inc(&ap_poll_requests);
1445 			ap_dev->pendingq_count++;
1446 			ap_increase_queue_count(ap_dev);
1447 			ap_dev->total_request_count++;
1448 			break;
1449 		case AP_RESPONSE_Q_FULL:
1450 		case AP_RESPONSE_RESET_IN_PROGRESS:
1451 			list_add_tail(&ap_msg->list, &ap_dev->requestq);
1452 			ap_dev->requestq_count++;
1453 			ap_dev->total_request_count++;
1454 			return -EBUSY;
1455 		case AP_RESPONSE_REQ_FAC_NOT_INST:
1456 		case AP_RESPONSE_MESSAGE_TOO_BIG:
1457 			ap_msg->receive(ap_dev, ap_msg, ERR_PTR(-EINVAL));
1458 			return -EINVAL;
1459 		default:	/* Device is gone. */
1460 			ap_msg->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
1461 			return -ENODEV;
1462 		}
1463 	} else {
1464 		list_add_tail(&ap_msg->list, &ap_dev->requestq);
1465 		ap_dev->requestq_count++;
1466 		ap_dev->total_request_count++;
1467 		return -EBUSY;
1468 	}
1469 	ap_schedule_poll_timer();
1470 	return 0;
1471 }
1472 
1473 void ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
1474 {
1475 	unsigned long flags;
1476 	int rc;
1477 
1478 	/* For asynchronous message handling a valid receive-callback
1479 	 * is required. */
1480 	BUG_ON(!ap_msg->receive);
1481 
1482 	spin_lock_bh(&ap_dev->lock);
1483 	if (!ap_dev->unregistered) {
1484 		/* Make room on the queue by polling for finished requests. */
1485 		rc = ap_poll_queue(ap_dev, &flags);
1486 		if (!rc)
1487 			rc = __ap_queue_message(ap_dev, ap_msg);
1488 		if (!rc)
1489 			wake_up(&ap_poll_wait);
1490 		if (rc == -ENODEV)
1491 			ap_dev->unregistered = 1;
1492 	} else {
1493 		ap_msg->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
1494 		rc = -ENODEV;
1495 	}
1496 	spin_unlock_bh(&ap_dev->lock);
1497 	if (rc == -ENODEV)
1498 		device_unregister(&ap_dev->device);
1499 }
1500 EXPORT_SYMBOL(ap_queue_message);
1501 
1502 /**
1503  * ap_cancel_message(): Cancel a crypto request.
1504  * @ap_dev: The AP device that has the message queued
1505  * @ap_msg: The message that is to be removed
1506  *
1507  * Cancel a crypto request. This is done by removing the request
1508  * from the device pending or request queue. Note that the
1509  * request stays on the AP queue. When it finishes the message
1510  * reply will be discarded because the psmid can't be found.
1511  */
1512 void ap_cancel_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
1513 {
1514 	struct ap_message *tmp;
1515 
1516 	spin_lock_bh(&ap_dev->lock);
1517 	if (!list_empty(&ap_msg->list)) {
1518 		list_for_each_entry(tmp, &ap_dev->pendingq, list)
1519 			if (tmp->psmid == ap_msg->psmid) {
1520 				ap_dev->pendingq_count--;
1521 				goto found;
1522 			}
1523 		ap_dev->requestq_count--;
1524 	found:
1525 		list_del_init(&ap_msg->list);
1526 	}
1527 	spin_unlock_bh(&ap_dev->lock);
1528 }
1529 EXPORT_SYMBOL(ap_cancel_message);
1530 
1531 /**
1532  * ap_poll_timeout(): AP receive polling for finished AP requests.
1533  * @unused: Unused pointer.
1534  *
1535  * Schedules the AP tasklet using a high resolution timer.
1536  */
1537 static enum hrtimer_restart ap_poll_timeout(struct hrtimer *unused)
1538 {
1539 	tasklet_schedule(&ap_tasklet);
1540 	return HRTIMER_NORESTART;
1541 }
1542 
1543 /**
1544  * ap_reset(): Reset a not responding AP device.
1545  * @ap_dev: Pointer to the AP device
1546  *
1547  * Reset a not responding AP device and move all requests from the
1548  * pending queue to the request queue.
1549  */
1550 static void ap_reset(struct ap_device *ap_dev)
1551 {
1552 	int rc;
1553 
1554 	ap_dev->reset = AP_RESET_IGNORE;
1555 	atomic_sub(ap_dev->queue_count, &ap_poll_requests);
1556 	ap_dev->queue_count = 0;
1557 	list_splice_init(&ap_dev->pendingq, &ap_dev->requestq);
1558 	ap_dev->requestq_count += ap_dev->pendingq_count;
1559 	ap_dev->pendingq_count = 0;
1560 	rc = ap_init_queue(ap_dev->qid);
1561 	if (rc == -ENODEV)
1562 		ap_dev->unregistered = 1;
1563 	else
1564 		__ap_schedule_poll_timer();
1565 }
1566 
1567 static int __ap_poll_device(struct ap_device *ap_dev, unsigned long *flags)
1568 {
1569 	if (!ap_dev->unregistered) {
1570 		if (ap_poll_queue(ap_dev, flags))
1571 			ap_dev->unregistered = 1;
1572 		if (ap_dev->reset == AP_RESET_DO)
1573 			ap_reset(ap_dev);
1574 	}
1575 	return 0;
1576 }
1577 
1578 /**
1579  * ap_poll_all(): Poll all AP devices.
1580  * @dummy: Unused variable
1581  *
1582  * Poll all AP devices on the bus in a round robin fashion. Continue
1583  * polling until bit 2^0 of the control flags is not set. If bit 2^1
1584  * of the control flags has been set arm the poll timer.
1585  */
1586 static void ap_poll_all(unsigned long dummy)
1587 {
1588 	unsigned long flags;
1589 	struct ap_device *ap_dev;
1590 
1591 	/* Reset the indicator if interrupts are used. Thus new interrupts can
1592 	 * be received. Doing it in the beginning of the tasklet is therefor
1593 	 * important that no requests on any AP get lost.
1594 	 */
1595 	if (ap_using_interrupts())
1596 		xchg((u8 *)ap_interrupt_indicator, 0);
1597 	do {
1598 		flags = 0;
1599 		spin_lock(&ap_device_list_lock);
1600 		list_for_each_entry(ap_dev, &ap_device_list, list) {
1601 			spin_lock(&ap_dev->lock);
1602 			__ap_poll_device(ap_dev, &flags);
1603 			spin_unlock(&ap_dev->lock);
1604 		}
1605 		spin_unlock(&ap_device_list_lock);
1606 	} while (flags & 1);
1607 	if (flags & 2)
1608 		ap_schedule_poll_timer();
1609 }
1610 
1611 /**
1612  * ap_poll_thread(): Thread that polls for finished requests.
1613  * @data: Unused pointer
1614  *
1615  * AP bus poll thread. The purpose of this thread is to poll for
1616  * finished requests in a loop if there is a "free" cpu - that is
1617  * a cpu that doesn't have anything better to do. The polling stops
1618  * as soon as there is another task or if all messages have been
1619  * delivered.
1620  */
1621 static int ap_poll_thread(void *data)
1622 {
1623 	DECLARE_WAITQUEUE(wait, current);
1624 	unsigned long flags;
1625 	int requests;
1626 	struct ap_device *ap_dev;
1627 
1628 	set_user_nice(current, 19);
1629 	while (1) {
1630 		if (ap_suspend_flag)
1631 			return 0;
1632 		if (need_resched()) {
1633 			schedule();
1634 			continue;
1635 		}
1636 		add_wait_queue(&ap_poll_wait, &wait);
1637 		set_current_state(TASK_INTERRUPTIBLE);
1638 		if (kthread_should_stop())
1639 			break;
1640 		requests = atomic_read(&ap_poll_requests);
1641 		if (requests <= 0)
1642 			schedule();
1643 		set_current_state(TASK_RUNNING);
1644 		remove_wait_queue(&ap_poll_wait, &wait);
1645 
1646 		flags = 0;
1647 		spin_lock_bh(&ap_device_list_lock);
1648 		list_for_each_entry(ap_dev, &ap_device_list, list) {
1649 			spin_lock(&ap_dev->lock);
1650 			__ap_poll_device(ap_dev, &flags);
1651 			spin_unlock(&ap_dev->lock);
1652 		}
1653 		spin_unlock_bh(&ap_device_list_lock);
1654 	}
1655 	set_current_state(TASK_RUNNING);
1656 	remove_wait_queue(&ap_poll_wait, &wait);
1657 	return 0;
1658 }
1659 
1660 static int ap_poll_thread_start(void)
1661 {
1662 	int rc;
1663 
1664 	if (ap_using_interrupts() || ap_suspend_flag)
1665 		return 0;
1666 	mutex_lock(&ap_poll_thread_mutex);
1667 	if (!ap_poll_kthread) {
1668 		ap_poll_kthread = kthread_run(ap_poll_thread, NULL, "appoll");
1669 		rc = IS_ERR(ap_poll_kthread) ? PTR_ERR(ap_poll_kthread) : 0;
1670 		if (rc)
1671 			ap_poll_kthread = NULL;
1672 	}
1673 	else
1674 		rc = 0;
1675 	mutex_unlock(&ap_poll_thread_mutex);
1676 	return rc;
1677 }
1678 
1679 static void ap_poll_thread_stop(void)
1680 {
1681 	mutex_lock(&ap_poll_thread_mutex);
1682 	if (ap_poll_kthread) {
1683 		kthread_stop(ap_poll_kthread);
1684 		ap_poll_kthread = NULL;
1685 	}
1686 	mutex_unlock(&ap_poll_thread_mutex);
1687 }
1688 
1689 /**
1690  * ap_request_timeout(): Handling of request timeouts
1691  * @data: Holds the AP device.
1692  *
1693  * Handles request timeouts.
1694  */
1695 static void ap_request_timeout(unsigned long data)
1696 {
1697 	struct ap_device *ap_dev = (struct ap_device *) data;
1698 
1699 	if (ap_dev->reset == AP_RESET_ARMED) {
1700 		ap_dev->reset = AP_RESET_DO;
1701 
1702 		if (ap_using_interrupts())
1703 			tasklet_schedule(&ap_tasklet);
1704 	}
1705 }
1706 
1707 static void ap_reset_domain(void)
1708 {
1709 	int i;
1710 
1711 	if (ap_domain_index != -1)
1712 		for (i = 0; i < AP_DEVICES; i++)
1713 			ap_reset_queue(AP_MKQID(i, ap_domain_index));
1714 }
1715 
1716 static void ap_reset_all(void)
1717 {
1718 	int i, j;
1719 
1720 	for (i = 0; i < AP_DOMAINS; i++)
1721 		for (j = 0; j < AP_DEVICES; j++)
1722 			ap_reset_queue(AP_MKQID(j, i));
1723 }
1724 
1725 static struct reset_call ap_reset_call = {
1726 	.fn = ap_reset_all,
1727 };
1728 
1729 /**
1730  * ap_module_init(): The module initialization code.
1731  *
1732  * Initializes the module.
1733  */
1734 int __init ap_module_init(void)
1735 {
1736 	int rc, i;
1737 
1738 	if (ap_domain_index < -1 || ap_domain_index >= AP_DOMAINS) {
1739 		pr_warning("%d is not a valid cryptographic domain\n",
1740 			   ap_domain_index);
1741 		return -EINVAL;
1742 	}
1743 	/* In resume callback we need to know if the user had set the domain.
1744 	 * If so, we can not just reset it.
1745 	 */
1746 	if (ap_domain_index >= 0)
1747 		user_set_domain = 1;
1748 
1749 	if (ap_instructions_available() != 0) {
1750 		pr_warning("The hardware system does not support "
1751 			   "AP instructions\n");
1752 		return -ENODEV;
1753 	}
1754 	if (ap_interrupts_available()) {
1755 		isc_register(AP_ISC);
1756 		ap_interrupt_indicator = s390_register_adapter_interrupt(
1757 			&ap_interrupt_handler, NULL, AP_ISC);
1758 		if (IS_ERR(ap_interrupt_indicator)) {
1759 			ap_interrupt_indicator = NULL;
1760 			isc_unregister(AP_ISC);
1761 		}
1762 	}
1763 
1764 	register_reset_call(&ap_reset_call);
1765 
1766 	/* Create /sys/bus/ap. */
1767 	rc = bus_register(&ap_bus_type);
1768 	if (rc)
1769 		goto out;
1770 	for (i = 0; ap_bus_attrs[i]; i++) {
1771 		rc = bus_create_file(&ap_bus_type, ap_bus_attrs[i]);
1772 		if (rc)
1773 			goto out_bus;
1774 	}
1775 
1776 	/* Create /sys/devices/ap. */
1777 	ap_root_device = root_device_register("ap");
1778 	rc = IS_ERR(ap_root_device) ? PTR_ERR(ap_root_device) : 0;
1779 	if (rc)
1780 		goto out_bus;
1781 
1782 	ap_work_queue = create_singlethread_workqueue("kapwork");
1783 	if (!ap_work_queue) {
1784 		rc = -ENOMEM;
1785 		goto out_root;
1786 	}
1787 
1788 	if (ap_select_domain() == 0)
1789 		ap_scan_bus(NULL);
1790 
1791 	/* Setup the AP bus rescan timer. */
1792 	init_timer(&ap_config_timer);
1793 	ap_config_timer.function = ap_config_timeout;
1794 	ap_config_timer.data = 0;
1795 	ap_config_timer.expires = jiffies + ap_config_time * HZ;
1796 	add_timer(&ap_config_timer);
1797 
1798 	/* Setup the high resultion poll timer.
1799 	 * If we are running under z/VM adjust polling to z/VM polling rate.
1800 	 */
1801 	if (MACHINE_IS_VM)
1802 		poll_timeout = 1500000;
1803 	spin_lock_init(&ap_poll_timer_lock);
1804 	hrtimer_init(&ap_poll_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
1805 	ap_poll_timer.function = ap_poll_timeout;
1806 
1807 	/* Start the low priority AP bus poll thread. */
1808 	if (ap_thread_flag) {
1809 		rc = ap_poll_thread_start();
1810 		if (rc)
1811 			goto out_work;
1812 	}
1813 
1814 	return 0;
1815 
1816 out_work:
1817 	del_timer_sync(&ap_config_timer);
1818 	hrtimer_cancel(&ap_poll_timer);
1819 	destroy_workqueue(ap_work_queue);
1820 out_root:
1821 	root_device_unregister(ap_root_device);
1822 out_bus:
1823 	while (i--)
1824 		bus_remove_file(&ap_bus_type, ap_bus_attrs[i]);
1825 	bus_unregister(&ap_bus_type);
1826 out:
1827 	unregister_reset_call(&ap_reset_call);
1828 	if (ap_using_interrupts()) {
1829 		s390_unregister_adapter_interrupt(ap_interrupt_indicator, AP_ISC);
1830 		isc_unregister(AP_ISC);
1831 	}
1832 	return rc;
1833 }
1834 
1835 static int __ap_match_all(struct device *dev, void *data)
1836 {
1837 	return 1;
1838 }
1839 
1840 /**
1841  * ap_modules_exit(): The module termination code
1842  *
1843  * Terminates the module.
1844  */
1845 void ap_module_exit(void)
1846 {
1847 	int i;
1848 	struct device *dev;
1849 
1850 	ap_reset_domain();
1851 	ap_poll_thread_stop();
1852 	del_timer_sync(&ap_config_timer);
1853 	hrtimer_cancel(&ap_poll_timer);
1854 	destroy_workqueue(ap_work_queue);
1855 	tasklet_kill(&ap_tasklet);
1856 	root_device_unregister(ap_root_device);
1857 	while ((dev = bus_find_device(&ap_bus_type, NULL, NULL,
1858 		    __ap_match_all)))
1859 	{
1860 		device_unregister(dev);
1861 		put_device(dev);
1862 	}
1863 	for (i = 0; ap_bus_attrs[i]; i++)
1864 		bus_remove_file(&ap_bus_type, ap_bus_attrs[i]);
1865 	bus_unregister(&ap_bus_type);
1866 	unregister_reset_call(&ap_reset_call);
1867 	if (ap_using_interrupts()) {
1868 		s390_unregister_adapter_interrupt(ap_interrupt_indicator, AP_ISC);
1869 		isc_unregister(AP_ISC);
1870 	}
1871 }
1872 
1873 module_init(ap_module_init);
1874 module_exit(ap_module_exit);
1875