drivers/s390/cio/chsc_sch.c

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