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