blob: e7eeaf1c1826bede691716854272c1bf79c35297 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * drivers/s390/cio/device_ops.c
3 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
5 * IBM Corporation
6 * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
Cornelia Huck4ce3b302006-01-14 13:21:04 -08007 * Cornelia Huck (cornelia.huck@de.ibm.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/module.h>
10#include <linux/init.h>
11#include <linux/errno.h>
12#include <linux/slab.h>
13#include <linux/list.h>
14#include <linux/device.h>
15#include <linux/delay.h>
16
17#include <asm/ccwdev.h>
18#include <asm/idals.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019
20#include "cio.h"
21#include "cio_debug.h"
22#include "css.h"
23#include "chsc.h"
24#include "device.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
26int
27ccw_device_set_options(struct ccw_device *cdev, unsigned long flags)
28{
29 /*
30 * The flag usage is mutal exclusive ...
31 */
32 if ((flags & CCWDEV_EARLY_NOTIFICATION) &&
33 (flags & CCWDEV_REPORT_ALL))
34 return -EINVAL;
35 cdev->private->options.fast = (flags & CCWDEV_EARLY_NOTIFICATION) != 0;
36 cdev->private->options.repall = (flags & CCWDEV_REPORT_ALL) != 0;
37 cdev->private->options.pgroup = (flags & CCWDEV_DO_PATHGROUP) != 0;
38 cdev->private->options.force = (flags & CCWDEV_ALLOW_FORCE) != 0;
39 return 0;
40}
41
42int
43ccw_device_clear(struct ccw_device *cdev, unsigned long intparm)
44{
45 struct subchannel *sch;
46 int ret;
47
48 if (!cdev)
49 return -ENODEV;
50 if (cdev->private->state == DEV_STATE_NOT_OPER)
51 return -ENODEV;
52 if (cdev->private->state != DEV_STATE_ONLINE &&
53 cdev->private->state != DEV_STATE_WAIT4IO &&
54 cdev->private->state != DEV_STATE_W4SENSE)
55 return -EINVAL;
56 sch = to_subchannel(cdev->dev.parent);
57 if (!sch)
58 return -ENODEV;
59 ret = cio_clear(sch);
60 if (ret == 0)
61 cdev->private->intparm = intparm;
62 return ret;
63}
64
65int
66ccw_device_start_key(struct ccw_device *cdev, struct ccw1 *cpa,
67 unsigned long intparm, __u8 lpm, __u8 key,
68 unsigned long flags)
69{
70 struct subchannel *sch;
71 int ret;
72
73 if (!cdev)
74 return -ENODEV;
75 sch = to_subchannel(cdev->dev.parent);
76 if (!sch)
77 return -ENODEV;
78 if (cdev->private->state == DEV_STATE_NOT_OPER)
79 return -ENODEV;
Cornelia Huckb4f7b1e2006-06-29 15:03:35 +020080 if (cdev->private->state == DEV_STATE_VERIFY ||
81 cdev->private->state == DEV_STATE_CLEAR_VERIFY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 /* Remember to fake irb when finished. */
83 if (!cdev->private->flags.fake_irb) {
84 cdev->private->flags.fake_irb = 1;
85 cdev->private->intparm = intparm;
86 return 0;
87 } else
88 /* There's already a fake I/O around. */
89 return -EBUSY;
90 }
91 if (cdev->private->state != DEV_STATE_ONLINE ||
92 ((sch->schib.scsw.stctl & SCSW_STCTL_PRIM_STATUS) &&
93 !(sch->schib.scsw.stctl & SCSW_STCTL_SEC_STATUS)) ||
94 cdev->private->flags.doverify)
95 return -EBUSY;
96 ret = cio_set_options (sch, flags);
97 if (ret)
98 return ret;
Peter Oberparleitere0e32c82006-09-20 15:59:57 +020099 /* Adjust requested path mask to excluded varied off paths. */
100 if (lpm) {
101 lpm &= sch->opm;
102 if (lpm == 0)
103 return -EACCES;
104 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 ret = cio_start_key (sch, cpa, lpm, key);
106 if (ret == 0)
107 cdev->private->intparm = intparm;
108 return ret;
109}
110
111
112int
113ccw_device_start_timeout_key(struct ccw_device *cdev, struct ccw1 *cpa,
114 unsigned long intparm, __u8 lpm, __u8 key,
115 unsigned long flags, int expires)
116{
117 int ret;
118
119 if (!cdev)
120 return -ENODEV;
121 ccw_device_set_timeout(cdev, expires);
122 ret = ccw_device_start_key(cdev, cpa, intparm, lpm, key, flags);
123 if (ret != 0)
124 ccw_device_set_timeout(cdev, 0);
125 return ret;
126}
127
128int
129ccw_device_start(struct ccw_device *cdev, struct ccw1 *cpa,
130 unsigned long intparm, __u8 lpm, unsigned long flags)
131{
132 return ccw_device_start_key(cdev, cpa, intparm, lpm,
Peter Oberparleiter0b642ed2005-05-01 08:58:58 -0700133 PAGE_DEFAULT_KEY, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134}
135
136int
137ccw_device_start_timeout(struct ccw_device *cdev, struct ccw1 *cpa,
138 unsigned long intparm, __u8 lpm, unsigned long flags,
139 int expires)
140{
141 return ccw_device_start_timeout_key(cdev, cpa, intparm, lpm,
Peter Oberparleiter0b642ed2005-05-01 08:58:58 -0700142 PAGE_DEFAULT_KEY, flags,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 expires);
144}
145
146
147int
148ccw_device_halt(struct ccw_device *cdev, unsigned long intparm)
149{
150 struct subchannel *sch;
151 int ret;
152
153 if (!cdev)
154 return -ENODEV;
155 if (cdev->private->state == DEV_STATE_NOT_OPER)
156 return -ENODEV;
157 if (cdev->private->state != DEV_STATE_ONLINE &&
158 cdev->private->state != DEV_STATE_WAIT4IO &&
159 cdev->private->state != DEV_STATE_W4SENSE)
160 return -EINVAL;
161 sch = to_subchannel(cdev->dev.parent);
162 if (!sch)
163 return -ENODEV;
164 ret = cio_halt(sch);
165 if (ret == 0)
166 cdev->private->intparm = intparm;
167 return ret;
168}
169
170int
171ccw_device_resume(struct ccw_device *cdev)
172{
173 struct subchannel *sch;
174
175 if (!cdev)
176 return -ENODEV;
177 sch = to_subchannel(cdev->dev.parent);
178 if (!sch)
179 return -ENODEV;
180 if (cdev->private->state == DEV_STATE_NOT_OPER)
181 return -ENODEV;
182 if (cdev->private->state != DEV_STATE_ONLINE ||
183 !(sch->schib.scsw.actl & SCSW_ACTL_SUSPENDED))
184 return -EINVAL;
185 return cio_resume(sch);
186}
187
188/*
189 * Pass interrupt to device driver.
190 */
191int
192ccw_device_call_handler(struct ccw_device *cdev)
193{
194 struct subchannel *sch;
195 unsigned int stctl;
196 int ending_status;
197
198 sch = to_subchannel(cdev->dev.parent);
199
200 /*
201 * we allow for the device action handler if .
202 * - we received ending status
203 * - the action handler requested to see all interrupts
204 * - we received an intermediate status
205 * - fast notification was requested (primary status)
206 * - unsolicited interrupts
207 */
208 stctl = cdev->private->irb.scsw.stctl;
209 ending_status = (stctl & SCSW_STCTL_SEC_STATUS) ||
210 (stctl == (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND)) ||
211 (stctl == SCSW_STCTL_STATUS_PEND);
212 if (!ending_status &&
213 !cdev->private->options.repall &&
214 !(stctl & SCSW_STCTL_INTER_STATUS) &&
215 !(cdev->private->options.fast &&
216 (stctl & SCSW_STCTL_PRIM_STATUS)))
217 return 0;
218
Cornelia Huckf1ee3282006-10-04 20:02:02 +0200219 /* Clear pending timers for device driver initiated I/O. */
220 if (ending_status)
221 ccw_device_set_timeout(cdev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 /*
223 * Now we are ready to call the device driver interrupt handler.
224 */
225 if (cdev->handler)
226 cdev->handler(cdev, cdev->private->intparm,
227 &cdev->private->irb);
228
229 /*
230 * Clear the old and now useless interrupt response block.
231 */
232 memset(&cdev->private->irb, 0, sizeof(struct irb));
233
234 return 1;
235}
236
237/*
238 * Search for CIW command in extended sense data.
239 */
240struct ciw *
241ccw_device_get_ciw(struct ccw_device *cdev, __u32 ct)
242{
243 int ciw_cnt;
244
245 if (cdev->private->flags.esid == 0)
246 return NULL;
247 for (ciw_cnt = 0; ciw_cnt < MAX_CIWS; ciw_cnt++)
248 if (cdev->private->senseid.ciw[ciw_cnt].ct == ct)
249 return cdev->private->senseid.ciw + ciw_cnt;
250 return NULL;
251}
252
253__u8
254ccw_device_get_path_mask(struct ccw_device *cdev)
255{
256 struct subchannel *sch;
257
258 sch = to_subchannel(cdev->dev.parent);
259 if (!sch)
260 return 0;
261 else
Peter Oberparleiter28bdc6f2006-09-20 15:59:59 +0200262 return sch->lpm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263}
264
265static void
266ccw_device_wake_up(struct ccw_device *cdev, unsigned long ip, struct irb *irb)
267{
268 if (!ip)
269 /* unsolicited interrupt */
270 return;
271
272 /* Abuse intparm for error reporting. */
273 if (IS_ERR(irb))
274 cdev->private->intparm = -EIO;
Cornelia Huck4bc0c4f2006-08-07 17:00:30 +0200275 else if (irb->scsw.cc == 1)
276 /* Retry for deferred condition code. */
277 cdev->private->intparm = -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 else if ((irb->scsw.dstat !=
279 (DEV_STAT_CHN_END|DEV_STAT_DEV_END)) ||
280 (irb->scsw.cstat != 0)) {
281 /*
282 * We didn't get channel end / device end. Check if path
283 * verification has been started; we can retry after it has
284 * finished. We also retry unit checks except for command reject
Peter Oberparleiterda039bd2006-06-29 14:56:38 +0200285 * or intervention required. Also check for long busy
286 * conditions.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 */
288 if (cdev->private->flags.doverify ||
289 cdev->private->state == DEV_STATE_VERIFY)
290 cdev->private->intparm = -EAGAIN;
291 if ((irb->scsw.dstat & DEV_STAT_UNIT_CHECK) &&
292 !(irb->ecw[0] &
293 (SNS0_CMD_REJECT | SNS0_INTERVENTION_REQ)))
294 cdev->private->intparm = -EAGAIN;
Peter Oberparleiterda039bd2006-06-29 14:56:38 +0200295 else if ((irb->scsw.dstat & DEV_STAT_ATTENTION) &&
296 (irb->scsw.dstat & DEV_STAT_DEV_END) &&
297 (irb->scsw.dstat & DEV_STAT_UNIT_EXCEP))
298 cdev->private->intparm = -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 else
300 cdev->private->intparm = -EIO;
301
302 } else
303 cdev->private->intparm = 0;
304 wake_up(&cdev->private->wait_q);
305}
306
307static inline int
308__ccw_device_retry_loop(struct ccw_device *cdev, struct ccw1 *ccw, long magic, __u8 lpm)
309{
310 int ret;
311 struct subchannel *sch;
312
313 sch = to_subchannel(cdev->dev.parent);
314 do {
315 ret = cio_start (sch, ccw, lpm);
Peter Oberparleitere0e32c82006-09-20 15:59:57 +0200316 if (ret == -EBUSY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 /* Try again later. */
318 spin_unlock_irq(&sch->lock);
319 msleep(10);
320 spin_lock_irq(&sch->lock);
321 continue;
322 }
323 if (ret != 0)
324 /* Non-retryable error. */
325 break;
326 /* Wait for end of request. */
327 cdev->private->intparm = magic;
328 spin_unlock_irq(&sch->lock);
329 wait_event(cdev->private->wait_q,
330 (cdev->private->intparm == -EIO) ||
331 (cdev->private->intparm == -EAGAIN) ||
332 (cdev->private->intparm == 0));
333 spin_lock_irq(&sch->lock);
334 /* Check at least for channel end / device end */
335 if (cdev->private->intparm == -EIO) {
336 /* Non-retryable error. */
337 ret = -EIO;
338 break;
339 }
340 if (cdev->private->intparm == 0)
341 /* Success. */
342 break;
343 /* Try again later. */
344 spin_unlock_irq(&sch->lock);
345 msleep(10);
346 spin_lock_irq(&sch->lock);
347 } while (1);
348
349 return ret;
350}
351
352/**
353 * read_dev_chars() - read device characteristics
354 * @param cdev target ccw device
355 * @param buffer pointer to buffer for rdc data
356 * @param length size of rdc data
357 * @returns 0 for success, negative error value on failure
358 *
359 * Context:
360 * called for online device, lock not held
361 **/
362int
363read_dev_chars (struct ccw_device *cdev, void **buffer, int length)
364{
365 void (*handler)(struct ccw_device *, unsigned long, struct irb *);
366 struct subchannel *sch;
367 int ret;
368 struct ccw1 *rdc_ccw;
369
370 if (!cdev)
371 return -ENODEV;
372 if (!buffer || !length)
373 return -EINVAL;
374 sch = to_subchannel(cdev->dev.parent);
375
376 CIO_TRACE_EVENT (4, "rddevch");
377 CIO_TRACE_EVENT (4, sch->dev.bus_id);
378
Eric Sesterhenn88abaab2006-03-24 03:15:31 -0800379 rdc_ccw = kzalloc(sizeof(struct ccw1), GFP_KERNEL | GFP_DMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 if (!rdc_ccw)
381 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 rdc_ccw->cmd_code = CCW_CMD_RDC;
383 rdc_ccw->count = length;
384 rdc_ccw->flags = CCW_FLAG_SLI;
385 ret = set_normalized_cda (rdc_ccw, (*buffer));
386 if (ret != 0) {
387 kfree(rdc_ccw);
388 return ret;
389 }
390
391 spin_lock_irq(&sch->lock);
392 /* Save interrupt handler. */
393 handler = cdev->handler;
394 /* Temporarily install own handler. */
395 cdev->handler = ccw_device_wake_up;
396 if (cdev->private->state != DEV_STATE_ONLINE)
397 ret = -ENODEV;
398 else if (((sch->schib.scsw.stctl & SCSW_STCTL_PRIM_STATUS) &&
399 !(sch->schib.scsw.stctl & SCSW_STCTL_SEC_STATUS)) ||
400 cdev->private->flags.doverify)
401 ret = -EBUSY;
402 else
403 /* 0x00D9C4C3 == ebcdic "RDC" */
404 ret = __ccw_device_retry_loop(cdev, rdc_ccw, 0x00D9C4C3, 0);
405
406 /* Restore interrupt handler. */
407 cdev->handler = handler;
408 spin_unlock_irq(&sch->lock);
409
410 clear_normalized_cda (rdc_ccw);
411 kfree(rdc_ccw);
412
413 return ret;
414}
415
416/*
417 * Read Configuration data using path mask
418 */
419int
420read_conf_data_lpm (struct ccw_device *cdev, void **buffer, int *length, __u8 lpm)
421{
422 void (*handler)(struct ccw_device *, unsigned long, struct irb *);
423 struct subchannel *sch;
424 struct ciw *ciw;
425 char *rcd_buf;
426 int ret;
427 struct ccw1 *rcd_ccw;
428
429 if (!cdev)
430 return -ENODEV;
431 if (!buffer || !length)
432 return -EINVAL;
433 sch = to_subchannel(cdev->dev.parent);
434
435 CIO_TRACE_EVENT (4, "rdconf");
436 CIO_TRACE_EVENT (4, sch->dev.bus_id);
437
438 /*
439 * scan for RCD command in extended SenseID data
440 */
441 ciw = ccw_device_get_ciw(cdev, CIW_TYPE_RCD);
442 if (!ciw || ciw->cmd == 0)
443 return -EOPNOTSUPP;
444
Peter Oberparleitere0e32c82006-09-20 15:59:57 +0200445 /* Adjust requested path mask to excluded varied off paths. */
446 if (lpm) {
447 lpm &= sch->opm;
448 if (lpm == 0)
449 return -EACCES;
450 }
451
Eric Sesterhenn88abaab2006-03-24 03:15:31 -0800452 rcd_ccw = kzalloc(sizeof(struct ccw1), GFP_KERNEL | GFP_DMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 if (!rcd_ccw)
454 return -ENOMEM;
Eric Sesterhenn88abaab2006-03-24 03:15:31 -0800455 rcd_buf = kzalloc(ciw->count, GFP_KERNEL | GFP_DMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 if (!rcd_buf) {
457 kfree(rcd_ccw);
458 return -ENOMEM;
459 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 rcd_ccw->cmd_code = ciw->cmd;
461 rcd_ccw->cda = (__u32) __pa (rcd_buf);
462 rcd_ccw->count = ciw->count;
463 rcd_ccw->flags = CCW_FLAG_SLI;
464
465 spin_lock_irq(&sch->lock);
466 /* Save interrupt handler. */
467 handler = cdev->handler;
468 /* Temporarily install own handler. */
469 cdev->handler = ccw_device_wake_up;
470 if (cdev->private->state != DEV_STATE_ONLINE)
471 ret = -ENODEV;
472 else if (((sch->schib.scsw.stctl & SCSW_STCTL_PRIM_STATUS) &&
473 !(sch->schib.scsw.stctl & SCSW_STCTL_SEC_STATUS)) ||
474 cdev->private->flags.doverify)
475 ret = -EBUSY;
476 else
477 /* 0x00D9C3C4 == ebcdic "RCD" */
478 ret = __ccw_device_retry_loop(cdev, rcd_ccw, 0x00D9C3C4, lpm);
479
480 /* Restore interrupt handler. */
481 cdev->handler = handler;
482 spin_unlock_irq(&sch->lock);
483
484 /*
485 * on success we update the user input parms
486 */
487 if (ret) {
488 kfree (rcd_buf);
489 *buffer = NULL;
490 *length = 0;
491 } else {
492 *length = ciw->count;
493 *buffer = rcd_buf;
494 }
495 kfree(rcd_ccw);
496
497 return ret;
498}
499
500/*
501 * Read Configuration data
502 */
503int
504read_conf_data (struct ccw_device *cdev, void **buffer, int *length)
505{
506 return read_conf_data_lpm (cdev, buffer, length, 0);
507}
508
509/*
510 * Try to break the lock on a boxed device.
511 */
512int
513ccw_device_stlck(struct ccw_device *cdev)
514{
515 void *buf, *buf2;
516 unsigned long flags;
517 struct subchannel *sch;
518 int ret;
519
520 if (!cdev)
521 return -ENODEV;
522
523 if (cdev->drv && !cdev->private->options.force)
524 return -EINVAL;
525
526 sch = to_subchannel(cdev->dev.parent);
527
528 CIO_TRACE_EVENT(2, "stl lock");
529 CIO_TRACE_EVENT(2, cdev->dev.bus_id);
530
531 buf = kmalloc(32*sizeof(char), GFP_DMA|GFP_KERNEL);
532 if (!buf)
533 return -ENOMEM;
534 buf2 = kmalloc(32*sizeof(char), GFP_DMA|GFP_KERNEL);
535 if (!buf2) {
536 kfree(buf);
537 return -ENOMEM;
538 }
539 spin_lock_irqsave(&sch->lock, flags);
540 ret = cio_enable_subchannel(sch, 3);
541 if (ret)
542 goto out_unlock;
543 /*
544 * Setup ccw. We chain an unconditional reserve and a release so we
545 * only break the lock.
546 */
547 cdev->private->iccws[0].cmd_code = CCW_CMD_STLCK;
548 cdev->private->iccws[0].cda = (__u32) __pa(buf);
549 cdev->private->iccws[0].count = 32;
550 cdev->private->iccws[0].flags = CCW_FLAG_CC;
551 cdev->private->iccws[1].cmd_code = CCW_CMD_RELEASE;
552 cdev->private->iccws[1].cda = (__u32) __pa(buf2);
553 cdev->private->iccws[1].count = 32;
554 cdev->private->iccws[1].flags = 0;
555 ret = cio_start(sch, cdev->private->iccws, 0);
556 if (ret) {
557 cio_disable_subchannel(sch); //FIXME: return code?
558 goto out_unlock;
559 }
560 cdev->private->irb.scsw.actl |= SCSW_ACTL_START_PEND;
561 spin_unlock_irqrestore(&sch->lock, flags);
562 wait_event(cdev->private->wait_q, cdev->private->irb.scsw.actl == 0);
563 spin_lock_irqsave(&sch->lock, flags);
564 cio_disable_subchannel(sch); //FIXME: return code?
565 if ((cdev->private->irb.scsw.dstat !=
566 (DEV_STAT_CHN_END|DEV_STAT_DEV_END)) ||
567 (cdev->private->irb.scsw.cstat != 0))
568 ret = -EIO;
569 /* Clear irb. */
570 memset(&cdev->private->irb, 0, sizeof(struct irb));
571out_unlock:
Jesper Juhl17fd6822005-11-07 01:01:30 -0800572 kfree(buf);
573 kfree(buf2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 spin_unlock_irqrestore(&sch->lock, flags);
575 return ret;
576}
577
578void *
579ccw_device_get_chp_desc(struct ccw_device *cdev, int chp_no)
580{
581 struct subchannel *sch;
582
583 sch = to_subchannel(cdev->dev.parent);
584 return chsc_get_chp_desc(sch, chp_no);
585}
586
587// FIXME: these have to go:
588
589int
590_ccw_device_get_subchannel_number(struct ccw_device *cdev)
591{
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800592 return cdev->private->sch_no;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593}
594
595int
596_ccw_device_get_device_number(struct ccw_device *cdev)
597{
598 return cdev->private->devno;
599}
600
601
602MODULE_LICENSE("GPL");
603EXPORT_SYMBOL(ccw_device_set_options);
604EXPORT_SYMBOL(ccw_device_clear);
605EXPORT_SYMBOL(ccw_device_halt);
606EXPORT_SYMBOL(ccw_device_resume);
607EXPORT_SYMBOL(ccw_device_start_timeout);
608EXPORT_SYMBOL(ccw_device_start);
609EXPORT_SYMBOL(ccw_device_start_timeout_key);
610EXPORT_SYMBOL(ccw_device_start_key);
611EXPORT_SYMBOL(ccw_device_get_ciw);
612EXPORT_SYMBOL(ccw_device_get_path_mask);
613EXPORT_SYMBOL(read_conf_data);
614EXPORT_SYMBOL(read_dev_chars);
615EXPORT_SYMBOL(_ccw_device_get_subchannel_number);
616EXPORT_SYMBOL(_ccw_device_get_device_number);
617EXPORT_SYMBOL_GPL(ccw_device_get_chp_desc);
618EXPORT_SYMBOL_GPL(read_conf_data_lpm);