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