1 /* 2 * IUCV base infrastructure. 3 * 4 * Copyright IBM Corp. 2001, 2009 5 * 6 * Author(s): 7 * Original source: 8 * Alan Altmark (Alan_Altmark@us.ibm.com) Sept. 2000 9 * Xenia Tkatschow (xenia@us.ibm.com) 10 * 2Gb awareness and general cleanup: 11 * Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com) 12 * Rewritten for af_iucv: 13 * Martin Schwidefsky <schwidefsky@de.ibm.com> 14 * PM functions: 15 * Ursula Braun (ursula.braun@de.ibm.com) 16 * 17 * Documentation used: 18 * The original source 19 * CP Programming Service, IBM document # SC24-5760 20 * 21 * This program is free software; you can redistribute it and/or modify 22 * it under the terms of the GNU General Public License as published by 23 * the Free Software Foundation; either version 2, or (at your option) 24 * any later version. 25 * 26 * This program is distributed in the hope that it will be useful, 27 * but WITHOUT ANY WARRANTY; without even the implied warranty of 28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 29 * GNU General Public License for more details. 30 * 31 * You should have received a copy of the GNU General Public License 32 * along with this program; if not, write to the Free Software 33 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 34 */ 35 36 #define KMSG_COMPONENT "iucv" 37 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 38 39 #include <linux/kernel_stat.h> 40 #include <linux/module.h> 41 #include <linux/moduleparam.h> 42 #include <linux/spinlock.h> 43 #include <linux/kernel.h> 44 #include <linux/slab.h> 45 #include <linux/init.h> 46 #include <linux/interrupt.h> 47 #include <linux/list.h> 48 #include <linux/errno.h> 49 #include <linux/err.h> 50 #include <linux/device.h> 51 #include <linux/cpu.h> 52 #include <linux/reboot.h> 53 #include <net/iucv/iucv.h> 54 #include <linux/atomic.h> 55 #include <asm/ebcdic.h> 56 #include <asm/io.h> 57 #include <asm/irq.h> 58 #include <asm/smp.h> 59 60 /* 61 * FLAGS: 62 * All flags are defined in the field IPFLAGS1 of each function 63 * and can be found in CP Programming Services. 64 * IPSRCCLS - Indicates you have specified a source class. 65 * IPTRGCLS - Indicates you have specified a target class. 66 * IPFGPID - Indicates you have specified a pathid. 67 * IPFGMID - Indicates you have specified a message ID. 68 * IPNORPY - Indicates a one-way message. No reply expected. 69 * IPALL - Indicates that all paths are affected. 70 */ 71 #define IUCV_IPSRCCLS 0x01 72 #define IUCV_IPTRGCLS 0x01 73 #define IUCV_IPFGPID 0x02 74 #define IUCV_IPFGMID 0x04 75 #define IUCV_IPNORPY 0x10 76 #define IUCV_IPALL 0x80 77 78 static int iucv_bus_match(struct device *dev, struct device_driver *drv) 79 { 80 return 0; 81 } 82 83 enum iucv_pm_states { 84 IUCV_PM_INITIAL = 0, 85 IUCV_PM_FREEZING = 1, 86 IUCV_PM_THAWING = 2, 87 IUCV_PM_RESTORING = 3, 88 }; 89 static enum iucv_pm_states iucv_pm_state; 90 91 static int iucv_pm_prepare(struct device *); 92 static void iucv_pm_complete(struct device *); 93 static int iucv_pm_freeze(struct device *); 94 static int iucv_pm_thaw(struct device *); 95 static int iucv_pm_restore(struct device *); 96 97 static const struct dev_pm_ops iucv_pm_ops = { 98 .prepare = iucv_pm_prepare, 99 .complete = iucv_pm_complete, 100 .freeze = iucv_pm_freeze, 101 .thaw = iucv_pm_thaw, 102 .restore = iucv_pm_restore, 103 }; 104 105 struct bus_type iucv_bus = { 106 .name = "iucv", 107 .match = iucv_bus_match, 108 .pm = &iucv_pm_ops, 109 }; 110 EXPORT_SYMBOL(iucv_bus); 111 112 struct device *iucv_root; 113 EXPORT_SYMBOL(iucv_root); 114 115 static int iucv_available; 116 117 /* General IUCV interrupt structure */ 118 struct iucv_irq_data { 119 u16 ippathid; 120 u8 ipflags1; 121 u8 iptype; 122 u32 res2[8]; 123 }; 124 125 struct iucv_irq_list { 126 struct list_head list; 127 struct iucv_irq_data data; 128 }; 129 130 static struct iucv_irq_data *iucv_irq_data[NR_CPUS]; 131 static cpumask_t iucv_buffer_cpumask = { CPU_BITS_NONE }; 132 static cpumask_t iucv_irq_cpumask = { CPU_BITS_NONE }; 133 134 /* 135 * Queue of interrupt buffers lock for delivery via the tasklet 136 * (fast but can't call smp_call_function). 137 */ 138 static LIST_HEAD(iucv_task_queue); 139 140 /* 141 * The tasklet for fast delivery of iucv interrupts. 142 */ 143 static void iucv_tasklet_fn(unsigned long); 144 static DECLARE_TASKLET(iucv_tasklet, iucv_tasklet_fn,0); 145 146 /* 147 * Queue of interrupt buffers for delivery via a work queue 148 * (slower but can call smp_call_function). 149 */ 150 static LIST_HEAD(iucv_work_queue); 151 152 /* 153 * The work element to deliver path pending interrupts. 154 */ 155 static void iucv_work_fn(struct work_struct *work); 156 static DECLARE_WORK(iucv_work, iucv_work_fn); 157 158 /* 159 * Spinlock protecting task and work queue. 160 */ 161 static DEFINE_SPINLOCK(iucv_queue_lock); 162 163 enum iucv_command_codes { 164 IUCV_QUERY = 0, 165 IUCV_RETRIEVE_BUFFER = 2, 166 IUCV_SEND = 4, 167 IUCV_RECEIVE = 5, 168 IUCV_REPLY = 6, 169 IUCV_REJECT = 8, 170 IUCV_PURGE = 9, 171 IUCV_ACCEPT = 10, 172 IUCV_CONNECT = 11, 173 IUCV_DECLARE_BUFFER = 12, 174 IUCV_QUIESCE = 13, 175 IUCV_RESUME = 14, 176 IUCV_SEVER = 15, 177 IUCV_SETMASK = 16, 178 IUCV_SETCONTROLMASK = 17, 179 }; 180 181 /* 182 * Error messages that are used with the iucv_sever function. They get 183 * converted to EBCDIC. 184 */ 185 static char iucv_error_no_listener[16] = "NO LISTENER"; 186 static char iucv_error_no_memory[16] = "NO MEMORY"; 187 static char iucv_error_pathid[16] = "INVALID PATHID"; 188 189 /* 190 * iucv_handler_list: List of registered handlers. 191 */ 192 static LIST_HEAD(iucv_handler_list); 193 194 /* 195 * iucv_path_table: an array of iucv_path structures. 196 */ 197 static struct iucv_path **iucv_path_table; 198 static unsigned long iucv_max_pathid; 199 200 /* 201 * iucv_lock: spinlock protecting iucv_handler_list and iucv_pathid_table 202 */ 203 static DEFINE_SPINLOCK(iucv_table_lock); 204 205 /* 206 * iucv_active_cpu: contains the number of the cpu executing the tasklet 207 * or the work handler. Needed for iucv_path_sever called from tasklet. 208 */ 209 static int iucv_active_cpu = -1; 210 211 /* 212 * Mutex and wait queue for iucv_register/iucv_unregister. 213 */ 214 static DEFINE_MUTEX(iucv_register_mutex); 215 216 /* 217 * Counter for number of non-smp capable handlers. 218 */ 219 static int iucv_nonsmp_handler; 220 221 /* 222 * IUCV control data structure. Used by iucv_path_accept, iucv_path_connect, 223 * iucv_path_quiesce and iucv_path_sever. 224 */ 225 struct iucv_cmd_control { 226 u16 ippathid; 227 u8 ipflags1; 228 u8 iprcode; 229 u16 ipmsglim; 230 u16 res1; 231 u8 ipvmid[8]; 232 u8 ipuser[16]; 233 u8 iptarget[8]; 234 } __attribute__ ((packed,aligned(8))); 235 236 /* 237 * Data in parameter list iucv structure. Used by iucv_message_send, 238 * iucv_message_send2way and iucv_message_reply. 239 */ 240 struct iucv_cmd_dpl { 241 u16 ippathid; 242 u8 ipflags1; 243 u8 iprcode; 244 u32 ipmsgid; 245 u32 iptrgcls; 246 u8 iprmmsg[8]; 247 u32 ipsrccls; 248 u32 ipmsgtag; 249 u32 ipbfadr2; 250 u32 ipbfln2f; 251 u32 res; 252 } __attribute__ ((packed,aligned(8))); 253 254 /* 255 * Data in buffer iucv structure. Used by iucv_message_receive, 256 * iucv_message_reject, iucv_message_send, iucv_message_send2way 257 * and iucv_declare_cpu. 258 */ 259 struct iucv_cmd_db { 260 u16 ippathid; 261 u8 ipflags1; 262 u8 iprcode; 263 u32 ipmsgid; 264 u32 iptrgcls; 265 u32 ipbfadr1; 266 u32 ipbfln1f; 267 u32 ipsrccls; 268 u32 ipmsgtag; 269 u32 ipbfadr2; 270 u32 ipbfln2f; 271 u32 res; 272 } __attribute__ ((packed,aligned(8))); 273 274 /* 275 * Purge message iucv structure. Used by iucv_message_purge. 276 */ 277 struct iucv_cmd_purge { 278 u16 ippathid; 279 u8 ipflags1; 280 u8 iprcode; 281 u32 ipmsgid; 282 u8 ipaudit[3]; 283 u8 res1[5]; 284 u32 res2; 285 u32 ipsrccls; 286 u32 ipmsgtag; 287 u32 res3[3]; 288 } __attribute__ ((packed,aligned(8))); 289 290 /* 291 * Set mask iucv structure. Used by iucv_enable_cpu. 292 */ 293 struct iucv_cmd_set_mask { 294 u8 ipmask; 295 u8 res1[2]; 296 u8 iprcode; 297 u32 res2[9]; 298 } __attribute__ ((packed,aligned(8))); 299 300 union iucv_param { 301 struct iucv_cmd_control ctrl; 302 struct iucv_cmd_dpl dpl; 303 struct iucv_cmd_db db; 304 struct iucv_cmd_purge purge; 305 struct iucv_cmd_set_mask set_mask; 306 }; 307 308 /* 309 * Anchor for per-cpu IUCV command parameter block. 310 */ 311 static union iucv_param *iucv_param[NR_CPUS]; 312 static union iucv_param *iucv_param_irq[NR_CPUS]; 313 314 /** 315 * iucv_call_b2f0 316 * @code: identifier of IUCV call to CP. 317 * @parm: pointer to a struct iucv_parm block 318 * 319 * Calls CP to execute IUCV commands. 320 * 321 * Returns the result of the CP IUCV call. 322 */ 323 static inline int iucv_call_b2f0(int command, union iucv_param *parm) 324 { 325 register unsigned long reg0 asm ("0"); 326 register unsigned long reg1 asm ("1"); 327 int ccode; 328 329 reg0 = command; 330 reg1 = virt_to_phys(parm); 331 asm volatile( 332 " .long 0xb2f01000\n" 333 " ipm %0\n" 334 " srl %0,28\n" 335 : "=d" (ccode), "=m" (*parm), "+d" (reg0), "+a" (reg1) 336 : "m" (*parm) : "cc"); 337 return (ccode == 1) ? parm->ctrl.iprcode : ccode; 338 } 339 340 /** 341 * iucv_query_maxconn 342 * 343 * Determines the maximum number of connections that may be established. 344 * 345 * Returns the maximum number of connections or -EPERM is IUCV is not 346 * available. 347 */ 348 static int iucv_query_maxconn(void) 349 { 350 register unsigned long reg0 asm ("0"); 351 register unsigned long reg1 asm ("1"); 352 void *param; 353 int ccode; 354 355 param = kzalloc(sizeof(union iucv_param), GFP_KERNEL|GFP_DMA); 356 if (!param) 357 return -ENOMEM; 358 reg0 = IUCV_QUERY; 359 reg1 = (unsigned long) param; 360 asm volatile ( 361 " .long 0xb2f01000\n" 362 " ipm %0\n" 363 " srl %0,28\n" 364 : "=d" (ccode), "+d" (reg0), "+d" (reg1) : : "cc"); 365 if (ccode == 0) 366 iucv_max_pathid = reg1; 367 kfree(param); 368 return ccode ? -EPERM : 0; 369 } 370 371 /** 372 * iucv_allow_cpu 373 * @data: unused 374 * 375 * Allow iucv interrupts on this cpu. 376 */ 377 static void iucv_allow_cpu(void *data) 378 { 379 int cpu = smp_processor_id(); 380 union iucv_param *parm; 381 382 /* 383 * Enable all iucv interrupts. 384 * ipmask contains bits for the different interrupts 385 * 0x80 - Flag to allow nonpriority message pending interrupts 386 * 0x40 - Flag to allow priority message pending interrupts 387 * 0x20 - Flag to allow nonpriority message completion interrupts 388 * 0x10 - Flag to allow priority message completion interrupts 389 * 0x08 - Flag to allow IUCV control interrupts 390 */ 391 parm = iucv_param_irq[cpu]; 392 memset(parm, 0, sizeof(union iucv_param)); 393 parm->set_mask.ipmask = 0xf8; 394 iucv_call_b2f0(IUCV_SETMASK, parm); 395 396 /* 397 * Enable all iucv control interrupts. 398 * ipmask contains bits for the different interrupts 399 * 0x80 - Flag to allow pending connections interrupts 400 * 0x40 - Flag to allow connection complete interrupts 401 * 0x20 - Flag to allow connection severed interrupts 402 * 0x10 - Flag to allow connection quiesced interrupts 403 * 0x08 - Flag to allow connection resumed interrupts 404 */ 405 memset(parm, 0, sizeof(union iucv_param)); 406 parm->set_mask.ipmask = 0xf8; 407 iucv_call_b2f0(IUCV_SETCONTROLMASK, parm); 408 /* Set indication that iucv interrupts are allowed for this cpu. */ 409 cpumask_set_cpu(cpu, &iucv_irq_cpumask); 410 } 411 412 /** 413 * iucv_block_cpu 414 * @data: unused 415 * 416 * Block iucv interrupts on this cpu. 417 */ 418 static void iucv_block_cpu(void *data) 419 { 420 int cpu = smp_processor_id(); 421 union iucv_param *parm; 422 423 /* Disable all iucv interrupts. */ 424 parm = iucv_param_irq[cpu]; 425 memset(parm, 0, sizeof(union iucv_param)); 426 iucv_call_b2f0(IUCV_SETMASK, parm); 427 428 /* Clear indication that iucv interrupts are allowed for this cpu. */ 429 cpumask_clear_cpu(cpu, &iucv_irq_cpumask); 430 } 431 432 /** 433 * iucv_block_cpu_almost 434 * @data: unused 435 * 436 * Allow connection-severed interrupts only on this cpu. 437 */ 438 static void iucv_block_cpu_almost(void *data) 439 { 440 int cpu = smp_processor_id(); 441 union iucv_param *parm; 442 443 /* Allow iucv control interrupts only */ 444 parm = iucv_param_irq[cpu]; 445 memset(parm, 0, sizeof(union iucv_param)); 446 parm->set_mask.ipmask = 0x08; 447 iucv_call_b2f0(IUCV_SETMASK, parm); 448 /* Allow iucv-severed interrupt only */ 449 memset(parm, 0, sizeof(union iucv_param)); 450 parm->set_mask.ipmask = 0x20; 451 iucv_call_b2f0(IUCV_SETCONTROLMASK, parm); 452 453 /* Clear indication that iucv interrupts are allowed for this cpu. */ 454 cpumask_clear_cpu(cpu, &iucv_irq_cpumask); 455 } 456 457 /** 458 * iucv_declare_cpu 459 * @data: unused 460 * 461 * Declare a interrupt buffer on this cpu. 462 */ 463 static void iucv_declare_cpu(void *data) 464 { 465 int cpu = smp_processor_id(); 466 union iucv_param *parm; 467 int rc; 468 469 if (cpumask_test_cpu(cpu, &iucv_buffer_cpumask)) 470 return; 471 472 /* Declare interrupt buffer. */ 473 parm = iucv_param_irq[cpu]; 474 memset(parm, 0, sizeof(union iucv_param)); 475 parm->db.ipbfadr1 = virt_to_phys(iucv_irq_data[cpu]); 476 rc = iucv_call_b2f0(IUCV_DECLARE_BUFFER, parm); 477 if (rc) { 478 char *err = "Unknown"; 479 switch (rc) { 480 case 0x03: 481 err = "Directory error"; 482 break; 483 case 0x0a: 484 err = "Invalid length"; 485 break; 486 case 0x13: 487 err = "Buffer already exists"; 488 break; 489 case 0x3e: 490 err = "Buffer overlap"; 491 break; 492 case 0x5c: 493 err = "Paging or storage error"; 494 break; 495 } 496 pr_warning("Defining an interrupt buffer on CPU %i" 497 " failed with 0x%02x (%s)\n", cpu, rc, err); 498 return; 499 } 500 501 /* Set indication that an iucv buffer exists for this cpu. */ 502 cpumask_set_cpu(cpu, &iucv_buffer_cpumask); 503 504 if (iucv_nonsmp_handler == 0 || cpumask_empty(&iucv_irq_cpumask)) 505 /* Enable iucv interrupts on this cpu. */ 506 iucv_allow_cpu(NULL); 507 else 508 /* Disable iucv interrupts on this cpu. */ 509 iucv_block_cpu(NULL); 510 } 511 512 /** 513 * iucv_retrieve_cpu 514 * @data: unused 515 * 516 * Retrieve interrupt buffer on this cpu. 517 */ 518 static void iucv_retrieve_cpu(void *data) 519 { 520 int cpu = smp_processor_id(); 521 union iucv_param *parm; 522 523 if (!cpumask_test_cpu(cpu, &iucv_buffer_cpumask)) 524 return; 525 526 /* Block iucv interrupts. */ 527 iucv_block_cpu(NULL); 528 529 /* Retrieve interrupt buffer. */ 530 parm = iucv_param_irq[cpu]; 531 iucv_call_b2f0(IUCV_RETRIEVE_BUFFER, parm); 532 533 /* Clear indication that an iucv buffer exists for this cpu. */ 534 cpumask_clear_cpu(cpu, &iucv_buffer_cpumask); 535 } 536 537 /** 538 * iucv_setmask_smp 539 * 540 * Allow iucv interrupts on all cpus. 541 */ 542 static void iucv_setmask_mp(void) 543 { 544 int cpu; 545 546 get_online_cpus(); 547 for_each_online_cpu(cpu) 548 /* Enable all cpus with a declared buffer. */ 549 if (cpumask_test_cpu(cpu, &iucv_buffer_cpumask) && 550 !cpumask_test_cpu(cpu, &iucv_irq_cpumask)) 551 smp_call_function_single(cpu, iucv_allow_cpu, 552 NULL, 1); 553 put_online_cpus(); 554 } 555 556 /** 557 * iucv_setmask_up 558 * 559 * Allow iucv interrupts on a single cpu. 560 */ 561 static void iucv_setmask_up(void) 562 { 563 cpumask_t cpumask; 564 int cpu; 565 566 /* Disable all cpu but the first in cpu_irq_cpumask. */ 567 cpumask_copy(&cpumask, &iucv_irq_cpumask); 568 cpumask_clear_cpu(cpumask_first(&iucv_irq_cpumask), &cpumask); 569 for_each_cpu(cpu, &cpumask) 570 smp_call_function_single(cpu, iucv_block_cpu, NULL, 1); 571 } 572 573 /** 574 * iucv_enable 575 * 576 * This function makes iucv ready for use. It allocates the pathid 577 * table, declares an iucv interrupt buffer and enables the iucv 578 * interrupts. Called when the first user has registered an iucv 579 * handler. 580 */ 581 static int iucv_enable(void) 582 { 583 size_t alloc_size; 584 int cpu, rc; 585 586 get_online_cpus(); 587 rc = -ENOMEM; 588 alloc_size = iucv_max_pathid * sizeof(struct iucv_path); 589 iucv_path_table = kzalloc(alloc_size, GFP_KERNEL); 590 if (!iucv_path_table) 591 goto out; 592 /* Declare per cpu buffers. */ 593 rc = -EIO; 594 for_each_online_cpu(cpu) 595 smp_call_function_single(cpu, iucv_declare_cpu, NULL, 1); 596 if (cpumask_empty(&iucv_buffer_cpumask)) 597 /* No cpu could declare an iucv buffer. */ 598 goto out; 599 put_online_cpus(); 600 return 0; 601 out: 602 kfree(iucv_path_table); 603 iucv_path_table = NULL; 604 put_online_cpus(); 605 return rc; 606 } 607 608 /** 609 * iucv_disable 610 * 611 * This function shuts down iucv. It disables iucv interrupts, retrieves 612 * the iucv interrupt buffer and frees the pathid table. Called after the 613 * last user unregister its iucv handler. 614 */ 615 static void iucv_disable(void) 616 { 617 get_online_cpus(); 618 on_each_cpu(iucv_retrieve_cpu, NULL, 1); 619 kfree(iucv_path_table); 620 iucv_path_table = NULL; 621 put_online_cpus(); 622 } 623 624 static int iucv_cpu_notify(struct notifier_block *self, 625 unsigned long action, void *hcpu) 626 { 627 cpumask_t cpumask; 628 long cpu = (long) hcpu; 629 630 switch (action) { 631 case CPU_UP_PREPARE: 632 case CPU_UP_PREPARE_FROZEN: 633 iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data), 634 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu)); 635 if (!iucv_irq_data[cpu]) 636 return notifier_from_errno(-ENOMEM); 637 638 iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param), 639 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu)); 640 if (!iucv_param[cpu]) { 641 kfree(iucv_irq_data[cpu]); 642 iucv_irq_data[cpu] = NULL; 643 return notifier_from_errno(-ENOMEM); 644 } 645 iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param), 646 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu)); 647 if (!iucv_param_irq[cpu]) { 648 kfree(iucv_param[cpu]); 649 iucv_param[cpu] = NULL; 650 kfree(iucv_irq_data[cpu]); 651 iucv_irq_data[cpu] = NULL; 652 return notifier_from_errno(-ENOMEM); 653 } 654 break; 655 case CPU_UP_CANCELED: 656 case CPU_UP_CANCELED_FROZEN: 657 case CPU_DEAD: 658 case CPU_DEAD_FROZEN: 659 kfree(iucv_param_irq[cpu]); 660 iucv_param_irq[cpu] = NULL; 661 kfree(iucv_param[cpu]); 662 iucv_param[cpu] = NULL; 663 kfree(iucv_irq_data[cpu]); 664 iucv_irq_data[cpu] = NULL; 665 break; 666 case CPU_ONLINE: 667 case CPU_ONLINE_FROZEN: 668 case CPU_DOWN_FAILED: 669 case CPU_DOWN_FAILED_FROZEN: 670 if (!iucv_path_table) 671 break; 672 smp_call_function_single(cpu, iucv_declare_cpu, NULL, 1); 673 break; 674 case CPU_DOWN_PREPARE: 675 case CPU_DOWN_PREPARE_FROZEN: 676 if (!iucv_path_table) 677 break; 678 cpumask_copy(&cpumask, &iucv_buffer_cpumask); 679 cpumask_clear_cpu(cpu, &cpumask); 680 if (cpumask_empty(&cpumask)) 681 /* Can't offline last IUCV enabled cpu. */ 682 return notifier_from_errno(-EINVAL); 683 smp_call_function_single(cpu, iucv_retrieve_cpu, NULL, 1); 684 if (cpumask_empty(&iucv_irq_cpumask)) 685 smp_call_function_single( 686 cpumask_first(&iucv_buffer_cpumask), 687 iucv_allow_cpu, NULL, 1); 688 break; 689 } 690 return NOTIFY_OK; 691 } 692 693 static struct notifier_block __refdata iucv_cpu_notifier = { 694 .notifier_call = iucv_cpu_notify, 695 }; 696 697 /** 698 * iucv_sever_pathid 699 * @pathid: path identification number. 700 * @userdata: 16-bytes of user data. 701 * 702 * Sever an iucv path to free up the pathid. Used internally. 703 */ 704 static int iucv_sever_pathid(u16 pathid, u8 userdata[16]) 705 { 706 union iucv_param *parm; 707 708 parm = iucv_param_irq[smp_processor_id()]; 709 memset(parm, 0, sizeof(union iucv_param)); 710 if (userdata) 711 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser)); 712 parm->ctrl.ippathid = pathid; 713 return iucv_call_b2f0(IUCV_SEVER, parm); 714 } 715 716 /** 717 * __iucv_cleanup_queue 718 * @dummy: unused dummy argument 719 * 720 * Nop function called via smp_call_function to force work items from 721 * pending external iucv interrupts to the work queue. 722 */ 723 static void __iucv_cleanup_queue(void *dummy) 724 { 725 } 726 727 /** 728 * iucv_cleanup_queue 729 * 730 * Function called after a path has been severed to find all remaining 731 * work items for the now stale pathid. The caller needs to hold the 732 * iucv_table_lock. 733 */ 734 static void iucv_cleanup_queue(void) 735 { 736 struct iucv_irq_list *p, *n; 737 738 /* 739 * When a path is severed, the pathid can be reused immediately 740 * on a iucv connect or a connection pending interrupt. Remove 741 * all entries from the task queue that refer to a stale pathid 742 * (iucv_path_table[ix] == NULL). Only then do the iucv connect 743 * or deliver the connection pending interrupt. To get all the 744 * pending interrupts force them to the work queue by calling 745 * an empty function on all cpus. 746 */ 747 smp_call_function(__iucv_cleanup_queue, NULL, 1); 748 spin_lock_irq(&iucv_queue_lock); 749 list_for_each_entry_safe(p, n, &iucv_task_queue, list) { 750 /* Remove stale work items from the task queue. */ 751 if (iucv_path_table[p->data.ippathid] == NULL) { 752 list_del(&p->list); 753 kfree(p); 754 } 755 } 756 spin_unlock_irq(&iucv_queue_lock); 757 } 758 759 /** 760 * iucv_register: 761 * @handler: address of iucv handler structure 762 * @smp: != 0 indicates that the handler can deal with out of order messages 763 * 764 * Registers a driver with IUCV. 765 * 766 * Returns 0 on success, -ENOMEM if the memory allocation for the pathid 767 * table failed, or -EIO if IUCV_DECLARE_BUFFER failed on all cpus. 768 */ 769 int iucv_register(struct iucv_handler *handler, int smp) 770 { 771 int rc; 772 773 if (!iucv_available) 774 return -ENOSYS; 775 mutex_lock(&iucv_register_mutex); 776 if (!smp) 777 iucv_nonsmp_handler++; 778 if (list_empty(&iucv_handler_list)) { 779 rc = iucv_enable(); 780 if (rc) 781 goto out_mutex; 782 } else if (!smp && iucv_nonsmp_handler == 1) 783 iucv_setmask_up(); 784 INIT_LIST_HEAD(&handler->paths); 785 786 spin_lock_bh(&iucv_table_lock); 787 list_add_tail(&handler->list, &iucv_handler_list); 788 spin_unlock_bh(&iucv_table_lock); 789 rc = 0; 790 out_mutex: 791 mutex_unlock(&iucv_register_mutex); 792 return rc; 793 } 794 EXPORT_SYMBOL(iucv_register); 795 796 /** 797 * iucv_unregister 798 * @handler: address of iucv handler structure 799 * @smp: != 0 indicates that the handler can deal with out of order messages 800 * 801 * Unregister driver from IUCV. 802 */ 803 void iucv_unregister(struct iucv_handler *handler, int smp) 804 { 805 struct iucv_path *p, *n; 806 807 mutex_lock(&iucv_register_mutex); 808 spin_lock_bh(&iucv_table_lock); 809 /* Remove handler from the iucv_handler_list. */ 810 list_del_init(&handler->list); 811 /* Sever all pathids still referring to the handler. */ 812 list_for_each_entry_safe(p, n, &handler->paths, list) { 813 iucv_sever_pathid(p->pathid, NULL); 814 iucv_path_table[p->pathid] = NULL; 815 list_del(&p->list); 816 iucv_path_free(p); 817 } 818 spin_unlock_bh(&iucv_table_lock); 819 if (!smp) 820 iucv_nonsmp_handler--; 821 if (list_empty(&iucv_handler_list)) 822 iucv_disable(); 823 else if (!smp && iucv_nonsmp_handler == 0) 824 iucv_setmask_mp(); 825 mutex_unlock(&iucv_register_mutex); 826 } 827 EXPORT_SYMBOL(iucv_unregister); 828 829 static int iucv_reboot_event(struct notifier_block *this, 830 unsigned long event, void *ptr) 831 { 832 int i; 833 834 if (cpumask_empty(&iucv_irq_cpumask)) 835 return NOTIFY_DONE; 836 837 get_online_cpus(); 838 on_each_cpu_mask(&iucv_irq_cpumask, iucv_block_cpu, NULL, 1); 839 preempt_disable(); 840 for (i = 0; i < iucv_max_pathid; i++) { 841 if (iucv_path_table[i]) 842 iucv_sever_pathid(i, NULL); 843 } 844 preempt_enable(); 845 put_online_cpus(); 846 iucv_disable(); 847 return NOTIFY_DONE; 848 } 849 850 static struct notifier_block iucv_reboot_notifier = { 851 .notifier_call = iucv_reboot_event, 852 }; 853 854 /** 855 * iucv_path_accept 856 * @path: address of iucv path structure 857 * @handler: address of iucv handler structure 858 * @userdata: 16 bytes of data reflected to the communication partner 859 * @private: private data passed to interrupt handlers for this path 860 * 861 * This function is issued after the user received a connection pending 862 * external interrupt and now wishes to complete the IUCV communication path. 863 * 864 * Returns the result of the CP IUCV call. 865 */ 866 int iucv_path_accept(struct iucv_path *path, struct iucv_handler *handler, 867 u8 userdata[16], void *private) 868 { 869 union iucv_param *parm; 870 int rc; 871 872 local_bh_disable(); 873 if (cpumask_empty(&iucv_buffer_cpumask)) { 874 rc = -EIO; 875 goto out; 876 } 877 /* Prepare parameter block. */ 878 parm = iucv_param[smp_processor_id()]; 879 memset(parm, 0, sizeof(union iucv_param)); 880 parm->ctrl.ippathid = path->pathid; 881 parm->ctrl.ipmsglim = path->msglim; 882 if (userdata) 883 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser)); 884 parm->ctrl.ipflags1 = path->flags; 885 886 rc = iucv_call_b2f0(IUCV_ACCEPT, parm); 887 if (!rc) { 888 path->private = private; 889 path->msglim = parm->ctrl.ipmsglim; 890 path->flags = parm->ctrl.ipflags1; 891 } 892 out: 893 local_bh_enable(); 894 return rc; 895 } 896 EXPORT_SYMBOL(iucv_path_accept); 897 898 /** 899 * iucv_path_connect 900 * @path: address of iucv path structure 901 * @handler: address of iucv handler structure 902 * @userid: 8-byte user identification 903 * @system: 8-byte target system identification 904 * @userdata: 16 bytes of data reflected to the communication partner 905 * @private: private data passed to interrupt handlers for this path 906 * 907 * This function establishes an IUCV path. Although the connect may complete 908 * successfully, you are not able to use the path until you receive an IUCV 909 * Connection Complete external interrupt. 910 * 911 * Returns the result of the CP IUCV call. 912 */ 913 int iucv_path_connect(struct iucv_path *path, struct iucv_handler *handler, 914 u8 userid[8], u8 system[8], u8 userdata[16], 915 void *private) 916 { 917 union iucv_param *parm; 918 int rc; 919 920 spin_lock_bh(&iucv_table_lock); 921 iucv_cleanup_queue(); 922 if (cpumask_empty(&iucv_buffer_cpumask)) { 923 rc = -EIO; 924 goto out; 925 } 926 parm = iucv_param[smp_processor_id()]; 927 memset(parm, 0, sizeof(union iucv_param)); 928 parm->ctrl.ipmsglim = path->msglim; 929 parm->ctrl.ipflags1 = path->flags; 930 if (userid) { 931 memcpy(parm->ctrl.ipvmid, userid, sizeof(parm->ctrl.ipvmid)); 932 ASCEBC(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid)); 933 EBC_TOUPPER(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid)); 934 } 935 if (system) { 936 memcpy(parm->ctrl.iptarget, system, 937 sizeof(parm->ctrl.iptarget)); 938 ASCEBC(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget)); 939 EBC_TOUPPER(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget)); 940 } 941 if (userdata) 942 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser)); 943 944 rc = iucv_call_b2f0(IUCV_CONNECT, parm); 945 if (!rc) { 946 if (parm->ctrl.ippathid < iucv_max_pathid) { 947 path->pathid = parm->ctrl.ippathid; 948 path->msglim = parm->ctrl.ipmsglim; 949 path->flags = parm->ctrl.ipflags1; 950 path->handler = handler; 951 path->private = private; 952 list_add_tail(&path->list, &handler->paths); 953 iucv_path_table[path->pathid] = path; 954 } else { 955 iucv_sever_pathid(parm->ctrl.ippathid, 956 iucv_error_pathid); 957 rc = -EIO; 958 } 959 } 960 out: 961 spin_unlock_bh(&iucv_table_lock); 962 return rc; 963 } 964 EXPORT_SYMBOL(iucv_path_connect); 965 966 /** 967 * iucv_path_quiesce: 968 * @path: address of iucv path structure 969 * @userdata: 16 bytes of data reflected to the communication partner 970 * 971 * This function temporarily suspends incoming messages on an IUCV path. 972 * You can later reactivate the path by invoking the iucv_resume function. 973 * 974 * Returns the result from the CP IUCV call. 975 */ 976 int iucv_path_quiesce(struct iucv_path *path, u8 userdata[16]) 977 { 978 union iucv_param *parm; 979 int rc; 980 981 local_bh_disable(); 982 if (cpumask_empty(&iucv_buffer_cpumask)) { 983 rc = -EIO; 984 goto out; 985 } 986 parm = iucv_param[smp_processor_id()]; 987 memset(parm, 0, sizeof(union iucv_param)); 988 if (userdata) 989 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser)); 990 parm->ctrl.ippathid = path->pathid; 991 rc = iucv_call_b2f0(IUCV_QUIESCE, parm); 992 out: 993 local_bh_enable(); 994 return rc; 995 } 996 EXPORT_SYMBOL(iucv_path_quiesce); 997 998 /** 999 * iucv_path_resume: 1000 * @path: address of iucv path structure 1001 * @userdata: 16 bytes of data reflected to the communication partner 1002 * 1003 * This function resumes incoming messages on an IUCV path that has 1004 * been stopped with iucv_path_quiesce. 1005 * 1006 * Returns the result from the CP IUCV call. 1007 */ 1008 int iucv_path_resume(struct iucv_path *path, u8 userdata[16]) 1009 { 1010 union iucv_param *parm; 1011 int rc; 1012 1013 local_bh_disable(); 1014 if (cpumask_empty(&iucv_buffer_cpumask)) { 1015 rc = -EIO; 1016 goto out; 1017 } 1018 parm = iucv_param[smp_processor_id()]; 1019 memset(parm, 0, sizeof(union iucv_param)); 1020 if (userdata) 1021 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser)); 1022 parm->ctrl.ippathid = path->pathid; 1023 rc = iucv_call_b2f0(IUCV_RESUME, parm); 1024 out: 1025 local_bh_enable(); 1026 return rc; 1027 } 1028 1029 /** 1030 * iucv_path_sever 1031 * @path: address of iucv path structure 1032 * @userdata: 16 bytes of data reflected to the communication partner 1033 * 1034 * This function terminates an IUCV path. 1035 * 1036 * Returns the result from the CP IUCV call. 1037 */ 1038 int iucv_path_sever(struct iucv_path *path, u8 userdata[16]) 1039 { 1040 int rc; 1041 1042 preempt_disable(); 1043 if (cpumask_empty(&iucv_buffer_cpumask)) { 1044 rc = -EIO; 1045 goto out; 1046 } 1047 if (iucv_active_cpu != smp_processor_id()) 1048 spin_lock_bh(&iucv_table_lock); 1049 rc = iucv_sever_pathid(path->pathid, userdata); 1050 iucv_path_table[path->pathid] = NULL; 1051 list_del_init(&path->list); 1052 if (iucv_active_cpu != smp_processor_id()) 1053 spin_unlock_bh(&iucv_table_lock); 1054 out: 1055 preempt_enable(); 1056 return rc; 1057 } 1058 EXPORT_SYMBOL(iucv_path_sever); 1059 1060 /** 1061 * iucv_message_purge 1062 * @path: address of iucv path structure 1063 * @msg: address of iucv msg structure 1064 * @srccls: source class of message 1065 * 1066 * Cancels a message you have sent. 1067 * 1068 * Returns the result from the CP IUCV call. 1069 */ 1070 int iucv_message_purge(struct iucv_path *path, struct iucv_message *msg, 1071 u32 srccls) 1072 { 1073 union iucv_param *parm; 1074 int rc; 1075 1076 local_bh_disable(); 1077 if (cpumask_empty(&iucv_buffer_cpumask)) { 1078 rc = -EIO; 1079 goto out; 1080 } 1081 parm = iucv_param[smp_processor_id()]; 1082 memset(parm, 0, sizeof(union iucv_param)); 1083 parm->purge.ippathid = path->pathid; 1084 parm->purge.ipmsgid = msg->id; 1085 parm->purge.ipsrccls = srccls; 1086 parm->purge.ipflags1 = IUCV_IPSRCCLS | IUCV_IPFGMID | IUCV_IPFGPID; 1087 rc = iucv_call_b2f0(IUCV_PURGE, parm); 1088 if (!rc) { 1089 msg->audit = (*(u32 *) &parm->purge.ipaudit) >> 8; 1090 msg->tag = parm->purge.ipmsgtag; 1091 } 1092 out: 1093 local_bh_enable(); 1094 return rc; 1095 } 1096 EXPORT_SYMBOL(iucv_message_purge); 1097 1098 /** 1099 * iucv_message_receive_iprmdata 1100 * @path: address of iucv path structure 1101 * @msg: address of iucv msg structure 1102 * @flags: how the message is received (IUCV_IPBUFLST) 1103 * @buffer: address of data buffer or address of struct iucv_array 1104 * @size: length of data buffer 1105 * @residual: 1106 * 1107 * Internal function used by iucv_message_receive and __iucv_message_receive 1108 * to receive RMDATA data stored in struct iucv_message. 1109 */ 1110 static int iucv_message_receive_iprmdata(struct iucv_path *path, 1111 struct iucv_message *msg, 1112 u8 flags, void *buffer, 1113 size_t size, size_t *residual) 1114 { 1115 struct iucv_array *array; 1116 u8 *rmmsg; 1117 size_t copy; 1118 1119 /* 1120 * Message is 8 bytes long and has been stored to the 1121 * message descriptor itself. 1122 */ 1123 if (residual) 1124 *residual = abs(size - 8); 1125 rmmsg = msg->rmmsg; 1126 if (flags & IUCV_IPBUFLST) { 1127 /* Copy to struct iucv_array. */ 1128 size = (size < 8) ? size : 8; 1129 for (array = buffer; size > 0; array++) { 1130 copy = min_t(size_t, size, array->length); 1131 memcpy((u8 *)(addr_t) array->address, 1132 rmmsg, copy); 1133 rmmsg += copy; 1134 size -= copy; 1135 } 1136 } else { 1137 /* Copy to direct buffer. */ 1138 memcpy(buffer, rmmsg, min_t(size_t, size, 8)); 1139 } 1140 return 0; 1141 } 1142 1143 /** 1144 * __iucv_message_receive 1145 * @path: address of iucv path structure 1146 * @msg: address of iucv msg structure 1147 * @flags: how the message is received (IUCV_IPBUFLST) 1148 * @buffer: address of data buffer or address of struct iucv_array 1149 * @size: length of data buffer 1150 * @residual: 1151 * 1152 * This function receives messages that are being sent to you over 1153 * established paths. This function will deal with RMDATA messages 1154 * embedded in struct iucv_message as well. 1155 * 1156 * Locking: no locking 1157 * 1158 * Returns the result from the CP IUCV call. 1159 */ 1160 int __iucv_message_receive(struct iucv_path *path, struct iucv_message *msg, 1161 u8 flags, void *buffer, size_t size, size_t *residual) 1162 { 1163 union iucv_param *parm; 1164 int rc; 1165 1166 if (msg->flags & IUCV_IPRMDATA) 1167 return iucv_message_receive_iprmdata(path, msg, flags, 1168 buffer, size, residual); 1169 if (cpumask_empty(&iucv_buffer_cpumask)) { 1170 rc = -EIO; 1171 goto out; 1172 } 1173 parm = iucv_param[smp_processor_id()]; 1174 memset(parm, 0, sizeof(union iucv_param)); 1175 parm->db.ipbfadr1 = (u32)(addr_t) buffer; 1176 parm->db.ipbfln1f = (u32) size; 1177 parm->db.ipmsgid = msg->id; 1178 parm->db.ippathid = path->pathid; 1179 parm->db.iptrgcls = msg->class; 1180 parm->db.ipflags1 = (flags | IUCV_IPFGPID | 1181 IUCV_IPFGMID | IUCV_IPTRGCLS); 1182 rc = iucv_call_b2f0(IUCV_RECEIVE, parm); 1183 if (!rc || rc == 5) { 1184 msg->flags = parm->db.ipflags1; 1185 if (residual) 1186 *residual = parm->db.ipbfln1f; 1187 } 1188 out: 1189 return rc; 1190 } 1191 EXPORT_SYMBOL(__iucv_message_receive); 1192 1193 /** 1194 * iucv_message_receive 1195 * @path: address of iucv path structure 1196 * @msg: address of iucv msg structure 1197 * @flags: how the message is received (IUCV_IPBUFLST) 1198 * @buffer: address of data buffer or address of struct iucv_array 1199 * @size: length of data buffer 1200 * @residual: 1201 * 1202 * This function receives messages that are being sent to you over 1203 * established paths. This function will deal with RMDATA messages 1204 * embedded in struct iucv_message as well. 1205 * 1206 * Locking: local_bh_enable/local_bh_disable 1207 * 1208 * Returns the result from the CP IUCV call. 1209 */ 1210 int iucv_message_receive(struct iucv_path *path, struct iucv_message *msg, 1211 u8 flags, void *buffer, size_t size, size_t *residual) 1212 { 1213 int rc; 1214 1215 if (msg->flags & IUCV_IPRMDATA) 1216 return iucv_message_receive_iprmdata(path, msg, flags, 1217 buffer, size, residual); 1218 local_bh_disable(); 1219 rc = __iucv_message_receive(path, msg, flags, buffer, size, residual); 1220 local_bh_enable(); 1221 return rc; 1222 } 1223 EXPORT_SYMBOL(iucv_message_receive); 1224 1225 /** 1226 * iucv_message_reject 1227 * @path: address of iucv path structure 1228 * @msg: address of iucv msg structure 1229 * 1230 * The reject function refuses a specified message. Between the time you 1231 * are notified of a message and the time that you complete the message, 1232 * the message may be rejected. 1233 * 1234 * Returns the result from the CP IUCV call. 1235 */ 1236 int iucv_message_reject(struct iucv_path *path, struct iucv_message *msg) 1237 { 1238 union iucv_param *parm; 1239 int rc; 1240 1241 local_bh_disable(); 1242 if (cpumask_empty(&iucv_buffer_cpumask)) { 1243 rc = -EIO; 1244 goto out; 1245 } 1246 parm = iucv_param[smp_processor_id()]; 1247 memset(parm, 0, sizeof(union iucv_param)); 1248 parm->db.ippathid = path->pathid; 1249 parm->db.ipmsgid = msg->id; 1250 parm->db.iptrgcls = msg->class; 1251 parm->db.ipflags1 = (IUCV_IPTRGCLS | IUCV_IPFGMID | IUCV_IPFGPID); 1252 rc = iucv_call_b2f0(IUCV_REJECT, parm); 1253 out: 1254 local_bh_enable(); 1255 return rc; 1256 } 1257 EXPORT_SYMBOL(iucv_message_reject); 1258 1259 /** 1260 * iucv_message_reply 1261 * @path: address of iucv path structure 1262 * @msg: address of iucv msg structure 1263 * @flags: how the reply is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST) 1264 * @reply: address of reply data buffer or address of struct iucv_array 1265 * @size: length of reply data buffer 1266 * 1267 * This function responds to the two-way messages that you receive. You 1268 * must identify completely the message to which you wish to reply. ie, 1269 * pathid, msgid, and trgcls. Prmmsg signifies the data is moved into 1270 * the parameter list. 1271 * 1272 * Returns the result from the CP IUCV call. 1273 */ 1274 int iucv_message_reply(struct iucv_path *path, struct iucv_message *msg, 1275 u8 flags, void *reply, size_t size) 1276 { 1277 union iucv_param *parm; 1278 int rc; 1279 1280 local_bh_disable(); 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 parm->dpl.ippathid = path->pathid; 1289 parm->dpl.ipflags1 = flags; 1290 parm->dpl.ipmsgid = msg->id; 1291 parm->dpl.iptrgcls = msg->class; 1292 memcpy(parm->dpl.iprmmsg, reply, min_t(size_t, size, 8)); 1293 } else { 1294 parm->db.ipbfadr1 = (u32)(addr_t) reply; 1295 parm->db.ipbfln1f = (u32) size; 1296 parm->db.ippathid = path->pathid; 1297 parm->db.ipflags1 = flags; 1298 parm->db.ipmsgid = msg->id; 1299 parm->db.iptrgcls = msg->class; 1300 } 1301 rc = iucv_call_b2f0(IUCV_REPLY, parm); 1302 out: 1303 local_bh_enable(); 1304 return rc; 1305 } 1306 EXPORT_SYMBOL(iucv_message_reply); 1307 1308 /** 1309 * __iucv_message_send 1310 * @path: address of iucv path structure 1311 * @msg: address of iucv msg structure 1312 * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST) 1313 * @srccls: source class of message 1314 * @buffer: address of send buffer or address of struct iucv_array 1315 * @size: length of send buffer 1316 * 1317 * This function transmits data to another application. Data to be 1318 * transmitted is in a buffer and this is a one-way message and the 1319 * receiver will not reply to the message. 1320 * 1321 * Locking: no locking 1322 * 1323 * Returns the result from the CP IUCV call. 1324 */ 1325 int __iucv_message_send(struct iucv_path *path, struct iucv_message *msg, 1326 u8 flags, u32 srccls, void *buffer, size_t size) 1327 { 1328 union iucv_param *parm; 1329 int rc; 1330 1331 if (cpumask_empty(&iucv_buffer_cpumask)) { 1332 rc = -EIO; 1333 goto out; 1334 } 1335 parm = iucv_param[smp_processor_id()]; 1336 memset(parm, 0, sizeof(union iucv_param)); 1337 if (flags & IUCV_IPRMDATA) { 1338 /* Message of 8 bytes can be placed into the parameter list. */ 1339 parm->dpl.ippathid = path->pathid; 1340 parm->dpl.ipflags1 = flags | IUCV_IPNORPY; 1341 parm->dpl.iptrgcls = msg->class; 1342 parm->dpl.ipsrccls = srccls; 1343 parm->dpl.ipmsgtag = msg->tag; 1344 memcpy(parm->dpl.iprmmsg, buffer, 8); 1345 } else { 1346 parm->db.ipbfadr1 = (u32)(addr_t) buffer; 1347 parm->db.ipbfln1f = (u32) size; 1348 parm->db.ippathid = path->pathid; 1349 parm->db.ipflags1 = flags | IUCV_IPNORPY; 1350 parm->db.iptrgcls = msg->class; 1351 parm->db.ipsrccls = srccls; 1352 parm->db.ipmsgtag = msg->tag; 1353 } 1354 rc = iucv_call_b2f0(IUCV_SEND, parm); 1355 if (!rc) 1356 msg->id = parm->db.ipmsgid; 1357 out: 1358 return rc; 1359 } 1360 EXPORT_SYMBOL(__iucv_message_send); 1361 1362 /** 1363 * iucv_message_send 1364 * @path: address of iucv path structure 1365 * @msg: address of iucv msg structure 1366 * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST) 1367 * @srccls: source class of message 1368 * @buffer: address of send buffer or address of struct iucv_array 1369 * @size: length of send buffer 1370 * 1371 * This function transmits data to another application. Data to be 1372 * transmitted is in a buffer and this is a one-way message and the 1373 * receiver will not reply to the message. 1374 * 1375 * Locking: local_bh_enable/local_bh_disable 1376 * 1377 * Returns the result from the CP IUCV call. 1378 */ 1379 int iucv_message_send(struct iucv_path *path, struct iucv_message *msg, 1380 u8 flags, u32 srccls, void *buffer, size_t size) 1381 { 1382 int rc; 1383 1384 local_bh_disable(); 1385 rc = __iucv_message_send(path, msg, flags, srccls, buffer, size); 1386 local_bh_enable(); 1387 return rc; 1388 } 1389 EXPORT_SYMBOL(iucv_message_send); 1390 1391 /** 1392 * iucv_message_send2way 1393 * @path: address of iucv path structure 1394 * @msg: address of iucv msg structure 1395 * @flags: how the message is sent and the reply is received 1396 * (IUCV_IPRMDATA, IUCV_IPBUFLST, IUCV_IPPRTY, IUCV_ANSLST) 1397 * @srccls: source class of message 1398 * @buffer: address of send buffer or address of struct iucv_array 1399 * @size: length of send buffer 1400 * @ansbuf: address of answer buffer or address of struct iucv_array 1401 * @asize: size of reply buffer 1402 * 1403 * This function transmits data to another application. Data to be 1404 * transmitted is in a buffer. The receiver of the send is expected to 1405 * reply to the message and a buffer is provided into which IUCV moves 1406 * the reply to this message. 1407 * 1408 * Returns the result from the CP IUCV call. 1409 */ 1410 int iucv_message_send2way(struct iucv_path *path, struct iucv_message *msg, 1411 u8 flags, u32 srccls, void *buffer, size_t size, 1412 void *answer, size_t asize, size_t *residual) 1413 { 1414 union iucv_param *parm; 1415 int rc; 1416 1417 local_bh_disable(); 1418 if (cpumask_empty(&iucv_buffer_cpumask)) { 1419 rc = -EIO; 1420 goto out; 1421 } 1422 parm = iucv_param[smp_processor_id()]; 1423 memset(parm, 0, sizeof(union iucv_param)); 1424 if (flags & IUCV_IPRMDATA) { 1425 parm->dpl.ippathid = path->pathid; 1426 parm->dpl.ipflags1 = path->flags; /* priority message */ 1427 parm->dpl.iptrgcls = msg->class; 1428 parm->dpl.ipsrccls = srccls; 1429 parm->dpl.ipmsgtag = msg->tag; 1430 parm->dpl.ipbfadr2 = (u32)(addr_t) answer; 1431 parm->dpl.ipbfln2f = (u32) asize; 1432 memcpy(parm->dpl.iprmmsg, buffer, 8); 1433 } else { 1434 parm->db.ippathid = path->pathid; 1435 parm->db.ipflags1 = path->flags; /* priority message */ 1436 parm->db.iptrgcls = msg->class; 1437 parm->db.ipsrccls = srccls; 1438 parm->db.ipmsgtag = msg->tag; 1439 parm->db.ipbfadr1 = (u32)(addr_t) buffer; 1440 parm->db.ipbfln1f = (u32) size; 1441 parm->db.ipbfadr2 = (u32)(addr_t) answer; 1442 parm->db.ipbfln2f = (u32) asize; 1443 } 1444 rc = iucv_call_b2f0(IUCV_SEND, parm); 1445 if (!rc) 1446 msg->id = parm->db.ipmsgid; 1447 out: 1448 local_bh_enable(); 1449 return rc; 1450 } 1451 EXPORT_SYMBOL(iucv_message_send2way); 1452 1453 /** 1454 * iucv_path_pending 1455 * @data: Pointer to external interrupt buffer 1456 * 1457 * Process connection pending work item. Called from tasklet while holding 1458 * iucv_table_lock. 1459 */ 1460 struct iucv_path_pending { 1461 u16 ippathid; 1462 u8 ipflags1; 1463 u8 iptype; 1464 u16 ipmsglim; 1465 u16 res1; 1466 u8 ipvmid[8]; 1467 u8 ipuser[16]; 1468 u32 res3; 1469 u8 ippollfg; 1470 u8 res4[3]; 1471 } __packed; 1472 1473 static void iucv_path_pending(struct iucv_irq_data *data) 1474 { 1475 struct iucv_path_pending *ipp = (void *) data; 1476 struct iucv_handler *handler; 1477 struct iucv_path *path; 1478 char *error; 1479 1480 BUG_ON(iucv_path_table[ipp->ippathid]); 1481 /* New pathid, handler found. Create a new path struct. */ 1482 error = iucv_error_no_memory; 1483 path = iucv_path_alloc(ipp->ipmsglim, ipp->ipflags1, GFP_ATOMIC); 1484 if (!path) 1485 goto out_sever; 1486 path->pathid = ipp->ippathid; 1487 iucv_path_table[path->pathid] = path; 1488 EBCASC(ipp->ipvmid, 8); 1489 1490 /* Call registered handler until one is found that wants the path. */ 1491 list_for_each_entry(handler, &iucv_handler_list, list) { 1492 if (!handler->path_pending) 1493 continue; 1494 /* 1495 * Add path to handler to allow a call to iucv_path_sever 1496 * inside the path_pending function. If the handler returns 1497 * an error remove the path from the handler again. 1498 */ 1499 list_add(&path->list, &handler->paths); 1500 path->handler = handler; 1501 if (!handler->path_pending(path, ipp->ipvmid, ipp->ipuser)) 1502 return; 1503 list_del(&path->list); 1504 path->handler = NULL; 1505 } 1506 /* No handler wanted the path. */ 1507 iucv_path_table[path->pathid] = NULL; 1508 iucv_path_free(path); 1509 error = iucv_error_no_listener; 1510 out_sever: 1511 iucv_sever_pathid(ipp->ippathid, error); 1512 } 1513 1514 /** 1515 * iucv_path_complete 1516 * @data: Pointer to external interrupt buffer 1517 * 1518 * Process connection complete work item. Called from tasklet while holding 1519 * iucv_table_lock. 1520 */ 1521 struct iucv_path_complete { 1522 u16 ippathid; 1523 u8 ipflags1; 1524 u8 iptype; 1525 u16 ipmsglim; 1526 u16 res1; 1527 u8 res2[8]; 1528 u8 ipuser[16]; 1529 u32 res3; 1530 u8 ippollfg; 1531 u8 res4[3]; 1532 } __packed; 1533 1534 static void iucv_path_complete(struct iucv_irq_data *data) 1535 { 1536 struct iucv_path_complete *ipc = (void *) data; 1537 struct iucv_path *path = iucv_path_table[ipc->ippathid]; 1538 1539 if (path) 1540 path->flags = ipc->ipflags1; 1541 if (path && path->handler && path->handler->path_complete) 1542 path->handler->path_complete(path, ipc->ipuser); 1543 } 1544 1545 /** 1546 * iucv_path_severed 1547 * @data: Pointer to external interrupt buffer 1548 * 1549 * Process connection severed work item. Called from tasklet while holding 1550 * iucv_table_lock. 1551 */ 1552 struct iucv_path_severed { 1553 u16 ippathid; 1554 u8 res1; 1555 u8 iptype; 1556 u32 res2; 1557 u8 res3[8]; 1558 u8 ipuser[16]; 1559 u32 res4; 1560 u8 ippollfg; 1561 u8 res5[3]; 1562 } __packed; 1563 1564 static void iucv_path_severed(struct iucv_irq_data *data) 1565 { 1566 struct iucv_path_severed *ips = (void *) data; 1567 struct iucv_path *path = iucv_path_table[ips->ippathid]; 1568 1569 if (!path || !path->handler) /* Already severed */ 1570 return; 1571 if (path->handler->path_severed) 1572 path->handler->path_severed(path, ips->ipuser); 1573 else { 1574 iucv_sever_pathid(path->pathid, NULL); 1575 iucv_path_table[path->pathid] = NULL; 1576 list_del(&path->list); 1577 iucv_path_free(path); 1578 } 1579 } 1580 1581 /** 1582 * iucv_path_quiesced 1583 * @data: Pointer to external interrupt buffer 1584 * 1585 * Process connection quiesced work item. Called from tasklet while holding 1586 * iucv_table_lock. 1587 */ 1588 struct iucv_path_quiesced { 1589 u16 ippathid; 1590 u8 res1; 1591 u8 iptype; 1592 u32 res2; 1593 u8 res3[8]; 1594 u8 ipuser[16]; 1595 u32 res4; 1596 u8 ippollfg; 1597 u8 res5[3]; 1598 } __packed; 1599 1600 static void iucv_path_quiesced(struct iucv_irq_data *data) 1601 { 1602 struct iucv_path_quiesced *ipq = (void *) data; 1603 struct iucv_path *path = iucv_path_table[ipq->ippathid]; 1604 1605 if (path && path->handler && path->handler->path_quiesced) 1606 path->handler->path_quiesced(path, ipq->ipuser); 1607 } 1608 1609 /** 1610 * iucv_path_resumed 1611 * @data: Pointer to external interrupt buffer 1612 * 1613 * Process connection resumed work item. Called from tasklet while holding 1614 * iucv_table_lock. 1615 */ 1616 struct iucv_path_resumed { 1617 u16 ippathid; 1618 u8 res1; 1619 u8 iptype; 1620 u32 res2; 1621 u8 res3[8]; 1622 u8 ipuser[16]; 1623 u32 res4; 1624 u8 ippollfg; 1625 u8 res5[3]; 1626 } __packed; 1627 1628 static void iucv_path_resumed(struct iucv_irq_data *data) 1629 { 1630 struct iucv_path_resumed *ipr = (void *) data; 1631 struct iucv_path *path = iucv_path_table[ipr->ippathid]; 1632 1633 if (path && path->handler && path->handler->path_resumed) 1634 path->handler->path_resumed(path, ipr->ipuser); 1635 } 1636 1637 /** 1638 * iucv_message_complete 1639 * @data: Pointer to external interrupt buffer 1640 * 1641 * Process message complete work item. Called from tasklet while holding 1642 * iucv_table_lock. 1643 */ 1644 struct iucv_message_complete { 1645 u16 ippathid; 1646 u8 ipflags1; 1647 u8 iptype; 1648 u32 ipmsgid; 1649 u32 ipaudit; 1650 u8 iprmmsg[8]; 1651 u32 ipsrccls; 1652 u32 ipmsgtag; 1653 u32 res; 1654 u32 ipbfln2f; 1655 u8 ippollfg; 1656 u8 res2[3]; 1657 } __packed; 1658 1659 static void iucv_message_complete(struct iucv_irq_data *data) 1660 { 1661 struct iucv_message_complete *imc = (void *) data; 1662 struct iucv_path *path = iucv_path_table[imc->ippathid]; 1663 struct iucv_message msg; 1664 1665 if (path && path->handler && path->handler->message_complete) { 1666 msg.flags = imc->ipflags1; 1667 msg.id = imc->ipmsgid; 1668 msg.audit = imc->ipaudit; 1669 memcpy(msg.rmmsg, imc->iprmmsg, 8); 1670 msg.class = imc->ipsrccls; 1671 msg.tag = imc->ipmsgtag; 1672 msg.length = imc->ipbfln2f; 1673 path->handler->message_complete(path, &msg); 1674 } 1675 } 1676 1677 /** 1678 * iucv_message_pending 1679 * @data: Pointer to external interrupt buffer 1680 * 1681 * Process message pending work item. Called from tasklet while holding 1682 * iucv_table_lock. 1683 */ 1684 struct iucv_message_pending { 1685 u16 ippathid; 1686 u8 ipflags1; 1687 u8 iptype; 1688 u32 ipmsgid; 1689 u32 iptrgcls; 1690 union { 1691 u32 iprmmsg1_u32; 1692 u8 iprmmsg1[4]; 1693 } ln1msg1; 1694 union { 1695 u32 ipbfln1f; 1696 u8 iprmmsg2[4]; 1697 } ln1msg2; 1698 u32 res1[3]; 1699 u32 ipbfln2f; 1700 u8 ippollfg; 1701 u8 res2[3]; 1702 } __packed; 1703 1704 static void iucv_message_pending(struct iucv_irq_data *data) 1705 { 1706 struct iucv_message_pending *imp = (void *) data; 1707 struct iucv_path *path = iucv_path_table[imp->ippathid]; 1708 struct iucv_message msg; 1709 1710 if (path && path->handler && path->handler->message_pending) { 1711 msg.flags = imp->ipflags1; 1712 msg.id = imp->ipmsgid; 1713 msg.class = imp->iptrgcls; 1714 if (imp->ipflags1 & IUCV_IPRMDATA) { 1715 memcpy(msg.rmmsg, imp->ln1msg1.iprmmsg1, 8); 1716 msg.length = 8; 1717 } else 1718 msg.length = imp->ln1msg2.ipbfln1f; 1719 msg.reply_size = imp->ipbfln2f; 1720 path->handler->message_pending(path, &msg); 1721 } 1722 } 1723 1724 /** 1725 * iucv_tasklet_fn: 1726 * 1727 * This tasklet loops over the queue of irq buffers created by 1728 * iucv_external_interrupt, calls the appropriate action handler 1729 * and then frees the buffer. 1730 */ 1731 static void iucv_tasklet_fn(unsigned long ignored) 1732 { 1733 typedef void iucv_irq_fn(struct iucv_irq_data *); 1734 static iucv_irq_fn *irq_fn[] = { 1735 [0x02] = iucv_path_complete, 1736 [0x03] = iucv_path_severed, 1737 [0x04] = iucv_path_quiesced, 1738 [0x05] = iucv_path_resumed, 1739 [0x06] = iucv_message_complete, 1740 [0x07] = iucv_message_complete, 1741 [0x08] = iucv_message_pending, 1742 [0x09] = iucv_message_pending, 1743 }; 1744 LIST_HEAD(task_queue); 1745 struct iucv_irq_list *p, *n; 1746 1747 /* Serialize tasklet, iucv_path_sever and iucv_path_connect. */ 1748 if (!spin_trylock(&iucv_table_lock)) { 1749 tasklet_schedule(&iucv_tasklet); 1750 return; 1751 } 1752 iucv_active_cpu = smp_processor_id(); 1753 1754 spin_lock_irq(&iucv_queue_lock); 1755 list_splice_init(&iucv_task_queue, &task_queue); 1756 spin_unlock_irq(&iucv_queue_lock); 1757 1758 list_for_each_entry_safe(p, n, &task_queue, list) { 1759 list_del_init(&p->list); 1760 irq_fn[p->data.iptype](&p->data); 1761 kfree(p); 1762 } 1763 1764 iucv_active_cpu = -1; 1765 spin_unlock(&iucv_table_lock); 1766 } 1767 1768 /** 1769 * iucv_work_fn: 1770 * 1771 * This work function loops over the queue of path pending irq blocks 1772 * created by iucv_external_interrupt, calls the appropriate action 1773 * handler and then frees the buffer. 1774 */ 1775 static void iucv_work_fn(struct work_struct *work) 1776 { 1777 LIST_HEAD(work_queue); 1778 struct iucv_irq_list *p, *n; 1779 1780 /* Serialize tasklet, iucv_path_sever and iucv_path_connect. */ 1781 spin_lock_bh(&iucv_table_lock); 1782 iucv_active_cpu = smp_processor_id(); 1783 1784 spin_lock_irq(&iucv_queue_lock); 1785 list_splice_init(&iucv_work_queue, &work_queue); 1786 spin_unlock_irq(&iucv_queue_lock); 1787 1788 iucv_cleanup_queue(); 1789 list_for_each_entry_safe(p, n, &work_queue, list) { 1790 list_del_init(&p->list); 1791 iucv_path_pending(&p->data); 1792 kfree(p); 1793 } 1794 1795 iucv_active_cpu = -1; 1796 spin_unlock_bh(&iucv_table_lock); 1797 } 1798 1799 /** 1800 * iucv_external_interrupt 1801 * @code: irq code 1802 * 1803 * Handles external interrupts coming in from CP. 1804 * Places the interrupt buffer on a queue and schedules iucv_tasklet_fn(). 1805 */ 1806 static void iucv_external_interrupt(struct ext_code ext_code, 1807 unsigned int param32, unsigned long param64) 1808 { 1809 struct iucv_irq_data *p; 1810 struct iucv_irq_list *work; 1811 1812 inc_irq_stat(IRQEXT_IUC); 1813 p = iucv_irq_data[smp_processor_id()]; 1814 if (p->ippathid >= iucv_max_pathid) { 1815 WARN_ON(p->ippathid >= iucv_max_pathid); 1816 iucv_sever_pathid(p->ippathid, iucv_error_no_listener); 1817 return; 1818 } 1819 BUG_ON(p->iptype < 0x01 || p->iptype > 0x09); 1820 work = kmalloc(sizeof(struct iucv_irq_list), GFP_ATOMIC); 1821 if (!work) { 1822 pr_warning("iucv_external_interrupt: out of memory\n"); 1823 return; 1824 } 1825 memcpy(&work->data, p, sizeof(work->data)); 1826 spin_lock(&iucv_queue_lock); 1827 if (p->iptype == 0x01) { 1828 /* Path pending interrupt. */ 1829 list_add_tail(&work->list, &iucv_work_queue); 1830 schedule_work(&iucv_work); 1831 } else { 1832 /* The other interrupts. */ 1833 list_add_tail(&work->list, &iucv_task_queue); 1834 tasklet_schedule(&iucv_tasklet); 1835 } 1836 spin_unlock(&iucv_queue_lock); 1837 } 1838 1839 static int iucv_pm_prepare(struct device *dev) 1840 { 1841 int rc = 0; 1842 1843 #ifdef CONFIG_PM_DEBUG 1844 printk(KERN_INFO "iucv_pm_prepare\n"); 1845 #endif 1846 if (dev->driver && dev->driver->pm && dev->driver->pm->prepare) 1847 rc = dev->driver->pm->prepare(dev); 1848 return rc; 1849 } 1850 1851 static void iucv_pm_complete(struct device *dev) 1852 { 1853 #ifdef CONFIG_PM_DEBUG 1854 printk(KERN_INFO "iucv_pm_complete\n"); 1855 #endif 1856 if (dev->driver && dev->driver->pm && dev->driver->pm->complete) 1857 dev->driver->pm->complete(dev); 1858 } 1859 1860 /** 1861 * iucv_path_table_empty() - determine if iucv path table is empty 1862 * 1863 * Returns 0 if there are still iucv pathes defined 1864 * 1 if there are no iucv pathes defined 1865 */ 1866 int iucv_path_table_empty(void) 1867 { 1868 int i; 1869 1870 for (i = 0; i < iucv_max_pathid; i++) { 1871 if (iucv_path_table[i]) 1872 return 0; 1873 } 1874 return 1; 1875 } 1876 1877 /** 1878 * iucv_pm_freeze() - Freeze PM callback 1879 * @dev: iucv-based device 1880 * 1881 * disable iucv interrupts 1882 * invoke callback function of the iucv-based driver 1883 * shut down iucv, if no iucv-pathes are established anymore 1884 */ 1885 static int iucv_pm_freeze(struct device *dev) 1886 { 1887 int cpu; 1888 struct iucv_irq_list *p, *n; 1889 int rc = 0; 1890 1891 #ifdef CONFIG_PM_DEBUG 1892 printk(KERN_WARNING "iucv_pm_freeze\n"); 1893 #endif 1894 if (iucv_pm_state != IUCV_PM_FREEZING) { 1895 for_each_cpu(cpu, &iucv_irq_cpumask) 1896 smp_call_function_single(cpu, iucv_block_cpu_almost, 1897 NULL, 1); 1898 cancel_work_sync(&iucv_work); 1899 list_for_each_entry_safe(p, n, &iucv_work_queue, list) { 1900 list_del_init(&p->list); 1901 iucv_sever_pathid(p->data.ippathid, 1902 iucv_error_no_listener); 1903 kfree(p); 1904 } 1905 } 1906 iucv_pm_state = IUCV_PM_FREEZING; 1907 if (dev->driver && dev->driver->pm && dev->driver->pm->freeze) 1908 rc = dev->driver->pm->freeze(dev); 1909 if (iucv_path_table_empty()) 1910 iucv_disable(); 1911 return rc; 1912 } 1913 1914 /** 1915 * iucv_pm_thaw() - Thaw PM callback 1916 * @dev: iucv-based device 1917 * 1918 * make iucv ready for use again: allocate path table, declare interrupt buffers 1919 * and enable iucv interrupts 1920 * invoke callback function of the iucv-based driver 1921 */ 1922 static int iucv_pm_thaw(struct device *dev) 1923 { 1924 int rc = 0; 1925 1926 #ifdef CONFIG_PM_DEBUG 1927 printk(KERN_WARNING "iucv_pm_thaw\n"); 1928 #endif 1929 iucv_pm_state = IUCV_PM_THAWING; 1930 if (!iucv_path_table) { 1931 rc = iucv_enable(); 1932 if (rc) 1933 goto out; 1934 } 1935 if (cpumask_empty(&iucv_irq_cpumask)) { 1936 if (iucv_nonsmp_handler) 1937 /* enable interrupts on one cpu */ 1938 iucv_allow_cpu(NULL); 1939 else 1940 /* enable interrupts on all cpus */ 1941 iucv_setmask_mp(); 1942 } 1943 if (dev->driver && dev->driver->pm && dev->driver->pm->thaw) 1944 rc = dev->driver->pm->thaw(dev); 1945 out: 1946 return rc; 1947 } 1948 1949 /** 1950 * iucv_pm_restore() - Restore PM callback 1951 * @dev: iucv-based device 1952 * 1953 * make iucv ready for use again: allocate path table, declare interrupt buffers 1954 * and enable iucv interrupts 1955 * invoke callback function of the iucv-based driver 1956 */ 1957 static int iucv_pm_restore(struct device *dev) 1958 { 1959 int rc = 0; 1960 1961 #ifdef CONFIG_PM_DEBUG 1962 printk(KERN_WARNING "iucv_pm_restore %p\n", iucv_path_table); 1963 #endif 1964 if ((iucv_pm_state != IUCV_PM_RESTORING) && iucv_path_table) 1965 pr_warning("Suspending Linux did not completely close all IUCV " 1966 "connections\n"); 1967 iucv_pm_state = IUCV_PM_RESTORING; 1968 if (cpumask_empty(&iucv_irq_cpumask)) { 1969 rc = iucv_query_maxconn(); 1970 rc = iucv_enable(); 1971 if (rc) 1972 goto out; 1973 } 1974 if (dev->driver && dev->driver->pm && dev->driver->pm->restore) 1975 rc = dev->driver->pm->restore(dev); 1976 out: 1977 return rc; 1978 } 1979 1980 struct iucv_interface iucv_if = { 1981 .message_receive = iucv_message_receive, 1982 .__message_receive = __iucv_message_receive, 1983 .message_reply = iucv_message_reply, 1984 .message_reject = iucv_message_reject, 1985 .message_send = iucv_message_send, 1986 .__message_send = __iucv_message_send, 1987 .message_send2way = iucv_message_send2way, 1988 .message_purge = iucv_message_purge, 1989 .path_accept = iucv_path_accept, 1990 .path_connect = iucv_path_connect, 1991 .path_quiesce = iucv_path_quiesce, 1992 .path_resume = iucv_path_resume, 1993 .path_sever = iucv_path_sever, 1994 .iucv_register = iucv_register, 1995 .iucv_unregister = iucv_unregister, 1996 .bus = NULL, 1997 .root = NULL, 1998 }; 1999 EXPORT_SYMBOL(iucv_if); 2000 2001 /** 2002 * iucv_init 2003 * 2004 * Allocates and initializes various data structures. 2005 */ 2006 static int __init iucv_init(void) 2007 { 2008 int rc; 2009 int cpu; 2010 2011 if (!MACHINE_IS_VM) { 2012 rc = -EPROTONOSUPPORT; 2013 goto out; 2014 } 2015 ctl_set_bit(0, 1); 2016 rc = iucv_query_maxconn(); 2017 if (rc) 2018 goto out_ctl; 2019 rc = register_external_interrupt(0x4000, iucv_external_interrupt); 2020 if (rc) 2021 goto out_ctl; 2022 iucv_root = root_device_register("iucv"); 2023 if (IS_ERR(iucv_root)) { 2024 rc = PTR_ERR(iucv_root); 2025 goto out_int; 2026 } 2027 2028 for_each_online_cpu(cpu) { 2029 /* Note: GFP_DMA used to get memory below 2G */ 2030 iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data), 2031 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu)); 2032 if (!iucv_irq_data[cpu]) { 2033 rc = -ENOMEM; 2034 goto out_free; 2035 } 2036 2037 /* Allocate parameter blocks. */ 2038 iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param), 2039 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu)); 2040 if (!iucv_param[cpu]) { 2041 rc = -ENOMEM; 2042 goto out_free; 2043 } 2044 iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param), 2045 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu)); 2046 if (!iucv_param_irq[cpu]) { 2047 rc = -ENOMEM; 2048 goto out_free; 2049 } 2050 2051 } 2052 rc = register_hotcpu_notifier(&iucv_cpu_notifier); 2053 if (rc) 2054 goto out_free; 2055 rc = register_reboot_notifier(&iucv_reboot_notifier); 2056 if (rc) 2057 goto out_cpu; 2058 ASCEBC(iucv_error_no_listener, 16); 2059 ASCEBC(iucv_error_no_memory, 16); 2060 ASCEBC(iucv_error_pathid, 16); 2061 iucv_available = 1; 2062 rc = bus_register(&iucv_bus); 2063 if (rc) 2064 goto out_reboot; 2065 iucv_if.root = iucv_root; 2066 iucv_if.bus = &iucv_bus; 2067 return 0; 2068 2069 out_reboot: 2070 unregister_reboot_notifier(&iucv_reboot_notifier); 2071 out_cpu: 2072 unregister_hotcpu_notifier(&iucv_cpu_notifier); 2073 out_free: 2074 for_each_possible_cpu(cpu) { 2075 kfree(iucv_param_irq[cpu]); 2076 iucv_param_irq[cpu] = NULL; 2077 kfree(iucv_param[cpu]); 2078 iucv_param[cpu] = NULL; 2079 kfree(iucv_irq_data[cpu]); 2080 iucv_irq_data[cpu] = NULL; 2081 } 2082 root_device_unregister(iucv_root); 2083 out_int: 2084 unregister_external_interrupt(0x4000, iucv_external_interrupt); 2085 out_ctl: 2086 ctl_clear_bit(0, 1); 2087 out: 2088 return rc; 2089 } 2090 2091 /** 2092 * iucv_exit 2093 * 2094 * Frees everything allocated from iucv_init. 2095 */ 2096 static void __exit iucv_exit(void) 2097 { 2098 struct iucv_irq_list *p, *n; 2099 int cpu; 2100 2101 spin_lock_irq(&iucv_queue_lock); 2102 list_for_each_entry_safe(p, n, &iucv_task_queue, list) 2103 kfree(p); 2104 list_for_each_entry_safe(p, n, &iucv_work_queue, list) 2105 kfree(p); 2106 spin_unlock_irq(&iucv_queue_lock); 2107 unregister_reboot_notifier(&iucv_reboot_notifier); 2108 unregister_hotcpu_notifier(&iucv_cpu_notifier); 2109 for_each_possible_cpu(cpu) { 2110 kfree(iucv_param_irq[cpu]); 2111 iucv_param_irq[cpu] = NULL; 2112 kfree(iucv_param[cpu]); 2113 iucv_param[cpu] = NULL; 2114 kfree(iucv_irq_data[cpu]); 2115 iucv_irq_data[cpu] = NULL; 2116 } 2117 root_device_unregister(iucv_root); 2118 bus_unregister(&iucv_bus); 2119 unregister_external_interrupt(0x4000, iucv_external_interrupt); 2120 } 2121 2122 subsys_initcall(iucv_init); 2123 module_exit(iucv_exit); 2124 2125 MODULE_AUTHOR("(C) 2001 IBM Corp. by Fritz Elfert (felfert@millenux.com)"); 2126 MODULE_DESCRIPTION("Linux for S/390 IUCV lowlevel driver"); 2127 MODULE_LICENSE("GPL"); 2128