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