SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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) {
 761                         ap_dev = to_ap_dev(dev);
 762                         spin_lock_bh(&ap_dev->lock);
 763                         if (rc || ap_dev->unregistered) {
 764                                 spin_unlock_bh(&ap_dev->lock);
 765                                 put_device(dev);
 766                                 device_unregister(dev);
 767                                 continue;
 768                         } else
 769                                 spin_unlock_bh(&ap_dev->lock);
 770                 }
 771                 if (dev) {
 772                         put_device(dev);
 773                         continue;
 774                 }
 775                 if (rc)
 776                         continue;
 777                 rc = ap_init_queue(qid);
 778                 if (rc)
 779                         continue;
 780                 ap_dev = kzalloc(sizeof(*ap_dev), GFP_KERNEL);
 781                 if (!ap_dev)
 782                         break;
 783                 ap_dev->qid = qid;
 784                 ap_dev->queue_depth = queue_depth;
 785                 ap_dev->unregistered = 1;
 786                 spin_lock_init(&ap_dev->lock);
 787                 INIT_LIST_HEAD(&ap_dev->pendingq);
 788                 INIT_LIST_HEAD(&ap_dev->requestq);
 789                 INIT_LIST_HEAD(&ap_dev->list);
 790                 if (device_type == 0)
 791                         ap_probe_device_type(ap_dev);
 792                 else
 793                         ap_dev->device_type = device_type;
 794
 795                 ap_dev->device.bus = &ap_bus_type;
 796                 ap_dev->device.parent = ap_root_device;
 797                 snprintf(ap_dev->device.bus_id, BUS_ID_SIZE, "card%02x",
 798                          AP_QID_DEVICE(ap_dev->qid));
 799                 ap_dev->device.release = ap_device_release;
 800                 rc = device_register(&ap_dev->device);
 801                 if (rc) {
 802                         kfree(ap_dev);
 803                         continue;
 804                 }
 805                 /* Add device attributes. */
 806                 rc = sysfs_create_group(&ap_dev->device.kobj,
 807                                         &ap_dev_attr_group);
 808                 if (!rc) {
 809                         spin_lock_bh(&ap_dev->lock);
 810                         ap_dev->unregistered = 0;
 811                         spin_unlock_bh(&ap_dev->lock);
 812                 }
 813                 else
 814                         device_unregister(&ap_dev->device);
 815         }
 816 }
 817
 818 static void
 819 ap_config_timeout(unsigned long ptr)
 820 {
 821         queue_work(ap_work_queue, &ap_config_work);
 822         ap_config_timer.expires = jiffies + ap_config_time * HZ;
 823         add_timer(&ap_config_timer);
 824 }
 825
 826 /**
 827  * Set up the timer to run the poll tasklet
 828  */
 829 static inline void ap_schedule_poll_timer(void)
 830 {
 831         if (timer_pending(&ap_poll_timer))
 832                 return;
 833         mod_timer(&ap_poll_timer, jiffies + AP_POLL_TIME);
 834 }
 835
 836 /**
 837  * Receive pending reply messages from an AP device.
 838  * @ap_dev: pointer to the AP device
 839  * @flags: pointer to control flags, bit 2^0 is set if another poll is
 840  *         required, bit 2^1 is set if the poll timer needs to get armed
 841  * Returns 0 if the device is still present, -ENODEV if not.
 842  */
 843 static int ap_poll_read(struct ap_device *ap_dev, unsigned long *flags)
 844 {
 845         struct ap_queue_status status;
 846         struct ap_message *ap_msg;
 847
 848         if (ap_dev->queue_count <= 0)
 849                 return 0;
 850         status = __ap_recv(ap_dev->qid, &ap_dev->reply->psmid,
 851                            ap_dev->reply->message, ap_dev->reply->length);
 852         switch (status.response_code) {
 853         case AP_RESPONSE_NORMAL:
 854                 atomic_dec(&ap_poll_requests);
 855                 ap_dev->queue_count--;
 856                 list_for_each_entry(ap_msg, &ap_dev->pendingq, list) {
 857                         if (ap_msg->psmid != ap_dev->reply->psmid)
 858                                 continue;
 859                         list_del_init(&ap_msg->list);
 860                         ap_dev->pendingq_count--;
 861                         ap_dev->drv->receive(ap_dev, ap_msg, ap_dev->reply);
 862                         break;
 863                 }
 864                 if (ap_dev->queue_count > 0)
 865                         *flags |= 1;
 866                 break;
 867         case AP_RESPONSE_NO_PENDING_REPLY:
 868                 if (status.queue_empty) {
 869                         /* The card shouldn't forget requests but who knows. */
 870                         ap_dev->queue_count = 0;
 871                         list_splice_init(&ap_dev->pendingq, &ap_dev->requestq);
 872                         ap_dev->requestq_count += ap_dev->pendingq_count;
 873                         ap_dev->pendingq_count = 0;
 874                 } else
 875                         *flags |= 2;
 876                 break;
 877         default:
 878                 return -ENODEV;
 879         }
 880         return 0;
 881 }
 882
 883 /**
 884  * Send messages from the request queue to an AP device.
 885  * @ap_dev: pointer to the AP device
 886  * @flags: pointer to control flags, bit 2^0 is set if another poll is
 887  *         required, bit 2^1 is set if the poll timer needs to get armed
 888  * Returns 0 if the device is still present, -ENODEV if not.
 889  */
 890 static int ap_poll_write(struct ap_device *ap_dev, unsigned long *flags)
 891 {
 892         struct ap_queue_status status;
 893         struct ap_message *ap_msg;
 894
 895         if (ap_dev->requestq_count <= 0 ||
 896             ap_dev->queue_count >= ap_dev->queue_depth)
 897                 return 0;
 898         /* Start the next request on the queue. */
 899         ap_msg = list_entry(ap_dev->requestq.next, struct ap_message, list);
 900         status = __ap_send(ap_dev->qid, ap_msg->psmid,
 901                            ap_msg->message, ap_msg->length);
 902         switch (status.response_code) {
 903         case AP_RESPONSE_NORMAL:
 904                 atomic_inc(&ap_poll_requests);
 905                 ap_dev->queue_count++;
 906                 list_move_tail(&ap_msg->list, &ap_dev->pendingq);
 907                 ap_dev->requestq_count--;
 908                 ap_dev->pendingq_count++;
 909                 if (ap_dev->queue_count < ap_dev->queue_depth &&
 910                     ap_dev->requestq_count > 0)
 911                         *flags |= 1;
 912                 *flags |= 2;
 913                 break;
 914         case AP_RESPONSE_Q_FULL:
 915                 *flags |= 2;
 916                 break;
 917         case AP_RESPONSE_MESSAGE_TOO_BIG:
 918                 return -EINVAL;
 919         default:
 920                 return -ENODEV;
 921         }
 922         return 0;
 923 }
 924
 925 /**
 926  * Poll AP device for pending replies and send new messages. If either
 927  * ap_poll_read or ap_poll_write returns -ENODEV unregister the device.
 928  * @ap_dev: pointer to the bus device
 929  * @flags: pointer to control flags, bit 2^0 is set if another poll is
 930  *         required, bit 2^1 is set if the poll timer needs to get armed
 931  * Returns 0.
 932  */
 933 static inline int ap_poll_queue(struct ap_device *ap_dev, unsigned long *flags)
 934 {
 935         int rc;
 936
 937         rc = ap_poll_read(ap_dev, flags);
 938         if (rc)
 939                 return rc;
 940         return ap_poll_write(ap_dev, flags);
 941 }
 942
 943 /**
 944  * Queue a message to a device.
 945  * @ap_dev: pointer to the AP device
 946  * @ap_msg: the message to be queued
 947  */
 948 static int __ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
 949 {
 950         struct ap_queue_status status;
 951
 952         if (list_empty(&ap_dev->requestq) &&
 953             ap_dev->queue_count < ap_dev->queue_depth) {
 954                 status = __ap_send(ap_dev->qid, ap_msg->psmid,
 955                                    ap_msg->message, ap_msg->length);
 956                 switch (status.response_code) {
 957                 case AP_RESPONSE_NORMAL:
 958                         list_add_tail(&ap_msg->list, &ap_dev->pendingq);
 959                         atomic_inc(&ap_poll_requests);
 960                         ap_dev->pendingq_count++;
 961                         ap_dev->queue_count++;
 962                         ap_dev->total_request_count++;
 963                         break;
 964                 case AP_RESPONSE_Q_FULL:
 965                         list_add_tail(&ap_msg->list, &ap_dev->requestq);
 966                         ap_dev->requestq_count++;
 967                         ap_dev->total_request_count++;
 968                         return -EBUSY;
 969                 case AP_RESPONSE_MESSAGE_TOO_BIG:
 970                         ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-EINVAL));
 971                         return -EINVAL;
 972                 default:        /* Device is gone. */
 973                         ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
 974                         return -ENODEV;
 975                 }
 976         } else {
 977                 list_add_tail(&ap_msg->list, &ap_dev->requestq);
 978                 ap_dev->requestq_count++;
 979                 ap_dev->total_request_count++;
 980                 return -EBUSY;
 981         }
 982         ap_schedule_poll_timer();
 983         return 0;
 984 }
 985
 986 void ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
 987 {
 988         unsigned long flags;
 989         int rc;
 990
 991         spin_lock_bh(&ap_dev->lock);
 992         if (!ap_dev->unregistered) {
 993                 /* Make room on the queue by polling for finished requests. */
 994                 rc = ap_poll_queue(ap_dev, &flags);
 995                 if (!rc)
 996                         rc = __ap_queue_message(ap_dev, ap_msg);
 997                 if (!rc)
 998                         wake_up(&ap_poll_wait);
 999                 if (rc == -ENODEV)
1000                         ap_dev->unregistered = 1;
1001         } else {
1002                 ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-ENODEV));
1003                 rc = -ENODEV;
1004         }
1005         spin_unlock_bh(&ap_dev->lock);
1006         if (rc == -ENODEV)
1007                 device_unregister(&ap_dev->device);
1008 }
1009 EXPORT_SYMBOL(ap_queue_message);
1010
1011 /**
1012  * Cancel a crypto request. This is done by removing the request
1013  * from the devive pendingq or requestq queue. Note that the
1014  * request stays on the AP queue. When it finishes the message
1015  * reply will be discarded because the psmid can't be found.
1016  * @ap_dev: AP device that has the message queued
1017  * @ap_msg: the message that is to be removed
1018  */
1019 void ap_cancel_message(struct ap_device *ap_dev, struct ap_message *ap_msg)
1020 {
1021         struct ap_message *tmp;
1022
1023         spin_lock_bh(&ap_dev->lock);
1024         if (!list_empty(&ap_msg->list)) {
1025                 list_for_each_entry(tmp, &ap_dev->pendingq, list)
1026                         if (tmp->psmid == ap_msg->psmid) {
1027                                 ap_dev->pendingq_count--;
1028                                 goto found;
1029                         }
1030                 ap_dev->requestq_count--;
1031         found:
1032                 list_del_init(&ap_msg->list);
1033         }
1034         spin_unlock_bh(&ap_dev->lock);
1035 }
1036 EXPORT_SYMBOL(ap_cancel_message);
1037
1038 /**
1039  * AP receive polling for finished AP requests
1040  */
1041 static void ap_poll_timeout(unsigned long unused)
1042 {
1043         tasklet_schedule(&ap_tasklet);
1044 }
1045
1046 /**
1047  * Poll all AP devices on the bus in a round robin fashion. Continue
1048  * polling until bit 2^0 of the control flags is not set. If bit 2^1
1049  * of the control flags has been set arm the poll timer.
1050  */
1051 static int __ap_poll_all(struct ap_device *ap_dev, unsigned long *flags)
1052 {
1053         spin_lock(&ap_dev->lock);
1054         if (!ap_dev->unregistered) {
1055                 if (ap_poll_queue(ap_dev, flags))
1056                         ap_dev->unregistered = 1;
1057         }
1058         spin_unlock(&ap_dev->lock);
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