This source file includes following definitions.
- sr_ioctl_done
- do_ioctl
- sr_ioctl
1 #include <linux/kernel.h>
2 #include <linux/sched.h>
3 #include <linux/fs.h>
4 #include <asm/segment.h>
5 #include <linux/errno.h>
6
7 #include "../block/blk.h"
8 #include "scsi.h"
9 #include "hosts.h"
10 #include "sr.h"
11 #include "scsi_ioctl.h"
12
13 #include <linux/cdrom.h>
14
15 #define IOCTL_RETRIES 3
16
17 #define IOCTL_TIMEOUT 200
18
19 extern int scsi_ioctl (Scsi_Device *dev, int cmd, void *arg);
20
21 static void sr_ioctl_done(Scsi_Cmnd * SCpnt)
22 {
23 struct request * req;
24
25 req = &SCpnt->request;
26 req->dev = 0xfffe;
27
28 if (req->sem != NULL) {
29 up(req->sem);
30 }
31 }
32
33
34
35
36
37 static int do_ioctl(int target, unsigned char * sr_cmd, void * buffer, unsigned buflength)
38 {
39 Scsi_Cmnd * SCpnt;
40 int result;
41
42 SCpnt = allocate_device(NULL, scsi_CDs[target].device, 1);
43 scsi_do_cmd(SCpnt,
44 (void *) sr_cmd, buffer, buflength, sr_ioctl_done,
45 IOCTL_TIMEOUT, IOCTL_RETRIES);
46
47
48 if (SCpnt->request.dev != 0xfffe){
49 struct semaphore sem = MUTEX_LOCKED;
50 SCpnt->request.sem = &sem;
51 down(&sem);
52
53 while (SCpnt->request.dev != 0xfffe) schedule();
54 };
55
56 result = SCpnt->result;
57
58
59 if(driver_byte(result) != 0)
60 switch(SCpnt->sense_buffer[2] & 0xf) {
61 case UNIT_ATTENTION:
62 scsi_CDs[target].device->changed = 1;
63 printk("Disc change detected.\n");
64 break;
65 case NOT_READY:
66 printk("CDROM not ready. Make sure there is a disc in the drive.\n");
67 break;
68 case ILLEGAL_REQUEST:
69 printk("CDROM (ioctl) reports ILLEGAL REQUEST.\n");
70 break;
71 default:
72 printk("SCSI CD error: host %d id %d lun %d return code = %03x\n",
73 scsi_CDs[target].device->host->host_no,
74 scsi_CDs[target].device->id,
75 scsi_CDs[target].device->lun,
76 result);
77 printk("\tSense class %x, sense error %x, extended sense %x\n",
78 sense_class(SCpnt->sense_buffer[0]),
79 sense_error(SCpnt->sense_buffer[0]),
80 SCpnt->sense_buffer[2] & 0xf);
81
82 };
83
84 result = SCpnt->result;
85 SCpnt->request.dev = -1;
86 wake_up(&SCpnt->device->device_wait);
87
88 return result;
89 }
90
91 int sr_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg)
92 {
93 u_char sr_cmd[10];
94
95 int dev = inode->i_rdev;
96 int result, target, err;
97
98 target = MINOR(dev);
99 if (target >= NR_SR) return -ENXIO;
100
101 switch (cmd)
102 {
103
104 case CDROMPAUSE:
105
106 sr_cmd[0] = SCMD_PAUSE_RESUME;
107 sr_cmd[1] = scsi_CDs[target].device->lun << 5;
108 sr_cmd[2] = sr_cmd[3] = sr_cmd[4] = 0;
109 sr_cmd[5] = sr_cmd[6] = sr_cmd[7] = 0;
110 sr_cmd[8] = 0;
111 sr_cmd[9] = 0;
112
113 result = do_ioctl(target, sr_cmd, NULL, 255);
114 return result;
115
116 case CDROMRESUME:
117
118 sr_cmd[0] = SCMD_PAUSE_RESUME;
119 sr_cmd[1] = scsi_CDs[target].device->lun << 5;
120 sr_cmd[2] = sr_cmd[3] = sr_cmd[4] = 0;
121 sr_cmd[5] = sr_cmd[6] = sr_cmd[7] = 0;
122 sr_cmd[8] = 1;
123 sr_cmd[9] = 0;
124
125 result = do_ioctl(target, sr_cmd, NULL, 255);
126
127 return result;
128
129 case CDROMPLAYMSF:
130 {
131 struct cdrom_msf msf;
132 memcpy_fromfs(&msf, (void *) arg, sizeof(msf));
133
134 sr_cmd[0] = SCMD_PLAYAUDIO_MSF;
135 sr_cmd[1] = scsi_CDs[target].device->lun << 5;
136 sr_cmd[2] = 0;
137 sr_cmd[3] = msf.cdmsf_min0;
138 sr_cmd[4] = msf.cdmsf_sec0;
139 sr_cmd[5] = msf.cdmsf_frame0;
140 sr_cmd[6] = msf.cdmsf_min1;
141 sr_cmd[7] = msf.cdmsf_sec1;
142 sr_cmd[8] = msf.cdmsf_frame1;
143 sr_cmd[9] = 0;
144
145 result = do_ioctl(target, sr_cmd, NULL, 255);
146 return result;
147 }
148
149 case CDROMPLAYTRKIND:
150 {
151 struct cdrom_ti ti;
152 memcpy_fromfs(&ti, (void *) arg, sizeof(ti));
153
154 sr_cmd[0] = SCMD_PLAYAUDIO_TI;
155 sr_cmd[1] = scsi_CDs[target].device->lun << 5;
156 sr_cmd[2] = 0;
157 sr_cmd[3] = 0;
158 sr_cmd[4] = ti.cdti_trk0;
159 sr_cmd[5] = ti.cdti_ind0;
160 sr_cmd[6] = 0;
161 sr_cmd[7] = ti.cdti_trk1;
162 sr_cmd[8] = ti.cdti_ind1;
163 sr_cmd[9] = 0;
164
165 result = do_ioctl(target, sr_cmd, NULL, 255);
166
167 return result;
168 }
169
170 case CDROMREADTOCHDR:
171 {
172 struct cdrom_tochdr tochdr;
173 char * buffer;
174
175 sr_cmd[0] = SCMD_READ_TOC;
176 sr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 0x02;
177 sr_cmd[2] = sr_cmd[3] = sr_cmd[4] = sr_cmd[5] = 0;
178 sr_cmd[6] = 0;
179 sr_cmd[7] = 0;
180 sr_cmd[8] = 12;
181 sr_cmd[9] = 0;
182
183 buffer = (unsigned char *) scsi_malloc(512);
184 if(!buffer) return -ENOMEM;
185
186 result = do_ioctl(target, sr_cmd, buffer, 12);
187
188 tochdr.cdth_trk0 = buffer[2];
189 tochdr.cdth_trk1 = buffer[3];
190
191 scsi_free(buffer, 512);
192
193 err = verify_area (VERIFY_WRITE, (void *) arg, sizeof (struct cdrom_tochdr));
194 if (err)
195 return err;
196 memcpy_tofs ((void *) arg, &tochdr, sizeof (struct cdrom_tochdr));
197
198 return result;
199 }
200
201 case CDROMREADTOCENTRY:
202 {
203 struct cdrom_tocentry tocentry;
204 char * buffer;
205
206 verify_area (VERIFY_READ, (void *) arg, sizeof (struct cdrom_tocentry));
207 memcpy_fromfs (&tocentry, (void *) arg, sizeof (struct cdrom_tocentry));
208
209 sr_cmd[0] = SCMD_READ_TOC;
210 sr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 0x02;
211 sr_cmd[2] = sr_cmd[3] = sr_cmd[4] = sr_cmd[5] = 0;
212 sr_cmd[6] = tocentry.cdte_track;
213 sr_cmd[7] = 0;
214 sr_cmd[8] = 12;
215 sr_cmd[9] = 0;
216
217 buffer = (unsigned char *) scsi_malloc(512);
218 if(!buffer) return -ENOMEM;
219
220 result = do_ioctl (target, sr_cmd, buffer, 12);
221
222 if (tocentry.cdte_format == CDROM_MSF) {
223 tocentry.cdte_addr.msf.minute = buffer[9];
224 tocentry.cdte_addr.msf.second = buffer[10];
225 tocentry.cdte_addr.msf.frame = buffer[11];
226 tocentry.cdte_ctrl = buffer[5] & 0xf;
227 }
228 else
229 tocentry.cdte_addr.lba = (int) buffer[0];
230
231 scsi_free(buffer, 512);
232
233 err = verify_area (VERIFY_WRITE, (void *) arg, sizeof (struct cdrom_tocentry));
234 if (err)
235 return err;
236 memcpy_tofs ((void *) arg, &tocentry, sizeof (struct cdrom_tocentry));
237
238 return result;
239 }
240
241 case CDROMSTOP:
242 sr_cmd[0] = START_STOP;
243 sr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 1;
244 sr_cmd[2] = sr_cmd[3] = sr_cmd[5] = 0;
245 sr_cmd[4] = 0;
246
247 result = do_ioctl(target, sr_cmd, NULL, 255);
248 return result;
249
250 case CDROMSTART:
251 sr_cmd[0] = START_STOP;
252 sr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 1;
253 sr_cmd[2] = sr_cmd[3] = sr_cmd[5] = 0;
254 sr_cmd[4] = 1;
255
256 result = do_ioctl(target, sr_cmd, NULL, 255);
257 return result;
258
259 case CDROMEJECT:
260 if (scsi_CDs[target].device -> access_count == 1)
261 sr_ioctl (inode, NULL, SCSI_IOCTL_DOORUNLOCK, 0);
262
263 sr_cmd[0] = START_STOP;
264 sr_cmd[1] = ((scsi_CDs[target].device -> lun) << 5) | 1;
265 sr_cmd[2] = sr_cmd[3] = sr_cmd[5] = 0;
266 sr_cmd[4] = 0x02;
267
268 if (!(result = do_ioctl(target, sr_cmd, NULL, 255)))
269 scsi_CDs[target].device -> changed = 1;
270
271 return result;
272
273 case CDROMVOLCTRL:
274 {
275 char * buffer, * mask;
276 struct cdrom_volctrl volctrl;
277
278 verify_area (VERIFY_READ, (void *) arg, sizeof (struct cdrom_volctrl));
279 memcpy_fromfs (&volctrl, (void *) arg, sizeof (struct cdrom_volctrl));
280
281
282
283 sr_cmd[0] = MODE_SENSE;
284 sr_cmd[1] = (scsi_CDs[target].device -> lun) << 5;
285 sr_cmd[2] = 0xe;
286 sr_cmd[3] = 0;
287 sr_cmd[4] = 28;
288 sr_cmd[5] = 0;
289
290 buffer = (unsigned char *) scsi_malloc(512);
291 if(!buffer) return -ENOMEM;
292
293 if ((result = do_ioctl (target, sr_cmd, buffer, 28))) {
294 printk ("Hosed while obtaining audio mode page\n");
295 scsi_free(buffer, 512);
296 return result;
297 }
298
299 sr_cmd[0] = MODE_SENSE;
300 sr_cmd[1] = (scsi_CDs[target].device -> lun) << 5;
301 sr_cmd[2] = 0x4e;
302 sr_cmd[3] = 0;
303 sr_cmd[4] = 28;
304 sr_cmd[5] = 0;
305
306 mask = (unsigned char *) scsi_malloc(512);
307 if(!mask) {
308 scsi_free(buffer, 512);
309 return -ENOMEM;
310 };
311
312 if ((result = do_ioctl (target, sr_cmd, mask, 28))) {
313 printk ("Hosed while obtaining mask for audio mode page\n");
314 scsi_free(buffer, 512);
315 scsi_free(mask, 512);
316 return result;
317 }
318
319
320 buffer[0] = 0;
321
322 buffer[21] = volctrl.channel0 & mask[21];
323 buffer[23] = volctrl.channel1 & mask[23];
324 buffer[25] = volctrl.channel2 & mask[25];
325 buffer[27] = volctrl.channel3 & mask[27];
326
327 sr_cmd[0] = MODE_SELECT;
328 sr_cmd[1] = ((scsi_CDs[target].device -> lun) << 5) | 0x10;
329 sr_cmd[2] = sr_cmd[3] = 0;
330 sr_cmd[4] = 28;
331 sr_cmd[5] = 0;
332
333 result = do_ioctl (target, sr_cmd, buffer, 28);
334 scsi_free(buffer, 512);
335 scsi_free(mask, 512);
336 return result;
337 }
338
339 case CDROMSUBCHNL:
340 {
341 struct cdrom_subchnl subchnl;
342 char * buffer;
343
344 sr_cmd[0] = SCMD_READ_SUBCHANNEL;
345 sr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 0x02;
346 sr_cmd[2] = 0x40;
347 sr_cmd[3] = 0x01;
348 sr_cmd[4] = sr_cmd[5] = 0;
349 sr_cmd[6] = 0;
350 sr_cmd[7] = 0;
351 sr_cmd[8] = 16;
352 sr_cmd[9] = 0;
353
354 buffer = (unsigned char*) scsi_malloc(512);
355 if(!buffer) return -ENOMEM;
356
357 result = do_ioctl(target, sr_cmd, buffer, 16);
358
359 subchnl.cdsc_audiostatus = buffer[1];
360 subchnl.cdsc_format = CDROM_MSF;
361 subchnl.cdsc_ctrl = buffer[5] & 0xf;
362 subchnl.cdsc_trk = buffer[6];
363 subchnl.cdsc_ind = buffer[7];
364
365 subchnl.cdsc_reladdr.msf.minute = buffer[13];
366 subchnl.cdsc_reladdr.msf.second = buffer[14];
367 subchnl.cdsc_reladdr.msf.frame = buffer[15];
368 subchnl.cdsc_absaddr.msf.minute = buffer[9];
369 subchnl.cdsc_absaddr.msf.second = buffer[10];
370 subchnl.cdsc_absaddr.msf.frame = buffer[11];
371
372 scsi_free(buffer, 512);
373
374 err = verify_area (VERIFY_WRITE, (void *) arg, sizeof (struct cdrom_subchnl));
375 if (err)
376 return err;
377 memcpy_tofs ((void *) arg, &subchnl, sizeof (struct cdrom_subchnl));
378 return result;
379 }
380
381 case CDROMREADMODE2:
382 return -EINVAL;
383 case CDROMREADMODE1:
384 return -EINVAL;
385
386 case BLKRASET:
387 if(!suser()) return -EACCES;
388 if(!inode->i_rdev) return -EINVAL;
389 if(arg > 0xff) return -EINVAL;
390 read_ahead[MAJOR(inode->i_rdev)] = arg;
391 return 0;
392 RO_IOCTLS(dev,arg);
393 default:
394 return scsi_ioctl(scsi_CDs[target].device,cmd,(void *) arg);
395 }
396 }