drm/i915: Implement batch and ring buffer dumping
[linux-2.6] / drivers / staging / comedi / comedi_compat32.c
1 /*
2     comedi/comedi_compat32.c
3     32-bit ioctl compatibility for 64-bit comedi kernel module.
4
5     Author: Ian Abbott, MEV Ltd. <abbotti@mev.co.uk>
6     Copyright (C) 2007 MEV Ltd. <http://www.mev.co.uk/>
7
8     COMEDI - Linux Control and Measurement Device Interface
9     Copyright (C) 1997-2007 David A. Schleef <ds@schleef.org>
10
11     This program is free software; you can redistribute it and/or modify
12     it under the terms of the GNU General Public License as published by
13     the Free Software Foundation; either version 2 of the License, or
14     (at your option) any later version.
15
16     This program is distributed in the hope that it will be useful,
17     but WITHOUT ANY WARRANTY; without even the implied warranty of
18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19     GNU General Public License for more details.
20
21     You should have received a copy of the GNU General Public License
22     along with this program; if not, write to the Free Software
23     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24
25 */
26
27 #define __NO_VERSION__
28 #include "comedi.h"
29 #include <linux/smp_lock.h>
30 #include <asm/uaccess.h>
31
32 #include "comedi_compat32.h"
33
34 #ifdef CONFIG_COMPAT
35
36 #ifndef HAVE_COMPAT_IOCTL
37 #include <linux/ioctl32.h>      /* for (un)register_ioctl32_conversion */
38 #endif
39
40 #define COMEDI32_CHANINFO _IOR(CIO,3,comedi32_chaninfo)
41 #define COMEDI32_RANGEINFO _IOR(CIO,8,comedi32_rangeinfo)
42 /* N.B. COMEDI32_CMD and COMEDI_CMD ought to use _IOWR, not _IOR.
43  * It's too late to change it now, but it only affects the command number. */
44 #define COMEDI32_CMD _IOR(CIO,9,comedi32_cmd)
45 /* N.B. COMEDI32_CMDTEST and COMEDI_CMDTEST ought to use _IOWR, not _IOR.
46  * It's too late to change it now, but it only affects the command number. */
47 #define COMEDI32_CMDTEST _IOR(CIO,10,comedi32_cmd)
48 #define COMEDI32_INSNLIST _IOR(CIO,11,comedi32_insnlist)
49 #define COMEDI32_INSN _IOR(CIO,12,comedi32_insn)
50
51 typedef struct comedi32_chaninfo_struct {
52         unsigned int subdev;
53         compat_uptr_t maxdata_list;     /* 32-bit 'lsampl_t *' */
54         compat_uptr_t flaglist;         /* 32-bit 'unsigned int *' */
55         compat_uptr_t rangelist;        /* 32-bit 'unsigned int *' */
56         unsigned int unused[4];
57 } comedi32_chaninfo;
58
59 typedef struct comedi32_rangeinfo_struct {
60         unsigned int range_type;
61         compat_uptr_t range_ptr;        /* 32-bit 'void *' */
62 } comedi32_rangeinfo;
63
64 typedef struct comedi32_cmd_struct {
65         unsigned int subdev;
66         unsigned int flags;
67         unsigned int start_src;
68         unsigned int start_arg;
69         unsigned int scan_begin_src;
70         unsigned int scan_begin_arg;
71         unsigned int convert_src;
72         unsigned int convert_arg;
73         unsigned int scan_end_src;
74         unsigned int scan_end_arg;
75         unsigned int stop_src;
76         unsigned int stop_arg;
77         compat_uptr_t chanlist;         /* 32-bit 'unsigned int *' */
78         unsigned int chanlist_len;
79         compat_uptr_t data;             /* 32-bit 'sampl_t *' */
80         unsigned int data_len;
81 } comedi32_cmd;
82
83 typedef struct comedi32_insn_struct {
84         unsigned int insn;
85         unsigned int n;
86         compat_uptr_t data;             /* 32-bit 'lsampl_t *' */
87         unsigned int subdev;
88         unsigned int chanspec;
89         unsigned int unused[3];
90 } comedi32_insn;
91
92 typedef struct comedi32_insnlist_struct {
93         unsigned int n_insns;
94         compat_uptr_t insns;            /* 32-bit 'comedi_insn *' */
95 } comedi32_insnlist;
96
97 /* Handle translated ioctl. */
98 static int translated_ioctl(struct file *file, unsigned int cmd,
99                 unsigned long arg)
100 {
101         if (!file->f_op) {
102                 return -ENOTTY;
103         }
104 #ifdef HAVE_UNLOCKED_IOCTL
105         if (file->f_op->unlocked_ioctl) {
106                 int rc = (int)(*file->f_op->unlocked_ioctl)(file, cmd, arg);
107                 if (rc == -ENOIOCTLCMD) {
108                         rc = -ENOTTY;
109                 }
110                 return rc;
111         }
112 #endif
113         if (file->f_op->ioctl) {
114                 int rc;
115                 lock_kernel();
116                 rc = (*file->f_op->ioctl)(file->f_dentry->d_inode,
117                                 file, cmd, arg);
118                 unlock_kernel();
119                 return rc;
120         }
121         return -ENOTTY;
122 }
123
124 /* Handle 32-bit COMEDI_CHANINFO ioctl. */
125 static int compat_chaninfo(struct file *file, unsigned long arg)
126 {
127         comedi_chaninfo __user *chaninfo;
128         comedi32_chaninfo __user *chaninfo32;
129         int err;
130         union {
131                 unsigned int uint;
132                 compat_uptr_t uptr;
133         } temp;
134
135         chaninfo32 = compat_ptr(arg);
136         chaninfo = compat_alloc_user_space(sizeof(*chaninfo));
137
138         /* Copy chaninfo structure.  Ignore unused members. */
139         if (!access_ok(VERIFY_READ, chaninfo32, sizeof(*chaninfo32))
140                         || !access_ok(VERIFY_WRITE, chaninfo,
141                                 sizeof(*chaninfo))) {
142                 return -EFAULT;
143         }
144         err = 0;
145         err |= __get_user(temp.uint, &chaninfo32->subdev);
146         err |= __put_user(temp.uint, &chaninfo->subdev);
147         err |= __get_user(temp.uptr, &chaninfo32->maxdata_list);
148         err |= __put_user(compat_ptr(temp.uptr), &chaninfo->maxdata_list);
149         err |= __get_user(temp.uptr, &chaninfo32->flaglist);
150         err |= __put_user(compat_ptr(temp.uptr), &chaninfo->flaglist);
151         err |= __get_user(temp.uptr, &chaninfo32->rangelist);
152         err |= __put_user(compat_ptr(temp.uptr), &chaninfo->rangelist);
153         if (err) {
154                 return -EFAULT;
155         }
156
157         return translated_ioctl(file, COMEDI_CHANINFO, (unsigned long)chaninfo);
158 }
159
160 /* Handle 32-bit COMEDI_RANGEINFO ioctl. */
161 static int compat_rangeinfo(struct file *file, unsigned long arg)
162 {
163         comedi_rangeinfo __user *rangeinfo;
164         comedi32_rangeinfo __user *rangeinfo32;
165         int err;
166         union {
167                 unsigned int uint;
168                 compat_uptr_t uptr;
169         } temp;
170
171         rangeinfo32 = compat_ptr(arg);
172         rangeinfo = compat_alloc_user_space(sizeof(*rangeinfo));
173
174         /* Copy rangeinfo structure. */
175         if (!access_ok(VERIFY_READ, rangeinfo32, sizeof(*rangeinfo32))
176                         || !access_ok(VERIFY_WRITE, rangeinfo,
177                                 sizeof(*rangeinfo))) {
178                 return -EFAULT;
179         }
180         err = 0;
181         err |= __get_user(temp.uint, &rangeinfo32->range_type);
182         err |= __put_user(temp.uint, &rangeinfo->range_type);
183         err |= __get_user(temp.uptr, &rangeinfo32->range_ptr);
184         err |= __put_user(compat_ptr(temp.uptr), &rangeinfo->range_ptr);
185         if (err) {
186                 return -EFAULT;
187         }
188
189         return translated_ioctl(file, COMEDI_RANGEINFO,
190                         (unsigned long)rangeinfo);
191 }
192
193 /* Copy 32-bit cmd structure to native cmd structure. */
194 static int get_compat_cmd(comedi_cmd __user *cmd,
195                 comedi32_cmd __user *cmd32)
196 {
197         int err;
198         union {
199                 unsigned int uint;
200                 compat_uptr_t uptr;
201         } temp;
202
203         /* Copy cmd structure. */
204         if (!access_ok(VERIFY_READ, cmd32, sizeof(*cmd32))
205                         || !access_ok(VERIFY_WRITE, cmd, sizeof(*cmd))) {
206                 return -EFAULT;
207         }
208         err = 0;
209         err |= __get_user(temp.uint, &cmd32->subdev);
210         err |= __put_user(temp.uint, &cmd->subdev);
211         err |= __get_user(temp.uint, &cmd32->flags);
212         err |= __put_user(temp.uint, &cmd->flags);
213         err |= __get_user(temp.uint, &cmd32->start_src);
214         err |= __put_user(temp.uint, &cmd->start_src);
215         err |= __get_user(temp.uint, &cmd32->start_arg);
216         err |= __put_user(temp.uint, &cmd->start_arg);
217         err |= __get_user(temp.uint, &cmd32->scan_begin_src);
218         err |= __put_user(temp.uint, &cmd->scan_begin_src);
219         err |= __get_user(temp.uint, &cmd32->scan_begin_arg);
220         err |= __put_user(temp.uint, &cmd->scan_begin_arg);
221         err |= __get_user(temp.uint, &cmd32->convert_src);
222         err |= __put_user(temp.uint, &cmd->convert_src);
223         err |= __get_user(temp.uint, &cmd32->convert_arg);
224         err |= __put_user(temp.uint, &cmd->convert_arg);
225         err |= __get_user(temp.uint, &cmd32->scan_end_src);
226         err |= __put_user(temp.uint, &cmd->scan_end_src);
227         err |= __get_user(temp.uint, &cmd32->scan_end_arg);
228         err |= __put_user(temp.uint, &cmd->scan_end_arg);
229         err |= __get_user(temp.uint, &cmd32->stop_src);
230         err |= __put_user(temp.uint, &cmd->stop_src);
231         err |= __get_user(temp.uint, &cmd32->stop_arg);
232         err |= __put_user(temp.uint, &cmd->stop_arg);
233         err |= __get_user(temp.uptr, &cmd32->chanlist);
234         err |= __put_user(compat_ptr(temp.uptr), &cmd->chanlist);
235         err |= __get_user(temp.uint, &cmd32->chanlist_len);
236         err |= __put_user(temp.uint, &cmd->chanlist_len);
237         err |= __get_user(temp.uptr, &cmd32->data);
238         err |= __put_user(compat_ptr(temp.uptr), &cmd->data);
239         err |= __get_user(temp.uint, &cmd32->data_len);
240         err |= __put_user(temp.uint, &cmd->data_len);
241         return err ? -EFAULT : 0;
242 }
243
244 /* Copy native cmd structure to 32-bit cmd structure. */
245 static int put_compat_cmd(comedi32_cmd __user *cmd32, comedi_cmd __user *cmd)
246 {
247         int err;
248         unsigned int temp;
249
250         /* Copy back most of cmd structure. */
251         /* Assume the pointer values are already valid. */
252         /* (Could use ptr_to_compat() to set them, but that wasn't implemented
253          * until kernel version 2.6.11.) */
254         if (!access_ok(VERIFY_READ, cmd, sizeof(*cmd))
255                         || !access_ok(VERIFY_WRITE, cmd32, sizeof(*cmd32))) {
256                 return -EFAULT;
257         }
258         err = 0;
259         err |= __get_user(temp, &cmd->subdev);
260         err |= __put_user(temp, &cmd32->subdev);
261         err |= __get_user(temp, &cmd->flags);
262         err |= __put_user(temp, &cmd32->flags);
263         err |= __get_user(temp, &cmd->start_src);
264         err |= __put_user(temp, &cmd32->start_src);
265         err |= __get_user(temp, &cmd->start_arg);
266         err |= __put_user(temp, &cmd32->start_arg);
267         err |= __get_user(temp, &cmd->scan_begin_src);
268         err |= __put_user(temp, &cmd32->scan_begin_src);
269         err |= __get_user(temp, &cmd->scan_begin_arg);
270         err |= __put_user(temp, &cmd32->scan_begin_arg);
271         err |= __get_user(temp, &cmd->convert_src);
272         err |= __put_user(temp, &cmd32->convert_src);
273         err |= __get_user(temp, &cmd->convert_arg);
274         err |= __put_user(temp, &cmd32->convert_arg);
275         err |= __get_user(temp, &cmd->scan_end_src);
276         err |= __put_user(temp, &cmd32->scan_end_src);
277         err |= __get_user(temp, &cmd->scan_end_arg);
278         err |= __put_user(temp, &cmd32->scan_end_arg);
279         err |= __get_user(temp, &cmd->stop_src);
280         err |= __put_user(temp, &cmd32->stop_src);
281         err |= __get_user(temp, &cmd->stop_arg);
282         err |= __put_user(temp, &cmd32->stop_arg);
283         /* Assume chanlist pointer is unchanged. */
284         err |= __get_user(temp, &cmd->chanlist_len);
285         err |= __put_user(temp, &cmd32->chanlist_len);
286         /* Assume data pointer is unchanged. */
287         err |= __get_user(temp, &cmd->data_len);
288         err |= __put_user(temp, &cmd32->data_len);
289         return err ? -EFAULT : 0;
290 }
291
292 /* Handle 32-bit COMEDI_CMD ioctl. */
293 static int compat_cmd(struct file *file, unsigned long arg)
294 {
295         comedi_cmd __user *cmd;
296         comedi32_cmd __user *cmd32;
297         int rc;
298
299         cmd32 = compat_ptr(arg);
300         cmd = compat_alloc_user_space(sizeof(*cmd));
301
302         rc = get_compat_cmd(cmd, cmd32);
303         if (rc) {
304                 return rc;
305         }
306
307         return translated_ioctl(file, COMEDI_CMD, (unsigned long)cmd);
308 }
309
310 /* Handle 32-bit COMEDI_CMDTEST ioctl. */
311 static int compat_cmdtest(struct file *file, unsigned long arg)
312 {
313         comedi_cmd __user *cmd;
314         comedi32_cmd __user *cmd32;
315         int rc, err;
316
317         cmd32 = compat_ptr(arg);
318         cmd = compat_alloc_user_space(sizeof(*cmd));
319
320         rc = get_compat_cmd(cmd, cmd32);
321         if (rc) {
322                 return rc;
323         }
324
325         rc = translated_ioctl(file, COMEDI_CMDTEST, (unsigned long)cmd);
326         if (rc < 0) {
327                 return rc;
328         }
329
330         err = put_compat_cmd(cmd32, cmd);
331         if (err) {
332                 rc = err;
333         }
334         return rc;
335 }
336
337 /* Copy 32-bit insn structure to native insn structure. */
338 static int get_compat_insn(comedi_insn __user *insn,
339                 comedi32_insn __user *insn32)
340 {
341         int err;
342         union {
343                 unsigned int uint;
344                 compat_uptr_t uptr;
345         } temp;
346
347         /* Copy insn structure.  Ignore the unused members. */
348         err = 0;
349         if (!access_ok(VERIFY_READ, insn32, sizeof(*insn32))
350                         || !access_ok(VERIFY_WRITE, insn, sizeof(*insn))) {
351                 return -EFAULT;
352         }
353         err |= __get_user(temp.uint, &insn32->insn);
354         err |= __put_user(temp.uint, &insn->insn);
355         err |= __get_user(temp.uint, &insn32->n);
356         err |= __put_user(temp.uint, &insn->n);
357         err |= __get_user(temp.uptr, &insn32->data);
358         err |= __put_user(compat_ptr(temp.uptr), &insn->data);
359         err |= __get_user(temp.uint, &insn32->subdev);
360         err |= __put_user(temp.uint, &insn->subdev);
361         err |= __get_user(temp.uint, &insn32->chanspec);
362         err |= __put_user(temp.uint, &insn->chanspec);
363         return err ? -EFAULT : 0;
364 }
365
366 /* Handle 32-bit COMEDI_INSNLIST ioctl. */
367 static int compat_insnlist(struct file *file, unsigned long arg)
368 {
369         struct combined_insnlist {
370                 comedi_insnlist insnlist;
371                 comedi_insn insn[1];
372         } __user *s;
373         comedi32_insnlist __user *insnlist32;
374         comedi32_insn __user *insn32;
375         compat_uptr_t uptr;
376         unsigned int n_insns, n;
377         int err, rc;
378
379         insnlist32 = compat_ptr(arg);
380
381         /* Get 32-bit insnlist structure.  */
382         if (!access_ok(VERIFY_READ, insnlist32, sizeof(*insnlist32))) {
383                 return -EFAULT;
384         }
385         err = 0;
386         err |= __get_user(n_insns, &insnlist32->n_insns);
387         err |= __get_user(uptr, &insnlist32->insns);
388         insn32 = compat_ptr(uptr);
389         if (err) {
390                 return -EFAULT;
391         }
392
393         /* Allocate user memory to copy insnlist and insns into. */
394         s = compat_alloc_user_space(offsetof(struct combined_insnlist,
395                                 insn[n_insns]));
396
397         /* Set native insnlist structure. */
398         if (!access_ok(VERIFY_WRITE, &s->insnlist, sizeof(s->insnlist))) {
399                 return -EFAULT;
400         }
401         err |= __put_user(n_insns, &s->insnlist.n_insns);
402         err |= __put_user(&s->insn[0], &s->insnlist.insns);
403         if (err) {
404                 return -EFAULT;
405         }
406
407         /* Copy insn structures. */
408         for (n = 0; n < n_insns; n++) {
409                 rc = get_compat_insn(&s->insn[n], &insn32[n]);
410                 if (rc) {
411                         return rc;
412                 }
413         }
414
415         return translated_ioctl(file, COMEDI_INSNLIST,
416                         (unsigned long)&s->insnlist);
417 }
418
419 /* Handle 32-bit COMEDI_INSN ioctl. */
420 static int compat_insn(struct file *file, unsigned long arg)
421 {
422         comedi_insn __user *insn;
423         comedi32_insn __user *insn32;
424         int rc;
425
426         insn32 = compat_ptr(arg);
427         insn = compat_alloc_user_space(sizeof(*insn));
428
429         rc = get_compat_insn(insn, insn32);
430         if (rc) {
431                 return rc;
432         }
433
434         return translated_ioctl(file, COMEDI_INSN, (unsigned long)insn);
435 }
436
437 /* Process untranslated ioctl. */
438 /* Returns -ENOIOCTLCMD for unrecognised ioctl codes. */
439 static inline int raw_ioctl(struct file *file, unsigned int cmd,
440                 unsigned long arg)
441 {
442         int rc;
443
444         switch (cmd) {
445         case COMEDI_DEVCONFIG:
446         case COMEDI_DEVINFO:
447         case COMEDI_SUBDINFO:
448         case COMEDI_BUFCONFIG:
449         case COMEDI_BUFINFO:
450                 /* Just need to translate the pointer argument. */
451                 arg = (unsigned long)compat_ptr(arg);
452                 rc = translated_ioctl(file, cmd, arg);
453                 break;
454         case COMEDI_LOCK:
455         case COMEDI_UNLOCK:
456         case COMEDI_CANCEL:
457         case COMEDI_POLL:
458                 /* No translation needed. */
459                 rc = translated_ioctl(file, cmd, arg);
460                 break;
461         case COMEDI32_CHANINFO:
462                 rc = compat_chaninfo(file, arg);
463                 break;
464         case COMEDI32_RANGEINFO:
465                 rc = compat_rangeinfo(file, arg);
466                 break;
467         case COMEDI32_CMD:
468                 rc = compat_cmd(file, arg);
469                 break;
470         case COMEDI32_CMDTEST:
471                 rc = compat_cmdtest(file, arg);
472                 break;
473         case COMEDI32_INSNLIST:
474                 rc = compat_insnlist(file, arg);
475                 break;
476         case COMEDI32_INSN:
477                 rc = compat_insn(file, arg);
478                 break;
479         default:
480                 rc = -ENOIOCTLCMD;
481                 break;
482         }
483         return rc;
484 }
485
486 #ifdef HAVE_COMPAT_IOCTL        /* defined in <linux/fs.h> 2.6.11 onwards */
487
488 /* compat_ioctl file operation. */
489 /* Returns -ENOIOCTLCMD for unrecognised ioctl codes. */
490 long comedi_compat_ioctl(struct file *file, unsigned int cmd,
491                 unsigned long arg)
492 {
493         return raw_ioctl(file, cmd, arg);
494 }
495
496 #else /* HAVE_COMPAT_IOCTL */
497
498 /*
499  * Brain-dead ioctl compatibility for 2.6.10 and earlier.
500  *
501  * It's brain-dead because cmd numbers need to be unique system-wide!
502  * The comedi driver could end up attempting to execute ioctls for non-Comedi
503  * devices because it registered the system-wide cmd code first.  Similarly,
504  * another driver could end up attempting to execute ioctls for a Comedi
505  * device because it registered the cmd code first.  Chaos ensues.
506  */
507
508 /* Handler for all 32-bit ioctl codes registered by this driver. */
509 static int mapped_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg,
510                 struct file *file)
511 {
512         int rc;
513
514         /* Make sure we are dealing with a Comedi device. */
515         if (imajor(file->f_dentry->d_inode) != COMEDI_MAJOR) {
516                 return -ENOTTY;
517         }
518         rc = raw_ioctl(file, cmd, arg);
519         /* Do not return -ENOIOCTLCMD. */
520         if (rc == -ENOIOCTLCMD) {
521                 rc = -ENOTTY;
522         }
523         return rc;
524 }
525
526 struct ioctl32_map {
527         unsigned int cmd;
528         int (*handler)(unsigned int, unsigned int, unsigned long,
529                         struct file *);
530         int registered;
531 };
532
533 static struct ioctl32_map comedi_ioctl32_map[] = {
534         { COMEDI_DEVCONFIG, mapped_ioctl, 0 },
535         { COMEDI_DEVINFO, mapped_ioctl, 0 },
536         { COMEDI_SUBDINFO, mapped_ioctl, 0 },
537         { COMEDI_BUFCONFIG, mapped_ioctl, 0 },
538         { COMEDI_BUFINFO, mapped_ioctl, 0 },
539         { COMEDI_LOCK, mapped_ioctl, 0 },
540         { COMEDI_UNLOCK, mapped_ioctl, 0 },
541         { COMEDI_CANCEL, mapped_ioctl, 0 },
542         { COMEDI_POLL, mapped_ioctl, 0 },
543         { COMEDI32_CHANINFO, mapped_ioctl, 0 },
544         { COMEDI32_RANGEINFO, mapped_ioctl, 0 },
545         { COMEDI32_CMD, mapped_ioctl, 0 },
546         { COMEDI32_CMDTEST, mapped_ioctl, 0 },
547         { COMEDI32_INSNLIST, mapped_ioctl, 0 },
548         { COMEDI32_INSN, mapped_ioctl, 0 },
549 };
550
551 #define NUM_IOCTL32_MAPS ARRAY_SIZE(comedi_ioctl32_map)
552
553 /* Register system-wide 32-bit ioctl handlers. */
554 void comedi_register_ioctl32(void)
555 {
556         int n, rc;
557
558         for (n = 0; n < NUM_IOCTL32_MAPS; n++) {
559                 rc = register_ioctl32_conversion(comedi_ioctl32_map[n].cmd,
560                                 comedi_ioctl32_map[n].handler);
561                 if (rc) {
562                         printk(KERN_WARNING
563                                         "comedi: failed to register 32-bit "
564                                         "compatible ioctl handler for 0x%X - "
565                                         "expect bad things to happen!\n",
566                                         comedi_ioctl32_map[n].cmd);
567                 }
568                 comedi_ioctl32_map[n].registered = !rc;
569         }
570 }
571
572 /* Unregister system-wide 32-bit ioctl translations. */
573 void comedi_unregister_ioctl32(void)
574 {
575         int n, rc;
576
577         for (n = 0; n < NUM_IOCTL32_MAPS; n++) {
578                 if (comedi_ioctl32_map[n].registered) {
579                         rc = unregister_ioctl32_conversion(
580                                         comedi_ioctl32_map[n].cmd,
581                                         comedi_ioctl32_map[n].handler);
582                         if (rc) {
583                                 printk(KERN_ERR
584                                         "comedi: failed to unregister 32-bit "
585                                         "compatible ioctl handler for 0x%X - "
586                                         "expect kernel Oops!\n",
587                                         comedi_ioctl32_map[n].cmd);
588                         } else {
589                                 comedi_ioctl32_map[n].registered = 0;
590                         }
591                 }
592         }
593 }
594
595 #endif  /* HAVE_COMPAT_IOCTL */
596
597 #endif  /* CONFIG_COMPAT */