lxdream 0.9.1| filename | src/gdrom/linux.c |
| changeset | 468:3a49695e081a |
| prev | 464:8e099fad42a6 |
| next | 480:d28c2992f5ee |
| author | nkeynes |
| date | Sun Oct 28 07:23:46 2007 +0000 (16 years ago) |
| permissions | -rw-r--r-- |
| last change | Fix CDI with multiple tracks/session Fix file being closed too early |
| view | annotate | diff | log | raw |
1 /**
2 * $Id: linux.c,v 1.7 2007-10-28 07:23:46 nkeynes Exp $
3 *
4 * Linux cd-rom device driver.
5 *
6 * Copyright (c) 2005 Nathan Keynes.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 */
18 #include <stdlib.h>
19 #include <stdio.h>
20 #include <string.h>
21 #include <errno.h>
22 #include <linux/cdrom.h>
23 #include <sys/stat.h>
24 #include <sys/ioctl.h>
25 #include <fstab.h>
26 #include <fcntl.h>
28 #include "gdrom/gdrom.h"
29 #include "gdrom/packet.h"
30 #include "dream.h"
32 #define MAXTOCENTRIES 600 /* This is a fairly generous overestimate really */
33 #define MAXTOCSIZE 4 + (MAXTOCENTRIES*11)
34 #define MAX_SECTORS_PER_CALL 1
36 #define MSFTOLBA( m,s,f ) (f + (s*CD_FRAMES) + (m*CD_FRAMES*CD_SECS))
38 static uint32_t inline lbatomsf( uint32_t lba ) {
39 union cdrom_addr addr;
40 lba = lba + CD_MSF_OFFSET;
41 addr.msf.frame = lba % CD_FRAMES;
42 int seconds = lba / CD_FRAMES;
43 addr.msf.second = seconds % CD_SECS;
44 addr.msf.minute = seconds / CD_SECS;
45 return addr.lba;
46 }
48 #define LBATOMSF( lba ) lbatomsf(lba)
51 static gboolean linux_image_is_valid( FILE *f );
52 static gdrom_disc_t linux_open_device( const gchar *filename, FILE *f );
53 static gdrom_error_t linux_read_disc_toc( gdrom_image_t disc );
54 static gdrom_error_t linux_read_sector( gdrom_disc_t disc, uint32_t sector,
55 int mode, unsigned char *buf, uint32_t *length );
56 static gdrom_error_t linux_send_command( int fd, char *cmd, unsigned char *buffer, size_t *buflen,
57 int direction );
58 static int linux_drive_status( gdrom_disc_t disc );
60 struct gdrom_image_class linux_device_class = { "Linux", NULL,
61 linux_image_is_valid, linux_open_device };
62 GList *gdrom_get_native_devices(void)
63 {
64 GList *list = NULL;
65 struct fstab *ent;
66 struct stat st;
67 setfsent();
68 while( (ent = getfsent()) != NULL ) {
69 if( (stat(ent->fs_spec, &st) != -1) &&
70 S_ISBLK(st.st_mode) ) {
71 /* Got a valid block device - is it a CDROM? */
72 int fd = open(ent->fs_spec, O_RDONLY|O_NONBLOCK);
73 if( fd == -1 )
74 continue;
75 int caps = ioctl(fd, CDROM_GET_CAPABILITY);
76 if( caps != -1 ) {
77 /* Appears to support CDROM functions */
78 list = g_list_append( list, g_strdup(ent->fs_spec) );
79 }
80 close(fd);
81 }
82 }
83 return list;
84 }
86 static gboolean linux_image_is_valid( FILE *f )
87 {
88 struct stat st;
89 struct cdrom_tochdr tochdr;
91 if( fstat(fileno(f), &st) == -1 ) {
92 return FALSE; /* can't stat device? */
93 }
94 if( !S_ISBLK(st.st_mode) ) {
95 return FALSE; /* Not a block device */
96 }
98 if( ioctl(fileno(f), CDROMREADTOCHDR, &tochdr) == -1 ) {
99 /* Quick check that this is really a CD */
100 return FALSE;
101 }
103 return TRUE;
104 }
106 static gdrom_disc_t linux_open_device( const gchar *filename, FILE *f )
107 {
108 gdrom_disc_t disc;
110 disc = gdrom_image_new(filename, f);
111 if( disc == NULL ) {
112 ERROR("Unable to allocate memory!");
113 return NULL;
114 }
116 gdrom_error_t status = linux_read_disc_toc( (gdrom_image_t)disc );
117 if( status != 0 ) {
118 gdrom_image_destroy_no_close(disc);
119 if( status == 0xFFFF ) {
120 ERROR("Unable to load disc table of contents (%s)", strerror(errno));
121 } else {
122 ERROR("Unable to load disc table of contents (sense %d,%d)",
123 status &0xFF, status >> 8 );
124 }
125 return NULL;
126 }
127 disc->read_sector = linux_read_sector;
128 disc->drive_status = linux_drive_status;
129 ((gdrom_image_t)disc)->disc_type = IDE_DISC_CDROM;
130 return disc;
131 }
133 static int linux_drive_status( gdrom_disc_t disc )
134 {
135 int fd = fileno(((gdrom_image_t)disc)->file);
136 int status = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
137 if( status == CDS_DISC_OK ) {
138 status = ioctl(fd, CDROM_MEDIA_CHANGED, CDSL_CURRENT);
139 if( status != 0 ) {
140 linux_read_disc_toc( (gdrom_image_t)disc);
141 }
142 return ((gdrom_image_t)disc)->disc_type | IDE_DISC_READY;
143 } else {
144 return IDE_DISC_NONE;
145 }
146 }
147 /**
148 * Read the full table of contents into the disc from the device.
149 */
150 static gdrom_error_t linux_read_disc_toc( gdrom_image_t disc )
151 {
152 int fd = fileno(disc->file);
153 unsigned char buf[MAXTOCSIZE];
154 size_t buflen = sizeof(buf);
155 char cmd[12] = { 0x43, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
157 cmd[7] = (sizeof(buf))>>8;
158 cmd[8] = (sizeof(buf))&0xFF;
159 memset( buf, 0, sizeof(buf) );
160 gdrom_error_t status = linux_send_command( fd, cmd, buf, &buflen, CGC_DATA_READ );
161 if( status != 0 ) {
162 return status;
163 }
165 int max_track = 0;
166 int last_track = -1;
167 int leadout = -1;
168 int len = (buf[0] << 8) | buf[1];
169 int session_type = GDROM_MODE1;
170 int i;
171 for( i = 4; i<len; i+=11 ) {
172 int session = buf[i];
173 int adr = buf[i+1] >> 4;
174 int point = buf[i+3];
175 if( adr == 0x01 && point > 0 && point < 100 ) {
176 /* Track info */
177 int trackno = point-1;
178 if( point > max_track ) {
179 max_track = point;
180 }
181 disc->track[trackno].flags = (buf[i+1] & 0x0F) << 4;
182 disc->track[trackno].session = session - 1;
183 disc->track[trackno].lba = MSFTOLBA(buf[i+8],buf[i+9],buf[i+10]);
184 if( disc->track[trackno].flags & TRACK_DATA ) {
185 disc->track[trackno].mode = GDROM_MODE1;
186 } else {
187 disc->track[trackno].mode = GDROM_CDDA;
188 }
189 if( last_track != -1 ) {
190 disc->track[last_track].sector_count = disc->track[trackno].lba -
191 disc->track[last_track].lba;
192 }
193 last_track = trackno;
194 } else switch( (adr << 8) | point ) {
195 case 0x1A0: /* session info */
196 if( buf[i+9] == 0x20 ) {
197 session_type = GDROM_MODE2;
198 } else {
199 session_type = GDROM_MODE1;
200 }
201 case 0x1A2: /* leadout */
202 leadout = MSFTOLBA(buf[i+8], buf[i+9], buf[i+10]);
203 break;
204 }
205 }
206 disc->track_count = max_track;
208 if( leadout != -1 && last_track != -1 ) {
209 disc->track[last_track].sector_count = leadout - disc->track[last_track].lba;
210 }
211 return 0;
212 }
214 static gdrom_error_t linux_play_audio( gdrom_disc_t disc, uint32_t lba, uint32_t endlba )
215 {
216 int fd = fileno( ((gdrom_image_t)disc)->file );
217 uint32_t real_sector = lba - CD_MSF_OFFSET;
218 uint32_t length = endlba - lba;
219 uint32_t buflen = 0;
220 char cmd[12] = { 0xA5, 0,0,0, 0,0,0,0, 0,0,0,0 };
221 cmd[2] = (real_sector >> 24) & 0xFF;
222 cmd[3] = (real_sector >> 16) & 0xFF;
223 cmd[4] = (real_sector >> 8) & 0xFF;
224 cmd[5] = real_sector & 0xFF;
225 cmd[6] = (length >> 24) & 0xFF;
226 cmd[7] = (length >> 16) & 0xFF;
227 cmd[8] = (length >> 8) & 0xFF;
228 cmd[9] = length & 0xFF;
230 return linux_send_command( fd, cmd, NULL, &buflen, CGC_DATA_NONE );
231 }
233 static gdrom_error_t linux_stop_audio( gdrom_disc_t disc )
234 {
235 int fd = fileno( ((gdrom_image_t)disc)->file );
236 uint32_t buflen = 0;
237 char cmd[12] = {0x4E,0,0,0, 0,0,0,0, 0,0,0,0};
238 return linux_send_command( fd, cmd, NULL, &buflen, CGC_DATA_NONE );
239 }
241 static gdrom_error_t linux_read_sector( gdrom_disc_t disc, uint32_t sector,
242 int mode, unsigned char *buf, uint32_t *length )
243 {
244 gdrom_image_t image = (gdrom_image_t)disc;
245 int fd = fileno(image->file);
246 uint32_t real_sector = sector - CD_MSF_OFFSET;
247 uint32_t sector_size = MAX_SECTOR_SIZE;
248 char cmd[12] = { 0xBE, 0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
250 cmd[1] = (mode & 0x0E) << 1;
251 cmd[2] = (real_sector >> 24) & 0xFF;
252 cmd[3] = (real_sector >> 16) & 0xFF;
253 cmd[4] = (real_sector >> 8) & 0xFF;
254 cmd[5] = real_sector & 0xFF;
255 cmd[6] = 0;
256 cmd[7] = 0;
257 cmd[8] = 1;
258 cmd[9] = 0x10;
260 gdrom_error_t status = linux_send_command( fd, cmd, buf, §or_size, CGC_DATA_READ );
261 if( status != 0 ) {
262 return status;
263 }
264 *length = 2048;
265 return 0;
266 }
268 /**
269 * Send a packet command to the device and wait for a response.
270 * @return 0 on success, -1 on an operating system error, or a sense error
271 * code on a device error.
272 */
273 static gdrom_error_t linux_send_command( int fd, char *cmd, unsigned char *buffer, size_t *buflen,
274 int direction )
275 {
276 struct request_sense sense;
277 struct cdrom_generic_command cgc;
279 memset( &cgc, 0, sizeof(cgc) );
280 memset( &sense, 0, sizeof(sense) );
281 memcpy( cgc.cmd, cmd, 12 );
282 cgc.buffer = buffer;
283 cgc.buflen = *buflen;
284 cgc.sense = &sense;
285 cgc.data_direction = direction;
287 if( ioctl(fd, CDROM_SEND_PACKET, &cgc) == -1 ) {
288 if( sense.sense_key == 0 ) {
289 return -1;
290 } else {
291 /* TODO: Map newer codes back to the ones used by the gd-rom. */
292 return sense.sense_key | (sense.asc<<8);
293 }
294 } else {
295 *buflen = cgc.buflen;
296 return 0;
297 }
298 }
.