drivers/s390/crypto/ap_bus.c

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