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