drivers/s390/crypto/ap_bus.c

   1 /*
   2  * linux/drivers/s390/crypto/ap_bus.c
   3  *
   4  * Copyright (C) 2006 IBM Corporation
   5  * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
   6  *            Martin Schwidefsky <schwidefsky@de.ibm.com>
   7  *            Ralph Wuerthner <rwuerthn@de.ibm.com>
   8  *
   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 #include <linux/module.h>
  27 #include <linux/init.h>
  28 #include <linux/delay.h>
  29 #include <linux/err.h>
  30 #include <linux/interrupt.h>
  31 #include <linux/workqueue.h>
  32 #include <linux/notifier.h>
  33 #include <linux/kthread.h>
  34 #include <linux/mutex.h>
  35 #include <asm/s390_rdev.h>
  36 #include <asm/reset.h>
  37
  38 #include "ap_bus.h"
  39
  40 /* Some prototypes. */
  41 static void ap_scan_bus(struct work_struct *);
  42 static void ap_poll_all(unsigned long);
  43 static void ap_poll_timeout(unsigned long);
  44 static int ap_poll_thread_start(void);
  45 static void ap_poll_thread_stop(void);
  46
  47 /**
  48  * Module description.
  49  */
  50 MODULE_AUTHOR("IBM Corporation");
  51 MODULE_DESCRIPTION("Adjunct Processor Bus driver, "
  52                    "Copyright 2006 IBM Corporation");
  53 MODULE_LICENSE("GPL");
  54
  55 /**
  56  * Module parameter
  57  */
  58 int ap_domain_index = -1;       /* Adjunct Processor Domain Index */
  59 module_param_named(domain, ap_domain_index, int, 0000);
  60 MODULE_PARM_DESC(domain, "domain index for ap devices");
  61 EXPORT_SYMBOL(ap_domain_index);
  62
  63 static int ap_thread_flag = 1;
  64 module_param_named(poll_thread, ap_thread_flag, int, 0000);
  65 MODULE_PARM_DESC(poll_thread, "Turn on/off poll thread, default is 1 (on).");
  66
  67 static struct device *ap_root_device = NULL;
  68 static DEFINE_SPINLOCK(ap_device_lock);
  69 static LIST_HEAD(ap_device_list);
  70
  71 /**
  72  * Workqueue & timer for bus rescan.
  73  */
  74 static struct workqueue_struct *ap_work_queue;
  75 static struct timer_list ap_config_timer;
  76 static int ap_config_time = AP_CONFIG_TIME;
  77 static DECLARE_WORK(ap_config_work, ap_scan_bus);
  78
  79 /**
  80  * Tasklet & timer for AP request polling.
  81  */
  82 static struct timer_list ap_poll_timer = TIMER_INITIALIZER(ap_poll_timeout,0,0);
  83 static DECLARE_TASKLET(ap_tasklet, ap_poll_all, 0);
  84 static atomic_t ap_poll_requests = ATOMIC_INIT(0);
  85 static DECLARE_WAIT_QUEUE_HEAD(ap_poll_wait);
  86 static struct task_struct *ap_poll_kthread = NULL;
  87 static DEFINE_MUTEX(ap_poll_thread_mutex);
  88
  89 /**
  90  * Test if ap instructions are available.
  91  *
  92  * Returns 0 if the ap instructions are installed.
  93  */
  94 static inline int ap_instructions_available(void)
  95 {
  96         register unsigned long reg0 asm ("0") = AP_MKQID(0,0);
  97         register unsigned long reg1 asm ("1") = -ENODEV;
  98         register unsigned long reg2 asm ("2") = 0UL;
  99
 100         asm volatile(
 101                 "   .long 0xb2af0000\n"         /* PQAP(TAPQ) */
 102                 "0: la    %1,0\n"
 103                 "1:\n"
 104                 EX_TABLE(0b, 1b)
 105                 : "+d" (reg0), "+d" (reg1), "+d" (reg2) : : "cc" );
 106         return reg1;
 107 }
 108
 109 /**
 110  * Test adjunct processor queue.
 111  * @qid: the ap queue number
 112  * @queue_depth: pointer to queue depth value
 113  * @device_type: pointer to device type value
 114  *
 115  * Returns ap queue status structure.
 116  */
 117 static inline struct ap_queue_status
 118 ap_test_queue(ap_qid_t qid, int *queue_depth, int *device_type)
 119 {
 120         register unsigned long reg0 asm ("0") = qid;
 121         register struct ap_queue_status reg1 asm ("1");
 122         register unsigned long reg2 asm ("2") = 0UL;
 123
 124         asm volatile(".long 0xb2af0000"         /* PQAP(TAPQ) */
 125                      : "+d" (reg0), "=d" (reg1), "+d" (reg2) : : "cc");
 126         *device_type = (int) (reg2 >> 24);
 127         *queue_depth = (int) (reg2 & 0xff);
 128         return reg1;
 129 }
 130
 131 /**
 132  * Reset adjunct processor queue.
 133  * @qid: the ap queue number
 134  *
 135  * Returns ap queue status structure.
 136  */
 137 static inline struct ap_queue_status ap_reset_queue(ap_qid_t qid)
 138 {
 139         register unsigned long reg0 asm ("0") = qid | 0x01000000UL;
 140         register struct ap_queue_status reg1 asm ("1");
 141         register unsigned long reg2 asm ("2") = 0UL;
 142
 143         asm volatile(
 144                 ".long 0xb2af0000"              /* PQAP(RAPQ) */
 145                 : "+d" (reg0), "=d" (reg1), "+d" (reg2) : : "cc");
 146         return reg1;
 147 }
 148
 149 /**
 150  * Send message to adjunct processor queue.
 151  * @qid: the ap queue number
 152  * @psmid: the program supplied message identifier
 153  * @msg: the message text
 154  * @length: the message length
 155  *
 156  * Returns ap queue status structure.
 157  *
 158  * Condition code 1 on NQAP can't happen because the L bit is 1.
 159  *
 160  * Condition code 2 on NQAP also means the send is incomplete,
 161  * because a segment boundary was reached. The NQAP is repeated.
 162  */
 163 static inline struct ap_queue_status
 164 __ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length)
 165 {
 166         typedef struct { char _[length]; } msgblock;
 167         register unsigned long reg0 asm ("0") = qid | 0x40000000UL;
 168         register struct ap_queue_status reg1 asm ("1");
 169         register unsigned long reg2 asm ("2") = (unsigned long) msg;
 170         register unsigned long reg3 asm ("3") = (unsigned long) length;
 171         register unsigned long reg4 asm ("4") = (unsigned int) (psmid >> 32);
 172         register unsigned long reg5 asm ("5") = (unsigned int) psmid;
 173
 174         asm volatile (
 175                 "0: .long 0xb2ad0042\n"         /* DQAP */
 176                 "   brc   2,0b"
 177                 : "+d" (reg0), "=d" (reg1), "+d" (reg2), "+d" (reg3)
 178                 : "d" (reg4), "d" (reg5), "m" (*(msgblock *) msg)
 179                 : "cc" );
 180         return reg1;
 181 }
 182
 183 int ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length)
 184 {
 185         struct ap_queue_status status;
 186
 187         status = __ap_send(qid, psmid, msg, length);
 188         switch (status.response_code) {
 189         case AP_RESPONSE_NORMAL:
 190                 return 0;
 191         case AP_RESPONSE_Q_FULL:
 192                 return -EBUSY;
 193         default:        /* Device is gone. */
 194                 return -ENODEV;
 195         }
 196 }
 197 EXPORT_SYMBOL(ap_send);
 198
 199 /*
 200  * Receive message from adjunct processor queue.
 201  * @qid: the ap queue number
 202  * @psmid: pointer to program supplied message identifier
 203  * @msg: the message text
 204  * @length: the message length
 205  *
 206  * Returns ap queue status structure.
 207  *
 208  * Condition code 1 on DQAP means the receive has taken place
 209  * but only partially.  The response is incomplete, hence the
 210  * DQAP is repeated.
 211  *
 212  * Condition code 2 on DQAP also means the receive is incomplete,
 213  * this time because a segment boundary was reached. Again, the
 214  * DQAP is repeated.
 215  *
 216  * Note that gpr2 is used by the DQAP instruction to keep track of
 217  * any 'residual' length, in case the instruction gets interrupted.
 218  * Hence it gets zeroed before the instruction.
 219  */
 220 static inline struct ap_queue_status
 221 __ap_recv(ap_qid_t qid, unsigned long long *psmid, void *msg, size_t length)
 222 {
 223         typedef struct { char _[length]; } msgblock;
 224         register unsigned long reg0 asm("0") = qid | 0x80000000UL;
 225         register struct ap_queue_status reg1 asm ("1");
 226         register unsigned long reg2 asm("2") = 0UL;
 227         register unsigned long reg4 asm("4") = (unsigned long) msg;
 228         register unsigned long reg5 asm("5") = (unsigned long) length;
 229         register unsigned long reg6 asm("6") = 0UL;
 230         register unsigned long reg7 asm("7") = 0UL;
 231
 232
 233         asm volatile(
 234                 "0: .long 0xb2ae0064\n"
 235                 "   brc   6,0b\n"
 236                 : "+d" (reg0), "=d" (reg1), "+d" (reg2),
 237                 "+d" (reg4), "+d" (reg5), "+d" (reg6), "+d" (reg7),
 238                 "=m" (*(msgblock *) msg) : : "cc" );
 239         *psmid = (((unsigned long long) reg6) << 32) + reg7;
 240         return reg1;
 241 }
 242
 243 int ap_recv(ap_qid_t qid, unsigned long long *psmid, void *msg, size_t length)
 244 {
 245         struct ap_queue_status status;
 246
 247         status = __ap_recv(qid, psmid, msg, length);
 248         switch (status.response_code) {
 249         case AP_RESPONSE_NORMAL:
 250                 return 0;
 251         case AP_RESPONSE_NO_PENDING_REPLY:
 252                 if (status.queue_empty)
 253                         return -ENOENT;
 254                 return -EBUSY;
 255         default:
 256                 return -ENODEV;
 257         }
 258 }
 259 EXPORT_SYMBOL(ap_recv);
 260
 261 /**
 262  * Check if an AP queue is available. The test is repeated for
 263  * AP_MAX_RESET times.
 264  * @qid: the ap queue number
 265  * @queue_depth: pointer to queue depth value
 266  * @device_type: pointer to device type value
 267  */
 268 static int ap_query_queue(ap_qid_t qid, int *queue_depth, int *device_type)
 269 {
 270         struct ap_queue_status status;
 271         int t_depth, t_device_type, rc, i;
 272
 273         rc = -EBUSY;
 274         for (i = 0; i < AP_MAX_RESET; i++) {
 275                 status = ap_test_queue(qid, &t_depth, &t_device_type);
 276                 switch (status.response_code) {
 277                 case AP_RESPONSE_NORMAL:
 278                         *queue_depth = t_depth + 1;
 279                         *device_type = t_device_type;
 280                         rc = 0;
 281                         break;
 282                 case AP_RESPONSE_Q_NOT_AVAIL:
 283                         rc = -ENODEV;
 284                         break;
 285                 case AP_RESPONSE_RESET_IN_PROGRESS:
 286                         break;
 287                 case AP_RESPONSE_DECONFIGURED:
 288                         rc = -ENODEV;
 289                         break;
 290                 case AP_RESPONSE_CHECKSTOPPED:
 291                         rc = -ENODEV;
 292                         break;
 293                 case AP_RESPONSE_BUSY:
 294                         break;
 295                 default:
 296                         BUG();
 297                 }
 298                 if (rc != -EBUSY)
 299                         break;
 300                 if (i < AP_MAX_RESET - 1)
 301                         udelay(5);
 302         }
 303         return rc;
 304 }
 305
 306 /**
 307  * Reset an AP queue and wait for it to become available again.
 308  * @qid: the ap queue number
 309  */
 310 static int ap_init_queue(ap_qid_t qid)
 311 {
 312         struct ap_queue_status status;
 313         int rc, dummy, i;
 314
 315         rc = -ENODEV;
 316         status = ap_reset_queue(qid);
 317         for (i = 0; i < AP_MAX_RESET; i++) {
 318                 switch (status.response_code) {
 319                 case AP_RESPONSE_NORMAL:
 320                         if (status.queue_empty)
 321                                 rc = 0;
 322                         break;
 323                 case AP_RESPONSE_Q_NOT_AVAIL:
 324                 case AP_RESPONSE_DECONFIGURED:
 325                 case AP_RESPONSE_CHECKSTOPPED:
 326                         i = AP_MAX_RESET;       /* return with -ENODEV */
 327                         break;
 328                 case AP_RESPONSE_RESET_IN_PROGRESS:
 329                 case AP_RESPONSE_BUSY:
 330                 default:
 331                         break;
 332                 }
 333                 if (rc != -ENODEV)
 334                         break;
 335                 if (i < AP_MAX_RESET - 1) {
 336                         udelay(5);
 337                         status = ap_test_queue(qid, &dummy, &dummy);
 338                 }
 339         }
 340         return rc;
 341 }
 342
 343 /**
 344  * AP device related attributes.
 345  */
 346 static ssize_t ap_hwtype_show(struct device *dev,
 347                               struct device_attribute *attr, char *buf)
 348 {
 349         struct ap_device *ap_dev = to_ap_dev(dev);
 350         return snprintf(buf, PAGE_SIZE, "%d\n", ap_dev->device_type);
 351 }
 352 static DEVICE_ATTR(hwtype, 0444, ap_hwtype_show, NULL);
 353
 354 static ssize_t ap_depth_show(struct device *dev, struct device_attribute *attr,
 355                              char *buf)
 356 {
 357         struct ap_device *ap_dev = to_ap_dev(dev);
 358         return snprintf(buf, PAGE_SIZE, "%d\n", ap_dev->queue_depth);
 359 }
 360 static DEVICE_ATTR(depth, 0444, ap_depth_show, NULL);
 361
 362 static ssize_t ap_request_count_show(struct device *dev,
 363                                      struct device_attribute *attr,
 364                                      char *buf)
 365 {
 366         struct ap_device *ap_dev = to_ap_dev(dev);
 367         int rc;
 368
 369         spin_lock_bh(&ap_dev->lock);
 370         rc = snprintf(buf, PAGE_SIZE, "%d\n", ap_dev->total_request_count);
 371         spin_unlock_bh(&ap_dev->lock);
 372         return rc;
 373 }
 374
 375 static DEVICE_ATTR(request_count, 0444, ap_request_count_show, NULL);
 376
 377 static ssize_t ap_modalias_show(struct device *dev,
 378                                 struct device_attribute *attr, char *buf)
 379 {
 380         return sprintf(buf, "ap:t%02X", to_ap_dev(dev)->device_type);
 381 }
 382
 383 static DEVICE_ATTR(modalias, 0444, ap_modalias_show, NULL);
 384
 385 static struct attribute *ap_dev_attrs[] = {
 386         &dev_attr_hwtype.attr,
 387         &dev_attr_depth.attr,
 388         &dev_attr_request_count.attr,
 389         &dev_attr_modalias.attr,
 390         NULL
 391 };
 392 static struct attribute_group ap_dev_attr_group = {
 393         .attrs = ap_dev_attrs
 394 };
 395
 396 /**
 397  * AP bus driver registration/unregistration.
 398  */
 399 static int ap_bus_match(struct device *dev, struct device_driver *drv)
 400 {
 401         struct ap_device *ap_dev = to_ap_dev(dev);
 402         struct ap_driver *ap_drv = to_ap_drv(drv);
 403         struct ap_device_id *id;
 404
 405         /**
 406          * Compare device type of the device with the list of
 407          * supported types of the device_driver.
 408          */
 409         for (id = ap_drv->ids; id->match_flags; id++) {
 410                 if ((id->match_flags & AP_DEVICE_ID_MATCH_DEVICE_TYPE) &&
 411                     (id->dev_type != ap_dev->device_type))
 412                         continue;
 413                 return 1;
 414         }
 415         return 0;
 416 }
 417
 418 /**
 419  * uevent function for AP devices. It sets up a single environment
 420  * variable DEV_TYPE which contains the hardware device type.
 421  */
 422 static int ap_uevent (struct device *dev, char **envp, int num_envp,
 423                        char *buffer, int buffer_size)
 424 {
 425         struct ap_device *ap_dev = to_ap_dev(dev);
 426         int length;
 427
 428         if (!ap_dev)
 429                 return -ENODEV;
 430
 431         /* Set up DEV_TYPE environment variable. */
 432         envp[0] = buffer;
 433         length = scnprintf(buffer, buffer_size, "DEV_TYPE=%04X",
 434                            ap_dev->device_type);
 435         if (buffer_size - length <= 0)
 436                 return -ENOMEM;
 437         buffer += length;
 438         buffer_size -= length;
 439         /* Add MODALIAS= */
 440         envp[1] = buffer;
 441         length = scnprintf(buffer, buffer_size, "MODALIAS=ap:t%02X",
 442                            ap_dev->device_type);
 443         if (buffer_size - length <= 0)
 444                 return -ENOMEM;
 445         envp[2] = NULL;
 446         return 0;
 447 }
 448
 449 static struct bus_type ap_bus_type = {
 450         .name = "ap",
 451         .match = &ap_bus_match,
 452         .uevent = &ap_uevent,
 453 };
 454
 455 static int ap_device_probe(struct device *dev)
 456 {
 457         struct ap_device *ap_dev = to_ap_dev(dev);
 458         struct ap_driver *ap_drv = to_ap_drv(dev->driver);
 459         int rc;
 460
 461         ap_dev->drv = ap_drv;
 462         spin_lock_bh(&ap_device_lock);
 463         list_add(&ap_dev->list, &ap_device_list);
 464         spin_unlock_bh(&ap_device_lock);
 465         rc = ap_drv->probe ? ap_drv->probe(ap_dev) : -ENODEV;
 466         return rc;
 467 }
 468
 469 /**
 470  * Flush all requests from the request/pending queue of an AP device.
 471  * @ap_dev: pointer to the AP device.
 472  */
 473 static void __ap_flush_queue(struct ap_device *ap_dev)
 474 {
 475         struct ap_message *ap_msg, *next;
 476
 477         list_for_each_entry_safe(ap_msg, next, &ap_dev->pendingq, list) {
 478                 list_del_init(&ap_msg->list);
 479                 ap_dev->pendingq_count--;
 480                 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
 481         }
 482         list_for_each_entry_safe(ap_msg, next, &ap_dev->requestq, list) {
 483                 list_del_init(&ap_msg->list);
 484                 ap_dev->requestq_count--;
 485                 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
 486         }
 487 }
 488
 489 void ap_flush_queue(struct ap_device *ap_dev)
 490 {
 491         spin_lock_bh(&ap_dev->lock);
 492         __ap_flush_queue(ap_dev);
 493         spin_unlock_bh(&ap_dev->lock);
 494 }
 495 EXPORT_SYMBOL(ap_flush_queue);
 496
 497 static int ap_device_remove(struct device *dev)
 498 {
 499         struct ap_device *ap_dev = to_ap_dev(dev);
 500         struct ap_driver *ap_drv = ap_dev->drv;
 501
 502         ap_flush_queue(ap_dev);
 503         if (ap_drv->remove)
 504                 ap_drv->remove(ap_dev);
 505         spin_lock_bh(&ap_device_lock);
 506         list_del_init(&ap_dev->list);
 507         spin_unlock_bh(&ap_device_lock);
 508         return 0;
 509 }
 510
 511 int ap_driver_register(struct ap_driver *ap_drv, struct module *owner,
 512                        char *name)
 513 {
 514         struct device_driver *drv = &ap_drv->driver;
 515
 516         drv->bus = &ap_bus_type;
 517         drv->probe = ap_device_probe;
 518         drv->remove = ap_device_remove;
 519         drv->owner = owner;
 520         drv->name = name;
 521         return driver_register(drv);
 522 }
 523 EXPORT_SYMBOL(ap_driver_register);
 524
 525 void ap_driver_unregister(struct ap_driver *ap_drv)
 526 {
 527         driver_unregister(&ap_drv->driver);
 528 }
 529 EXPORT_SYMBOL(ap_driver_unregister);
 530
 531 /**
 532  * AP bus attributes.
 533  */
 534 static ssize_t ap_domain_show(struct bus_type *bus, char *buf)
 535 {
 536         return snprintf(buf, PAGE_SIZE, "%d\n", ap_domain_index);
 537 }
 538
 539 static BUS_ATTR(ap_domain, 0444, ap_domain_show, NULL);
 540
 541 static ssize_t ap_config_time_show(struct bus_type *bus, char *buf)
 542 {
 543         return snprintf(buf, PAGE_SIZE, "%d\n", ap_config_time);
 544 }
 545
 546 static ssize_t ap_config_time_store(struct bus_type *bus,
 547                                     const char *buf, size_t count)
 548 {
 549         int time;
 550
 551         if (sscanf(buf, "%d\n", &time) != 1 || time < 5 || time > 120)
 552                 return -EINVAL;
 553         ap_config_time = time;
 554         if (!timer_pending(&ap_config_timer) ||
 555             !mod_timer(&ap_config_timer, jiffies + ap_config_time * HZ)) {
 556                 ap_config_timer.expires = jiffies + ap_config_time * HZ;
 557                 add_timer(&ap_config_timer);
 558         }
 559         return count;
 560 }
 561
 562 static BUS_ATTR(config_time, 0644, ap_config_time_show, ap_config_time_store);
 563
 564 static ssize_t ap_poll_thread_show(struct bus_type *bus, char *buf)
 565 {
 566         return snprintf(buf, PAGE_SIZE, "%d\n", ap_poll_kthread ? 1 : 0);
 567 }
 568
 569 static ssize_t ap_poll_thread_store(struct bus_type *bus,
 570                                     const char *buf, size_t count)
 571 {
 572         int flag, rc;
 573
 574         if (sscanf(buf, "%d\n", &flag) != 1)
 575                 return -EINVAL;
 576         if (flag) {
 577                 rc = ap_poll_thread_start();
 578                 if (rc)
 579                         return rc;
 580         }
 581         else
 582                 ap_poll_thread_stop();
 583         return count;
 584 }
 585
 586 static BUS_ATTR(poll_thread, 0644, ap_poll_thread_show, ap_poll_thread_store);
 587
 588 static struct bus_attribute *const ap_bus_attrs[] = {
 589         &bus_attr_ap_domain,
 590         &bus_attr_config_time,
 591         &bus_attr_poll_thread,
 592         NULL
 593 };
 594
 595 /**
 596  * Pick one of the 16 ap domains.
 597  */
 598 static int ap_select_domain(void)
 599 {
 600         int queue_depth, device_type, count, max_count, best_domain;
 601         int rc, i, j;
 602
 603         /**
 604          * We want to use a single domain. Either the one specified with
 605          * the "domain=" parameter or the domain with the maximum number
 606          * of devices.
 607          */
 608         if (ap_domain_index >= 0 && ap_domain_index < AP_DOMAINS)
 609                 /* Domain has already been selected. */
 610                 return 0;
 611         best_domain = -1;
 612         max_count = 0;
 613         for (i = 0; i < AP_DOMAINS; i++) {
 614                 count = 0;
 615                 for (j = 0; j < AP_DEVICES; j++) {
 616                         ap_qid_t qid = AP_MKQID(j, i);
 617                         rc = ap_query_queue(qid, &queue_depth, &device_type);
 618                         if (rc)
 619                                 continue;
 620                         count++;
 621                 }
 622                 if (count > max_count) {
 623                         max_count = count;
 624                         best_domain = i;
 625                 }
 626         }
 627         if (best_domain >= 0){
 628                 ap_domain_index = best_domain;
 629                 return 0;
 630         }
 631         return -ENODEV;
 632 }
 633
 634 /**
 635  * Find the device type if query queue returned a device type of 0.
 636  * @ap_dev: pointer to the AP device.
 637  */
 638 static int ap_probe_device_type(struct ap_device *ap_dev)
 639 {
 640         static unsigned char msg[] = {
 641                 0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,
 642                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 643                 0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,
 644                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 645                 0x01,0x00,0x43,0x43,0x41,0x2d,0x41,0x50,
 646                 0x50,0x4c,0x20,0x20,0x20,0x01,0x01,0x01,
 647                 0x00,0x00,0x00,0x00,0x50,0x4b,0x00,0x00,
 648                 0x00,0x00,0x01,0x1c,0x00,0x00,0x00,0x00,
 649                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 650                 0x00,0x00,0x05,0xb8,0x00,0x00,0x00,0x00,
 651                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 652                 0x70,0x00,0x41,0x00,0x00,0x00,0x00,0x00,
 653                 0x00,0x00,0x54,0x32,0x01,0x00,0xa0,0x00,
 654                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 655                 0x00,0x00,0x00,0x00,0xb8,0x05,0x00,0x00,
 656                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 657                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 658                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 659                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 660                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 661                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 662                 0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,
 663                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 664                 0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,
 665                 0x49,0x43,0x53,0x46,0x20,0x20,0x20,0x20,
 666                 0x50,0x4b,0x0a,0x00,0x50,0x4b,0x43,0x53,
 667                 0x2d,0x31,0x2e,0x32,0x37,0x00,0x11,0x22,
 668                 0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00,
 669                 0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,
 670                 0x99,0x00,0x11,0x22,0x33,0x44,0x55,0x66,
 671                 0x77,0x88,0x99,0x00,0x11,0x22,0x33,0x44,
 672                 0x55,0x66,0x77,0x88,0x99,0x00,0x11,0x22,
 673                 0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00,
 674                 0x11,0x22,0x33,0x5d,0x00,0x5b,0x00,0x77,
 675                 0x88,0x1e,0x00,0x00,0x57,0x00,0x00,0x00,
 676                 0x00,0x04,0x00,0x00,0x4f,0x00,0x00,0x00,
 677                 0x03,0x02,0x00,0x00,0x40,0x01,0x00,0x01,
 678                 0xce,0x02,0x68,0x2d,0x5f,0xa9,0xde,0x0c,
 679                 0xf6,0xd2,0x7b,0x58,0x4b,0xf9,0x28,0x68,
 680                 0x3d,0xb4,0xf4,0xef,0x78,0xd5,0xbe,0x66,
 681                 0x63,0x42,0xef,0xf8,0xfd,0xa4,0xf8,0xb0,
 682                 0x8e,0x29,0xc2,0xc9,0x2e,0xd8,0x45,0xb8,
 683                 0x53,0x8c,0x6f,0x4e,0x72,0x8f,0x6c,0x04,
 684                 0x9c,0x88,0xfc,0x1e,0xc5,0x83,0x55,0x57,
 685                 0xf7,0xdd,0xfd,0x4f,0x11,0x36,0x95,0x5d,
 686         };
 687         struct ap_queue_status status;
 688         unsigned long long psmid;
 689         char *reply;
 690         int rc, i;
 691
 692         reply = (void *) get_zeroed_page(GFP_KERNEL);
 693         if (!reply) {
 694                 rc = -ENOMEM;
 695                 goto out;
 696         }
 697
 698         status = __ap_send(ap_dev->qid, 0x0102030405060708ULL,
 699                            msg, sizeof(msg));
 700         if (status.response_code != AP_RESPONSE_NORMAL) {
 701                 rc = -ENODEV;
 702                 goto out_free;
 703         }
 704
 705         /* Wait for the test message to complete. */
 706         for (i = 0; i < 6; i++) {
 707                 mdelay(300);
 708                 status = __ap_recv(ap_dev->qid, &psmid, reply, 4096);
 709                 if (status.response_code == AP_RESPONSE_NORMAL &&
 710                     psmid == 0x0102030405060708ULL)
 711                         break;
 712         }
 713         if (i < 6) {
 714                 /* Got an answer. */
 715                 if (reply[0] == 0x00 && reply[1] == 0x86)
 716                         ap_dev->device_type = AP_DEVICE_TYPE_PCICC;
 717                 else
 718                         ap_dev->device_type = AP_DEVICE_TYPE_PCICA;
 719                 rc = 0;
 720         } else
 721                 rc = -ENODEV;
 722
 723 out_free:
 724         free_page((unsigned long) reply);
 725 out:
 726         return rc;
 727 }
 728
 729 /**
 730  * Scan the ap bus for new devices.
 731  */
 732 static int __ap_scan_bus(struct device *dev, void *data)
 733 {
 734         return to_ap_dev(dev)->qid == (ap_qid_t)(unsigned long) data;
 735 }
 736
 737 static void ap_device_release(struct device *dev)
 738 {
 739         struct ap_device *ap_dev = to_ap_dev(dev);
 740
 741         kfree(ap_dev);
 742 }
 743
 744 static void ap_scan_bus(struct work_struct *unused)
 745 {
 746         struct ap_device *ap_dev;
 747         struct device *dev;
 748         ap_qid_t qid;
 749         int queue_depth, device_type;
 750         int rc, i;
 751
 752         if (ap_select_domain() != 0)
 753                 return;
 754         for (i = 0; i < AP_DEVICES; i++) {
 755                 qid = AP_MKQID(i, ap_domain_index);
 756                 dev = bus_find_device(&ap_bus_type, NULL,
 757                                       (void *)(unsigned long)qid,
 758                                       __ap_scan_bus);
 759                 rc = ap_query_queue(qid, &queue_depth, &device_type);
 760                 if (dev && rc) {
 761                         put_device(dev);
 762                         device_unregister(dev);
 763                         continue;
 764                 }
 765                 if (dev) {
 766                         put_device(dev);
 767                         continue;
 768                 }
 769                 if (rc)
 770                         continue;
 771                 rc = ap_init_queue(qid);
 772                 if (rc)
 773                         continue;
 774                 ap_dev = kzalloc(sizeof(*ap_dev), GFP_KERNEL);
 775                 if (!ap_dev)
 776                         break;
 777                 ap_dev->qid = qid;
 778                 ap_dev->queue_depth = queue_depth;
 779                 ap_dev->unregistered = 1;
 780                 spin_lock_init(&ap_dev->lock);
 781                 INIT_LIST_HEAD(&ap_dev->pendingq);
 782                 INIT_LIST_HEAD(&ap_dev->requestq);
 783                 INIT_LIST_HEAD(&ap_dev->list);
 784                 if (device_type == 0)
 785                         ap_probe_device_type(ap_dev);
 786                 else
 787                         ap_dev->device_type = device_type;
 788
 789                 ap_dev->device.bus = &ap_bus_type;
 790                 ap_dev->device.parent = ap_root_device;
 791                 snprintf(ap_dev->device.bus_id, BUS_ID_SIZE, "card%02x",
 792                          AP_QID_DEVICE(ap_dev->qid));
 793                 ap_dev->device.release = ap_device_release;
 794                 rc = device_register(&ap_dev->device);
 795                 if (rc) {
 796                         kfree(ap_dev);
 797                         continue;
 798                 }
 799                 /* Add device attributes. */
 800                 rc = sysfs_create_group(&ap_dev->device.kobj,
 801                                         &ap_dev_attr_group);
 802                 if (!rc) {
 803                         spin_lock_bh(&ap_dev->lock);
 804                         ap_dev->unregistered = 0;
 805                         spin_unlock_bh(&ap_dev->lock);
 806                 }
 807                 else
 808                         device_unregister(&ap_dev->device);
 809         }
 810 }
 811
 812 static void
 813 ap_config_timeout(unsigned long ptr)
 814 {
 815         queue_work(ap_work_queue, &ap_config_work);
 816         ap_config_timer.expires = jiffies + ap_config_time * HZ;
 817         add_timer(&ap_config_timer);
 818 }
 819
 820 /**
 821  * Set up the timer to run the poll tasklet
 822  */
 823 static inline void ap_schedule_poll_timer(void)
 824 {
 825         if (timer_pending(&ap_poll_timer))
 826                 return;
 827         mod_timer(&ap_poll_timer, jiffies + AP_POLL_TIME);
 828 }
 829
 830 /**
 831  * Receive pending reply messages from an AP device.
 832  * @ap_dev: pointer to the AP device
 833  * @flags: pointer to control flags, bit 2^0 is set if another poll is
 834  *         required, bit 2^1 is set if the poll timer needs to get armed
 835  * Returns 0 if the device is still present, -ENODEV if not.
 836  */
 837 static int ap_poll_read(struct ap_device *ap_dev, unsigned long *flags)
 838 {
 839         struct ap_queue_status status;
 840         struct ap_message *ap_msg;
 841
 842         if (ap_dev->queue_count <= 0)
 843                 return 0;
 844         status = __ap_recv(ap_dev->qid, &ap_dev->reply->psmid,
 845                            ap_dev->reply->message, ap_dev->reply->length);
 846         switch (status.response_code) {
 847         case AP_RESPONSE_NORMAL:
 848                 atomic_dec(&ap_poll_requests);
 849                 ap_dev->queue_count--;
 850                 list_for_each_entry(ap_msg, &ap_dev->pendingq, list) {
 851                         if (ap_msg->psmid != ap_dev->reply->psmid)
 852                                 continue;
 853                         list_del_init(&ap_msg->list);
 854                         ap_dev->pendingq_count--;
 855                         ap_dev->drv->receive(ap_dev, ap_msg, ap_dev->reply);
 856                         break;
 857                 }
 858                 if (ap_dev->queue_count > 0)
 859                         *flags |= 1;
 860                 break;
 861         case AP_RESPONSE_NO_PENDING_REPLY:
 862                 if (status.queue_empty) {
 863                         /* The card shouldn't forget requests but who knows. */
 864                         ap_dev->queue_count = 0;
 865                         list_splice_init(&ap_dev->pendingq, &ap_dev->requestq);
 866                         ap_dev->requestq_count += ap_dev->pendingq_count;
 867                         ap_dev->pendingq_count = 0;
 868                 } else
 869                         *flags |= 2;
 870                 break;
 871         default:
 872                 return -ENODEV;
 873         }
 874         return 0;
 875 }
 876
 877 /**
 878  * Send messages from the request queue to an AP device.
 879  * @ap_dev: pointer to the AP device
 880  * @flags: pointer to control flags, bit 2^0 is set if another poll is
 881  *         required, bit 2^1 is set if the poll timer needs to get armed
 882  * Returns 0 if the device is still present, -ENODEV if not.
 883  */
 884 static int ap_poll_write(struct ap_device *ap_dev, unsigned long *flags)
 885 {
 886         struct ap_queue_status status;
 887         struct ap_message *ap_msg;
 888
 889         if (ap_dev->requestq_count <= 0 ||
 890             ap_dev->queue_count >= ap_dev->queue_depth)
 891                 return 0;
 892         /* Start the next request on the queue. */
 893         ap_msg = list_entry(ap_dev->requestq.next, struct ap_message, list);
 894         status = __ap_send(ap_dev->qid, ap_msg->psmid,
 895                            ap_msg->message, ap_msg->length);
 896         switch (status.response_code) {
 897         case AP_RESPONSE_NORMAL:
 898                 atomic_inc(&ap_poll_requests);
 899                 ap_dev->queue_count++;
 900                 list_move_tail(&ap_msg->list, &ap_dev->pendingq);
 901                 ap_dev->requestq_count--;
 902                 ap_dev->pendingq_count++;
 903                 if (ap_dev->queue_count < ap_dev->queue_depth &&
 904                     ap_dev->requestq_count > 0)
 905                         *flags |= 1;
 906                 *flags |= 2;
 907                 break;
 908         case AP_RESPONSE_Q_FULL:
 909                 *flags |= 2;
 910                 break;
 911         case AP_RESPONSE_MESSAGE_TOO_BIG:
 912                 return -EINVAL;
 913         default:
 914                 return -ENODEV;
 915         }
 916         return 0;
 917 }
 918
 919 /**
 920  * Poll AP device for pending replies and send new messages. If either
 921  * ap_poll_read or ap_poll_write returns -ENODEV unregister the device.
 922  * @ap_dev: pointer to the bus device
 923  * @flags: pointer to control flags, bit 2^0 is set if another poll is
 924  *         required, bit 2^1 is set if the poll timer needs to get armed
 925  * Returns 0.
 926  */
 927 static inline int ap_poll_queue(struct ap_device *ap_dev, unsigned long *flags)
 928 {
 929         int rc;
 930
 931         rc = ap_poll_read(ap_dev, flags);
 932         if (rc)
 933                 return rc;
 934         return ap_poll_write(ap_dev, flags);
 935 }
 936
 937 /**
 938  * Queue a message to a device.
 939  * @ap_dev: pointer to the AP device
 940  * @ap_msg: the message to be queued
 941  */
 942 static int __ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
 943 {
 944         struct ap_queue_status status;
 945
 946         if (list_empty(&ap_dev->requestq) &&
 947             ap_dev->queue_count < ap_dev->queue_depth) {
 948                 status = __ap_send(ap_dev->qid, ap_msg->psmid,
 949                                    ap_msg->message, ap_msg->length);
 950                 switch (status.response_code) {
 951                 case AP_RESPONSE_NORMAL:
 952                         list_add_tail(&ap_msg->list, &ap_dev->pendingq);
 953                         atomic_inc(&ap_poll_requests);
 954                         ap_dev->pendingq_count++;
 955                         ap_dev->queue_count++;
 956                         ap_dev->total_request_count++;
 957                         break;
 958                 case AP_RESPONSE_Q_FULL:
 959                         list_add_tail(&ap_msg->list, &ap_dev->requestq);
 960                         ap_dev->requestq_count++;
 961                         ap_dev->total_request_count++;
 962                         return -EBUSY;
 963                 case AP_RESPONSE_MESSAGE_TOO_BIG:
 964                         ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-EINVAL));
 965                         return -EINVAL;
 966                 default:        /* Device is gone. */
 967                         ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
 968                         return -ENODEV;
 969                 }
 970         } else {
 971                 list_add_tail(&ap_msg->list, &ap_dev->requestq);
 972                 ap_dev->requestq_count++;
 973                 ap_dev->total_request_count++;
 974                 return -EBUSY;
 975         }
 976         ap_schedule_poll_timer();
 977         return 0;
 978 }
 979
 980 void ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
 981 {
 982         unsigned long flags;
 983         int rc;
 984
 985         spin_lock_bh(&ap_dev->lock);
 986         if (!ap_dev->unregistered) {
 987                 /* Make room on the queue by polling for finished requests. */
 988                 rc = ap_poll_queue(ap_dev, &flags);
 989                 if (!rc)
 990                         rc = __ap_queue_message(ap_dev, ap_msg);
 991                 if (!rc)
 992                         wake_up(&ap_poll_wait);
 993                 if (rc == -ENODEV)
 994                         ap_dev->unregistered = 1;
 995         } else {
 996                 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
 997                 rc = 0;
 998         }
 999         spin_unlock_bh(&ap_dev->lock);
1000         if (rc == -ENODEV)
1001                 device_unregister(&ap_dev->device);
1002 }
1003 EXPORT_SYMBOL(ap_queue_message);
1004
1005 /**
1006  * Cancel a crypto request. This is done by removing the request
1007  * from the devive pendingq or requestq queue. Note that the
1008  * request stays on the AP queue. When it finishes the message
1009  * reply will be discarded because the psmid can't be found.
1010  * @ap_dev: AP device that has the message queued
1011  * @ap_msg: the message that is to be removed
1012  */
1013 void ap_cancel_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
1014 {
1015         struct ap_message *tmp;
1016
1017         spin_lock_bh(&ap_dev->lock);
1018         if (!list_empty(&ap_msg->list)) {
1019                 list_for_each_entry(tmp, &ap_dev->pendingq, list)
1020                         if (tmp->psmid == ap_msg->psmid) {
1021                                 ap_dev->pendingq_count--;
1022                                 goto found;
1023                         }
1024                 ap_dev->requestq_count--;
1025         found:
1026                 list_del_init(&ap_msg->list);
1027         }
1028         spin_unlock_bh(&ap_dev->lock);
1029 }
1030 EXPORT_SYMBOL(ap_cancel_message);
1031
1032 /**
1033  * AP receive polling for finished AP requests
1034  */
1035 static void ap_poll_timeout(unsigned long unused)
1036 {
1037         tasklet_schedule(&ap_tasklet);
1038 }
1039
1040 /**
1041  * Poll all AP devices on the bus in a round robin fashion. Continue
1042  * polling until bit 2^0 of the control flags is not set. If bit 2^1
1043  * of the control flags has been set arm the poll timer.
1044  */
1045 static int __ap_poll_all(struct ap_device *ap_dev, unsigned long *flags)
1046 {
1047         int rc;
1048
1049         spin_lock(&ap_dev->lock);
1050         if (!ap_dev->unregistered) {
1051                 rc = ap_poll_queue(ap_dev, flags);
1052                 if (rc)
1053                         ap_dev->unregistered = 1;
1054         } else
1055                 rc = 0;
1056         spin_unlock(&ap_dev->lock);
1057         if (rc)
1058                 device_unregister(&ap_dev->device);
1059         return 0;
1060 }
1061
1062 static void ap_poll_all(unsigned long dummy)
1063 {
1064         unsigned long flags;
1065         struct ap_device *ap_dev;
1066
1067         do {
1068                 flags = 0;
1069                 spin_lock(&ap_device_lock);
1070                 list_for_each_entry(ap_dev, &ap_device_list, list) {
1071                         __ap_poll_all(ap_dev, &flags);
1072                 }
1073                 spin_unlock(&ap_device_lock);
1074         } while (flags & 1);
1075         if (flags & 2)
1076                 ap_schedule_poll_timer();
1077 }
1078
1079 /**
1080  * AP bus poll thread. The purpose of this thread is to poll for
1081  * finished requests in a loop if there is a "free" cpu - that is
1082  * a cpu that doesn't have anything better to do. The polling stops
1083  * as soon as there is another task or if all messages have been
1084  * delivered.
1085  */
1086 static int ap_poll_thread(void *data)
1087 {
1088         DECLARE_WAITQUEUE(wait, current);
1089         unsigned long flags;
1090         int requests;
1091         struct ap_device *ap_dev;
1092
1093         set_user_nice(current, 19);
1094         while (1) {
1095                 if (need_resched()) {
1096                         schedule();
1097                         continue;
1098                 }
1099                 add_wait_queue(&ap_poll_wait, &wait);
1100                 set_current_state(TASK_INTERRUPTIBLE);
1101                 if (kthread_should_stop())
1102                         break;
1103                 requests = atomic_read(&ap_poll_requests);
1104                 if (requests <= 0)
1105                         schedule();
1106                 set_current_state(TASK_RUNNING);
1107                 remove_wait_queue(&ap_poll_wait, &wait);
1108
1109                 flags = 0;
1110                 spin_lock_bh(&ap_device_lock);
1111                 list_for_each_entry(ap_dev, &ap_device_list, list) {
1112                         __ap_poll_all(ap_dev, &flags);
1113                 }
1114                 spin_unlock_bh(&ap_device_lock);
1115         }
1116         set_current_state(TASK_RUNNING);
1117         remove_wait_queue(&ap_poll_wait, &wait);
1118         return 0;
1119 }
1120
1121 static int ap_poll_thread_start(void)
1122 {
1123         int rc;
1124
1125         mutex_lock(&ap_poll_thread_mutex);
1126         if (!ap_poll_kthread) {
1127                 ap_poll_kthread = kthread_run(ap_poll_thread, NULL, "appoll");
1128                 rc = IS_ERR(ap_poll_kthread) ? PTR_ERR(ap_poll_kthread) : 0;
1129                 if (rc)
1130                         ap_poll_kthread = NULL;
1131         }
1132         else
1133                 rc = 0;
1134         mutex_unlock(&ap_poll_thread_mutex);
1135         return rc;
1136 }
1137
1138 static void ap_poll_thread_stop(void)
1139 {
1140         mutex_lock(&ap_poll_thread_mutex);
1141         if (ap_poll_kthread) {
1142                 kthread_stop(ap_poll_kthread);
1143                 ap_poll_kthread = NULL;
1144         }
1145         mutex_unlock(&ap_poll_thread_mutex);
1146 }
1147
1148 static void ap_reset_domain(void)
1149 {
1150         int i;
1151
1152         for (i = 0; i < AP_DEVICES; i++)
1153                 ap_reset_queue(AP_MKQID(i, ap_domain_index));
1154 }
1155
1156 static void ap_reset_all(void)
1157 {
1158         int i, j;
1159
1160         for (i = 0; i < AP_DOMAINS; i++)
1161                 for (j = 0; j < AP_DEVICES; j++)
1162                         ap_reset_queue(AP_MKQID(j, i));
1163 }
1164
1165 static struct reset_call ap_reset_call = {
1166         .fn = ap_reset_all,
1167 };
1168
1169 /**
1170  * The module initialization code.
1171  */
1172 int __init ap_module_init(void)
1173 {
1174         int rc, i;
1175
1176         if (ap_domain_index < -1 || ap_domain_index >= AP_DOMAINS) {
1177                 printk(KERN_WARNING "Invalid param: domain = %d. "
1178                        " Not loading.\n", ap_domain_index);
1179                 return -EINVAL;
1180         }
1181         if (ap_instructions_available() != 0) {
1182                 printk(KERN_WARNING "AP instructions not installed.\n");
1183                 return -ENODEV;
1184         }
1185         register_reset_call(&ap_reset_call);
1186
1187         /* Create /sys/bus/ap. */
1188         rc = bus_register(&ap_bus_type);
1189         if (rc)
1190                 goto out;
1191         for (i = 0; ap_bus_attrs[i]; i++) {
1192                 rc = bus_create_file(&ap_bus_type, ap_bus_attrs[i]);
1193                 if (rc)
1194                         goto out_bus;
1195         }
1196
1197         /* Create /sys/devices/ap. */
1198         ap_root_device = s390_root_dev_register("ap");
1199         rc = IS_ERR(ap_root_device) ? PTR_ERR(ap_root_device) : 0;
1200         if (rc)
1201                 goto out_bus;
1202
1203         ap_work_queue = create_singlethread_workqueue("kapwork");
1204         if (!ap_work_queue) {
1205                 rc = -ENOMEM;
1206                 goto out_root;
1207         }
1208
1209         if (ap_select_domain() == 0)
1210                 ap_scan_bus(NULL);
1211
1212         /* Setup the ap bus rescan timer. */
1213         init_timer(&ap_config_timer);
1214         ap_config_timer.function = ap_config_timeout;
1215         ap_config_timer.data = 0;
1216         ap_config_timer.expires = jiffies + ap_config_time * HZ;
1217         add_timer(&ap_config_timer);
1218
1219         /* Start the low priority AP bus poll thread. */
1220         if (ap_thread_flag) {
1221                 rc = ap_poll_thread_start();
1222                 if (rc)
1223                         goto out_work;
1224         }
1225
1226         return 0;
1227
1228 out_work:
1229         del_timer_sync(&ap_config_timer);
1230         del_timer_sync(&ap_poll_timer);
1231         destroy_workqueue(ap_work_queue);
1232 out_root:
1233         s390_root_dev_unregister(ap_root_device);
1234 out_bus:
1235         while (i--)
1236                 bus_remove_file(&ap_bus_type, ap_bus_attrs[i]);
1237         bus_unregister(&ap_bus_type);
1238 out:
1239         unregister_reset_call(&ap_reset_call);
1240         return rc;
1241 }
1242
1243 static int __ap_match_all(struct device *dev, void *data)
1244 {
1245         return 1;
1246 }
1247
1248 /**
1249  * The module termination code
1250  */
1251 void ap_module_exit(void)
1252 {
1253         int i;
1254         struct device *dev;
1255
1256         ap_reset_domain();
1257         ap_poll_thread_stop();
1258         del_timer_sync(&ap_config_timer);
1259         del_timer_sync(&ap_poll_timer);
1260         destroy_workqueue(ap_work_queue);
1261         tasklet_kill(&ap_tasklet);
1262         s390_root_dev_unregister(ap_root_device);
1263         while ((dev = bus_find_device(&ap_bus_type, NULL, NULL,
1264                     __ap_match_all)))
1265         {
1266                 device_unregister(dev);
1267                 put_device(dev);
1268         }
1269         for (i = 0; ap_bus_attrs[i]; i++)
1270                 bus_remove_file(&ap_bus_type, ap_bus_attrs[i]);
1271         bus_unregister(&ap_bus_type);
1272         unregister_reset_call(&ap_reset_call);
1273 }
1274
1275 #ifndef CONFIG_ZCRYPT_MONOLITHIC
1276 module_init(ap_module_init);
1277 module_exit(ap_module_exit);
1278 #endif