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