2
$Id: _cdio_sunos.c,v 1.79 2004/11/18 01:56:09 rocky Exp $
4
Copyright (C) 2001 Herbert Valerio Riedel <hvr@gnu.org>
5
Copyright (C) 2002, 2003, 2004 Rocky Bernstein <rocky@panix.com>
7
This program is free software; you can redistribute it and/or modify
8
it under the terms of the GNU General Public License as published by
9
the Free Software Foundation; either version 2 of the License, or
10
(at your option) any later version.
12
This program is distributed in the hope that it will be useful,
13
but WITHOUT ANY WARRANTY; without even the implied warranty of
14
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15
GNU General Public License for more details.
17
You should have received a copy of the GNU General Public License
18
along with this program; if not, write to the Free Software
19
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30
#include <cdio/logging.h>
31
#include <cdio/sector.h>
32
#include <cdio/util.h>
33
#include <cdio/scsi_mmc.h>
34
#include "cdio_assert.h"
35
#include "cdio_private.h"
37
#define DEFAULT_CDIO_DEVICE "/vol/dev/aliases/cdrom0"
39
#ifdef HAVE_SOLARIS_CDROM
41
static const char _rcsid[] = "$Id: _cdio_sunos.c,v 1.79 2004/11/18 01:56:09 rocky Exp $";
53
#ifdef HAVE_SYS_CDIO_H
54
# include <sys/cdio.h> /* CDIOCALLOW etc... */
56
#error "You need <sys/cdio.h> to have CDROM support"
60
#include <sys/scsi/generic/commands.h>
61
#include <sys/scsi/impl/uscsi.h>
64
#include <sys/types.h>
65
#include <sys/ioctl.h>
66
#include "cdtext_private.h"
68
/* not defined in dkio.h yet */
85
/* Things common to all drivers like this.
86
This must be first. */
87
generic_img_private_t gen;
89
access_mode_t access_mode;
91
/* Some of the more OS specific things. */
92
/* Entry info for each track, add 1 for leadout. */
93
struct cdrom_tocentry tocent[CDIO_CD_MAX_TRACKS+1];
95
/* Track information */
96
struct cdrom_tochdr tochdr;
99
static track_format_t get_track_format_solaris(void *p_user_data,
103
str_to_access_mode_sunos(const char *psz_access_mode)
105
const access_mode_t default_access_mode = _AM_SUN_CTRL_SCSI;
107
if (NULL==psz_access_mode) return default_access_mode;
109
if (!strcmp(psz_access_mode, "ATAPI"))
110
return _AM_SUN_CTRL_SCSI; /* force ATAPI to be SCSI */
111
else if (!strcmp(psz_access_mode, "SCSI"))
112
return _AM_SUN_CTRL_SCSI;
114
cdio_warn ("unknown access type: %s. Default SCSI used.",
116
return default_access_mode;
122
Initialize CD device.
125
init_solaris (_img_private_t *p_env)
128
if (!cdio_generic_init(p_env)) return false;
130
p_env->access_mode = _AM_SUN_CTRL_SCSI;
136
Run a SCSI MMC command.
138
p_user_data internal CD structure.
139
i_timeout_ms time in milliseconds we will wait for the command
143
e_direction direction the transfer is to go.
145
p_buf Buffer for data, both sending and receiving
147
Return 0 if no error.
150
run_scsi_cmd_solaris( const void *p_user_data, unsigned int i_timeout_ms,
151
unsigned int i_cdb, const scsi_mmc_cdb_t *p_cdb,
152
scsi_mmc_direction_t e_direction,
153
unsigned int i_buf, /*in/out*/ void *p_buf )
155
const _img_private_t *p_env = p_user_data;
156
struct uscsi_cmd cgc;
158
memset (&cgc, 0, sizeof (struct uscsi_cmd));
159
cgc.uscsi_cdb = (caddr_t) p_cdb;
161
cgc.uscsi_flags = SCSI_MMC_DATA_READ == e_direction ?
162
USCSI_READ : USCSI_WRITE;
164
cgc.uscsi_timeout = msecs2secs(i_timeout_ms);
165
cgc.uscsi_bufaddr = p_buf;
166
cgc.uscsi_buflen = i_buf;
167
cgc.uscsi_cdblen = i_cdb;
169
return ioctl(p_env->gen.fd, USCSICMD, &cgc);
173
Reads audio sectors from CD device into data starting from lsn.
174
Returns 0 if no error.
176
May have to check size of nblocks. There may be a limit that
177
can be read in one go, e.g. 25 blocks.
181
_read_audio_sectors_solaris (void *p_user_data, void *data, lsn_t lsn,
182
unsigned int nblocks)
184
struct cdrom_msf solaris_msf;
186
struct cdrom_cdda cdda;
188
_img_private_t *p_env = p_user_data;
190
cdio_lba_to_msf (cdio_lsn_to_lba(lsn), &_msf);
191
solaris_msf.cdmsf_min0 = cdio_from_bcd8(_msf.m);
192
solaris_msf.cdmsf_sec0 = cdio_from_bcd8(_msf.s);
193
solaris_msf.cdmsf_frame0 = cdio_from_bcd8(_msf.f);
195
if (p_env->gen.ioctls_debugged == 75)
196
cdio_debug ("only displaying every 75th ioctl from now on");
198
if (p_env->gen.ioctls_debugged == 30 * 75)
199
cdio_debug ("only displaying every 30*75th ioctl from now on");
201
if (p_env->gen.ioctls_debugged < 75
202
|| (p_env->gen.ioctls_debugged < (30 * 75)
203
&& p_env->gen.ioctls_debugged % 75 == 0)
204
|| p_env->gen.ioctls_debugged % (30 * 75) == 0)
205
cdio_debug ("reading %d", lsn);
207
p_env->gen.ioctls_debugged++;
209
cdda.cdda_addr = lsn;
210
cdda.cdda_length = nblocks;
211
cdda.cdda_data = (caddr_t) data;
212
cdda.cdda_subcode = CDROM_DA_NO_SUBCODE;
214
if (ioctl (p_env->gen.fd, CDROMCDDA, &cdda) == -1) {
215
perror ("ioctl(..,CDROMCDDA,..)");
217
/* exit (EXIT_FAILURE); */
224
Reads a single mode1 sector from cd device into data starting
225
from lsn. Returns 0 if no error.
228
_read_mode1_sector_solaris (void *env, void *data, lsn_t lsn,
235
return cdio_generic_read_form1_sector(env, data, lsn);
240
Reads nblocks of mode2 sectors from cd device into data starting
242
Returns 0 if no error.
245
_read_mode1_sectors_solaris (void *p_user_data, void *p_data, lsn_t lsn,
246
bool b_form2, unsigned int nblocks)
248
_img_private_t *p_env = p_user_data;
251
unsigned int blocksize = b_form2 ? M2RAW_SECTOR_SIZE : CDIO_CD_FRAMESIZE;
253
for (i = 0; i < nblocks; i++) {
254
if ( (retval = _read_mode1_sector_solaris (p_env,
255
((char *)p_data) + (blocksize * i),
263
Reads a single mode2 sector from cd device into data starting from lsn.
264
Returns 0 if no error.
267
_read_mode2_sector_solaris (void *p_user_data, void *p_data, lsn_t lsn,
270
char buf[CDIO_CD_FRAMESIZE_RAW] = { 0, };
271
struct cdrom_msf solaris_msf;
274
struct cdrom_cdxa cd_read;
276
_img_private_t *p_env = p_user_data;
278
cdio_lba_to_msf (cdio_lsn_to_lba(lsn), &_msf);
279
solaris_msf.cdmsf_min0 = cdio_from_bcd8(_msf.m);
280
solaris_msf.cdmsf_sec0 = cdio_from_bcd8(_msf.s);
281
solaris_msf.cdmsf_frame0 = cdio_from_bcd8(_msf.f);
283
if (p_env->gen.ioctls_debugged == 75)
284
cdio_debug ("only displaying every 75th ioctl from now on");
286
if (p_env->gen.ioctls_debugged == 30 * 75)
287
cdio_debug ("only displaying every 30*75th ioctl from now on");
289
if (p_env->gen.ioctls_debugged < 75
290
|| (p_env->gen.ioctls_debugged < (30 * 75)
291
&& p_env->gen.ioctls_debugged % 75 == 0)
292
|| p_env->gen.ioctls_debugged % (30 * 75) == 0)
293
cdio_debug ("reading %2.2d:%2.2d:%2.2d",
294
solaris_msf.cdmsf_min0, solaris_msf.cdmsf_sec0,
295
solaris_msf.cdmsf_frame0);
297
p_env->gen.ioctls_debugged++;
299
/* Using CDROMXA ioctl will actually use the same uscsi command
300
* as ATAPI, except we don't need to be root
302
offset = CDIO_CD_XA_SYNC_HEADER;
303
cd_read.cdxa_addr = lsn;
304
cd_read.cdxa_data = buf;
305
cd_read.cdxa_length = 1;
306
cd_read.cdxa_format = CDROM_XA_SECTOR_DATA;
307
if (ioctl (p_env->gen.fd, CDROMCDXA, &cd_read) == -1) {
308
perror ("ioctl(..,CDROMCDXA,..)");
310
/* exit (EXIT_FAILURE); */
314
memcpy (p_data, buf + (offset-CDIO_CD_SUBHEADER_SIZE), M2RAW_SECTOR_SIZE);
316
memcpy (((char *)p_data), buf + offset, CDIO_CD_FRAMESIZE);
322
Reads nblocks of mode2 sectors from cd device into data starting
324
Returns 0 if no error.
327
_read_mode2_sectors_solaris (void *p_user_data, void *data, lsn_t lsn,
328
bool b_form2, unsigned int nblocks)
330
_img_private_t *env = p_user_data;
333
unsigned int blocksize = b_form2 ? M2RAW_SECTOR_SIZE : CDIO_CD_FRAMESIZE;
335
for (i = 0; i < nblocks; i++) {
336
if ( (retval = _read_mode2_sector_solaris (env,
337
((char *)data) + (blocksize * i),
346
Return the size of the CD in logical block address (LBA) units.
349
_cdio_stat_size (void *p_user_data)
351
_img_private_t *env = p_user_data;
353
struct cdrom_tocentry tocent;
356
tocent.cdte_track = CDIO_CDROM_LEADOUT_TRACK;
357
tocent.cdte_format = CDIO_CDROM_LBA;
358
if (ioctl (env->gen.fd, CDROMREADTOCENTRY, &tocent) == -1)
360
perror ("ioctl(CDROMREADTOCENTRY)");
364
size = tocent.cdte_addr.lba;
370
Set the arg "key" with "value" in the source device.
371
Currently "source" and "access-mode" are valid keys.
372
"source" sets the source device in I/O operations
373
"access-mode" sets the the method of CD access
375
0 is returned if no error was found, and nonzero if there as an error.
378
_set_arg_solaris (void *p_user_data, const char key[], const char value[])
380
_img_private_t *env = p_user_data;
382
if (!strcmp (key, "source"))
387
free (env->gen.source_name);
389
env->gen.source_name = strdup (value);
391
else if (!strcmp (key, "access-mode"))
393
env->access_mode = str_to_access_mode_sunos(key);
402
Read and cache the CD's Track Table of Contents and track info.
403
Return true if successful or false if an error.
406
read_toc_solaris (void *p_user_data)
408
_img_private_t *p_env = p_user_data;
411
/* read TOC header */
412
if ( ioctl(p_env->gen.fd, CDROMREADTOCHDR, &p_env->tochdr) == -1 ) {
413
cdio_warn("%s: %s\n",
414
"error in ioctl CDROMREADTOCHDR", strerror(errno));
418
p_env->gen.i_first_track = p_env->tochdr.cdth_trk0;
419
p_env->gen.i_tracks = p_env->tochdr.cdth_trk1;
421
/* read individual tracks */
422
for (i=p_env->gen.i_first_track; i<=p_env->gen.i_tracks; i++) {
423
p_env->tocent[i-1].cdte_track = i;
424
p_env->tocent[i-1].cdte_format = CDIO_CDROM_MSF;
425
if ( ioctl(p_env->gen.fd, CDROMREADTOCENTRY, &p_env->tocent[i-1]) == -1 ) {
426
cdio_warn("%s %d: %s\n",
427
"error in ioctl CDROMREADTOCENTRY for track",
433
/* read the lead-out track */
434
p_env->tocent[p_env->tochdr.cdth_trk1].cdte_track = CDIO_CDROM_LEADOUT_TRACK;
435
p_env->tocent[p_env->tochdr.cdth_trk1].cdte_format = CDIO_CDROM_MSF;
437
if (ioctl(p_env->gen.fd, CDROMREADTOCENTRY,
438
&p_env->tocent[p_env->tochdr.cdth_trk1]) == -1 ) {
439
cdio_warn("%s: %s\n",
440
"error in ioctl CDROMREADTOCENTRY for lead-out",
445
p_env->gen.toc_init = true;
450
Eject media in CD drive. If successful, as a side effect we
454
eject_media_solaris (void *p_user_data) {
456
_img_private_t *env = p_user_data;
461
if (env->gen.fd > -1) {
462
if ((ret = ioctl(env->gen.fd, CDROMEJECT)) != 0) {
463
cdio_generic_free((void *) env);
464
cdio_warn ("CDROMEJECT failed: %s\n", strerror(errno));
475
_cdio_malloc_and_zero(size_t size) {
480
if((ptr = malloc(size)) == NULL) {
481
cdio_warn("malloc() failed: %s", strerror(errno));
485
memset(ptr, 0, size);
490
Return the value associated with the key "arg".
493
get_arg_solaris (void *p_user_data, const char key[])
495
_img_private_t *env = p_user_data;
497
if (!strcmp (key, "source")) {
498
return env->gen.source_name;
499
} else if (!strcmp (key, "access-mode")) {
500
switch (env->access_mode) {
501
case _AM_SUN_CTRL_ATAPI:
503
case _AM_SUN_CTRL_SCSI:
506
return "no access method";
513
Return a string containing the default CD device if none is specified.
516
cdio_get_default_device_solaris(void)
524
if ((volume_device = getenv("VOLUME_DEVICE")) != NULL &&
525
(volume_name = getenv("VOLUME_NAME")) != NULL &&
526
(volume_action = getenv("VOLUME_ACTION")) != NULL &&
527
strcmp(volume_action, "insert") == 0) {
529
device = _cdio_malloc_and_zero(strlen(volume_device)
530
+ strlen(volume_name) + 2);
532
return strdup(DEFAULT_CDIO_DEVICE);
533
sprintf(device, "%s/%s", volume_device, volume_name);
534
if (stat(device, &stb) != 0 || !S_ISCHR(stb.st_mode)) {
536
return strdup(DEFAULT_CDIO_DEVICE);
540
/* Check if it could be a Solaris media*/
541
if((stat(DEFAULT_CDIO_DEVICE, &stb) == 0) && S_ISDIR(stb.st_mode)) {
542
device = _cdio_malloc_and_zero(strlen(DEFAULT_CDIO_DEVICE) + 4);
543
sprintf(device, "%s/s0", DEFAULT_CDIO_DEVICE);
546
return strdup(DEFAULT_CDIO_DEVICE);
550
Get disc type associated with cd object.
554
get_discmode_solaris (void *p_user_data)
556
_img_private_t *p_env = p_user_data;
558
discmode_t discmode=CDIO_DISC_MODE_NO_INFO;
559
struct dk_minfo media;
562
/* Get the media info */
563
if((ret = ioctl(p_env->gen.fd, DKIOCGMEDIAINFO, &media)) != 0) {
564
cdio_warn ("DKIOCGMEDIAINFO failed: %s\n", strerror(errno));
565
return CDIO_DISC_MODE_NO_INFO;
567
switch(media.dki_media_type) {
571
/* Do cdrom detection */
573
case DK_DVDROM: return CDIO_DISC_MODE_DVD_ROM;
574
case DK_DVDR: discmode = CDIO_DISC_MODE_DVD_R;
576
case DK_DVDRAM: discmode = CDIO_DISC_MODE_DVD_RAM;
579
case DK_DVDRW+1: discmode = CDIO_DISC_MODE_DVD_RW;
581
default: /* no valid match */
582
return CDIO_DISC_MODE_NO_INFO;
585
if((discmode == CDIO_DISC_MODE_DVD_RAM ||
586
discmode == CDIO_DISC_MODE_DVD_RW ||
587
discmode == CDIO_DISC_MODE_DVD_R)) {
588
/* Fallback to uscsi if we can */
590
return get_discmode_solaris(p_user_data);
594
if (!p_env->gen.toc_init)
595
read_toc_solaris (p_env);
597
if (!p_env->gen.toc_init)
598
return CDIO_DISC_MODE_NO_INFO;
600
for (i_track = p_env->gen.i_first_track;
601
i_track < p_env->gen.i_first_track + p_env->tochdr.cdth_trk1 ;
603
track_format_t track_fmt=get_track_format_solaris(p_env, i_track);
606
case TRACK_FORMAT_AUDIO:
608
case CDIO_DISC_MODE_NO_INFO:
609
discmode = CDIO_DISC_MODE_CD_DA;
611
case CDIO_DISC_MODE_CD_DA:
612
case CDIO_DISC_MODE_CD_MIXED:
613
case CDIO_DISC_MODE_ERROR:
617
discmode = CDIO_DISC_MODE_CD_MIXED;
620
case TRACK_FORMAT_XA:
622
case CDIO_DISC_MODE_NO_INFO:
623
discmode = CDIO_DISC_MODE_CD_XA;
625
case CDIO_DISC_MODE_CD_XA:
626
case CDIO_DISC_MODE_CD_MIXED:
627
case CDIO_DISC_MODE_ERROR:
631
discmode = CDIO_DISC_MODE_CD_MIXED;
634
case TRACK_FORMAT_DATA:
636
case CDIO_DISC_MODE_NO_INFO:
637
discmode = CDIO_DISC_MODE_CD_DATA;
639
case CDIO_DISC_MODE_CD_DATA:
640
case CDIO_DISC_MODE_CD_MIXED:
641
case CDIO_DISC_MODE_ERROR:
645
discmode = CDIO_DISC_MODE_CD_MIXED;
648
case TRACK_FORMAT_ERROR:
650
discmode = CDIO_DISC_MODE_ERROR;
659
static track_format_t
660
get_track_format_solaris(void *p_user_data, track_t i_track)
662
_img_private_t *p_env = p_user_data;
664
if ( !p_env ) return TRACK_FORMAT_ERROR;
665
if (!p_env->gen.init) init_solaris(p_env);
666
if (!p_env->gen.toc_init) read_toc_solaris (p_user_data) ;
668
if ( (i_track > p_env->gen.i_tracks+p_env->gen.i_first_track)
669
|| i_track < p_env->gen.i_first_track)
670
return TRACK_FORMAT_ERROR;
672
i_track -= p_env->gen.i_first_track;
674
/* This is pretty much copied from the "badly broken" cdrom_count_tracks
677
if (p_env->tocent[i_track].cdte_ctrl & CDROM_DATA_TRACK) {
678
if (p_env->tocent[i_track].cdte_format == CDIO_CDROM_CDI_TRACK)
679
return TRACK_FORMAT_CDI;
680
else if (p_env->tocent[i_track].cdte_format == CDIO_CDROM_XA_TRACK)
681
return TRACK_FORMAT_XA;
683
return TRACK_FORMAT_DATA;
685
return TRACK_FORMAT_AUDIO;
690
Return true if we have XA data (green, mode2 form1) or
691
XA data (green, mode2 form2). That is track begins:
692
sync - header - subheader
695
FIXME: there's gotta be a better design for this and get_track_format?
698
_cdio_get_track_green(void *p_user_data, track_t i_track)
700
_img_private_t *p_env = p_user_data;
702
if ( !p_env ) return false;
703
if (!p_env->gen.init) init_solaris(p_env);
704
if (!p_env->gen.toc_init) read_toc_solaris (p_env) ;
706
if (i_track >= p_env->gen.i_tracks+p_env->gen.i_first_track
707
|| i_track < p_env->gen.i_first_track)
710
i_track -= p_env->gen.i_first_track;
712
/* FIXME: Dunno if this is the right way, but it's what
713
I was using in cd-info for a while.
715
return ((p_env->tocent[i_track].cdte_ctrl & 2) != 0);
719
Return the starting MSF (minutes/secs/frames) for track number
720
track_num in obj. Track numbers usually start at something
721
greater than 0, usually 1.
723
The "leadout" track is specified either by
724
using track_num LEADOUT_TRACK or the total tracks+1.
725
False is returned if there is no entry.
728
_cdio_get_track_msf(void *p_user_data, track_t i_track, msf_t *msf)
730
_img_private_t *p_env = p_user_data;
732
if (NULL == msf) return false;
734
if (!p_env->gen.init) init_solaris(p_env);
735
if (!p_env->gen.toc_init) read_toc_solaris (p_env) ;
737
if (i_track == CDIO_CDROM_LEADOUT_TRACK)
738
i_track = p_env->gen.i_tracks + p_env->gen.i_first_track;
740
if (i_track > (p_env->gen.i_tracks+p_env->gen.i_first_track)
741
|| i_track < p_env->gen.i_first_track) {
744
struct cdrom_tocentry *msf0 = &p_env->tocent[i_track-1];
745
msf->m = cdio_to_bcd8(msf0->cdte_addr.msf.minute);
746
msf->s = cdio_to_bcd8(msf0->cdte_addr.msf.second);
747
msf->f = cdio_to_bcd8(msf0->cdte_addr.msf.frame);
754
Return a string containing the default VCD device if none is specified.
757
cdio_get_default_device_solaris(void)
759
return strdup(DEFAULT_CDIO_DEVICE);
762
#endif /* HAVE_SOLARIS_CDROM */
765
Return an array of strings giving possible CD devices.
768
cdio_get_devices_solaris (void)
770
#ifndef HAVE_SOLARIS_CDROM
775
char **drives = NULL;
776
unsigned int i_files=0;
782
glob("/vol/dev/aliases/cdrom*", GLOB_DOOFFS, NULL, &globbuf);
783
for (i=0; i<globbuf.gl_pathc; i++) {
784
if(stat(globbuf.gl_pathv[i], &st) < 0)
787
/* Check if this is a directory, if so it's probably Solaris media */
788
if(S_ISDIR(st.st_mode)) {
789
sprintf(volpath, "%s/s0", globbuf.gl_pathv[i]);
790
if(stat(volpath, &st) == 0)
791
cdio_add_device_list(&drives, volpath, &i_files);
793
cdio_add_device_list(&drives, globbuf.gl_pathv[i], &i_files);
797
if(stat(DEFAULT_CDIO_DEVICE, &st) == 0) {
798
/* Check if this is a directory, if so it's probably Solaris media */
799
if(S_ISDIR(st.st_mode)) {
800
sprintf(volpath, "%s/s0", DEFAULT_CDIO_DEVICE);
801
if(stat(volpath, &st) == 0)
802
cdio_add_device_list(&drives, volpath, &i_files);
804
cdio_add_device_list(&drives, DEFAULT_CDIO_DEVICE, &i_files);
806
#endif /*HAVE_GLOB_H*/
807
cdio_add_device_list(&drives, NULL, &i_files);
809
#endif /*HAVE_SOLARIS_CDROM*/
813
Initialization routine. This is the only thing that doesn't
814
get called via a function pointer. In fact *we* are the
818
cdio_open_solaris (const char *psz_source_name)
820
return cdio_open_am_solaris(psz_source_name, NULL);
824
Initialization routine. This is the only thing that doesn't
825
get called via a function pointer. In fact *we* are the
829
cdio_open_am_solaris (const char *psz_orig_source, const char *access_mode)
832
#ifdef HAVE_SOLARIS_CDROM
834
_img_private_t *_data;
839
_funcs.eject_media = eject_media_solaris;
840
_funcs.free = cdio_generic_free;
841
_funcs.get_arg = get_arg_solaris;
842
_funcs.get_cdtext = get_cdtext_generic;
843
_funcs.get_default_device = cdio_get_default_device_solaris;
844
_funcs.get_devices = cdio_get_devices_solaris;
845
_funcs.get_discmode = get_discmode_solaris;
846
_funcs.get_drive_cap = scsi_mmc_get_drive_cap_generic;
847
_funcs.get_first_track_num= get_first_track_num_generic;
848
_funcs.get_hwinfo = NULL;
849
_funcs.get_mcn = scsi_mmc_get_mcn_generic,
850
_funcs.get_num_tracks = get_num_tracks_generic;
851
_funcs.get_track_format = get_track_format_solaris;
852
_funcs.get_track_green = _cdio_get_track_green;
853
_funcs.get_track_lba = NULL; /* This could be implemented if need be. */
854
_funcs.get_track_msf = _cdio_get_track_msf;
855
_funcs.lseek = cdio_generic_lseek;
856
_funcs.read = cdio_generic_read;
857
_funcs.read_audio_sectors = _read_audio_sectors_solaris;
858
_funcs.read_mode1_sector = _read_mode1_sector_solaris;
859
_funcs.read_mode1_sectors = _read_mode1_sectors_solaris;
860
_funcs.read_mode2_sector = _read_mode2_sector_solaris;
861
_funcs.read_mode2_sectors = _read_mode2_sectors_solaris;
862
_funcs.read_toc = read_toc_solaris;
863
_funcs.run_scsi_mmc_cmd = run_scsi_cmd_solaris;
864
_funcs.stat_size = _cdio_stat_size;
865
_funcs.set_arg = _set_arg_solaris;
867
_data = _cdio_malloc (sizeof (_img_private_t));
869
_data->access_mode = _AM_SUN_CTRL_SCSI;
870
_data->gen.init = false;
872
_data->gen.toc_init = false;
873
_data->gen.b_cdtext_init = false;
874
_data->gen.b_cdtext_error = false;
876
if (NULL == psz_orig_source) {
877
psz_source = cdio_get_default_device_solaris();
878
if (NULL == psz_source) return NULL;
879
_set_arg_solaris(_data, "source", psz_source);
882
if (cdio_is_device_generic(psz_orig_source))
883
_set_arg_solaris(_data, "source", psz_orig_source);
885
/* The below would be okay if all device drivers worked this way. */
887
cdio_info ("source %s is not a device", psz_orig_source);
893
ret = cdio_new ( (void *) _data, &_funcs );
894
if (ret == NULL) return NULL;
896
if (init_solaris(_data))
899
cdio_generic_free (_data);
905
#endif /* HAVE_SOLARIS_CDROM */
910
cdio_have_solaris (void)
912
#ifdef HAVE_SOLARIS_CDROM
916
#endif /* HAVE_SOLARIS_CDROM */
added
removed
lib/_cdio_sunos.c
