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