1 /* 2 * Driver for s390 chsc subchannels 3 * 4 * Copyright IBM Corp. 2008, 2011 5 * 6 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com> 7 * 8 */ 9 10 #include <linux/slab.h> 11 #include <linux/compat.h> 12 #include <linux/device.h> 13 #include <linux/module.h> 14 #include <linux/uaccess.h> 15 #include <linux/miscdevice.h> 16 #include <linux/kernel_stat.h> 17 18 #include <asm/compat.h> 19 #include <asm/cio.h> 20 #include <asm/chsc.h> 21 #include <asm/isc.h> 22 23 #include "cio.h" 24 #include "cio_debug.h" 25 #include "css.h" 26 #include "chsc_sch.h" 27 #include "ioasm.h" 28 29 static debug_info_t *chsc_debug_msg_id; 30 static debug_info_t *chsc_debug_log_id; 31 32 static struct chsc_request *on_close_request; 33 static struct chsc_async_area *on_close_chsc_area; 34 static DEFINE_MUTEX(on_close_mutex); 35 36 #define CHSC_MSG(imp, args...) do { \ 37 debug_sprintf_event(chsc_debug_msg_id, imp , ##args); \ 38 } while (0) 39 40 #define CHSC_LOG(imp, txt) do { \ 41 debug_text_event(chsc_debug_log_id, imp , txt); \ 42 } while (0) 43 44 static void CHSC_LOG_HEX(int level, void *data, int length) 45 { 46 while (length > 0) { 47 debug_event(chsc_debug_log_id, level, data, length); 48 length -= chsc_debug_log_id->buf_size; 49 data += chsc_debug_log_id->buf_size; 50 } 51 } 52 53 MODULE_AUTHOR("IBM Corporation"); 54 MODULE_DESCRIPTION("driver for s390 chsc subchannels"); 55 MODULE_LICENSE("GPL"); 56 57 static void chsc_subchannel_irq(struct subchannel *sch) 58 { 59 struct chsc_private *private = dev_get_drvdata(&sch->dev); 60 struct chsc_request *request = private->request; 61 struct irb *irb = (struct irb *)&S390_lowcore.irb; 62 63 CHSC_LOG(4, "irb"); 64 CHSC_LOG_HEX(4, irb, sizeof(*irb)); 65 inc_irq_stat(IRQIO_CSC); 66 67 /* Copy irb to provided request and set done. */ 68 if (!request) { 69 CHSC_MSG(0, "Interrupt on sch 0.%x.%04x with no request\n", 70 sch->schid.ssid, sch->schid.sch_no); 71 return; 72 } 73 private->request = NULL; 74 memcpy(&request->irb, irb, sizeof(*irb)); 75 cio_update_schib(sch); 76 complete(&request->completion); 77 put_device(&sch->dev); 78 } 79 80 static int chsc_subchannel_probe(struct subchannel *sch) 81 { 82 struct chsc_private *private; 83 int ret; 84 85 CHSC_MSG(6, "Detected chsc subchannel 0.%x.%04x\n", 86 sch->schid.ssid, sch->schid.sch_no); 87 sch->isc = CHSC_SCH_ISC; 88 private = kzalloc(sizeof(*private), GFP_KERNEL); 89 if (!private) 90 return -ENOMEM; 91 dev_set_drvdata(&sch->dev, private); 92 ret = cio_enable_subchannel(sch, (u32)(unsigned long)sch); 93 if (ret) { 94 CHSC_MSG(0, "Failed to enable 0.%x.%04x: %d\n", 95 sch->schid.ssid, sch->schid.sch_no, ret); 96 dev_set_drvdata(&sch->dev, NULL); 97 kfree(private); 98 } else { 99 if (dev_get_uevent_suppress(&sch->dev)) { 100 dev_set_uevent_suppress(&sch->dev, 0); 101 kobject_uevent(&sch->dev.kobj, KOBJ_ADD); 102 } 103 } 104 return ret; 105 } 106 107 static int chsc_subchannel_remove(struct subchannel *sch) 108 { 109 struct chsc_private *private; 110 111 cio_disable_subchannel(sch); 112 private = dev_get_drvdata(&sch->dev); 113 dev_set_drvdata(&sch->dev, NULL); 114 if (private->request) { 115 complete(&private->request->completion); 116 put_device(&sch->dev); 117 } 118 kfree(private); 119 return 0; 120 } 121 122 static void chsc_subchannel_shutdown(struct subchannel *sch) 123 { 124 cio_disable_subchannel(sch); 125 } 126 127 static int chsc_subchannel_prepare(struct subchannel *sch) 128 { 129 int cc; 130 struct schib schib; 131 /* 132 * Don't allow suspend while the subchannel is not idle 133 * since we don't have a way to clear the subchannel and 134 * cannot disable it with a request running. 135 */ 136 cc = stsch_err(sch->schid, &schib); 137 if (!cc && scsw_stctl(&schib.scsw)) 138 return -EAGAIN; 139 return 0; 140 } 141 142 static int chsc_subchannel_freeze(struct subchannel *sch) 143 { 144 return cio_disable_subchannel(sch); 145 } 146 147 static int chsc_subchannel_restore(struct subchannel *sch) 148 { 149 return cio_enable_subchannel(sch, (u32)(unsigned long)sch); 150 } 151 152 static struct css_device_id chsc_subchannel_ids[] = { 153 { .match_flags = 0x1, .type =SUBCHANNEL_TYPE_CHSC, }, 154 { /* end of list */ }, 155 }; 156 MODULE_DEVICE_TABLE(css, chsc_subchannel_ids); 157 158 static struct css_driver chsc_subchannel_driver = { 159 .drv = { 160 .owner = THIS_MODULE, 161 .name = "chsc_subchannel", 162 }, 163 .subchannel_type = chsc_subchannel_ids, 164 .irq = chsc_subchannel_irq, 165 .probe = chsc_subchannel_probe, 166 .remove = chsc_subchannel_remove, 167 .shutdown = chsc_subchannel_shutdown, 168 .prepare = chsc_subchannel_prepare, 169 .freeze = chsc_subchannel_freeze, 170 .thaw = chsc_subchannel_restore, 171 .restore = chsc_subchannel_restore, 172 }; 173 174 static int __init chsc_init_dbfs(void) 175 { 176 chsc_debug_msg_id = debug_register("chsc_msg", 8, 1, 4 * sizeof(long)); 177 if (!chsc_debug_msg_id) 178 goto out; 179 debug_register_view(chsc_debug_msg_id, &debug_sprintf_view); 180 debug_set_level(chsc_debug_msg_id, 2); 181 chsc_debug_log_id = debug_register("chsc_log", 16, 1, 16); 182 if (!chsc_debug_log_id) 183 goto out; 184 debug_register_view(chsc_debug_log_id, &debug_hex_ascii_view); 185 debug_set_level(chsc_debug_log_id, 2); 186 return 0; 187 out: 188 if (chsc_debug_msg_id) 189 debug_unregister(chsc_debug_msg_id); 190 return -ENOMEM; 191 } 192 193 static void chsc_remove_dbfs(void) 194 { 195 debug_unregister(chsc_debug_log_id); 196 debug_unregister(chsc_debug_msg_id); 197 } 198 199 static int __init chsc_init_sch_driver(void) 200 { 201 return css_driver_register(&chsc_subchannel_driver); 202 } 203 204 static void chsc_cleanup_sch_driver(void) 205 { 206 css_driver_unregister(&chsc_subchannel_driver); 207 } 208 209 static DEFINE_SPINLOCK(chsc_lock); 210 211 static int chsc_subchannel_match_next_free(struct device *dev, void *data) 212 { 213 struct subchannel *sch = to_subchannel(dev); 214 215 return sch->schib.pmcw.ena && !scsw_fctl(&sch->schib.scsw); 216 } 217 218 static struct subchannel *chsc_get_next_subchannel(struct subchannel *sch) 219 { 220 struct device *dev; 221 222 dev = driver_find_device(&chsc_subchannel_driver.drv, 223 sch ? &sch->dev : NULL, NULL, 224 chsc_subchannel_match_next_free); 225 return dev ? to_subchannel(dev) : NULL; 226 } 227 228 /** 229 * chsc_async() - try to start a chsc request asynchronously 230 * @chsc_area: request to be started 231 * @request: request structure to associate 232 * 233 * Tries to start a chsc request on one of the existing chsc subchannels. 234 * Returns: 235 * %0 if the request was performed synchronously 236 * %-EINPROGRESS if the request was successfully started 237 * %-EBUSY if all chsc subchannels are busy 238 * %-ENODEV if no chsc subchannels are available 239 * Context: 240 * interrupts disabled, chsc_lock held 241 */ 242 static int chsc_async(struct chsc_async_area *chsc_area, 243 struct chsc_request *request) 244 { 245 int cc; 246 struct chsc_private *private; 247 struct subchannel *sch = NULL; 248 int ret = -ENODEV; 249 char dbf[10]; 250 251 chsc_area->header.key = PAGE_DEFAULT_KEY >> 4; 252 while ((sch = chsc_get_next_subchannel(sch))) { 253 spin_lock(sch->lock); 254 private = dev_get_drvdata(&sch->dev); 255 if (private->request) { 256 spin_unlock(sch->lock); 257 ret = -EBUSY; 258 continue; 259 } 260 chsc_area->header.sid = sch->schid; 261 CHSC_LOG(2, "schid"); 262 CHSC_LOG_HEX(2, &sch->schid, sizeof(sch->schid)); 263 cc = chsc(chsc_area); 264 snprintf(dbf, sizeof(dbf), "cc:%d", cc); 265 CHSC_LOG(2, dbf); 266 switch (cc) { 267 case 0: 268 ret = 0; 269 break; 270 case 1: 271 sch->schib.scsw.cmd.fctl |= SCSW_FCTL_START_FUNC; 272 ret = -EINPROGRESS; 273 private->request = request; 274 break; 275 case 2: 276 ret = -EBUSY; 277 break; 278 default: 279 ret = -ENODEV; 280 } 281 spin_unlock(sch->lock); 282 CHSC_MSG(2, "chsc on 0.%x.%04x returned cc=%d\n", 283 sch->schid.ssid, sch->schid.sch_no, cc); 284 if (ret == -EINPROGRESS) 285 return -EINPROGRESS; 286 put_device(&sch->dev); 287 if (ret == 0) 288 return 0; 289 } 290 return ret; 291 } 292 293 static void chsc_log_command(void *chsc_area) 294 { 295 char dbf[10]; 296 297 snprintf(dbf, sizeof(dbf), "CHSC:%x", ((uint16_t *)chsc_area)[1]); 298 CHSC_LOG(0, dbf); 299 CHSC_LOG_HEX(0, chsc_area, 32); 300 } 301 302 static int chsc_examine_irb(struct chsc_request *request) 303 { 304 int backed_up; 305 306 if (!(scsw_stctl(&request->irb.scsw) & SCSW_STCTL_STATUS_PEND)) 307 return -EIO; 308 backed_up = scsw_cstat(&request->irb.scsw) & SCHN_STAT_CHAIN_CHECK; 309 request->irb.scsw.cmd.cstat &= ~SCHN_STAT_CHAIN_CHECK; 310 if (scsw_cstat(&request->irb.scsw) == 0) 311 return 0; 312 if (!backed_up) 313 return 0; 314 if (scsw_cstat(&request->irb.scsw) & SCHN_STAT_PROG_CHECK) 315 return -EIO; 316 if (scsw_cstat(&request->irb.scsw) & SCHN_STAT_PROT_CHECK) 317 return -EPERM; 318 if (scsw_cstat(&request->irb.scsw) & SCHN_STAT_CHN_DATA_CHK) 319 return -EAGAIN; 320 if (scsw_cstat(&request->irb.scsw) & SCHN_STAT_CHN_CTRL_CHK) 321 return -EAGAIN; 322 return -EIO; 323 } 324 325 static int chsc_ioctl_start(void __user *user_area) 326 { 327 struct chsc_request *request; 328 struct chsc_async_area *chsc_area; 329 int ret; 330 char dbf[10]; 331 332 if (!css_general_characteristics.dynio) 333 /* It makes no sense to try. */ 334 return -EOPNOTSUPP; 335 chsc_area = (void *)get_zeroed_page(GFP_DMA | GFP_KERNEL); 336 if (!chsc_area) 337 return -ENOMEM; 338 request = kzalloc(sizeof(*request), GFP_KERNEL); 339 if (!request) { 340 ret = -ENOMEM; 341 goto out_free; 342 } 343 init_completion(&request->completion); 344 if (copy_from_user(chsc_area, user_area, PAGE_SIZE)) { 345 ret = -EFAULT; 346 goto out_free; 347 } 348 chsc_log_command(chsc_area); 349 spin_lock_irq(&chsc_lock); 350 ret = chsc_async(chsc_area, request); 351 spin_unlock_irq(&chsc_lock); 352 if (ret == -EINPROGRESS) { 353 wait_for_completion(&request->completion); 354 ret = chsc_examine_irb(request); 355 } 356 /* copy area back to user */ 357 if (!ret) 358 if (copy_to_user(user_area, chsc_area, PAGE_SIZE)) 359 ret = -EFAULT; 360 out_free: 361 snprintf(dbf, sizeof(dbf), "ret:%d", ret); 362 CHSC_LOG(0, dbf); 363 kfree(request); 364 free_page((unsigned long)chsc_area); 365 return ret; 366 } 367 368 static int chsc_ioctl_on_close_set(void __user *user_area) 369 { 370 char dbf[13]; 371 int ret; 372 373 mutex_lock(&on_close_mutex); 374 if (on_close_chsc_area) { 375 ret = -EBUSY; 376 goto out_unlock; 377 } 378 on_close_request = kzalloc(sizeof(*on_close_request), GFP_KERNEL); 379 if (!on_close_request) { 380 ret = -ENOMEM; 381 goto out_unlock; 382 } 383 on_close_chsc_area = (void *)get_zeroed_page(GFP_DMA | GFP_KERNEL); 384 if (!on_close_chsc_area) { 385 ret = -ENOMEM; 386 goto out_free_request; 387 } 388 if (copy_from_user(on_close_chsc_area, user_area, PAGE_SIZE)) { 389 ret = -EFAULT; 390 goto out_free_chsc; 391 } 392 ret = 0; 393 goto out_unlock; 394 395 out_free_chsc: 396 free_page((unsigned long)on_close_chsc_area); 397 on_close_chsc_area = NULL; 398 out_free_request: 399 kfree(on_close_request); 400 on_close_request = NULL; 401 out_unlock: 402 mutex_unlock(&on_close_mutex); 403 snprintf(dbf, sizeof(dbf), "ocsret:%d", ret); 404 CHSC_LOG(0, dbf); 405 return ret; 406 } 407 408 static int chsc_ioctl_on_close_remove(void) 409 { 410 char dbf[13]; 411 int ret; 412 413 mutex_lock(&on_close_mutex); 414 if (!on_close_chsc_area) { 415 ret = -ENOENT; 416 goto out_unlock; 417 } 418 free_page((unsigned long)on_close_chsc_area); 419 on_close_chsc_area = NULL; 420 kfree(on_close_request); 421 on_close_request = NULL; 422 ret = 0; 423 out_unlock: 424 mutex_unlock(&on_close_mutex); 425 snprintf(dbf, sizeof(dbf), "ocrret:%d", ret); 426 CHSC_LOG(0, dbf); 427 return ret; 428 } 429 430 static int chsc_ioctl_start_sync(void __user *user_area) 431 { 432 struct chsc_sync_area *chsc_area; 433 int ret, ccode; 434 435 chsc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); 436 if (!chsc_area) 437 return -ENOMEM; 438 if (copy_from_user(chsc_area, user_area, PAGE_SIZE)) { 439 ret = -EFAULT; 440 goto out_free; 441 } 442 if (chsc_area->header.code & 0x4000) { 443 ret = -EINVAL; 444 goto out_free; 445 } 446 chsc_log_command(chsc_area); 447 ccode = chsc(chsc_area); 448 if (ccode != 0) { 449 ret = -EIO; 450 goto out_free; 451 } 452 if (copy_to_user(user_area, chsc_area, PAGE_SIZE)) 453 ret = -EFAULT; 454 else 455 ret = 0; 456 out_free: 457 free_page((unsigned long)chsc_area); 458 return ret; 459 } 460 461 static int chsc_ioctl_info_channel_path(void __user *user_cd) 462 { 463 struct chsc_chp_cd *cd; 464 int ret, ccode; 465 struct { 466 struct chsc_header request; 467 u32 : 2; 468 u32 m : 1; 469 u32 : 1; 470 u32 fmt1 : 4; 471 u32 cssid : 8; 472 u32 : 8; 473 u32 first_chpid : 8; 474 u32 : 24; 475 u32 last_chpid : 8; 476 u32 : 32; 477 struct chsc_header response; 478 u8 data[PAGE_SIZE - 20]; 479 } __attribute__ ((packed)) *scpcd_area; 480 481 scpcd_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); 482 if (!scpcd_area) 483 return -ENOMEM; 484 cd = kzalloc(sizeof(*cd), GFP_KERNEL); 485 if (!cd) { 486 ret = -ENOMEM; 487 goto out_free; 488 } 489 if (copy_from_user(cd, user_cd, sizeof(*cd))) { 490 ret = -EFAULT; 491 goto out_free; 492 } 493 scpcd_area->request.length = 0x0010; 494 scpcd_area->request.code = 0x0028; 495 scpcd_area->m = cd->m; 496 scpcd_area->fmt1 = cd->fmt; 497 scpcd_area->cssid = cd->chpid.cssid; 498 scpcd_area->first_chpid = cd->chpid.id; 499 scpcd_area->last_chpid = cd->chpid.id; 500 501 ccode = chsc(scpcd_area); 502 if (ccode != 0) { 503 ret = -EIO; 504 goto out_free; 505 } 506 if (scpcd_area->response.code != 0x0001) { 507 ret = -EIO; 508 CHSC_MSG(0, "scpcd: response code=%x\n", 509 scpcd_area->response.code); 510 goto out_free; 511 } 512 memcpy(&cd->cpcb, &scpcd_area->response, scpcd_area->response.length); 513 if (copy_to_user(user_cd, cd, sizeof(*cd))) 514 ret = -EFAULT; 515 else 516 ret = 0; 517 out_free: 518 kfree(cd); 519 free_page((unsigned long)scpcd_area); 520 return ret; 521 } 522 523 static int chsc_ioctl_info_cu(void __user *user_cd) 524 { 525 struct chsc_cu_cd *cd; 526 int ret, ccode; 527 struct { 528 struct chsc_header request; 529 u32 : 2; 530 u32 m : 1; 531 u32 : 1; 532 u32 fmt1 : 4; 533 u32 cssid : 8; 534 u32 : 8; 535 u32 first_cun : 8; 536 u32 : 24; 537 u32 last_cun : 8; 538 u32 : 32; 539 struct chsc_header response; 540 u8 data[PAGE_SIZE - 20]; 541 } __attribute__ ((packed)) *scucd_area; 542 543 scucd_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); 544 if (!scucd_area) 545 return -ENOMEM; 546 cd = kzalloc(sizeof(*cd), GFP_KERNEL); 547 if (!cd) { 548 ret = -ENOMEM; 549 goto out_free; 550 } 551 if (copy_from_user(cd, user_cd, sizeof(*cd))) { 552 ret = -EFAULT; 553 goto out_free; 554 } 555 scucd_area->request.length = 0x0010; 556 scucd_area->request.code = 0x0028; 557 scucd_area->m = cd->m; 558 scucd_area->fmt1 = cd->fmt; 559 scucd_area->cssid = cd->cssid; 560 scucd_area->first_cun = cd->cun; 561 scucd_area->last_cun = cd->cun; 562 563 ccode = chsc(scucd_area); 564 if (ccode != 0) { 565 ret = -EIO; 566 goto out_free; 567 } 568 if (scucd_area->response.code != 0x0001) { 569 ret = -EIO; 570 CHSC_MSG(0, "scucd: response code=%x\n", 571 scucd_area->response.code); 572 goto out_free; 573 } 574 memcpy(&cd->cucb, &scucd_area->response, scucd_area->response.length); 575 if (copy_to_user(user_cd, cd, sizeof(*cd))) 576 ret = -EFAULT; 577 else 578 ret = 0; 579 out_free: 580 kfree(cd); 581 free_page((unsigned long)scucd_area); 582 return ret; 583 } 584 585 static int chsc_ioctl_info_sch_cu(void __user *user_cud) 586 { 587 struct chsc_sch_cud *cud; 588 int ret, ccode; 589 struct { 590 struct chsc_header request; 591 u32 : 2; 592 u32 m : 1; 593 u32 : 5; 594 u32 fmt1 : 4; 595 u32 : 2; 596 u32 ssid : 2; 597 u32 first_sch : 16; 598 u32 : 8; 599 u32 cssid : 8; 600 u32 last_sch : 16; 601 u32 : 32; 602 struct chsc_header response; 603 u8 data[PAGE_SIZE - 20]; 604 } __attribute__ ((packed)) *sscud_area; 605 606 sscud_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); 607 if (!sscud_area) 608 return -ENOMEM; 609 cud = kzalloc(sizeof(*cud), GFP_KERNEL); 610 if (!cud) { 611 ret = -ENOMEM; 612 goto out_free; 613 } 614 if (copy_from_user(cud, user_cud, sizeof(*cud))) { 615 ret = -EFAULT; 616 goto out_free; 617 } 618 sscud_area->request.length = 0x0010; 619 sscud_area->request.code = 0x0006; 620 sscud_area->m = cud->schid.m; 621 sscud_area->fmt1 = cud->fmt; 622 sscud_area->ssid = cud->schid.ssid; 623 sscud_area->first_sch = cud->schid.sch_no; 624 sscud_area->cssid = cud->schid.cssid; 625 sscud_area->last_sch = cud->schid.sch_no; 626 627 ccode = chsc(sscud_area); 628 if (ccode != 0) { 629 ret = -EIO; 630 goto out_free; 631 } 632 if (sscud_area->response.code != 0x0001) { 633 ret = -EIO; 634 CHSC_MSG(0, "sscud: response code=%x\n", 635 sscud_area->response.code); 636 goto out_free; 637 } 638 memcpy(&cud->scub, &sscud_area->response, sscud_area->response.length); 639 if (copy_to_user(user_cud, cud, sizeof(*cud))) 640 ret = -EFAULT; 641 else 642 ret = 0; 643 out_free: 644 kfree(cud); 645 free_page((unsigned long)sscud_area); 646 return ret; 647 } 648 649 static int chsc_ioctl_conf_info(void __user *user_ci) 650 { 651 struct chsc_conf_info *ci; 652 int ret, ccode; 653 struct { 654 struct chsc_header request; 655 u32 : 2; 656 u32 m : 1; 657 u32 : 1; 658 u32 fmt1 : 4; 659 u32 cssid : 8; 660 u32 : 6; 661 u32 ssid : 2; 662 u32 : 8; 663 u64 : 64; 664 struct chsc_header response; 665 u8 data[PAGE_SIZE - 20]; 666 } __attribute__ ((packed)) *sci_area; 667 668 sci_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); 669 if (!sci_area) 670 return -ENOMEM; 671 ci = kzalloc(sizeof(*ci), GFP_KERNEL); 672 if (!ci) { 673 ret = -ENOMEM; 674 goto out_free; 675 } 676 if (copy_from_user(ci, user_ci, sizeof(*ci))) { 677 ret = -EFAULT; 678 goto out_free; 679 } 680 sci_area->request.length = 0x0010; 681 sci_area->request.code = 0x0012; 682 sci_area->m = ci->id.m; 683 sci_area->fmt1 = ci->fmt; 684 sci_area->cssid = ci->id.cssid; 685 sci_area->ssid = ci->id.ssid; 686 687 ccode = chsc(sci_area); 688 if (ccode != 0) { 689 ret = -EIO; 690 goto out_free; 691 } 692 if (sci_area->response.code != 0x0001) { 693 ret = -EIO; 694 CHSC_MSG(0, "sci: response code=%x\n", 695 sci_area->response.code); 696 goto out_free; 697 } 698 memcpy(&ci->scid, &sci_area->response, sci_area->response.length); 699 if (copy_to_user(user_ci, ci, sizeof(*ci))) 700 ret = -EFAULT; 701 else 702 ret = 0; 703 out_free: 704 kfree(ci); 705 free_page((unsigned long)sci_area); 706 return ret; 707 } 708 709 static int chsc_ioctl_conf_comp_list(void __user *user_ccl) 710 { 711 struct chsc_comp_list *ccl; 712 int ret, ccode; 713 struct { 714 struct chsc_header request; 715 u32 ctype : 8; 716 u32 : 4; 717 u32 fmt : 4; 718 u32 : 16; 719 u64 : 64; 720 u32 list_parm[2]; 721 u64 : 64; 722 struct chsc_header response; 723 u8 data[PAGE_SIZE - 36]; 724 } __attribute__ ((packed)) *sccl_area; 725 struct { 726 u32 m : 1; 727 u32 : 31; 728 u32 cssid : 8; 729 u32 : 16; 730 u32 chpid : 8; 731 } __attribute__ ((packed)) *chpid_parm; 732 struct { 733 u32 f_cssid : 8; 734 u32 l_cssid : 8; 735 u32 : 16; 736 u32 res; 737 } __attribute__ ((packed)) *cssids_parm; 738 739 sccl_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); 740 if (!sccl_area) 741 return -ENOMEM; 742 ccl = kzalloc(sizeof(*ccl), GFP_KERNEL); 743 if (!ccl) { 744 ret = -ENOMEM; 745 goto out_free; 746 } 747 if (copy_from_user(ccl, user_ccl, sizeof(*ccl))) { 748 ret = -EFAULT; 749 goto out_free; 750 } 751 sccl_area->request.length = 0x0020; 752 sccl_area->request.code = 0x0030; 753 sccl_area->fmt = ccl->req.fmt; 754 sccl_area->ctype = ccl->req.ctype; 755 switch (sccl_area->ctype) { 756 case CCL_CU_ON_CHP: 757 case CCL_IOP_CHP: 758 chpid_parm = (void *)&sccl_area->list_parm; 759 chpid_parm->m = ccl->req.chpid.m; 760 chpid_parm->cssid = ccl->req.chpid.chp.cssid; 761 chpid_parm->chpid = ccl->req.chpid.chp.id; 762 break; 763 case CCL_CSS_IMG: 764 case CCL_CSS_IMG_CONF_CHAR: 765 cssids_parm = (void *)&sccl_area->list_parm; 766 cssids_parm->f_cssid = ccl->req.cssids.f_cssid; 767 cssids_parm->l_cssid = ccl->req.cssids.l_cssid; 768 break; 769 } 770 ccode = chsc(sccl_area); 771 if (ccode != 0) { 772 ret = -EIO; 773 goto out_free; 774 } 775 if (sccl_area->response.code != 0x0001) { 776 ret = -EIO; 777 CHSC_MSG(0, "sccl: response code=%x\n", 778 sccl_area->response.code); 779 goto out_free; 780 } 781 memcpy(&ccl->sccl, &sccl_area->response, sccl_area->response.length); 782 if (copy_to_user(user_ccl, ccl, sizeof(*ccl))) 783 ret = -EFAULT; 784 else 785 ret = 0; 786 out_free: 787 kfree(ccl); 788 free_page((unsigned long)sccl_area); 789 return ret; 790 } 791 792 static int chsc_ioctl_chpd(void __user *user_chpd) 793 { 794 struct chsc_scpd *scpd_area; 795 struct chsc_cpd_info *chpd; 796 int ret; 797 798 chpd = kzalloc(sizeof(*chpd), GFP_KERNEL); 799 scpd_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); 800 if (!scpd_area || !chpd) { 801 ret = -ENOMEM; 802 goto out_free; 803 } 804 if (copy_from_user(chpd, user_chpd, sizeof(*chpd))) { 805 ret = -EFAULT; 806 goto out_free; 807 } 808 ret = chsc_determine_channel_path_desc(chpd->chpid, chpd->fmt, 809 chpd->rfmt, chpd->c, chpd->m, 810 scpd_area); 811 if (ret) 812 goto out_free; 813 memcpy(&chpd->chpdb, &scpd_area->response, scpd_area->response.length); 814 if (copy_to_user(user_chpd, chpd, sizeof(*chpd))) 815 ret = -EFAULT; 816 out_free: 817 kfree(chpd); 818 free_page((unsigned long)scpd_area); 819 return ret; 820 } 821 822 static int chsc_ioctl_dcal(void __user *user_dcal) 823 { 824 struct chsc_dcal *dcal; 825 int ret, ccode; 826 struct { 827 struct chsc_header request; 828 u32 atype : 8; 829 u32 : 4; 830 u32 fmt : 4; 831 u32 : 16; 832 u32 res0[2]; 833 u32 list_parm[2]; 834 u32 res1[2]; 835 struct chsc_header response; 836 u8 data[PAGE_SIZE - 36]; 837 } __attribute__ ((packed)) *sdcal_area; 838 839 sdcal_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); 840 if (!sdcal_area) 841 return -ENOMEM; 842 dcal = kzalloc(sizeof(*dcal), GFP_KERNEL); 843 if (!dcal) { 844 ret = -ENOMEM; 845 goto out_free; 846 } 847 if (copy_from_user(dcal, user_dcal, sizeof(*dcal))) { 848 ret = -EFAULT; 849 goto out_free; 850 } 851 sdcal_area->request.length = 0x0020; 852 sdcal_area->request.code = 0x0034; 853 sdcal_area->atype = dcal->req.atype; 854 sdcal_area->fmt = dcal->req.fmt; 855 memcpy(&sdcal_area->list_parm, &dcal->req.list_parm, 856 sizeof(sdcal_area->list_parm)); 857 858 ccode = chsc(sdcal_area); 859 if (ccode != 0) { 860 ret = -EIO; 861 goto out_free; 862 } 863 if (sdcal_area->response.code != 0x0001) { 864 ret = -EIO; 865 CHSC_MSG(0, "sdcal: response code=%x\n", 866 sdcal_area->response.code); 867 goto out_free; 868 } 869 memcpy(&dcal->sdcal, &sdcal_area->response, 870 sdcal_area->response.length); 871 if (copy_to_user(user_dcal, dcal, sizeof(*dcal))) 872 ret = -EFAULT; 873 else 874 ret = 0; 875 out_free: 876 kfree(dcal); 877 free_page((unsigned long)sdcal_area); 878 return ret; 879 } 880 881 static long chsc_ioctl(struct file *filp, unsigned int cmd, 882 unsigned long arg) 883 { 884 void __user *argp; 885 886 CHSC_MSG(2, "chsc_ioctl called, cmd=%x\n", cmd); 887 if (is_compat_task()) 888 argp = compat_ptr(arg); 889 else 890 argp = (void __user *)arg; 891 switch (cmd) { 892 case CHSC_START: 893 return chsc_ioctl_start(argp); 894 case CHSC_START_SYNC: 895 return chsc_ioctl_start_sync(argp); 896 case CHSC_INFO_CHANNEL_PATH: 897 return chsc_ioctl_info_channel_path(argp); 898 case CHSC_INFO_CU: 899 return chsc_ioctl_info_cu(argp); 900 case CHSC_INFO_SCH_CU: 901 return chsc_ioctl_info_sch_cu(argp); 902 case CHSC_INFO_CI: 903 return chsc_ioctl_conf_info(argp); 904 case CHSC_INFO_CCL: 905 return chsc_ioctl_conf_comp_list(argp); 906 case CHSC_INFO_CPD: 907 return chsc_ioctl_chpd(argp); 908 case CHSC_INFO_DCAL: 909 return chsc_ioctl_dcal(argp); 910 case CHSC_ON_CLOSE_SET: 911 return chsc_ioctl_on_close_set(argp); 912 case CHSC_ON_CLOSE_REMOVE: 913 return chsc_ioctl_on_close_remove(); 914 default: /* unknown ioctl number */ 915 return -ENOIOCTLCMD; 916 } 917 } 918 919 static atomic_t chsc_ready_for_use = ATOMIC_INIT(1); 920 921 static int chsc_open(struct inode *inode, struct file *file) 922 { 923 if (!atomic_dec_and_test(&chsc_ready_for_use)) { 924 atomic_inc(&chsc_ready_for_use); 925 return -EBUSY; 926 } 927 return nonseekable_open(inode, file); 928 } 929 930 static int chsc_release(struct inode *inode, struct file *filp) 931 { 932 char dbf[13]; 933 int ret; 934 935 mutex_lock(&on_close_mutex); 936 if (!on_close_chsc_area) 937 goto out_unlock; 938 init_completion(&on_close_request->completion); 939 CHSC_LOG(0, "on_close"); 940 chsc_log_command(on_close_chsc_area); 941 spin_lock_irq(&chsc_lock); 942 ret = chsc_async(on_close_chsc_area, on_close_request); 943 spin_unlock_irq(&chsc_lock); 944 if (ret == -EINPROGRESS) { 945 wait_for_completion(&on_close_request->completion); 946 ret = chsc_examine_irb(on_close_request); 947 } 948 snprintf(dbf, sizeof(dbf), "relret:%d", ret); 949 CHSC_LOG(0, dbf); 950 free_page((unsigned long)on_close_chsc_area); 951 on_close_chsc_area = NULL; 952 kfree(on_close_request); 953 on_close_request = NULL; 954 out_unlock: 955 mutex_unlock(&on_close_mutex); 956 atomic_inc(&chsc_ready_for_use); 957 return 0; 958 } 959 960 static const struct file_operations chsc_fops = { 961 .owner = THIS_MODULE, 962 .open = chsc_open, 963 .release = chsc_release, 964 .unlocked_ioctl = chsc_ioctl, 965 .compat_ioctl = chsc_ioctl, 966 .llseek = no_llseek, 967 }; 968 969 static struct miscdevice chsc_misc_device = { 970 .minor = MISC_DYNAMIC_MINOR, 971 .name = "chsc", 972 .fops = &chsc_fops, 973 }; 974 975 static int __init chsc_misc_init(void) 976 { 977 return misc_register(&chsc_misc_device); 978 } 979 980 static void chsc_misc_cleanup(void) 981 { 982 misc_deregister(&chsc_misc_device); 983 } 984 985 static int __init chsc_sch_init(void) 986 { 987 int ret; 988 989 ret = chsc_init_dbfs(); 990 if (ret) 991 return ret; 992 isc_register(CHSC_SCH_ISC); 993 ret = chsc_init_sch_driver(); 994 if (ret) 995 goto out_dbf; 996 ret = chsc_misc_init(); 997 if (ret) 998 goto out_driver; 999 return ret; 1000 out_driver: 1001 chsc_cleanup_sch_driver(); 1002 out_dbf: 1003 isc_unregister(CHSC_SCH_ISC); 1004 chsc_remove_dbfs(); 1005 return ret; 1006 } 1007 1008 static void __exit chsc_sch_exit(void) 1009 { 1010 chsc_misc_cleanup(); 1011 chsc_cleanup_sch_driver(); 1012 isc_unregister(CHSC_SCH_ISC); 1013 chsc_remove_dbfs(); 1014 } 1015 1016 module_init(chsc_sch_init); 1017 module_exit(chsc_sch_exit); 1018