[sdl_omap.git] / src / cdrom / aix / SDL_syscdrom.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Carsten Griwodz
    griff@kom.tu-darmstadt.de

    based on linux/SDL_syscdrom.c by Sam Lantinga
*/
#include "SDL_config.h"

#ifdef SDL_CDROM_AIX

/* Functions for system-level CD-ROM audio control */

/*#define DEBUG_CDROM 1*/

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>

#include <sys/ioctl.h>
#include <sys/devinfo.h>
#include <sys/mntctl.h>
#include <sys/statfs.h>
#include <sys/vmount.h>
#include <fstab.h>
#include <sys/scdisk.h>

#include "SDL_cdrom.h"
#include "../SDL_syscdrom.h"

/* The maximum number of CD-ROM drives we'll detect */
#define MAX_DRIVES	16	

/* A list of available CD-ROM drives */
static char *SDL_cdlist[MAX_DRIVES];
static dev_t SDL_cdmode[MAX_DRIVES];

/* The system-dependent CD control functions */
static const char *SDL_SYS_CDName(int drive);
static int         SDL_SYS_CDOpen(int drive);
static int         SDL_SYS_CDGetTOC(SDL_CD *cdrom);
static CDstatus    SDL_SYS_CDStatus(SDL_CD *cdrom, int *position);
static int         SDL_SYS_CDPlay(SDL_CD *cdrom, int start, int length);
static int         SDL_SYS_CDPause(SDL_CD *cdrom);
static int         SDL_SYS_CDResume(SDL_CD *cdrom);
static int         SDL_SYS_CDStop(SDL_CD *cdrom);
static int         SDL_SYS_CDEject(SDL_CD *cdrom);
static void        SDL_SYS_CDClose(SDL_CD *cdrom);
static int         SDL_SYS_CDioctl(int id, int command, void *arg);

/* Check a drive to see if it is a CD-ROM */
static int CheckDrive(char *drive, struct stat *stbuf)
{
    int is_cd;
    int cdfd;
    int ret;
    struct devinfo info;

    /* If it doesn't exist, return -1 */
    if ( stat(drive, stbuf) < 0 ) {
        return -1;
    }

    /* If it does exist, verify that it's an available CD-ROM */
    is_cd = 0;
    if ( S_ISCHR(stbuf->st_mode) || S_ISBLK(stbuf->st_mode) ) {
        cdfd = open(drive, (O_RDONLY|O_EXCL|O_NONBLOCK), 0);
        if ( cdfd >= 0 ) {
            ret = SDL_SYS_CDioctl( cdfd, IOCINFO, &info );
	    if ( ret < 0 ) {
		/* Some kind of error */
		is_cd = 0;
	    } else {
		if ( info.devtype == DD_CDROM ) {
		    is_cd = 1;
		} else {
		    is_cd = 0;
		}
	    }
            close(cdfd);
	}
#ifdef DEBUG_CDROM
	else
	{
            fprintf(stderr, "Could not open drive %s (%s)\n", drive, strerror(errno));
	}
#endif
    }
    return is_cd;
}

/* Add a CD-ROM drive to our list of valid drives */
static void AddDrive(char *drive, struct stat *stbuf)
{
	int i;

	if ( SDL_numcds < MAX_DRIVES ) {
		/* Check to make sure it's not already in our list.
	 	   This can happen when we see a drive via symbolic link.
		 */
		for ( i=0; i<SDL_numcds; ++i ) {
			if ( stbuf->st_rdev == SDL_cdmode[i] ) {
#ifdef DEBUG_CDROM
  fprintf(stderr, "Duplicate drive detected: %s == %s\n", drive, SDL_cdlist[i]);
#endif
				return;
			}
		}

		/* Add this drive to our list */
		i = SDL_numcds;
		SDL_cdlist[i] = SDL_strdup(drive);
		if ( SDL_cdlist[i] == NULL ) {
			SDL_OutOfMemory();
			return;
		}
		SDL_cdmode[i] = stbuf->st_rdev;
		++SDL_numcds;
#ifdef DEBUG_CDROM
  fprintf(stderr, "Added CD-ROM drive: %s\n", drive);
#endif
	}
}

static void CheckMounts()
{
    char*          buffer;
    int            bufsz;
    struct vmount* ptr;
    int            ret;

    buffer = (char*)SDL_malloc(10);
    bufsz  = 10;
    if ( buffer==NULL )
    {
        fprintf(stderr, "Could not allocate 10 bytes in aix/SDL_syscdrom.c:CheckMounts\n" );
	exit ( -10 );
    }

    do
    {
	/* mntctrl() returns an array of all mounted filesystems */
        ret = mntctl ( MCTL_QUERY, bufsz, buffer );
        if ( ret == 0 )
        {
				   /* Buffer was too small, realloc.    */
            bufsz = *(int*)buffer; /* Required size is in first word.   */
				   /* (whatever a word is in AIX 4.3.3) */
				   /* int seems to be OK in 32bit mode. */
            SDL_free(buffer);
            buffer = (char*)SDL_malloc(bufsz);
            if ( buffer==NULL )
            {
                fprintf(stderr,
			"Could not allocate %d bytes in aix/SDL_syscdrom.c:CheckMounts\n",
			bufsz );
	        exit ( -10 );
            }
        }
	else if ( ret < 0 )
	{
#ifdef DEBUG_CDROM
            fprintf(stderr, "Error reading vmount structures\n");
#endif
	    return;
	}
    }
    while ( ret == 0 );

#ifdef DEBUG_CDROM
    fprintf ( stderr, "Read %d vmount structures\n",ret );
#endif
    ptr = (struct vmount*)buffer;
    do
    {
            switch(ptr->vmt_gfstype)
            {
            case MNT_CDROM :
                {
		    struct stat stbuf;
		    char*       text;

		    text = (char*)ptr + ptr->vmt_data[VMT_OBJECT].vmt_off;
#ifdef DEBUG_CDROM
  fprintf(stderr, "Checking mount path: %s mounted on %s\n",
	text, (char*)ptr + ptr->vmt_data[VMT_STUB].vmt_off );
#endif
		    if ( CheckDrive( text, &stbuf) > 0)
		    {
		        AddDrive( text, &stbuf);
		    }
                }
                break;
            default :
                break;
            }
            ptr = (struct vmount*)((char*)ptr + ptr->vmt_length);
            ret--;
    }
    while ( ret > 0 );

    free ( buffer );
}

static int CheckNonmounts()
{
#ifdef _THREAD_SAFE
    AFILE_t      fsFile = NULL;
    int          passNo = 0;
    int          ret;
    struct fstab entry;
    struct stat  stbuf;

    ret = setfsent_r( &fsFile, &passNo );
    if ( ret != 0 ) return -1;
    do
    {
        ret = getfsent_r ( &entry, &fsFile, &passNo );
        if ( ret == 0 ) {
            char* l = SDL_strrchr(entry.fs_spec,'/');
            if ( l != NULL ) {
                if ( !SDL_strncmp("cd",++l,2) ) {
#ifdef DEBUG_CDROM
                    fprintf(stderr,
			    "Found unmounted CD ROM drive with device name %s\n",
			    entry.fs_spec);
#endif
		    if ( CheckDrive( entry.fs_spec, &stbuf) > 0)
		    {
		        AddDrive( entry.fs_spec, &stbuf);
		    }
                }
            }
        }
    }
    while ( ret == 0 );
    ret = endfsent_r ( &fsFile );
    if ( ret != 0 ) return -1;
    return 0;
#else
    struct fstab* entry;
    struct stat  stbuf;

    setfsent();
    do
    {
        entry = getfsent();
        if ( entry != NULL ) {
            char* l = SDL_strrchr(entry->fs_spec,'/');
            if ( l != NULL ) {
                if ( !SDL_strncmp("cd",++l,2) ) {
#ifdef DEBUG_CDROM
                    fprintf(stderr,"Found unmounted CD ROM drive with device name %s", entry->fs_spec);
#endif
		    if ( CheckDrive( entry->fs_spec, &stbuf) > 0)
		    {
		        AddDrive( entry->fs_spec, &stbuf);
		    }
                }
            }
        }
    }
    while ( entry != NULL );
    endfsent();
#endif
}

int  SDL_SYS_CDInit(void)
{
	char *SDLcdrom;
	struct stat stbuf;

	/* Fill in our driver capabilities */
	SDL_CDcaps.Name = SDL_SYS_CDName;
	SDL_CDcaps.Open = SDL_SYS_CDOpen;
	SDL_CDcaps.GetTOC = SDL_SYS_CDGetTOC;
	SDL_CDcaps.Status = SDL_SYS_CDStatus;
	SDL_CDcaps.Play = SDL_SYS_CDPlay;
	SDL_CDcaps.Pause = SDL_SYS_CDPause;
	SDL_CDcaps.Resume = SDL_SYS_CDResume;
	SDL_CDcaps.Stop = SDL_SYS_CDStop;
	SDL_CDcaps.Eject = SDL_SYS_CDEject;
	SDL_CDcaps.Close = SDL_SYS_CDClose;

	/* Look in the environment for our CD-ROM drive list */
	SDLcdrom = SDL_getenv("SDL_CDROM");	/* ':' separated list of devices */
	if ( SDLcdrom != NULL ) {
		char *cdpath, *delim;
		size_t len = SDL_strlen(SDLcdrom)+1;
		cdpath = SDL_stack_alloc(char, len);
		if ( cdpath != NULL ) {
			SDL_strlcpy(cdpath, SDLcdrom, len);
			SDLcdrom = cdpath;
			do {
				delim = SDL_strchr(SDLcdrom, ':');
				if ( delim ) {
					*delim++ = '\0';
				}
#ifdef DEBUG_CDROM
  fprintf(stderr, "Checking CD-ROM drive from SDL_CDROM: %s\n", SDLcdrom);
#endif
				if ( CheckDrive(SDLcdrom, &stbuf) > 0 ) {
					AddDrive(SDLcdrom, &stbuf);
				}
				if ( delim ) {
					SDLcdrom = delim;
				} else {
					SDLcdrom = NULL;
				}
			} while ( SDLcdrom );
			SDL_stack_free(cdpath);
		}

		/* If we found our drives, there's nothing left to do */
		if ( SDL_numcds > 0 ) {
			return(0);
		}
	}

	CheckMounts();
	CheckNonmounts();

	return 0;
}

/* General ioctl() CD-ROM command function */
static int SDL_SYS_CDioctl(int id, int command, void *arg)
{
    int retval;

    retval = ioctl(id, command, arg);
    if ( retval < 0 ) {
        SDL_SetError("ioctl() error: %s", strerror(errno));
    }
    return retval;
}

static const char *SDL_SYS_CDName(int drive)
{
	return(SDL_cdlist[drive]);
}

static int SDL_SYS_CDOpen(int drive)
{
    int   fd;
    char* lastsl;
    char* cdromname;
    size_t len;

    /*
     * We found /dev/cd? drives and that is in our list. But we can
     * open only the /dev/rcd? versions of those devices for Audio CD.
     */
    len = SDL_strlen(SDL_cdlist[drive])+2;
    cdromname = (char*)SDL_malloc(len);
    SDL_strlcpy(cdromname,SDL_cdlist[drive],len);
    lastsl = SDL_strrchr(cdromname,'/');
    if (lastsl) {
	*lastsl = 0;
	SDL_strlcat(cdromname,"/r",len);
	lastsl = SDL_strrchr(SDL_cdlist[drive],'/');
	if (lastsl) {
	    lastsl++;
	    SDL_strlcat(cdromname,lastsl,len);
	}
    }

#ifdef DEBUG_CDROM
    fprintf(stderr, "Should open drive %s, opening %s\n", SDL_cdlist[drive], cdromname);
#endif

    /*
     * Use exclusive access. Don't use SC_DIAGNOSTICS as xmcd does because they
     * require root priviledges, and we don't want that. SC_SINGLE provides
     * exclusive access with less trouble.
     */
    fd = openx(cdromname, O_RDONLY, NULL, SC_SINGLE);
    if ( fd < 0 )
    {
#ifdef DEBUG_CDROM
            fprintf(stderr, "Could not open drive %s (%s)\n", cdromname, strerror(errno));
#endif
    }
    else
    {
	struct mode_form_op cdMode;
	int                 ret;
#ifdef DEBUG_CDROM
	cdMode.action = CD_GET_MODE;
	ret = SDL_SYS_CDioctl(fd, DK_CD_MODE, &cdMode);
	if ( ret < 0 ) {
            fprintf(stderr,
	            "Could not get drive mode for %s (%s)\n",
		    cdromname, strerror(errno));
	} else {
	    switch(cdMode.cd_mode_form) {
		case CD_MODE1 :
                    fprintf(stderr,
	                "Drive mode for %s is %s\n",
		        cdromname, "CD-ROM Data Mode 1");
		    break;
		case CD_MODE2_FORM1 :
                    fprintf(stderr,
	                "Drive mode for %s is %s\n",
		        cdromname, "CD-ROM XA Data Mode 2 Form 1");
		    break;
		case CD_MODE2_FORM2 :
                    fprintf(stderr,
	                "Drive mode for %s is %s\n",
		        cdromname, "CD-ROM XA Data Mode 2 Form 2");
		    break;
		case CD_DA :
                    fprintf(stderr,
	                "Drive mode for %s is %s\n",
		        cdromname, "CD-DA");
		    break;
		default :
                    fprintf(stderr,
	                "Drive mode for %s is %s\n",
		        cdromname, "unknown");
		    break;
	    }
	}
#endif

	cdMode.action       = CD_CHG_MODE;
	cdMode.cd_mode_form = CD_DA;
	ret = SDL_SYS_CDioctl(fd, DK_CD_MODE, &cdMode);
	if ( ret < 0 ) {
#ifdef DEBUG_CDROM
            fprintf(stderr,
	            "Could not set drive mode for %s (%s)\n",
		    cdromname, strerror(errno));
#endif
            SDL_SetError("ioctl() error: Could not set CD drive mode, %s",
	                 strerror(errno));
	} else {
#ifdef DEBUG_CDROM
            fprintf(stderr,
	            "Drive mode for %s set to CD_DA\n",
		    cdromname);
#endif
	}
    }
    SDL_free(cdromname);
    return fd;
}

static int SDL_SYS_CDGetTOC(SDL_CD *cdrom)
{
    struct cd_audio_cmd cmd;
    struct cd_audio_cmd entry;
    int                 i;
    int                 okay;

    cmd.audio_cmds = CD_TRK_INFO_AUDIO;
    cmd.msf_flag   = FALSE;
    if ( SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd) < 0 ) {
	return -1;
    }

    okay = 0;
    cdrom->numtracks = cmd.indexing.track_index.last_track
		     - cmd.indexing.track_index.first_track+1;
    if ( cdrom->numtracks > SDL_MAX_TRACKS ) {
        cdrom->numtracks = SDL_MAX_TRACKS;
    }

    /* Read all the track TOC entries */
    for ( i=0; i<=cdrom->numtracks; ++i ) {
        if ( i == cdrom->numtracks ) {
            cdrom->track[i].id = 0xAA;;
        } else {
            cdrom->track[i].id = cmd.indexing.track_index.first_track+i;
        }
        entry.audio_cmds         = CD_GET_TRK_MSF;
	entry.indexing.track_msf.track = cdrom->track[i].id;
	if ( SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &entry) < 0 ) {
            break;
        } else {
            cdrom->track[i].type = 0;    /* don't know how to detect 0x04 data track */
            cdrom->track[i].offset = MSF_TO_FRAMES(
                entry.indexing.track_msf.mins,
                entry.indexing.track_msf.secs,
                entry.indexing.track_msf.frames);
            cdrom->track[i].length = 0;
            if ( i > 0 ) {
                cdrom->track[i-1].length = cdrom->track[i].offset
		                         - cdrom->track[i-1].offset;
            }
        }
    }
    if ( i == (cdrom->numtracks+1) ) {
        okay = 1;
    }
    return(okay ? 0 : -1);
}

/* Get CD-ROM status */
static CDstatus SDL_SYS_CDStatus(SDL_CD *cdrom, int *position)
{
    CDstatus            status;
    struct cd_audio_cmd cmd;
    cmd.audio_cmds = CD_INFO_AUDIO;

    if ( SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd) < 0 ) {
#ifdef DEBUG_CDROM
    fprintf(stderr, "ioctl failed in SDL_SYS_CDStatus (%s)\n", SDL_GetError());
#endif
        status = CD_ERROR;
    } else {
        switch (cmd.status) {
            case CD_NO_AUDIO:
            case CD_COMPLETED:
                status = CD_STOPPED;
                break;
            case CD_PLAY_AUDIO:
                status = CD_PLAYING;
                break;
            case CD_PAUSE_AUDIO:
                status = CD_PAUSED;
                break;
            case CD_NOT_VALID:
#ifdef DEBUG_CDROM
    fprintf(stderr, "cdStatus failed with CD_NOT_VALID\n");
#endif
                status = CD_ERROR;
                break;
            case CD_STATUS_ERROR:
#ifdef DEBUG_CDROM
    fprintf(stderr, "cdStatus failed with CD_STATUS_ERROR\n");
#endif
                status = CD_ERROR;
                break;
            default:
#ifdef DEBUG_CDROM
    fprintf(stderr, "cdStatus failed with unknown error\n");
#endif
                status = CD_ERROR;
                break;
        }
    }
    if ( position ) {
        if ( status == CD_PLAYING || (status == CD_PAUSED) ) {
            *position = MSF_TO_FRAMES( cmd.indexing.info_audio.current_mins,
                                       cmd.indexing.info_audio.current_secs,
                                       cmd.indexing.info_audio.current_frames);
        } else {
            *position = 0;
        }
    }
    return status;
}

/* Start play */
static int SDL_SYS_CDPlay(SDL_CD *cdrom, int start, int length)
{
    struct cd_audio_cmd cmd;

    /*
     * My CD Rom is muted by default. I think I read that this is new with
     * AIX 4.3. SDL does not change the volume, so I need a kludge. Maybe
     * its better to do this elsewhere?
     */
    cmd.audio_cmds = CD_PLAY_AUDIO | CD_SET_VOLUME;
    cmd.msf_flag   = TRUE;
    FRAMES_TO_MSF(start,
                  &cmd.indexing.msf.first_mins,
                  &cmd.indexing.msf.first_secs,
                  &cmd.indexing.msf.first_frames);
    FRAMES_TO_MSF(start+length,
                  &cmd.indexing.msf.last_mins,
                  &cmd.indexing.msf.last_secs,
                  &cmd.indexing.msf.last_frames);
    cmd.volume_type     = CD_VOLUME_ALL;
    cmd.all_channel_vol = 255;   /* This is a uchar. What is a good value? No docu! */
    cmd.out_port_0_sel  = CD_AUDIO_CHNL_0;
    cmd.out_port_1_sel  = CD_AUDIO_CHNL_1;
    cmd.out_port_2_sel  = CD_AUDIO_CHNL_2;
    cmd.out_port_3_sel  = CD_AUDIO_CHNL_3;

#ifdef DEBUG_CDROM
  fprintf(stderr, "Trying to play from %d:%d:%d to %d:%d:%d\n",
	cmd.indexing.msf.first_mins,
	cmd.indexing.msf.first_secs,
	cmd.indexing.msf.first_frames,
	cmd.indexing.msf.last_mins,
	cmd.indexing.msf.last_secs,
	cmd.indexing.msf.last_frames);
#endif
	return(SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd));
}

/* Pause play */
static int SDL_SYS_CDPause(SDL_CD *cdrom)
{
    struct cd_audio_cmd cmd;
    cmd.audio_cmds = CD_PAUSE_AUDIO;
    return(SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd));
}

/* Resume play */
static int SDL_SYS_CDResume(SDL_CD *cdrom)
{
    struct cd_audio_cmd cmd;
    cmd.audio_cmds = CD_RESUME_AUDIO;
    return(SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd));
}

/* Stop play */
static int SDL_SYS_CDStop(SDL_CD *cdrom)
{
    struct cd_audio_cmd cmd;
    cmd.audio_cmds = CD_STOP_AUDIO;
    return(SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd));
}

/* Eject the CD-ROM */
static int SDL_SYS_CDEject(SDL_CD *cdrom)
{
    return(SDL_SYS_CDioctl(cdrom->id, DKEJECT, 0));
}

/* Close the CD-ROM handle */
static void SDL_SYS_CDClose(SDL_CD *cdrom)
{
    close(cdrom->id);
}

void SDL_SYS_CDQuit(void)
{
	int i;

	if ( SDL_numcds > 0 ) {
		for ( i=0; i<SDL_numcds; ++i ) {
			SDL_free(SDL_cdlist[i]);
		}
		SDL_numcds = 0;
	}
}

#endif /* SDL_CDROM_AIX */
Commit	Line	Data
e14743d1	1	/*
	2	SDL - Simple DirectMedia Layer
	3	Copyright (C) 1997-2009 Sam Lantinga
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	This library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18
	19	Carsten Griwodz
	20	griff@kom.tu-darmstadt.de
	21
	22	based on linux/SDL_syscdrom.c by Sam Lantinga
	23	*/
	24	#include "SDL_config.h"
	25
	26	#ifdef SDL_CDROM_AIX
	27
	28	/* Functions for system-level CD-ROM audio control */
	29
	30	/#define DEBUG_CDROM 1/
	31
	32	#include <sys/types.h>
	33	#include <sys/stat.h>
	34	#include <fcntl.h>
	35	#include <errno.h>
	36	#include <unistd.h>
	37
	38	#include <sys/ioctl.h>
	39	#include <sys/devinfo.h>
	40	#include <sys/mntctl.h>
	41	#include <sys/statfs.h>
	42	#include <sys/vmount.h>
	43	#include <fstab.h>
	44	#include <sys/scdisk.h>
	45
	46	#include "SDL_cdrom.h"
	47	#include "../SDL_syscdrom.h"
	48
	49	/* The maximum number of CD-ROM drives we'll detect */
	50	#define MAX_DRIVES 16
	51
	52	/* A list of available CD-ROM drives */
	53	static char *SDL_cdlist[MAX_DRIVES];
	54	static dev_t SDL_cdmode[MAX_DRIVES];
	55
	56	/* The system-dependent CD control functions */
	57	static const char *SDL_SYS_CDName(int drive);
	58	static int SDL_SYS_CDOpen(int drive);
	59	static int SDL_SYS_CDGetTOC(SDL_CD *cdrom);
	60	static CDstatus SDL_SYS_CDStatus(SDL_CD cdrom, int position);
	61	static int SDL_SYS_CDPlay(SDL_CD *cdrom, int start, int length);
	62	static int SDL_SYS_CDPause(SDL_CD *cdrom);
	63	static int SDL_SYS_CDResume(SDL_CD *cdrom);
	64	static int SDL_SYS_CDStop(SDL_CD *cdrom);
65	static int SDL_SYS_CDEject(SDL_CD *cdrom);
66	static void SDL_SYS_CDClose(SDL_CD *cdrom);
67	static int SDL_SYS_CDioctl(int id, int command, void *arg);
68
69	/* Check a drive to see if it is a CD-ROM */
70	static int CheckDrive(char drive, struct stat stbuf)
71	{
72	int is_cd;
73	int cdfd;
74	int ret;
75	struct devinfo info;
76
77	/* If it doesn't exist, return -1 */
78	if ( stat(drive, stbuf) < 0 ) {
79	return -1;
80	}
81
82	/* If it does exist, verify that it's an available CD-ROM */
83	is_cd = 0;
84	if ( S_ISCHR(stbuf->st_mode) \|\| S_ISBLK(stbuf->st_mode) ) {
85	cdfd = open(drive, (O_RDONLY\|O_EXCL\|O_NONBLOCK), 0);
86	if ( cdfd >= 0 ) {
87	ret = SDL_SYS_CDioctl( cdfd, IOCINFO, &info );
88	if ( ret < 0 ) {
89	/* Some kind of error */
90	is_cd = 0;
91	} else {
92	if ( info.devtype == DD_CDROM ) {
93	is_cd = 1;
94	} else {
95	is_cd = 0;
96	}
97	}
98	close(cdfd);
99	}
100	#ifdef DEBUG_CDROM
101	else
102	{
103	fprintf(stderr, "Could not open drive %s (%s)\n", drive, strerror(errno));
104	}
105	#endif
106	}
107	return is_cd;
108	}
109
110	/* Add a CD-ROM drive to our list of valid drives */
111	static void AddDrive(char drive, struct stat stbuf)
112	{
113	int i;
114
115	if ( SDL_numcds < MAX_DRIVES ) {
116	/* Check to make sure it's not already in our list.
117	This can happen when we see a drive via symbolic link.
118	*/
119	for ( i=0; i<SDL_numcds; ++i ) {
120	if ( stbuf->st_rdev == SDL_cdmode[i] ) {
121	#ifdef DEBUG_CDROM
122	fprintf(stderr, "Duplicate drive detected: %s == %s\n", drive, SDL_cdlist[i]);
123	#endif
124	return;
125	}
126	}
127
128	/* Add this drive to our list */
129	i = SDL_numcds;
130	SDL_cdlist[i] = SDL_strdup(drive);
131	if ( SDL_cdlist[i] == NULL ) {
132	SDL_OutOfMemory();
133	return;
134	}
135	SDL_cdmode[i] = stbuf->st_rdev;
136	++SDL_numcds;
137	#ifdef DEBUG_CDROM
138	fprintf(stderr, "Added CD-ROM drive: %s\n", drive);
139	#endif
140	}
141	}
142
143	static void CheckMounts()
144	{
145	char* buffer;
146	int bufsz;
147	struct vmount* ptr;
148	int ret;
149
150	buffer = (char*)SDL_malloc(10);
151	bufsz = 10;
152	if ( buffer==NULL )
153	{
154	fprintf(stderr, "Could not allocate 10 bytes in aix/SDL_syscdrom.c:CheckMounts\n" );
155	exit ( -10 );
156	}
157
158	do
159	{
160	/* mntctrl() returns an array of all mounted filesystems */
161	ret = mntctl ( MCTL_QUERY, bufsz, buffer );
162	if ( ret == 0 )
163	{
164	/* Buffer was too small, realloc. */
165	bufsz = (int)buffer; /* Required size is in first word. */
166	/* (whatever a word is in AIX 4.3.3) */
167	/* int seems to be OK in 32bit mode. */
168	SDL_free(buffer);
169	buffer = (char*)SDL_malloc(bufsz);
170	if ( buffer==NULL )
171	{
172	fprintf(stderr,
173	"Could not allocate %d bytes in aix/SDL_syscdrom.c:CheckMounts\n",
174	bufsz );
175	exit ( -10 );
176	}
177	}
178	else if ( ret < 0 )
179	{
180	#ifdef DEBUG_CDROM
181	fprintf(stderr, "Error reading vmount structures\n");
182	#endif
183	return;
184	}
185	}
186	while ( ret == 0 );
187
188	#ifdef DEBUG_CDROM
189	fprintf ( stderr, "Read %d vmount structures\n",ret );
190	#endif
191	ptr = (struct vmount*)buffer;
192	do
193	{
194	switch(ptr->vmt_gfstype)
195	{
196	case MNT_CDROM :
197	{
198	struct stat stbuf;
199	char* text;
200
201	text = (char*)ptr + ptr->vmt_data[VMT_OBJECT].vmt_off;
202	#ifdef DEBUG_CDROM
203	fprintf(stderr, "Checking mount path: %s mounted on %s\n",
204	text, (char*)ptr + ptr->vmt_data[VMT_STUB].vmt_off );
205	#endif
206	if ( CheckDrive( text, &stbuf) > 0)
207	{
208	AddDrive( text, &stbuf);
209	}
210	}
211	break;
212	default :
213	break;
214	}
215	ptr = (struct vmount)((char)ptr + ptr->vmt_length);
216	ret--;
217	}
218	while ( ret > 0 );
219
220	free ( buffer );
221	}
222
223	static int CheckNonmounts()
224	{
225	#ifdef _THREAD_SAFE
226	AFILE_t fsFile = NULL;
227	int passNo = 0;
228	int ret;
229	struct fstab entry;
230	struct stat stbuf;
231
232	ret = setfsent_r( &fsFile, &passNo );
233	if ( ret != 0 ) return -1;
234	do
235	{
236	ret = getfsent_r ( &entry, &fsFile, &passNo );
237	if ( ret == 0 ) {
238	char* l = SDL_strrchr(entry.fs_spec,'/');
239	if ( l != NULL ) {
240	if ( !SDL_strncmp("cd",++l,2) ) {
241	#ifdef DEBUG_CDROM
242	fprintf(stderr,
243	"Found unmounted CD ROM drive with device name %s\n",
244	entry.fs_spec);
245	#endif
246	if ( CheckDrive( entry.fs_spec, &stbuf) > 0)
247	{
248	AddDrive( entry.fs_spec, &stbuf);
249	}
250	}
251	}
252	}
253	}
254	while ( ret == 0 );
255	ret = endfsent_r ( &fsFile );
256	if ( ret != 0 ) return -1;
257	return 0;
258	#else
259	struct fstab* entry;
260	struct stat stbuf;
261
262	setfsent();
263	do
264	{
265	entry = getfsent();
266	if ( entry != NULL ) {
267	char* l = SDL_strrchr(entry->fs_spec,'/');
268	if ( l != NULL ) {
269	if ( !SDL_strncmp("cd",++l,2) ) {
270	#ifdef DEBUG_CDROM
271	fprintf(stderr,"Found unmounted CD ROM drive with device name %s", entry->fs_spec);
272	#endif
273	if ( CheckDrive( entry->fs_spec, &stbuf) > 0)
274	{
275	AddDrive( entry->fs_spec, &stbuf);
276	}
277	}
278	}
279	}
280	}
281	while ( entry != NULL );
282	endfsent();
283	#endif
284	}
285
286	int SDL_SYS_CDInit(void)
287	{
288	char *SDLcdrom;
289	struct stat stbuf;
290
291	/* Fill in our driver capabilities */
292	SDL_CDcaps.Name = SDL_SYS_CDName;
293	SDL_CDcaps.Open = SDL_SYS_CDOpen;
294	SDL_CDcaps.GetTOC = SDL_SYS_CDGetTOC;
295	SDL_CDcaps.Status = SDL_SYS_CDStatus;
296	SDL_CDcaps.Play = SDL_SYS_CDPlay;
297	SDL_CDcaps.Pause = SDL_SYS_CDPause;
298	SDL_CDcaps.Resume = SDL_SYS_CDResume;
299	SDL_CDcaps.Stop = SDL_SYS_CDStop;
300	SDL_CDcaps.Eject = SDL_SYS_CDEject;
301	SDL_CDcaps.Close = SDL_SYS_CDClose;
302
303	/* Look in the environment for our CD-ROM drive list */
304	SDLcdrom = SDL_getenv("SDL_CDROM"); /* ':' separated list of devices */
305	if ( SDLcdrom != NULL ) {
306	char cdpath, delim;
307	size_t len = SDL_strlen(SDLcdrom)+1;
308	cdpath = SDL_stack_alloc(char, len);
309	if ( cdpath != NULL ) {
310	SDL_strlcpy(cdpath, SDLcdrom, len);
311	SDLcdrom = cdpath;
312	do {
313	delim = SDL_strchr(SDLcdrom, ':');
314	if ( delim ) {
315	*delim++ = '\0';
316	}
317	#ifdef DEBUG_CDROM
318	fprintf(stderr, "Checking CD-ROM drive from SDL_CDROM: %s\n", SDLcdrom);
319	#endif
320	if ( CheckDrive(SDLcdrom, &stbuf) > 0 ) {
321	AddDrive(SDLcdrom, &stbuf);
322	}
323	if ( delim ) {
324	SDLcdrom = delim;
325	} else {
326	SDLcdrom = NULL;
327	}
328	} while ( SDLcdrom );
329	SDL_stack_free(cdpath);
330	}
331
332	/* If we found our drives, there's nothing left to do */
333	if ( SDL_numcds > 0 ) {
334	return(0);
335	}
336	}
337
338	CheckMounts();
339	CheckNonmounts();
340
341	return 0;
342	}
343
344	/* General ioctl() CD-ROM command function */
345	static int SDL_SYS_CDioctl(int id, int command, void *arg)
346	{
347	int retval;
348
349	retval = ioctl(id, command, arg);
350	if ( retval < 0 ) {
351	SDL_SetError("ioctl() error: %s", strerror(errno));
352	}
353	return retval;
354	}
355
356	static const char *SDL_SYS_CDName(int drive)
357	{
358	return(SDL_cdlist[drive]);
359	}
360
361	static int SDL_SYS_CDOpen(int drive)
362	{
363	int fd;
364	char* lastsl;
365	char* cdromname;
366	size_t len;
367
368	/*
369	* We found /dev/cd? drives and that is in our list. But we can
370	* open only the /dev/rcd? versions of those devices for Audio CD.
371	*/
372	len = SDL_strlen(SDL_cdlist[drive])+2;
373	cdromname = (char*)SDL_malloc(len);
374	SDL_strlcpy(cdromname,SDL_cdlist[drive],len);
375	lastsl = SDL_strrchr(cdromname,'/');
376	if (lastsl) {
377	*lastsl = 0;
378	SDL_strlcat(cdromname,"/r",len);
379	lastsl = SDL_strrchr(SDL_cdlist[drive],'/');
380	if (lastsl) {
381	lastsl++;
382	SDL_strlcat(cdromname,lastsl,len);
383	}
384	}
385
386	#ifdef DEBUG_CDROM
387	fprintf(stderr, "Should open drive %s, opening %s\n", SDL_cdlist[drive], cdromname);
388	#endif
389
390	/*
391	* Use exclusive access. Don't use SC_DIAGNOSTICS as xmcd does because they
392	* require root priviledges, and we don't want that. SC_SINGLE provides
393	* exclusive access with less trouble.
394	*/
395	fd = openx(cdromname, O_RDONLY, NULL, SC_SINGLE);
396	if ( fd < 0 )
397	{
398	#ifdef DEBUG_CDROM
399	fprintf(stderr, "Could not open drive %s (%s)\n", cdromname, strerror(errno));
400	#endif
401	}
402	else
403	{
404	struct mode_form_op cdMode;
405	int ret;
406	#ifdef DEBUG_CDROM
407	cdMode.action = CD_GET_MODE;
408	ret = SDL_SYS_CDioctl(fd, DK_CD_MODE, &cdMode);
409	if ( ret < 0 ) {
410	fprintf(stderr,
411	"Could not get drive mode for %s (%s)\n",
412	cdromname, strerror(errno));
413	} else {
414	switch(cdMode.cd_mode_form) {
415	case CD_MODE1 :
416	fprintf(stderr,
417	"Drive mode for %s is %s\n",
418	cdromname, "CD-ROM Data Mode 1");
419	break;
420	case CD_MODE2_FORM1 :
421	fprintf(stderr,
422	"Drive mode for %s is %s\n",
423	cdromname, "CD-ROM XA Data Mode 2 Form 1");
424	break;
425	case CD_MODE2_FORM2 :
426	fprintf(stderr,
427	"Drive mode for %s is %s\n",
428	cdromname, "CD-ROM XA Data Mode 2 Form 2");
429	break;
430	case CD_DA :
431	fprintf(stderr,
432	"Drive mode for %s is %s\n",
433	cdromname, "CD-DA");
434	break;
435	default :
436	fprintf(stderr,
437	"Drive mode for %s is %s\n",
438	cdromname, "unknown");
439	break;
440	}
441	}
442	#endif
443
444	cdMode.action = CD_CHG_MODE;
445	cdMode.cd_mode_form = CD_DA;
446	ret = SDL_SYS_CDioctl(fd, DK_CD_MODE, &cdMode);
447	if ( ret < 0 ) {
448	#ifdef DEBUG_CDROM
449	fprintf(stderr,
450	"Could not set drive mode for %s (%s)\n",
451	cdromname, strerror(errno));
452	#endif
453	SDL_SetError("ioctl() error: Could not set CD drive mode, %s",
454	strerror(errno));
455	} else {
456	#ifdef DEBUG_CDROM
457	fprintf(stderr,
458	"Drive mode for %s set to CD_DA\n",
459	cdromname);
460	#endif
461	}
462	}
463	SDL_free(cdromname);
464	return fd;
465	}
466
467	static int SDL_SYS_CDGetTOC(SDL_CD *cdrom)
468	{
469	struct cd_audio_cmd cmd;
470	struct cd_audio_cmd entry;
471	int i;
472	int okay;
473
474	cmd.audio_cmds = CD_TRK_INFO_AUDIO;
475	cmd.msf_flag = FALSE;
476	if ( SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd) < 0 ) {
477	return -1;
478	}
479
480	okay = 0;
481	cdrom->numtracks = cmd.indexing.track_index.last_track
482	- cmd.indexing.track_index.first_track+1;
483	if ( cdrom->numtracks > SDL_MAX_TRACKS ) {
484	cdrom->numtracks = SDL_MAX_TRACKS;
485	}
486
487	/* Read all the track TOC entries */
488	for ( i=0; i<=cdrom->numtracks; ++i ) {
489	if ( i == cdrom->numtracks ) {
490	cdrom->track[i].id = 0xAA;;
491	} else {
492	cdrom->track[i].id = cmd.indexing.track_index.first_track+i;
493	}
494	entry.audio_cmds = CD_GET_TRK_MSF;
495	entry.indexing.track_msf.track = cdrom->track[i].id;
496	if ( SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &entry) < 0 ) {
497	break;
498	} else {
499	cdrom->track[i].type = 0; /* don't know how to detect 0x04 data track */
500	cdrom->track[i].offset = MSF_TO_FRAMES(
501	entry.indexing.track_msf.mins,
502	entry.indexing.track_msf.secs,
503	entry.indexing.track_msf.frames);
504	cdrom->track[i].length = 0;
505	if ( i > 0 ) {
506	cdrom->track[i-1].length = cdrom->track[i].offset
507	- cdrom->track[i-1].offset;
508	}
509	}
510	}
511	if ( i == (cdrom->numtracks+1) ) {
512	okay = 1;
513	}
514	return(okay ? 0 : -1);
515	}
516
517	/* Get CD-ROM status */
518	static CDstatus SDL_SYS_CDStatus(SDL_CD cdrom, int position)
519	{
520	CDstatus status;
521	struct cd_audio_cmd cmd;
522	cmd.audio_cmds = CD_INFO_AUDIO;
523
524	if ( SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd) < 0 ) {
525	#ifdef DEBUG_CDROM
526	fprintf(stderr, "ioctl failed in SDL_SYS_CDStatus (%s)\n", SDL_GetError());
527	#endif
528	status = CD_ERROR;
529	} else {
530	switch (cmd.status) {
531	case CD_NO_AUDIO:
532	case CD_COMPLETED:
533	status = CD_STOPPED;
534	break;
535	case CD_PLAY_AUDIO:
536	status = CD_PLAYING;
537	break;
538	case CD_PAUSE_AUDIO:
539	status = CD_PAUSED;
540	break;
541	case CD_NOT_VALID:
542	#ifdef DEBUG_CDROM
543	fprintf(stderr, "cdStatus failed with CD_NOT_VALID\n");
544	#endif
545	status = CD_ERROR;
546	break;
547	case CD_STATUS_ERROR:
548	#ifdef DEBUG_CDROM
549	fprintf(stderr, "cdStatus failed with CD_STATUS_ERROR\n");
550	#endif
551	status = CD_ERROR;
552	break;
553	default:
554	#ifdef DEBUG_CDROM
555	fprintf(stderr, "cdStatus failed with unknown error\n");
556	#endif
557	status = CD_ERROR;
558	break;
559	}
560	}
561	if ( position ) {
562	if ( status == CD_PLAYING \|\| (status == CD_PAUSED) ) {
563	*position = MSF_TO_FRAMES( cmd.indexing.info_audio.current_mins,
564	cmd.indexing.info_audio.current_secs,
565	cmd.indexing.info_audio.current_frames);
566	} else {
567	*position = 0;
568	}
569	}
570	return status;
571	}
572
573	/* Start play */
574	static int SDL_SYS_CDPlay(SDL_CD *cdrom, int start, int length)
575	{
576	struct cd_audio_cmd cmd;
577
578	/*
579	* My CD Rom is muted by default. I think I read that this is new with
580	* AIX 4.3. SDL does not change the volume, so I need a kludge. Maybe
581	* its better to do this elsewhere?
582	*/
583	cmd.audio_cmds = CD_PLAY_AUDIO \| CD_SET_VOLUME;
584	cmd.msf_flag = TRUE;
585	FRAMES_TO_MSF(start,
586	&cmd.indexing.msf.first_mins,
587	&cmd.indexing.msf.first_secs,
588	&cmd.indexing.msf.first_frames);
589	FRAMES_TO_MSF(start+length,
590	&cmd.indexing.msf.last_mins,
591	&cmd.indexing.msf.last_secs,
592	&cmd.indexing.msf.last_frames);
593	cmd.volume_type = CD_VOLUME_ALL;
594	cmd.all_channel_vol = 255; /* This is a uchar. What is a good value? No docu! */
595	cmd.out_port_0_sel = CD_AUDIO_CHNL_0;
596	cmd.out_port_1_sel = CD_AUDIO_CHNL_1;
597	cmd.out_port_2_sel = CD_AUDIO_CHNL_2;
598	cmd.out_port_3_sel = CD_AUDIO_CHNL_3;
599
600	#ifdef DEBUG_CDROM
601	fprintf(stderr, "Trying to play from %d:%d:%d to %d:%d:%d\n",
602	cmd.indexing.msf.first_mins,
603	cmd.indexing.msf.first_secs,
604	cmd.indexing.msf.first_frames,
605	cmd.indexing.msf.last_mins,
606	cmd.indexing.msf.last_secs,
607	cmd.indexing.msf.last_frames);
608	#endif
609	return(SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd));
610	}
611
612	/* Pause play */
613	static int SDL_SYS_CDPause(SDL_CD *cdrom)
614	{
615	struct cd_audio_cmd cmd;
616	cmd.audio_cmds = CD_PAUSE_AUDIO;
617	return(SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd));
618	}
619
620	/* Resume play */
621	static int SDL_SYS_CDResume(SDL_CD *cdrom)
622	{
623	struct cd_audio_cmd cmd;
624	cmd.audio_cmds = CD_RESUME_AUDIO;
625	return(SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd));
626	}
627
628	/* Stop play */
629	static int SDL_SYS_CDStop(SDL_CD *cdrom)
630	{
631	struct cd_audio_cmd cmd;
632	cmd.audio_cmds = CD_STOP_AUDIO;
633	return(SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd));
634	}
635
636	/* Eject the CD-ROM */
637	static int SDL_SYS_CDEject(SDL_CD *cdrom)
638	{
639	return(SDL_SYS_CDioctl(cdrom->id, DKEJECT, 0));
640	}
641
642	/* Close the CD-ROM handle */
643	static void SDL_SYS_CDClose(SDL_CD *cdrom)
644	{
645	close(cdrom->id);
646	}
647
648	void SDL_SYS_CDQuit(void)
649	{
650	int i;
651
652	if ( SDL_numcds > 0 ) {
653	for ( i=0; i<SDL_numcds; ++i ) {
654	SDL_free(SDL_cdlist[i]);
655	}
656	SDL_numcds = 0;
657	}
658	}
659
660	#endif /* SDL_CDROM_AIX */