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