linux_cdrom.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*      $NetBSD: linux_cdrom.c,v 1.20 2006/06/12 00:42:18 christos Exp $ */
    2 
    3 /*
    4  * Copyright (c) 1997 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. All advertising materials mentioning features or use of this software
   16  *    must display the following acknowledgement:
   17  *        This product includes software developed by the NetBSD
   18  *        Foundation, Inc. and its contributors.
   19  * 4. Neither the name of The NetBSD Foundation nor the names of its
   20  *    contributors may be used to endorse or promote products derived
   21  *    from this software without specific prior written permission.
   22  *
   23  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   24  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   25  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   26  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   27  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   31  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   33  * POSSIBILITY OF SUCH DAMAGE.
   34  */
   35 
   36 #include <sys/cdefs.h>
   37 __KERNEL_RCSID(0, "$NetBSD: linux_cdrom.c,v 1.20 2006/06/12 00:42:18 christos Exp $");
   38 
   39 #include <sys/param.h>
   40 #include <sys/systm.h>
   41 #include <sys/ioctl.h>
   42 #include <sys/file.h>
   43 #include <sys/filedesc.h>
   44 #include <sys/mount.h>
   45 #include <sys/proc.h>
   46 #include <sys/cdio.h>
   47 #include <sys/dvdio.h>
   48 #include <sys/malloc.h>
   49 
   50 #include <sys/sa.h>
   51 #include <sys/syscallargs.h>
   52 
   53 #include <compat/linux/common/linux_types.h>
   54 #include <compat/linux/common/linux_ioctl.h>
   55 #include <compat/linux/common/linux_signal.h>
   56 #include <compat/linux/common/linux_util.h>
   57 #include <compat/linux/common/linux_cdrom.h>
   58 
   59 #include <compat/linux/linux_syscallargs.h>
   60 
   61 static int bsd_to_linux_msf_lba(unsigned address_format, union msf_lba *bml,
   62                                 union linux_cdrom_addr *llml);
   63 
   64 #if DEBUG_LINUX
   65 #define DPRINTF(x) uprintf x
   66 #else
   67 #define DPRINTF(x)
   68 #endif
   69 
   70 /*
   71  * XXX from dev/scsipi/cd.c
   72  */
   73 #define MAXTRACK 99
   74 
   75 static int
   76 bsd_to_linux_msf_lba(unsigned address_format, union msf_lba *bml,
   77                       union linux_cdrom_addr *llml)
   78 {
   79         switch (address_format) {
   80         case CD_LBA_FORMAT:
   81                 llml->lba = bml->lba;
   82                 break;
   83         case CD_MSF_FORMAT:
   84                 llml->msf.minute = bml->msf.minute;
   85                 llml->msf.second = bml->msf.second;
   86                 llml->msf.frame = bml->msf.frame;
   87                 break;
   88         default:
   89                 return -1;
   90         }
   91         return 0;
   92 }
   93 
   94 int
   95 linux_ioctl_cdrom(l, uap, retval)
   96         struct lwp *l;
   97         struct linux_sys_ioctl_args /* {
   98                 syscallarg(int) fd;
   99                 syscallarg(u_long) com;
  100                 syscallarg(caddr_t) data;
  101         } */ *uap;
  102         register_t *retval;
  103 {
  104         int error, idata;
  105         u_long com, ncom;
  106         caddr_t sg;
  107         struct file *fp;
  108         struct filedesc *fdp;
  109         int (*ioctlf)(struct file *, u_long, void *, struct lwp *);
  110 
  111         union { 
  112                 struct linux_cdrom_blk ll_blk;
  113                 struct linux_cdrom_msf ll_msf;
  114                 struct linux_cdrom_ti ll_ti;
  115                 struct linux_cdrom_tochdr ll_tochdr;
  116                 struct linux_cdrom_tocentry ll_tocentry;
  117                 struct linux_cdrom_subchnl ll_subchnl;
  118                 struct linux_cdrom_volctrl ll_volctrl;
  119                 struct linux_cdrom_multisession ll_session;
  120                 dvd_struct ll_ds;
  121                 dvd_authinfo ll_dai;
  122         } *u1;
  123 
  124 #define l_blk u1->ll_blk
  125 #define l_msf u1->ll_msf
  126 #define l_ti u1->ll_ti
  127 #define l_tochdr u1->ll_tochdr
  128 #define l_tocentry u1->ll_tocentry
  129 #define l_subchnl u1->ll_subchnl
  130 #define l_volctrl u1->ll_volctrl
  131 #define l_session u1->ll_session
  132 #define ds u1->ll_ds
  133 #define dai u1->ll_dai
  134 
  135         union {
  136                 struct ioc_play_blocks tt_blocks;
  137                 struct ioc_play_msf tt_msf;
  138                 struct ioc_play_track tt_track;
  139                 struct ioc_toc_header tt_header;
  140                 struct cd_toc_entry tt_entry;
  141                 struct ioc_read_toc_entry tt_toc_entry;
  142                 struct cd_sub_channel_info tt_info;
  143                 struct ioc_read_subchannel tt_subchannel;
  144                 struct ioc_vol tt_vol;
  145         } *u2;
  146 
  147 #define t_blocks u2->tt_blocks
  148 #define t_msf u2->tt_msf
  149 #define t_track u2->tt_track
  150 #define t_header u2->tt_header
  151 #define t_entry u2->tt_entry
  152 #define t_toc_entry u2->tt_toc_entry
  153 #define t_info u2->tt_info
  154 #define t_subchannel u2->tt_subchannel
  155 #define t_vol u2->tt_vol
  156 
  157         struct cd_toc_entry *entry;
  158         struct cd_sub_channel_info *info;
  159         struct proc *p = l->l_proc;
  160 
  161         fdp = p->p_fd;
  162         if ((fp = fd_getfile(fdp, SCARG(uap, fd))) == NULL)
  163                 return (EBADF);
  164 
  165         FILE_USE(fp);
  166 
  167         com = SCARG(uap, com);
  168         ioctlf = fp->f_ops->fo_ioctl;
  169         retval[0] = error = 0;
  170 
  171         u1 = malloc(sizeof(*u1), M_TEMP, M_WAITOK);
  172         u2 = malloc(sizeof(*u2), M_TEMP, M_WAITOK);
  173 
  174         switch(com) {
  175         case LINUX_CDROMPLAYMSF:
  176                 error = copyin(SCARG(uap, data), &l_msf, sizeof l_msf);
  177                 if (error)
  178                         break;
  179 
  180                 t_msf.start_m = l_msf.cdmsf_min0;
  181                 t_msf.start_s = l_msf.cdmsf_sec0;
  182                 t_msf.start_f = l_msf.cdmsf_frame0;
  183                 t_msf.end_m = l_msf.cdmsf_min1;
  184                 t_msf.end_s = l_msf.cdmsf_sec1;
  185                 t_msf.end_f = l_msf.cdmsf_frame1;
  186 
  187                 error = ioctlf(fp, CDIOCPLAYMSF, (caddr_t)&t_msf, l);
  188                 break;
  189 
  190         case LINUX_CDROMPLAYTRKIND:
  191                 error = copyin(SCARG(uap, data), &l_ti, sizeof l_ti);
  192                 if (error)
  193                         break;
  194 
  195                 t_track.start_track = l_ti.cdti_trk0;
  196                 t_track.start_index = l_ti.cdti_ind0;
  197                 t_track.end_track = l_ti.cdti_trk1;
  198                 t_track.end_index = l_ti.cdti_ind1;
  199 
  200                 error = ioctlf(fp, CDIOCPLAYTRACKS, (caddr_t)&t_track, l);
  201                 break;
  202 
  203         case LINUX_CDROMREADTOCHDR:
  204                 error = ioctlf(fp, CDIOREADTOCHEADER, (caddr_t)&t_header, l);
  205                 if (error)
  206                         break;
  207 
  208                 l_tochdr.cdth_trk0 = t_header.starting_track;
  209                 l_tochdr.cdth_trk1 = t_header.ending_track;
  210 
  211                 error = copyout(&l_tochdr, SCARG(uap, data), sizeof l_tochdr);
  212                 break;
  213 
  214         case LINUX_CDROMREADTOCENTRY:
  215                 error = copyin(SCARG(uap, data), &l_tocentry,
  216                                sizeof l_tocentry);
  217                 if (error)
  218                         break;
  219 
  220                 sg = stackgap_init(p, 0);
  221                 entry = stackgap_alloc(p, &sg, sizeof *entry);
  222                 t_toc_entry.address_format = l_tocentry.cdte_format;
  223                 t_toc_entry.starting_track = l_tocentry.cdte_track;
  224                 t_toc_entry.data_len = sizeof *entry;
  225                 t_toc_entry.data = entry;
  226 
  227                 error = ioctlf(fp, CDIOREADTOCENTRIES, (caddr_t)&t_toc_entry,
  228                                l);
  229                 if (error)
  230                         break;
  231 
  232                 error = copyin(entry, &t_entry, sizeof t_entry);
  233                 if (error)
  234                         break;
  235 
  236                 l_tocentry.cdte_adr = t_entry.addr_type;
  237                 l_tocentry.cdte_ctrl = t_entry.control;
  238                 if (bsd_to_linux_msf_lba(t_entry.addr_type, &t_entry.addr,
  239                     &l_tocentry.cdte_addr) < 0) {
  240                         DPRINTF(("linux_ioctl: unknown format msf/lba\n"));
  241                         error = EINVAL;
  242                         break;
  243                 }
  244 
  245                 error = copyout(&l_tocentry, SCARG(uap, data),
  246                                sizeof l_tocentry);
  247                 break;
  248 
  249         case LINUX_CDROMVOLCTRL:
  250                 error = copyin(SCARG(uap, data), &l_volctrl, sizeof l_volctrl);
  251                 if (error)
  252                         break;
  253 
  254                 t_vol.vol[0] = l_volctrl.channel0;
  255                 t_vol.vol[1] = l_volctrl.channel1;
  256                 t_vol.vol[2] = l_volctrl.channel2;
  257                 t_vol.vol[3] = l_volctrl.channel3;
  258 
  259                 error = ioctlf(fp, CDIOCSETVOL, (caddr_t)&t_vol, l);
  260                 break;
  261 
  262         case LINUX_CDROMVOLREAD:
  263                 error = ioctlf(fp, CDIOCGETVOL, (caddr_t)&t_vol, l);
  264                 if (error)
  265                         break;
  266 
  267                 l_volctrl.channel0 = t_vol.vol[0];
  268                 l_volctrl.channel1 = t_vol.vol[1];
  269                 l_volctrl.channel2 = t_vol.vol[2];
  270                 l_volctrl.channel3 = t_vol.vol[3];
  271 
  272                 error = copyout(&l_volctrl, SCARG(uap, data), sizeof l_volctrl);
  273                 break;
  274 
  275         case LINUX_CDROMSUBCHNL:
  276                 error = copyin(SCARG(uap, data), &l_subchnl, sizeof l_subchnl);
  277                 if (error)
  278                         break;
  279 
  280                 sg = stackgap_init(p, 0);
  281                 info = stackgap_alloc(p, &sg, sizeof *info);
  282                 t_subchannel.address_format = CD_MSF_FORMAT;
  283                 t_subchannel.track = 0;
  284                 t_subchannel.data_format = l_subchnl.cdsc_format;
  285                 t_subchannel.data_len = sizeof *info;
  286                 t_subchannel.data = info;
  287                 DPRINTF(("linux_ioctl: CDROMSUBCHNL %d %d\n",
  288                          l_subchnl.cdsc_format, l_subchnl.cdsc_trk));
  289 
  290                 error = ioctlf(fp, CDIOCREADSUBCHANNEL, (caddr_t)&t_subchannel,
  291                                l);
  292                 if (error)
  293                         break;
  294 
  295                 error = copyin(info, &t_info, sizeof t_info);
  296                 if (error)
  297                         break;
  298 
  299                 l_subchnl.cdsc_audiostatus = t_info.header.audio_status;
  300                 l_subchnl.cdsc_adr = t_info.what.position.addr_type;
  301                 l_subchnl.cdsc_ctrl = t_info.what.position.control;
  302                 l_subchnl.cdsc_ind = t_info.what.position.index_number;
  303 
  304                 DPRINTF(("linux_ioctl: CDIOCREADSUBCHANNEL %d %d %d\n",
  305                         t_info.header.audio_status,
  306                         t_info.header.data_len[0],
  307                         t_info.header.data_len[1]));
  308                 DPRINTF(("(more) %d %d %d %d %d\n",
  309                         t_info.what.position.data_format,
  310                         t_info.what.position.control,
  311                         t_info.what.position.addr_type,
  312                         t_info.what.position.track_number,
  313                         t_info.what.position.index_number));
  314 
  315                 if (bsd_to_linux_msf_lba(t_subchannel.address_format,
  316                                          &t_info.what.position.absaddr,
  317                                          &l_subchnl.cdsc_absaddr) < 0 ||
  318                     bsd_to_linux_msf_lba(t_subchannel.address_format,
  319                                          &t_info.what.position.reladdr,
  320                                          &l_subchnl.cdsc_reladdr) < 0) {
  321                         DPRINTF(("linux_ioctl: unknown format msf/lba\n"));
  322                         error = EINVAL;
  323                         break;
  324                 }
  325 
  326                 error = copyout(&l_subchnl, SCARG(uap, data), sizeof l_subchnl);
  327                 break;
  328 
  329         case LINUX_CDROMPLAYBLK:
  330                 error = copyin(SCARG(uap, data), &l_blk, sizeof l_blk);
  331                 if (error)
  332                         break;
  333 
  334                 t_blocks.blk = l_blk.from;
  335                 t_blocks.len = l_blk.len;
  336 
  337                 error = ioctlf(fp, CDIOCPLAYBLOCKS, (caddr_t)&t_blocks, l);
  338                 break;
  339 
  340         case LINUX_CDROMEJECT_SW:
  341                 error = copyin(SCARG(uap, data), &idata, sizeof idata);
  342                 if (error)
  343                         break;
  344 
  345                 if (idata == 1)
  346                         ncom = CDIOCALLOW;
  347                 else
  348                         ncom = CDIOCPREVENT;
  349                 error = ioctlf(fp, ncom, NULL, l);
  350                 break;
  351 
  352         case LINUX_CDROMPAUSE:
  353                 error = ioctlf(fp, CDIOCPAUSE, NULL, l);
  354                 break;
  355 
  356         case LINUX_CDROMRESUME:
  357                 error = ioctlf(fp, CDIOCRESUME, NULL, l);
  358                 break;
  359 
  360         case LINUX_CDROMSTOP:
  361                 error = ioctlf(fp, CDIOCSTOP, NULL, l);
  362                 break;
  363 
  364         case LINUX_CDROMSTART:
  365                 error = ioctlf(fp, CDIOCSTART, NULL, l);
  366                 break;
  367 
  368         case LINUX_CDROMEJECT:
  369                 error = ioctlf(fp, CDIOCEJECT, NULL, l);
  370                 break;
  371 
  372         case LINUX_CDROMRESET:
  373                 error = ioctlf(fp, CDIOCRESET, NULL, l);
  374                 break;
  375 
  376         case LINUX_CDROMMULTISESSION:
  377                 error = copyin(SCARG(uap, data), &l_session, sizeof l_session);
  378                 if (error)
  379                         break;
  380 
  381                 error = ioctlf(fp, CDIOREADTOCHEADER, (caddr_t)&t_header, l);
  382                 if (error)
  383                         break;
  384 
  385                 sg = stackgap_init(p, 0);
  386                 entry = stackgap_alloc(p, &sg, sizeof *entry);
  387                 t_toc_entry.address_format = l_session.addr_format;
  388                 t_toc_entry.starting_track = 0;
  389                 t_toc_entry.data_len = sizeof *entry;
  390                 t_toc_entry.data = entry;
  391 
  392                 error = ioctlf(fp, CDIOREADTOCENTRIES,
  393                     (caddr_t)&t_toc_entry, l);
  394                 if (error)
  395                         break;
  396 
  397                 error = copyin(entry, &t_entry, sizeof t_entry);
  398                 if (error)
  399                         break;
  400 
  401                 if (bsd_to_linux_msf_lba(l_session.addr_format,
  402                     &t_entry.addr, &l_session.addr) < 0) {
  403                         error = EINVAL;
  404                         break;
  405                 }
  406 
  407                 l_session.xa_flag =
  408                     t_header.starting_track != t_header.ending_track;
  409 
  410                 error = copyout(&l_session, SCARG(uap, data), sizeof l_session);
  411                 break;
  412 
  413         case LINUX_CDROMCLOSETRAY:
  414                 error = ioctlf(fp, CDIOCCLOSE, NULL, l);
  415                 break;
  416 
  417         case LINUX_CDROM_LOCKDOOR:
  418                 ncom = SCARG(uap, data) != 0 ? CDIOCPREVENT : CDIOCALLOW;
  419                 error = ioctlf(fp, ncom, NULL, l);
  420                 break;
  421 
  422         case LINUX_CDROM_SET_OPTIONS:
  423         case LINUX_CDROM_CLEAR_OPTIONS:
  424                 /* whatever you say */
  425                 break;
  426 
  427         case LINUX_CDROM_DEBUG:
  428                 ncom = SCARG(uap, data) != 0 ? CDIOCSETDEBUG : CDIOCCLRDEBUG;
  429                 error = ioctlf(fp, ncom, NULL, l);
  430                 break;
  431 
  432         case LINUX_CDROM_SELECT_SPEED:
  433         case LINUX_CDROM_SELECT_DISC:
  434         case LINUX_CDROM_MEDIA_CHANGED:
  435         case LINUX_CDROM_DRIVE_STATUS:
  436         case LINUX_CDROM_DISC_STATUS:
  437         case LINUX_CDROM_CHANGER_NSLOTS:
  438         case LINUX_CDROM_GET_CAPABILITY:
  439                 error = ENOSYS;
  440                 break;
  441 
  442         case LINUX_DVD_READ_STRUCT:
  443                 error = copyin(SCARG(uap, data), &ds, sizeof ds);
  444                 if (error)
  445                         break;
  446                 error = ioctlf(fp, DVD_READ_STRUCT, (caddr_t)&ds, l);
  447                 if (error)
  448                         break;
  449                 error = copyout(&ds, SCARG(uap, data), sizeof ds);
  450                 break;
  451 
  452         case LINUX_DVD_WRITE_STRUCT:
  453                 error = copyin(SCARG(uap, data), &ds, sizeof ds);
  454                 if (error)
  455                         break;
  456                 error = ioctlf(fp, DVD_WRITE_STRUCT, (caddr_t)&ds, l);
  457                 if (error)
  458                         break;
  459                 error = copyout(&ds, SCARG(uap, data), sizeof ds);
  460                 break;
  461 
  462         case LINUX_DVD_AUTH:
  463                 error = copyin(SCARG(uap, data), &dai, sizeof dai);
  464                 if (error)
  465                         break;
  466                 error = ioctlf(fp, DVD_AUTH, (caddr_t)&dai, l);
  467                 if (error)
  468                         break;
  469                 error = copyout(&dai, SCARG(uap, data), sizeof dai);
  470                 break;
  471 
  472 
  473         default:
  474                 DPRINTF(("linux_ioctl: unimplemented ioctl %08lx\n", com));
  475                 error = EINVAL;
  476         }
  477 
  478         FILE_UNUSE(fp, l);
  479         free(u1, M_TEMP);
  480         free(u2, M_TEMP);
  481         return error;
  482 }
Cache object: 6d7c45feaae6e66e6a23a3cf9f4f3aa9
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/compat/linux/common/linux_cdrom.c

FreeBSD/Linux Kernel Cross Reference
sys/compat/linux/common/linux_cdrom.c
