1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#define KMSG_COMPONENT "iucv"
24#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
25
26#include <linux/kernel_stat.h>
27#include <linux/module.h>
28#include <linux/moduleparam.h>
29#include <linux/spinlock.h>
30#include <linux/kernel.h>
31#include <linux/slab.h>
32#include <linux/init.h>
33#include <linux/interrupt.h>
34#include <linux/list.h>
35#include <linux/errno.h>
36#include <linux/err.h>
37#include <linux/device.h>
38#include <linux/cpu.h>
39#include <linux/reboot.h>
40#include <net/iucv/iucv.h>
41#include <linux/atomic.h>
42#include <asm/ebcdic.h>
43#include <asm/io.h>
44#include <asm/irq.h>
45#include <asm/smp.h>
46
47
48
49
50
51
52
53
54
55
56
57
58#define IUCV_IPSRCCLS 0x01
59#define IUCV_IPTRGCLS 0x01
60#define IUCV_IPFGPID 0x02
61#define IUCV_IPFGMID 0x04
62#define IUCV_IPNORPY 0x10
63#define IUCV_IPALL 0x80
64
65static int iucv_bus_match(struct device *dev, struct device_driver *drv)
66{
67 return 0;
68}
69
70struct bus_type iucv_bus = {
71 .name = "iucv",
72 .match = iucv_bus_match,
73};
74EXPORT_SYMBOL(iucv_bus);
75
76struct device *iucv_root;
77EXPORT_SYMBOL(iucv_root);
78
79static int iucv_available;
80
81
82struct iucv_irq_data {
83 u16 ippathid;
84 u8 ipflags1;
85 u8 iptype;
86 u32 res2[8];
87};
88
89struct iucv_irq_list {
90 struct list_head list;
91 struct iucv_irq_data data;
92};
93
94static struct iucv_irq_data *iucv_irq_data[NR_CPUS];
95static cpumask_t iucv_buffer_cpumask = { CPU_BITS_NONE };
96static cpumask_t iucv_irq_cpumask = { CPU_BITS_NONE };
97
98
99
100
101
102static LIST_HEAD(iucv_task_queue);
103
104
105
106
107static void iucv_tasklet_fn(unsigned long);
108static DECLARE_TASKLET_OLD(iucv_tasklet, iucv_tasklet_fn);
109
110
111
112
113
114static LIST_HEAD(iucv_work_queue);
115
116
117
118
119static void iucv_work_fn(struct work_struct *work);
120static DECLARE_WORK(iucv_work, iucv_work_fn);
121
122
123
124
125static DEFINE_SPINLOCK(iucv_queue_lock);
126
127enum iucv_command_codes {
128 IUCV_QUERY = 0,
129 IUCV_RETRIEVE_BUFFER = 2,
130 IUCV_SEND = 4,
131 IUCV_RECEIVE = 5,
132 IUCV_REPLY = 6,
133 IUCV_REJECT = 8,
134 IUCV_PURGE = 9,
135 IUCV_ACCEPT = 10,
136 IUCV_CONNECT = 11,
137 IUCV_DECLARE_BUFFER = 12,
138 IUCV_QUIESCE = 13,
139 IUCV_RESUME = 14,
140 IUCV_SEVER = 15,
141 IUCV_SETMASK = 16,
142 IUCV_SETCONTROLMASK = 17,
143};
144
145
146
147
148
149static char iucv_error_no_listener[16] = "NO LISTENER";
150static char iucv_error_no_memory[16] = "NO MEMORY";
151static char iucv_error_pathid[16] = "INVALID PATHID";
152
153
154
155
156static LIST_HEAD(iucv_handler_list);
157
158
159
160
161static struct iucv_path **iucv_path_table;
162static unsigned long iucv_max_pathid;
163
164
165
166
167static DEFINE_SPINLOCK(iucv_table_lock);
168
169
170
171
172
173static int iucv_active_cpu = -1;
174
175
176
177
178static DEFINE_MUTEX(iucv_register_mutex);
179
180
181
182
183static int iucv_nonsmp_handler;
184
185
186
187
188
189struct iucv_cmd_control {
190 u16 ippathid;
191 u8 ipflags1;
192 u8 iprcode;
193 u16 ipmsglim;
194 u16 res1;
195 u8 ipvmid[8];
196 u8 ipuser[16];
197 u8 iptarget[8];
198} __attribute__ ((packed,aligned(8)));
199
200
201
202
203
204struct iucv_cmd_dpl {
205 u16 ippathid;
206 u8 ipflags1;
207 u8 iprcode;
208 u32 ipmsgid;
209 u32 iptrgcls;
210 u8 iprmmsg[8];
211 u32 ipsrccls;
212 u32 ipmsgtag;
213 u32 ipbfadr2;
214 u32 ipbfln2f;
215 u32 res;
216} __attribute__ ((packed,aligned(8)));
217
218
219
220
221
222
223struct iucv_cmd_db {
224 u16 ippathid;
225 u8 ipflags1;
226 u8 iprcode;
227 u32 ipmsgid;
228 u32 iptrgcls;
229 u32 ipbfadr1;
230 u32 ipbfln1f;
231 u32 ipsrccls;
232 u32 ipmsgtag;
233 u32 ipbfadr2;
234 u32 ipbfln2f;
235 u32 res;
236} __attribute__ ((packed,aligned(8)));
237
238
239
240
241struct iucv_cmd_purge {
242 u16 ippathid;
243 u8 ipflags1;
244 u8 iprcode;
245 u32 ipmsgid;
246 u8 ipaudit[3];
247 u8 res1[5];
248 u32 res2;
249 u32 ipsrccls;
250 u32 ipmsgtag;
251 u32 res3[3];
252} __attribute__ ((packed,aligned(8)));
253
254
255
256
257struct iucv_cmd_set_mask {
258 u8 ipmask;
259 u8 res1[2];
260 u8 iprcode;
261 u32 res2[9];
262} __attribute__ ((packed,aligned(8)));
263
264union iucv_param {
265 struct iucv_cmd_control ctrl;
266 struct iucv_cmd_dpl dpl;
267 struct iucv_cmd_db db;
268 struct iucv_cmd_purge purge;
269 struct iucv_cmd_set_mask set_mask;
270};
271
272
273
274
275static union iucv_param *iucv_param[NR_CPUS];
276static union iucv_param *iucv_param_irq[NR_CPUS];
277
278
279
280
281
282
283
284
285
286
287static inline int __iucv_call_b2f0(int command, union iucv_param *parm)
288{
289 int cc;
290
291 asm volatile(
292 " lgr 0,%[reg0]\n"
293 " lgr 1,%[reg1]\n"
294 " .long 0xb2f01000\n"
295 " ipm %[cc]\n"
296 " srl %[cc],28\n"
297 : [cc] "=&d" (cc), "+m" (*parm)
298 : [reg0] "d" ((unsigned long)command),
299 [reg1] "d" ((unsigned long)parm)
300 : "cc", "0", "1");
301 return cc;
302}
303
304static inline int iucv_call_b2f0(int command, union iucv_param *parm)
305{
306 int ccode;
307
308 ccode = __iucv_call_b2f0(command, parm);
309 return ccode == 1 ? parm->ctrl.iprcode : ccode;
310}
311
312
313
314
315
316
317
318
319
320static int __iucv_query_maxconn(void *param, unsigned long *max_pathid)
321{
322 unsigned long reg1 = (unsigned long)param;
323 int cc;
324
325 asm volatile (
326 " lghi 0,%[cmd]\n"
327 " lgr 1,%[reg1]\n"
328 " .long 0xb2f01000\n"
329 " ipm %[cc]\n"
330 " srl %[cc],28\n"
331 " lgr %[reg1],1\n"
332 : [cc] "=&d" (cc), [reg1] "+&d" (reg1)
333 : [cmd] "K" (IUCV_QUERY)
334 : "cc", "0", "1");
335 *max_pathid = reg1;
336 return cc;
337}
338
339static int iucv_query_maxconn(void)
340{
341 unsigned long max_pathid;
342 void *param;
343 int ccode;
344
345 param = kzalloc(sizeof(union iucv_param), GFP_KERNEL | GFP_DMA);
346 if (!param)
347 return -ENOMEM;
348 ccode = __iucv_query_maxconn(param, &max_pathid);
349 if (ccode == 0)
350 iucv_max_pathid = max_pathid;
351 kfree(param);
352 return ccode ? -EPERM : 0;
353}
354
355
356
357
358
359
360
361static void iucv_allow_cpu(void *data)
362{
363 int cpu = smp_processor_id();
364 union iucv_param *parm;
365
366
367
368
369
370
371
372
373
374
375 parm = iucv_param_irq[cpu];
376 memset(parm, 0, sizeof(union iucv_param));
377 parm->set_mask.ipmask = 0xf8;
378 iucv_call_b2f0(IUCV_SETMASK, parm);
379
380
381
382
383
384
385
386
387
388
389 memset(parm, 0, sizeof(union iucv_param));
390 parm->set_mask.ipmask = 0xf8;
391 iucv_call_b2f0(IUCV_SETCONTROLMASK, parm);
392
393 cpumask_set_cpu(cpu, &iucv_irq_cpumask);
394}
395
396
397
398
399
400
401
402static void iucv_block_cpu(void *data)
403{
404 int cpu = smp_processor_id();
405 union iucv_param *parm;
406
407
408 parm = iucv_param_irq[cpu];
409 memset(parm, 0, sizeof(union iucv_param));
410 iucv_call_b2f0(IUCV_SETMASK, parm);
411
412
413 cpumask_clear_cpu(cpu, &iucv_irq_cpumask);
414}
415
416
417
418
419
420
421
422static void iucv_declare_cpu(void *data)
423{
424 int cpu = smp_processor_id();
425 union iucv_param *parm;
426 int rc;
427
428 if (cpumask_test_cpu(cpu, &iucv_buffer_cpumask))
429 return;
430
431
432 parm = iucv_param_irq[cpu];
433 memset(parm, 0, sizeof(union iucv_param));
434 parm->db.ipbfadr1 = virt_to_phys(iucv_irq_data[cpu]);
435 rc = iucv_call_b2f0(IUCV_DECLARE_BUFFER, parm);
436 if (rc) {
437 char *err = "Unknown";
438 switch (rc) {
439 case 0x03:
440 err = "Directory error";
441 break;
442 case 0x0a:
443 err = "Invalid length";
444 break;
445 case 0x13:
446 err = "Buffer already exists";
447 break;
448 case 0x3e:
449 err = "Buffer overlap";
450 break;
451 case 0x5c:
452 err = "Paging or storage error";
453 break;
454 }
455 pr_warn("Defining an interrupt buffer on CPU %i failed with 0x%02x (%s)\n",
456 cpu, rc, err);
457 return;
458 }
459
460
461 cpumask_set_cpu(cpu, &iucv_buffer_cpumask);
462
463 if (iucv_nonsmp_handler == 0 || cpumask_empty(&iucv_irq_cpumask))
464
465 iucv_allow_cpu(NULL);
466 else
467
468 iucv_block_cpu(NULL);
469}
470
471
472
473
474
475
476
477static void iucv_retrieve_cpu(void *data)
478{
479 int cpu = smp_processor_id();
480 union iucv_param *parm;
481
482 if (!cpumask_test_cpu(cpu, &iucv_buffer_cpumask))
483 return;
484
485
486 iucv_block_cpu(NULL);
487
488
489 parm = iucv_param_irq[cpu];
490 iucv_call_b2f0(IUCV_RETRIEVE_BUFFER, parm);
491
492
493 cpumask_clear_cpu(cpu, &iucv_buffer_cpumask);
494}
495
496
497
498
499
500
501static void iucv_setmask_mp(void)
502{
503 int cpu;
504
505 cpus_read_lock();
506 for_each_online_cpu(cpu)
507
508 if (cpumask_test_cpu(cpu, &iucv_buffer_cpumask) &&
509 !cpumask_test_cpu(cpu, &iucv_irq_cpumask))
510 smp_call_function_single(cpu, iucv_allow_cpu,
511 NULL, 1);
512 cpus_read_unlock();
513}
514
515
516
517
518
519
520static void iucv_setmask_up(void)
521{
522 cpumask_t cpumask;
523 int cpu;
524
525
526 cpumask_copy(&cpumask, &iucv_irq_cpumask);
527 cpumask_clear_cpu(cpumask_first(&iucv_irq_cpumask), &cpumask);
528 for_each_cpu(cpu, &cpumask)
529 smp_call_function_single(cpu, iucv_block_cpu, NULL, 1);
530}
531
532
533
534
535
536
537
538
539
540static int iucv_enable(void)
541{
542 size_t alloc_size;
543 int cpu, rc;
544
545 cpus_read_lock();
546 rc = -ENOMEM;
547 alloc_size = iucv_max_pathid * sizeof(struct iucv_path);
548 iucv_path_table = kzalloc(alloc_size, GFP_KERNEL);
549 if (!iucv_path_table)
550 goto out;
551
552 rc = -EIO;
553 for_each_online_cpu(cpu)
554 smp_call_function_single(cpu, iucv_declare_cpu, NULL, 1);
555 if (cpumask_empty(&iucv_buffer_cpumask))
556
557 goto out;
558 cpus_read_unlock();
559 return 0;
560out:
561 kfree(iucv_path_table);
562 iucv_path_table = NULL;
563 cpus_read_unlock();
564 return rc;
565}
566
567
568
569
570
571
572
573
574static void iucv_disable(void)
575{
576 cpus_read_lock();
577 on_each_cpu(iucv_retrieve_cpu, NULL, 1);
578 kfree(iucv_path_table);
579 iucv_path_table = NULL;
580 cpus_read_unlock();
581}
582
583static int iucv_cpu_dead(unsigned int cpu)
584{
585 kfree(iucv_param_irq[cpu]);
586 iucv_param_irq[cpu] = NULL;
587 kfree(iucv_param[cpu]);
588 iucv_param[cpu] = NULL;
589 kfree(iucv_irq_data[cpu]);
590 iucv_irq_data[cpu] = NULL;
591 return 0;
592}
593
594static int iucv_cpu_prepare(unsigned int cpu)
595{
596
597 iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data),
598 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
599 if (!iucv_irq_data[cpu])
600 goto out_free;
601
602
603 iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param),
604 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
605 if (!iucv_param[cpu])
606 goto out_free;
607
608 iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param),
609 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
610 if (!iucv_param_irq[cpu])
611 goto out_free;
612
613 return 0;
614
615out_free:
616 iucv_cpu_dead(cpu);
617 return -ENOMEM;
618}
619
620static int iucv_cpu_online(unsigned int cpu)
621{
622 if (!iucv_path_table)
623 return 0;
624 iucv_declare_cpu(NULL);
625 return 0;
626}
627
628static int iucv_cpu_down_prep(unsigned int cpu)
629{
630 cpumask_t cpumask;
631
632 if (!iucv_path_table)
633 return 0;
634
635 cpumask_copy(&cpumask, &iucv_buffer_cpumask);
636 cpumask_clear_cpu(cpu, &cpumask);
637 if (cpumask_empty(&cpumask))
638
639 return -EINVAL;
640
641 iucv_retrieve_cpu(NULL);
642 if (!cpumask_empty(&iucv_irq_cpumask))
643 return 0;
644 smp_call_function_single(cpumask_first(&iucv_buffer_cpumask),
645 iucv_allow_cpu, NULL, 1);
646 return 0;
647}
648
649
650
651
652
653
654
655
656static int iucv_sever_pathid(u16 pathid, u8 *userdata)
657{
658 union iucv_param *parm;
659
660 parm = iucv_param_irq[smp_processor_id()];
661 memset(parm, 0, sizeof(union iucv_param));
662 if (userdata)
663 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
664 parm->ctrl.ippathid = pathid;
665 return iucv_call_b2f0(IUCV_SEVER, parm);
666}
667
668
669
670
671
672
673
674
675static void __iucv_cleanup_queue(void *dummy)
676{
677}
678
679
680
681
682
683
684
685
686static void iucv_cleanup_queue(void)
687{
688 struct iucv_irq_list *p, *n;
689
690
691
692
693
694
695
696
697
698
699 smp_call_function(__iucv_cleanup_queue, NULL, 1);
700 spin_lock_irq(&iucv_queue_lock);
701 list_for_each_entry_safe(p, n, &iucv_task_queue, list) {
702
703 if (iucv_path_table[p->data.ippathid] == NULL) {
704 list_del(&p->list);
705 kfree(p);
706 }
707 }
708 spin_unlock_irq(&iucv_queue_lock);
709}
710
711
712
713
714
715
716
717
718
719
720
721int iucv_register(struct iucv_handler *handler, int smp)
722{
723 int rc;
724
725 if (!iucv_available)
726 return -ENOSYS;
727 mutex_lock(&iucv_register_mutex);
728 if (!smp)
729 iucv_nonsmp_handler++;
730 if (list_empty(&iucv_handler_list)) {
731 rc = iucv_enable();
732 if (rc)
733 goto out_mutex;
734 } else if (!smp && iucv_nonsmp_handler == 1)
735 iucv_setmask_up();
736 INIT_LIST_HEAD(&handler->paths);
737
738 spin_lock_bh(&iucv_table_lock);
739 list_add_tail(&handler->list, &iucv_handler_list);
740 spin_unlock_bh(&iucv_table_lock);
741 rc = 0;
742out_mutex:
743 mutex_unlock(&iucv_register_mutex);
744 return rc;
745}
746EXPORT_SYMBOL(iucv_register);
747
748
749
750
751
752
753
754
755void iucv_unregister(struct iucv_handler *handler, int smp)
756{
757 struct iucv_path *p, *n;
758
759 mutex_lock(&iucv_register_mutex);
760 spin_lock_bh(&iucv_table_lock);
761
762 list_del_init(&handler->list);
763
764 list_for_each_entry_safe(p, n, &handler->paths, list) {
765 iucv_sever_pathid(p->pathid, NULL);
766 iucv_path_table[p->pathid] = NULL;
767 list_del(&p->list);
768 iucv_path_free(p);
769 }
770 spin_unlock_bh(&iucv_table_lock);
771 if (!smp)
772 iucv_nonsmp_handler--;
773 if (list_empty(&iucv_handler_list))
774 iucv_disable();
775 else if (!smp && iucv_nonsmp_handler == 0)
776 iucv_setmask_mp();
777 mutex_unlock(&iucv_register_mutex);
778}
779EXPORT_SYMBOL(iucv_unregister);
780
781static int iucv_reboot_event(struct notifier_block *this,
782 unsigned long event, void *ptr)
783{
784 int i;
785
786 if (cpumask_empty(&iucv_irq_cpumask))
787 return NOTIFY_DONE;
788
789 cpus_read_lock();
790 on_each_cpu_mask(&iucv_irq_cpumask, iucv_block_cpu, NULL, 1);
791 preempt_disable();
792 for (i = 0; i < iucv_max_pathid; i++) {
793 if (iucv_path_table[i])
794 iucv_sever_pathid(i, NULL);
795 }
796 preempt_enable();
797 cpus_read_unlock();
798 iucv_disable();
799 return NOTIFY_DONE;
800}
801
802static struct notifier_block iucv_reboot_notifier = {
803 .notifier_call = iucv_reboot_event,
804};
805
806
807
808
809
810
811
812
813
814
815
816
817
818int iucv_path_accept(struct iucv_path *path, struct iucv_handler *handler,
819 u8 *userdata, void *private)
820{
821 union iucv_param *parm;
822 int rc;
823
824 local_bh_disable();
825 if (cpumask_empty(&iucv_buffer_cpumask)) {
826 rc = -EIO;
827 goto out;
828 }
829
830 parm = iucv_param[smp_processor_id()];
831 memset(parm, 0, sizeof(union iucv_param));
832 parm->ctrl.ippathid = path->pathid;
833 parm->ctrl.ipmsglim = path->msglim;
834 if (userdata)
835 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
836 parm->ctrl.ipflags1 = path->flags;
837
838 rc = iucv_call_b2f0(IUCV_ACCEPT, parm);
839 if (!rc) {
840 path->private = private;
841 path->msglim = parm->ctrl.ipmsglim;
842 path->flags = parm->ctrl.ipflags1;
843 }
844out:
845 local_bh_enable();
846 return rc;
847}
848EXPORT_SYMBOL(iucv_path_accept);
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865int iucv_path_connect(struct iucv_path *path, struct iucv_handler *handler,
866 u8 *userid, u8 *system, u8 *userdata,
867 void *private)
868{
869 union iucv_param *parm;
870 int rc;
871
872 spin_lock_bh(&iucv_table_lock);
873 iucv_cleanup_queue();
874 if (cpumask_empty(&iucv_buffer_cpumask)) {
875 rc = -EIO;
876 goto out;
877 }
878 parm = iucv_param[smp_processor_id()];
879 memset(parm, 0, sizeof(union iucv_param));
880 parm->ctrl.ipmsglim = path->msglim;
881 parm->ctrl.ipflags1 = path->flags;
882 if (userid) {
883 memcpy(parm->ctrl.ipvmid, userid, sizeof(parm->ctrl.ipvmid));
884 ASCEBC(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid));
885 EBC_TOUPPER(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid));
886 }
887 if (system) {
888 memcpy(parm->ctrl.iptarget, system,
889 sizeof(parm->ctrl.iptarget));
890 ASCEBC(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget));
891 EBC_TOUPPER(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget));
892 }
893 if (userdata)
894 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
895
896 rc = iucv_call_b2f0(IUCV_CONNECT, parm);
897 if (!rc) {
898 if (parm->ctrl.ippathid < iucv_max_pathid) {
899 path->pathid = parm->ctrl.ippathid;
900 path->msglim = parm->ctrl.ipmsglim;
901 path->flags = parm->ctrl.ipflags1;
902 path->handler = handler;
903 path->private = private;
904 list_add_tail(&path->list, &handler->paths);
905 iucv_path_table[path->pathid] = path;
906 } else {
907 iucv_sever_pathid(parm->ctrl.ippathid,
908 iucv_error_pathid);
909 rc = -EIO;
910 }
911 }
912out:
913 spin_unlock_bh(&iucv_table_lock);
914 return rc;
915}
916EXPORT_SYMBOL(iucv_path_connect);
917
918
919
920
921
922
923
924
925
926
927
928int iucv_path_quiesce(struct iucv_path *path, u8 *userdata)
929{
930 union iucv_param *parm;
931 int rc;
932
933 local_bh_disable();
934 if (cpumask_empty(&iucv_buffer_cpumask)) {
935 rc = -EIO;
936 goto out;
937 }
938 parm = iucv_param[smp_processor_id()];
939 memset(parm, 0, sizeof(union iucv_param));
940 if (userdata)
941 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
942 parm->ctrl.ippathid = path->pathid;
943 rc = iucv_call_b2f0(IUCV_QUIESCE, parm);
944out:
945 local_bh_enable();
946 return rc;
947}
948EXPORT_SYMBOL(iucv_path_quiesce);
949
950
951
952
953
954
955
956
957
958
959
960int iucv_path_resume(struct iucv_path *path, u8 *userdata)
961{
962 union iucv_param *parm;
963 int rc;
964
965 local_bh_disable();
966 if (cpumask_empty(&iucv_buffer_cpumask)) {
967 rc = -EIO;
968 goto out;
969 }
970 parm = iucv_param[smp_processor_id()];
971 memset(parm, 0, sizeof(union iucv_param));
972 if (userdata)
973 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
974 parm->ctrl.ippathid = path->pathid;
975 rc = iucv_call_b2f0(IUCV_RESUME, parm);
976out:
977 local_bh_enable();
978 return rc;
979}
980
981
982
983
984
985
986
987
988
989
990int iucv_path_sever(struct iucv_path *path, u8 *userdata)
991{
992 int rc;
993
994 preempt_disable();
995 if (cpumask_empty(&iucv_buffer_cpumask)) {
996 rc = -EIO;
997 goto out;
998 }
999 if (iucv_active_cpu != smp_processor_id())
1000 spin_lock_bh(&iucv_table_lock);
1001 rc = iucv_sever_pathid(path->pathid, userdata);
1002 iucv_path_table[path->pathid] = NULL;
1003 list_del_init(&path->list);
1004 if (iucv_active_cpu != smp_processor_id())
1005 spin_unlock_bh(&iucv_table_lock);
1006out:
1007 preempt_enable();
1008 return rc;
1009}
1010EXPORT_SYMBOL(iucv_path_sever);
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022int iucv_message_purge(struct iucv_path *path, struct iucv_message *msg,
1023 u32 srccls)
1024{
1025 union iucv_param *parm;
1026 int rc;
1027
1028 local_bh_disable();
1029 if (cpumask_empty(&iucv_buffer_cpumask)) {
1030 rc = -EIO;
1031 goto out;
1032 }
1033 parm = iucv_param[smp_processor_id()];
1034 memset(parm, 0, sizeof(union iucv_param));
1035 parm->purge.ippathid = path->pathid;
1036 parm->purge.ipmsgid = msg->id;
1037 parm->purge.ipsrccls = srccls;
1038 parm->purge.ipflags1 = IUCV_IPSRCCLS | IUCV_IPFGMID | IUCV_IPFGPID;
1039 rc = iucv_call_b2f0(IUCV_PURGE, parm);
1040 if (!rc) {
1041 msg->audit = (*(u32 *) &parm->purge.ipaudit) >> 8;
1042 msg->tag = parm->purge.ipmsgtag;
1043 }
1044out:
1045 local_bh_enable();
1046 return rc;
1047}
1048EXPORT_SYMBOL(iucv_message_purge);
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062static int iucv_message_receive_iprmdata(struct iucv_path *path,
1063 struct iucv_message *msg,
1064 u8 flags, void *buffer,
1065 size_t size, size_t *residual)
1066{
1067 struct iucv_array *array;
1068 u8 *rmmsg;
1069 size_t copy;
1070
1071
1072
1073
1074
1075 if (residual)
1076 *residual = abs(size - 8);
1077 rmmsg = msg->rmmsg;
1078 if (flags & IUCV_IPBUFLST) {
1079
1080 size = (size < 8) ? size : 8;
1081 for (array = buffer; size > 0; array++) {
1082 copy = min_t(size_t, size, array->length);
1083 memcpy((u8 *)(addr_t) array->address,
1084 rmmsg, copy);
1085 rmmsg += copy;
1086 size -= copy;
1087 }
1088 } else {
1089
1090 memcpy(buffer, rmmsg, min_t(size_t, size, 8));
1091 }
1092 return 0;
1093}
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112int __iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
1113 u8 flags, void *buffer, size_t size, size_t *residual)
1114{
1115 union iucv_param *parm;
1116 int rc;
1117
1118 if (msg->flags & IUCV_IPRMDATA)
1119 return iucv_message_receive_iprmdata(path, msg, flags,
1120 buffer, size, residual);
1121 if (cpumask_empty(&iucv_buffer_cpumask))
1122 return -EIO;
1123
1124 parm = iucv_param[smp_processor_id()];
1125 memset(parm, 0, sizeof(union iucv_param));
1126 parm->db.ipbfadr1 = (u32)(addr_t) buffer;
1127 parm->db.ipbfln1f = (u32) size;
1128 parm->db.ipmsgid = msg->id;
1129 parm->db.ippathid = path->pathid;
1130 parm->db.iptrgcls = msg->class;
1131 parm->db.ipflags1 = (flags | IUCV_IPFGPID |
1132 IUCV_IPFGMID | IUCV_IPTRGCLS);
1133 rc = iucv_call_b2f0(IUCV_RECEIVE, parm);
1134 if (!rc || rc == 5) {
1135 msg->flags = parm->db.ipflags1;
1136 if (residual)
1137 *residual = parm->db.ipbfln1f;
1138 }
1139 return rc;
1140}
1141EXPORT_SYMBOL(__iucv_message_receive);
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160int iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
1161 u8 flags, void *buffer, size_t size, size_t *residual)
1162{
1163 int rc;
1164
1165 if (msg->flags & IUCV_IPRMDATA)
1166 return iucv_message_receive_iprmdata(path, msg, flags,
1167 buffer, size, residual);
1168 local_bh_disable();
1169 rc = __iucv_message_receive(path, msg, flags, buffer, size, residual);
1170 local_bh_enable();
1171 return rc;
1172}
1173EXPORT_SYMBOL(iucv_message_receive);
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186int iucv_message_reject(struct iucv_path *path, struct iucv_message *msg)
1187{
1188 union iucv_param *parm;
1189 int rc;
1190
1191 local_bh_disable();
1192 if (cpumask_empty(&iucv_buffer_cpumask)) {
1193 rc = -EIO;
1194 goto out;
1195 }
1196 parm = iucv_param[smp_processor_id()];
1197 memset(parm, 0, sizeof(union iucv_param));
1198 parm->db.ippathid = path->pathid;
1199 parm->db.ipmsgid = msg->id;
1200 parm->db.iptrgcls = msg->class;
1201 parm->db.ipflags1 = (IUCV_IPTRGCLS | IUCV_IPFGMID | IUCV_IPFGPID);
1202 rc = iucv_call_b2f0(IUCV_REJECT, parm);
1203out:
1204 local_bh_enable();
1205 return rc;
1206}
1207EXPORT_SYMBOL(iucv_message_reject);
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224int iucv_message_reply(struct iucv_path *path, struct iucv_message *msg,
1225 u8 flags, void *reply, size_t size)
1226{
1227 union iucv_param *parm;
1228 int rc;
1229
1230 local_bh_disable();
1231 if (cpumask_empty(&iucv_buffer_cpumask)) {
1232 rc = -EIO;
1233 goto out;
1234 }
1235 parm = iucv_param[smp_processor_id()];
1236 memset(parm, 0, sizeof(union iucv_param));
1237 if (flags & IUCV_IPRMDATA) {
1238 parm->dpl.ippathid = path->pathid;
1239 parm->dpl.ipflags1 = flags;
1240 parm->dpl.ipmsgid = msg->id;
1241 parm->dpl.iptrgcls = msg->class;
1242 memcpy(parm->dpl.iprmmsg, reply, min_t(size_t, size, 8));
1243 } else {
1244 parm->db.ipbfadr1 = (u32)(addr_t) reply;
1245 parm->db.ipbfln1f = (u32) size;
1246 parm->db.ippathid = path->pathid;
1247 parm->db.ipflags1 = flags;
1248 parm->db.ipmsgid = msg->id;
1249 parm->db.iptrgcls = msg->class;
1250 }
1251 rc = iucv_call_b2f0(IUCV_REPLY, parm);
1252out:
1253 local_bh_enable();
1254 return rc;
1255}
1256EXPORT_SYMBOL(iucv_message_reply);
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275int __iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
1276 u8 flags, u32 srccls, void *buffer, size_t size)
1277{
1278 union iucv_param *parm;
1279 int rc;
1280
1281 if (cpumask_empty(&iucv_buffer_cpumask)) {
1282 rc = -EIO;
1283 goto out;
1284 }
1285 parm = iucv_param[smp_processor_id()];
1286 memset(parm, 0, sizeof(union iucv_param));
1287 if (flags & IUCV_IPRMDATA) {
1288
1289 parm->dpl.ippathid = path->pathid;
1290 parm->dpl.ipflags1 = flags | IUCV_IPNORPY;
1291 parm->dpl.iptrgcls = msg->class;
1292 parm->dpl.ipsrccls = srccls;
1293 parm->dpl.ipmsgtag = msg->tag;
1294 memcpy(parm->dpl.iprmmsg, buffer, 8);
1295 } else {
1296 parm->db.ipbfadr1 = (u32)(addr_t) buffer;
1297 parm->db.ipbfln1f = (u32) size;
1298 parm->db.ippathid = path->pathid;
1299 parm->db.ipflags1 = flags | IUCV_IPNORPY;
1300 parm->db.iptrgcls = msg->class;
1301 parm->db.ipsrccls = srccls;
1302 parm->db.ipmsgtag = msg->tag;
1303 }
1304 rc = iucv_call_b2f0(IUCV_SEND, parm);
1305 if (!rc)
1306 msg->id = parm->db.ipmsgid;
1307out:
1308 return rc;
1309}
1310EXPORT_SYMBOL(__iucv_message_send);
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329int iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
1330 u8 flags, u32 srccls, void *buffer, size_t size)
1331{
1332 int rc;
1333
1334 local_bh_disable();
1335 rc = __iucv_message_send(path, msg, flags, srccls, buffer, size);
1336 local_bh_enable();
1337 return rc;
1338}
1339EXPORT_SYMBOL(iucv_message_send);
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360int iucv_message_send2way(struct iucv_path *path, struct iucv_message *msg,
1361 u8 flags, u32 srccls, void *buffer, size_t size,
1362 void *answer, size_t asize, size_t *residual)
1363{
1364 union iucv_param *parm;
1365 int rc;
1366
1367 local_bh_disable();
1368 if (cpumask_empty(&iucv_buffer_cpumask)) {
1369 rc = -EIO;
1370 goto out;
1371 }
1372 parm = iucv_param[smp_processor_id()];
1373 memset(parm, 0, sizeof(union iucv_param));
1374 if (flags & IUCV_IPRMDATA) {
1375 parm->dpl.ippathid = path->pathid;
1376 parm->dpl.ipflags1 = path->flags;
1377 parm->dpl.iptrgcls = msg->class;
1378 parm->dpl.ipsrccls = srccls;
1379 parm->dpl.ipmsgtag = msg->tag;
1380 parm->dpl.ipbfadr2 = (u32)(addr_t) answer;
1381 parm->dpl.ipbfln2f = (u32) asize;
1382 memcpy(parm->dpl.iprmmsg, buffer, 8);
1383 } else {
1384 parm->db.ippathid = path->pathid;
1385 parm->db.ipflags1 = path->flags;
1386 parm->db.iptrgcls = msg->class;
1387 parm->db.ipsrccls = srccls;
1388 parm->db.ipmsgtag = msg->tag;
1389 parm->db.ipbfadr1 = (u32)(addr_t) buffer;
1390 parm->db.ipbfln1f = (u32) size;
1391 parm->db.ipbfadr2 = (u32)(addr_t) answer;
1392 parm->db.ipbfln2f = (u32) asize;
1393 }
1394 rc = iucv_call_b2f0(IUCV_SEND, parm);
1395 if (!rc)
1396 msg->id = parm->db.ipmsgid;
1397out:
1398 local_bh_enable();
1399 return rc;
1400}
1401EXPORT_SYMBOL(iucv_message_send2way);
1402
1403
1404
1405
1406
1407
1408
1409
1410struct iucv_path_pending {
1411 u16 ippathid;
1412 u8 ipflags1;
1413 u8 iptype;
1414 u16 ipmsglim;
1415 u16 res1;
1416 u8 ipvmid[8];
1417 u8 ipuser[16];
1418 u32 res3;
1419 u8 ippollfg;
1420 u8 res4[3];
1421} __packed;
1422
1423static void iucv_path_pending(struct iucv_irq_data *data)
1424{
1425 struct iucv_path_pending *ipp = (void *) data;
1426 struct iucv_handler *handler;
1427 struct iucv_path *path;
1428 char *error;
1429
1430 BUG_ON(iucv_path_table[ipp->ippathid]);
1431
1432 error = iucv_error_no_memory;
1433 path = iucv_path_alloc(ipp->ipmsglim, ipp->ipflags1, GFP_ATOMIC);
1434 if (!path)
1435 goto out_sever;
1436 path->pathid = ipp->ippathid;
1437 iucv_path_table[path->pathid] = path;
1438 EBCASC(ipp->ipvmid, 8);
1439
1440
1441 list_for_each_entry(handler, &iucv_handler_list, list) {
1442 if (!handler->path_pending)
1443 continue;
1444
1445
1446
1447
1448
1449 list_add(&path->list, &handler->paths);
1450 path->handler = handler;
1451 if (!handler->path_pending(path, ipp->ipvmid, ipp->ipuser))
1452 return;
1453 list_del(&path->list);
1454 path->handler = NULL;
1455 }
1456
1457 iucv_path_table[path->pathid] = NULL;
1458 iucv_path_free(path);
1459 error = iucv_error_no_listener;
1460out_sever:
1461 iucv_sever_pathid(ipp->ippathid, error);
1462}
1463
1464
1465
1466
1467
1468
1469
1470
1471struct iucv_path_complete {
1472 u16 ippathid;
1473 u8 ipflags1;
1474 u8 iptype;
1475 u16 ipmsglim;
1476 u16 res1;
1477 u8 res2[8];
1478 u8 ipuser[16];
1479 u32 res3;
1480 u8 ippollfg;
1481 u8 res4[3];
1482} __packed;
1483
1484static void iucv_path_complete(struct iucv_irq_data *data)
1485{
1486 struct iucv_path_complete *ipc = (void *) data;
1487 struct iucv_path *path = iucv_path_table[ipc->ippathid];
1488
1489 if (path)
1490 path->flags = ipc->ipflags1;
1491 if (path && path->handler && path->handler->path_complete)
1492 path->handler->path_complete(path, ipc->ipuser);
1493}
1494
1495
1496
1497
1498
1499
1500
1501
1502struct iucv_path_severed {
1503 u16 ippathid;
1504 u8 res1;
1505 u8 iptype;
1506 u32 res2;
1507 u8 res3[8];
1508 u8 ipuser[16];
1509 u32 res4;
1510 u8 ippollfg;
1511 u8 res5[3];
1512} __packed;
1513
1514static void iucv_path_severed(struct iucv_irq_data *data)
1515{
1516 struct iucv_path_severed *ips = (void *) data;
1517 struct iucv_path *path = iucv_path_table[ips->ippathid];
1518
1519 if (!path || !path->handler)
1520 return;
1521 if (path->handler->path_severed)
1522 path->handler->path_severed(path, ips->ipuser);
1523 else {
1524 iucv_sever_pathid(path->pathid, NULL);
1525 iucv_path_table[path->pathid] = NULL;
1526 list_del(&path->list);
1527 iucv_path_free(path);
1528 }
1529}
1530
1531
1532
1533
1534
1535
1536
1537
1538struct iucv_path_quiesced {
1539 u16 ippathid;
1540 u8 res1;
1541 u8 iptype;
1542 u32 res2;
1543 u8 res3[8];
1544 u8 ipuser[16];
1545 u32 res4;
1546 u8 ippollfg;
1547 u8 res5[3];
1548} __packed;
1549
1550static void iucv_path_quiesced(struct iucv_irq_data *data)
1551{
1552 struct iucv_path_quiesced *ipq = (void *) data;
1553 struct iucv_path *path = iucv_path_table[ipq->ippathid];
1554
1555 if (path && path->handler && path->handler->path_quiesced)
1556 path->handler->path_quiesced(path, ipq->ipuser);
1557}
1558
1559
1560
1561
1562
1563
1564
1565
1566struct iucv_path_resumed {
1567 u16 ippathid;
1568 u8 res1;
1569 u8 iptype;
1570 u32 res2;
1571 u8 res3[8];
1572 u8 ipuser[16];
1573 u32 res4;
1574 u8 ippollfg;
1575 u8 res5[3];
1576} __packed;
1577
1578static void iucv_path_resumed(struct iucv_irq_data *data)
1579{
1580 struct iucv_path_resumed *ipr = (void *) data;
1581 struct iucv_path *path = iucv_path_table[ipr->ippathid];
1582
1583 if (path && path->handler && path->handler->path_resumed)
1584 path->handler->path_resumed(path, ipr->ipuser);
1585}
1586
1587
1588
1589
1590
1591
1592
1593
1594struct iucv_message_complete {
1595 u16 ippathid;
1596 u8 ipflags1;
1597 u8 iptype;
1598 u32 ipmsgid;
1599 u32 ipaudit;
1600 u8 iprmmsg[8];
1601 u32 ipsrccls;
1602 u32 ipmsgtag;
1603 u32 res;
1604 u32 ipbfln2f;
1605 u8 ippollfg;
1606 u8 res2[3];
1607} __packed;
1608
1609static void iucv_message_complete(struct iucv_irq_data *data)
1610{
1611 struct iucv_message_complete *imc = (void *) data;
1612 struct iucv_path *path = iucv_path_table[imc->ippathid];
1613 struct iucv_message msg;
1614
1615 if (path && path->handler && path->handler->message_complete) {
1616 msg.flags = imc->ipflags1;
1617 msg.id = imc->ipmsgid;
1618 msg.audit = imc->ipaudit;
1619 memcpy(msg.rmmsg, imc->iprmmsg, 8);
1620 msg.class = imc->ipsrccls;
1621 msg.tag = imc->ipmsgtag;
1622 msg.length = imc->ipbfln2f;
1623 path->handler->message_complete(path, &msg);
1624 }
1625}
1626
1627
1628
1629
1630
1631
1632
1633
1634struct iucv_message_pending {
1635 u16 ippathid;
1636 u8 ipflags1;
1637 u8 iptype;
1638 u32 ipmsgid;
1639 u32 iptrgcls;
1640 struct {
1641 union {
1642 u32 iprmmsg1_u32;
1643 u8 iprmmsg1[4];
1644 } ln1msg1;
1645 union {
1646 u32 ipbfln1f;
1647 u8 iprmmsg2[4];
1648 } ln1msg2;
1649 } rmmsg;
1650 u32 res1[3];
1651 u32 ipbfln2f;
1652 u8 ippollfg;
1653 u8 res2[3];
1654} __packed;
1655
1656static void iucv_message_pending(struct iucv_irq_data *data)
1657{
1658 struct iucv_message_pending *imp = (void *) data;
1659 struct iucv_path *path = iucv_path_table[imp->ippathid];
1660 struct iucv_message msg;
1661
1662 if (path && path->handler && path->handler->message_pending) {
1663 msg.flags = imp->ipflags1;
1664 msg.id = imp->ipmsgid;
1665 msg.class = imp->iptrgcls;
1666 if (imp->ipflags1 & IUCV_IPRMDATA) {
1667 memcpy(msg.rmmsg, &imp->rmmsg, 8);
1668 msg.length = 8;
1669 } else
1670 msg.length = imp->rmmsg.ln1msg2.ipbfln1f;
1671 msg.reply_size = imp->ipbfln2f;
1672 path->handler->message_pending(path, &msg);
1673 }
1674}
1675
1676
1677
1678
1679
1680
1681
1682
1683static void iucv_tasklet_fn(unsigned long ignored)
1684{
1685 typedef void iucv_irq_fn(struct iucv_irq_data *);
1686 static iucv_irq_fn *irq_fn[] = {
1687 [0x02] = iucv_path_complete,
1688 [0x03] = iucv_path_severed,
1689 [0x04] = iucv_path_quiesced,
1690 [0x05] = iucv_path_resumed,
1691 [0x06] = iucv_message_complete,
1692 [0x07] = iucv_message_complete,
1693 [0x08] = iucv_message_pending,
1694 [0x09] = iucv_message_pending,
1695 };
1696 LIST_HEAD(task_queue);
1697 struct iucv_irq_list *p, *n;
1698
1699
1700 if (!spin_trylock(&iucv_table_lock)) {
1701 tasklet_schedule(&iucv_tasklet);
1702 return;
1703 }
1704 iucv_active_cpu = smp_processor_id();
1705
1706 spin_lock_irq(&iucv_queue_lock);
1707 list_splice_init(&iucv_task_queue, &task_queue);
1708 spin_unlock_irq(&iucv_queue_lock);
1709
1710 list_for_each_entry_safe(p, n, &task_queue, list) {
1711 list_del_init(&p->list);
1712 irq_fn[p->data.iptype](&p->data);
1713 kfree(p);
1714 }
1715
1716 iucv_active_cpu = -1;
1717 spin_unlock(&iucv_table_lock);
1718}
1719
1720
1721
1722
1723
1724
1725
1726
1727static void iucv_work_fn(struct work_struct *work)
1728{
1729 LIST_HEAD(work_queue);
1730 struct iucv_irq_list *p, *n;
1731
1732
1733 spin_lock_bh(&iucv_table_lock);
1734 iucv_active_cpu = smp_processor_id();
1735
1736 spin_lock_irq(&iucv_queue_lock);
1737 list_splice_init(&iucv_work_queue, &work_queue);
1738 spin_unlock_irq(&iucv_queue_lock);
1739
1740 iucv_cleanup_queue();
1741 list_for_each_entry_safe(p, n, &work_queue, list) {
1742 list_del_init(&p->list);
1743 iucv_path_pending(&p->data);
1744 kfree(p);
1745 }
1746
1747 iucv_active_cpu = -1;
1748 spin_unlock_bh(&iucv_table_lock);
1749}
1750
1751
1752
1753
1754
1755
1756
1757
1758static void iucv_external_interrupt(struct ext_code ext_code,
1759 unsigned int param32, unsigned long param64)
1760{
1761 struct iucv_irq_data *p;
1762 struct iucv_irq_list *work;
1763
1764 inc_irq_stat(IRQEXT_IUC);
1765 p = iucv_irq_data[smp_processor_id()];
1766 if (p->ippathid >= iucv_max_pathid) {
1767 WARN_ON(p->ippathid >= iucv_max_pathid);
1768 iucv_sever_pathid(p->ippathid, iucv_error_no_listener);
1769 return;
1770 }
1771 BUG_ON(p->iptype < 0x01 || p->iptype > 0x09);
1772 work = kmalloc(sizeof(struct iucv_irq_list), GFP_ATOMIC);
1773 if (!work) {
1774 pr_warn("iucv_external_interrupt: out of memory\n");
1775 return;
1776 }
1777 memcpy(&work->data, p, sizeof(work->data));
1778 spin_lock(&iucv_queue_lock);
1779 if (p->iptype == 0x01) {
1780
1781 list_add_tail(&work->list, &iucv_work_queue);
1782 schedule_work(&iucv_work);
1783 } else {
1784
1785 list_add_tail(&work->list, &iucv_task_queue);
1786 tasklet_schedule(&iucv_tasklet);
1787 }
1788 spin_unlock(&iucv_queue_lock);
1789}
1790
1791struct iucv_interface iucv_if = {
1792 .message_receive = iucv_message_receive,
1793 .__message_receive = __iucv_message_receive,
1794 .message_reply = iucv_message_reply,
1795 .message_reject = iucv_message_reject,
1796 .message_send = iucv_message_send,
1797 .__message_send = __iucv_message_send,
1798 .message_send2way = iucv_message_send2way,
1799 .message_purge = iucv_message_purge,
1800 .path_accept = iucv_path_accept,
1801 .path_connect = iucv_path_connect,
1802 .path_quiesce = iucv_path_quiesce,
1803 .path_resume = iucv_path_resume,
1804 .path_sever = iucv_path_sever,
1805 .iucv_register = iucv_register,
1806 .iucv_unregister = iucv_unregister,
1807 .bus = NULL,
1808 .root = NULL,
1809};
1810EXPORT_SYMBOL(iucv_if);
1811
1812static enum cpuhp_state iucv_online;
1813
1814
1815
1816
1817
1818static int __init iucv_init(void)
1819{
1820 int rc;
1821
1822 if (!MACHINE_IS_VM) {
1823 rc = -EPROTONOSUPPORT;
1824 goto out;
1825 }
1826 ctl_set_bit(0, 1);
1827 rc = iucv_query_maxconn();
1828 if (rc)
1829 goto out_ctl;
1830 rc = register_external_irq(EXT_IRQ_IUCV, iucv_external_interrupt);
1831 if (rc)
1832 goto out_ctl;
1833 iucv_root = root_device_register("iucv");
1834 if (IS_ERR(iucv_root)) {
1835 rc = PTR_ERR(iucv_root);
1836 goto out_int;
1837 }
1838
1839 rc = cpuhp_setup_state(CPUHP_NET_IUCV_PREPARE, "net/iucv:prepare",
1840 iucv_cpu_prepare, iucv_cpu_dead);
1841 if (rc)
1842 goto out_dev;
1843 rc = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "net/iucv:online",
1844 iucv_cpu_online, iucv_cpu_down_prep);
1845 if (rc < 0)
1846 goto out_prep;
1847 iucv_online = rc;
1848
1849 rc = register_reboot_notifier(&iucv_reboot_notifier);
1850 if (rc)
1851 goto out_remove_hp;
1852 ASCEBC(iucv_error_no_listener, 16);
1853 ASCEBC(iucv_error_no_memory, 16);
1854 ASCEBC(iucv_error_pathid, 16);
1855 iucv_available = 1;
1856 rc = bus_register(&iucv_bus);
1857 if (rc)
1858 goto out_reboot;
1859 iucv_if.root = iucv_root;
1860 iucv_if.bus = &iucv_bus;
1861 return 0;
1862
1863out_reboot:
1864 unregister_reboot_notifier(&iucv_reboot_notifier);
1865out_remove_hp:
1866 cpuhp_remove_state(iucv_online);
1867out_prep:
1868 cpuhp_remove_state(CPUHP_NET_IUCV_PREPARE);
1869out_dev:
1870 root_device_unregister(iucv_root);
1871out_int:
1872 unregister_external_irq(EXT_IRQ_IUCV, iucv_external_interrupt);
1873out_ctl:
1874 ctl_clear_bit(0, 1);
1875out:
1876 return rc;
1877}
1878
1879
1880
1881
1882
1883
1884static void __exit iucv_exit(void)
1885{
1886 struct iucv_irq_list *p, *n;
1887
1888 spin_lock_irq(&iucv_queue_lock);
1889 list_for_each_entry_safe(p, n, &iucv_task_queue, list)
1890 kfree(p);
1891 list_for_each_entry_safe(p, n, &iucv_work_queue, list)
1892 kfree(p);
1893 spin_unlock_irq(&iucv_queue_lock);
1894 unregister_reboot_notifier(&iucv_reboot_notifier);
1895
1896 cpuhp_remove_state_nocalls(iucv_online);
1897 cpuhp_remove_state(CPUHP_NET_IUCV_PREPARE);
1898 root_device_unregister(iucv_root);
1899 bus_unregister(&iucv_bus);
1900 unregister_external_irq(EXT_IRQ_IUCV, iucv_external_interrupt);
1901}
1902
1903subsys_initcall(iucv_init);
1904module_exit(iucv_exit);
1905
1906MODULE_AUTHOR("(C) 2001 IBM Corp. by Fritz Elfert (felfert@millenux.com)");
1907MODULE_DESCRIPTION("Linux for S/390 IUCV lowlevel driver");
1908MODULE_LICENSE("GPL");
1909