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