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