![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sr_ioctl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi|
Return to sr_ioctl.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi |
1.1 root 1: #include <linux/kernel.h>
2: #include <linux/sched.h>
3: #include <linux/mm.h>
4: #include <linux/fs.h>
5: #include <asm/segment.h>
6: #include <linux/errno.h>
7:
8: #include <linux/blk.h>
9: #include "scsi.h"
10: #include "hosts.h"
11: #include "sr.h"
12: #include "scsi_ioctl.h"
13:
14: #include <linux/cdrom.h>
15:
16: #define IOCTL_RETRIES 3
17: /* The CDROM is fairly slow, so we need a little extra time */
18: /* In fact, it is very slow if it has to spin up first */
19: #define IOCTL_TIMEOUT 3000
20:
21: static void sr_ioctl_done(Scsi_Cmnd * SCpnt)
22: {
23: struct request * req;
24:
25: req = &SCpnt->request;
26: req->rq_status = RQ_SCSI_DONE; /* Busy, but indicate request done */
27:
28: if (req->sem != NULL) {
29: up(req->sem);
30: }
31: }
32:
33: /* We do our own retries because we want to know what the specific
34: error code is. Normally the UNIT_ATTENTION code will automatically
35: clear after one error */
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: {
44: struct semaphore sem = MUTEX_LOCKED;
45: SCpnt->request.sem = &sem;
46: scsi_do_cmd(SCpnt,
47: (void *) sr_cmd, buffer, buflength, sr_ioctl_done,
48: IOCTL_TIMEOUT, IOCTL_RETRIES);
49: down(&sem);
50: }
51:
52: result = SCpnt->result;
53:
54: /* Minimal error checking. Ignore cases we know about, and report the rest. */
55: if(driver_byte(result) != 0)
56: switch(SCpnt->sense_buffer[2] & 0xf) {
57: case UNIT_ATTENTION:
58: scsi_CDs[target].device->changed = 1;
59: printk("Disc change detected.\n");
60: break;
61: case NOT_READY: /* This happens if there is no disc in drive */
62: printk("CDROM not ready. Make sure there is a disc in the drive.\n");
63: break;
64: case ILLEGAL_REQUEST:
65: printk("CDROM (ioctl) reports ILLEGAL REQUEST.\n");
66: break;
67: default:
68: printk("SCSI CD error: host %d id %d lun %d return code = %03x\n",
69: scsi_CDs[target].device->host->host_no,
70: scsi_CDs[target].device->id,
71: scsi_CDs[target].device->lun,
72: result);
73: printk("\tSense class %x, sense error %x, extended sense %x\n",
74: sense_class(SCpnt->sense_buffer[0]),
75: sense_error(SCpnt->sense_buffer[0]),
76: SCpnt->sense_buffer[2] & 0xf);
77:
78: };
79:
80: result = SCpnt->result;
81: SCpnt->request.rq_status = RQ_INACTIVE; /* Deallocate */
82: wake_up(&SCpnt->device->device_wait);
83: /* Wake up a process waiting for device*/
84: return result;
85: }
86:
87: int sr_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg)
88: {
89: u_char sr_cmd[10];
90:
91: kdev_t dev = inode->i_rdev;
92: int result, target, err;
93:
94: target = MINOR(dev);
95:
96: if (target >= sr_template.nr_dev ||
97: !scsi_CDs[target].device) return -ENXIO;
98:
99: switch (cmd)
100: {
101: /* Sun-compatible */
102: case CDROMPAUSE:
103:
104: sr_cmd[0] = SCMD_PAUSE_RESUME;
105: sr_cmd[1] = scsi_CDs[target].device->lun << 5;
106: sr_cmd[2] = sr_cmd[3] = sr_cmd[4] = 0;
107: sr_cmd[5] = sr_cmd[6] = sr_cmd[7] = 0;
108: sr_cmd[8] = 0;
109: sr_cmd[9] = 0;
110:
111: result = do_ioctl(target, sr_cmd, NULL, 255);
112: return result;
113:
114: case CDROMRESUME:
115:
116: sr_cmd[0] = SCMD_PAUSE_RESUME;
117: sr_cmd[1] = scsi_CDs[target].device->lun << 5;
118: sr_cmd[2] = sr_cmd[3] = sr_cmd[4] = 0;
119: sr_cmd[5] = sr_cmd[6] = sr_cmd[7] = 0;
120: sr_cmd[8] = 1;
121: sr_cmd[9] = 0;
122:
123: result = do_ioctl(target, sr_cmd, NULL, 255);
124:
125: return result;
126:
127: case CDROMPLAYMSF:
128: {
129: struct cdrom_msf msf;
130:
131: err = verify_area (VERIFY_READ, (void *) arg, sizeof (msf));
132: if (err) return err;
133:
134: memcpy_fromfs(&msf, (void *) arg, sizeof(msf));
135:
136: sr_cmd[0] = SCMD_PLAYAUDIO_MSF;
137: sr_cmd[1] = scsi_CDs[target].device->lun << 5;
138: sr_cmd[2] = 0;
139: sr_cmd[3] = msf.cdmsf_min0;
140: sr_cmd[4] = msf.cdmsf_sec0;
141: sr_cmd[5] = msf.cdmsf_frame0;
142: sr_cmd[6] = msf.cdmsf_min1;
143: sr_cmd[7] = msf.cdmsf_sec1;
144: sr_cmd[8] = msf.cdmsf_frame1;
145: sr_cmd[9] = 0;
146:
147: result = do_ioctl(target, sr_cmd, NULL, 255);
148: return result;
149: }
150:
151: case CDROMPLAYBLK:
152: {
153: struct cdrom_blk blk;
154:
155: err = verify_area (VERIFY_READ, (void *) arg, sizeof (blk));
156: if (err) return err;
157:
158: memcpy_fromfs(&blk, (void *) arg, sizeof(blk));
159:
160: sr_cmd[0] = SCMD_PLAYAUDIO10;
161: sr_cmd[1] = scsi_CDs[target].device->lun << 5;
162: sr_cmd[2] = blk.from >> 24;
163: sr_cmd[3] = blk.from >> 16;
164: sr_cmd[4] = blk.from >> 8;
165: sr_cmd[5] = blk.from;
166: sr_cmd[6] = 0;
167: sr_cmd[7] = blk.len >> 8;
168: sr_cmd[8] = blk.len;
169: sr_cmd[9] = 0;
170:
171: result = do_ioctl(target, sr_cmd, NULL, 255);
172: return result;
173: }
174:
175: case CDROMPLAYTRKIND:
176: {
177: struct cdrom_ti ti;
178:
179: err = verify_area (VERIFY_READ, (void *) arg, sizeof (ti));
180: if (err) return err;
181:
182: memcpy_fromfs(&ti, (void *) arg, sizeof(ti));
183:
184: sr_cmd[0] = SCMD_PLAYAUDIO_TI;
185: sr_cmd[1] = scsi_CDs[target].device->lun << 5;
186: sr_cmd[2] = 0;
187: sr_cmd[3] = 0;
188: sr_cmd[4] = ti.cdti_trk0;
189: sr_cmd[5] = ti.cdti_ind0;
190: sr_cmd[6] = 0;
191: sr_cmd[7] = ti.cdti_trk1;
192: sr_cmd[8] = ti.cdti_ind1;
193: sr_cmd[9] = 0;
194:
195: result = do_ioctl(target, sr_cmd, NULL, 255);
196:
197: return result;
198: }
199:
200: case CDROMREADTOCHDR:
201: {
202: struct cdrom_tochdr tochdr;
203: char * buffer;
204:
205: sr_cmd[0] = SCMD_READ_TOC;
206: sr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 0x02; /* MSF format */
207: sr_cmd[2] = sr_cmd[3] = sr_cmd[4] = sr_cmd[5] = 0;
208: sr_cmd[6] = 0;
209: sr_cmd[7] = 0; /* MSB of length (12) */
210: sr_cmd[8] = 12; /* LSB of length */
211: sr_cmd[9] = 0;
212:
213: buffer = (unsigned char *) scsi_malloc(512);
214: if(!buffer) return -ENOMEM;
215:
216: result = do_ioctl(target, sr_cmd, buffer, 12);
217:
218: tochdr.cdth_trk0 = buffer[2];
219: tochdr.cdth_trk1 = buffer[3];
220:
221: scsi_free(buffer, 512);
222:
223: err = verify_area (VERIFY_WRITE, (void *) arg, sizeof (struct cdrom_tochdr));
224: if (err)
225: return err;
226: memcpy_tofs ((void *) arg, &tochdr, sizeof (struct cdrom_tochdr));
227:
228: return result;
229: }
230:
231: case CDROMREADTOCENTRY:
232: {
233: struct cdrom_tocentry tocentry;
234: char * buffer;
235:
236: err = verify_area (VERIFY_READ, (void *) arg, sizeof (struct cdrom_tocentry));
237: if (err) return err;
238:
239: memcpy_fromfs (&tocentry, (void *) arg, sizeof (struct cdrom_tocentry));
240:
241: sr_cmd[0] = SCMD_READ_TOC;
242: sr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 0x02; /* MSF format */
243: sr_cmd[2] = sr_cmd[3] = sr_cmd[4] = sr_cmd[5] = 0;
244: sr_cmd[6] = tocentry.cdte_track;
245: sr_cmd[7] = 0; /* MSB of length (12) */
246: sr_cmd[8] = 12; /* LSB of length */
247: sr_cmd[9] = 0;
248:
249: buffer = (unsigned char *) scsi_malloc(512);
250: if(!buffer) return -ENOMEM;
251:
252: result = do_ioctl (target, sr_cmd, buffer, 12);
253:
254: if (tocentry.cdte_format == CDROM_MSF) {
255: tocentry.cdte_addr.msf.minute = buffer[9];
256: tocentry.cdte_addr.msf.second = buffer[10];
257: tocentry.cdte_addr.msf.frame = buffer[11];
258: tocentry.cdte_ctrl = buffer[5] & 0xf;
259: }
260: else
261: tocentry.cdte_addr.lba = (int) buffer[0];
262:
263: scsi_free(buffer, 512);
264:
265: err = verify_area (VERIFY_WRITE, (void *) arg, sizeof (struct cdrom_tocentry));
266: if (err)
267: return err;
268: memcpy_tofs ((void *) arg, &tocentry, sizeof (struct cdrom_tocentry));
269:
270: return result;
271: }
272:
273: case CDROMSTOP:
274: sr_cmd[0] = START_STOP;
275: sr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 1;
276: sr_cmd[2] = sr_cmd[3] = sr_cmd[5] = 0;
277: sr_cmd[4] = 0;
278:
279: result = do_ioctl(target, sr_cmd, NULL, 255);
280: return result;
281:
282: case CDROMSTART:
283: sr_cmd[0] = START_STOP;
284: sr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 1;
285: sr_cmd[2] = sr_cmd[3] = sr_cmd[5] = 0;
286: sr_cmd[4] = 1;
287:
288: result = do_ioctl(target, sr_cmd, NULL, 255);
289: return result;
290:
291: case CDROMEJECT:
292: /*
293: * Allow 0 for access count for auto-eject feature.
294: */
295: if (scsi_CDs[target].device -> access_count > 1)
296: return -EBUSY;
297:
298: sr_ioctl (inode, NULL, SCSI_IOCTL_DOORUNLOCK, 0);
299: sr_cmd[0] = START_STOP;
300: sr_cmd[1] = ((scsi_CDs[target].device -> lun) << 5) | 1;
301: sr_cmd[2] = sr_cmd[3] = sr_cmd[5] = 0;
302: sr_cmd[4] = 0x02;
303:
304: if (!(result = do_ioctl(target, sr_cmd, NULL, 255)))
305: scsi_CDs[target].device -> changed = 1;
306:
307: return result;
308:
309: case CDROMEJECT_SW:
310: scsi_CDs[target].auto_eject = !!arg;
311: return 0;
312:
313: case CDROMVOLCTRL:
314: {
315: char * buffer, * mask;
316: struct cdrom_volctrl volctrl;
317:
318: err = verify_area (VERIFY_READ, (void *) arg, sizeof (struct cdrom_volctrl));
319: if (err) return err;
320:
321: memcpy_fromfs (&volctrl, (void *) arg, sizeof (struct cdrom_volctrl));
322:
323: /* First we get the current params so we can just twiddle the volume */
324:
325: sr_cmd[0] = MODE_SENSE;
326: sr_cmd[1] = (scsi_CDs[target].device -> lun) << 5;
327: sr_cmd[2] = 0xe; /* Want mode page 0xe, CDROM audio params */
328: sr_cmd[3] = 0;
329: sr_cmd[4] = 28;
330: sr_cmd[5] = 0;
331:
332: buffer = (unsigned char *) scsi_malloc(512);
333: if(!buffer) return -ENOMEM;
334:
335: if ((result = do_ioctl (target, sr_cmd, buffer, 28))) {
336: printk ("Hosed while obtaining audio mode page\n");
337: scsi_free(buffer, 512);
338: return result;
339: }
340:
341: sr_cmd[0] = MODE_SENSE;
342: sr_cmd[1] = (scsi_CDs[target].device -> lun) << 5;
343: sr_cmd[2] = 0x4e; /* Want the mask for mode page 0xe */
344: sr_cmd[3] = 0;
345: sr_cmd[4] = 28;
346: sr_cmd[5] = 0;
347:
348: mask = (unsigned char *) scsi_malloc(512);
349: if(!mask) {
350: scsi_free(buffer, 512);
351: return -ENOMEM;
352: };
353:
354: if ((result = do_ioctl (target, sr_cmd, mask, 28))) {
355: printk ("Hosed while obtaining mask for audio mode page\n");
356: scsi_free(buffer, 512);
357: scsi_free(mask, 512);
358: return result;
359: }
360:
361: /* Now mask and substitute our own volume and reuse the rest */
362: buffer[0] = 0; /* Clear reserved field */
363:
364: buffer[21] = volctrl.channel0 & mask[21];
365: buffer[23] = volctrl.channel1 & mask[23];
366: buffer[25] = volctrl.channel2 & mask[25];
367: buffer[27] = volctrl.channel3 & mask[27];
368:
369: sr_cmd[0] = MODE_SELECT;
370: sr_cmd[1] = ((scsi_CDs[target].device -> lun) << 5) | 0x10; /* Params are SCSI-2 */
371: sr_cmd[2] = sr_cmd[3] = 0;
372: sr_cmd[4] = 28;
373: sr_cmd[5] = 0;
374:
375: result = do_ioctl (target, sr_cmd, buffer, 28);
376: scsi_free(buffer, 512);
377: scsi_free(mask, 512);
378: return result;
379: }
380:
381: case CDROMSUBCHNL:
382: {
383: struct cdrom_subchnl subchnl;
384: char * buffer;
385:
386: sr_cmd[0] = SCMD_READ_SUBCHANNEL;
387: sr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 0x02; /* MSF format */
388: sr_cmd[2] = 0x40; /* I do want the subchannel info */
389: sr_cmd[3] = 0x01; /* Give me current position info */
390: sr_cmd[4] = sr_cmd[5] = 0;
391: sr_cmd[6] = 0;
392: sr_cmd[7] = 0;
393: sr_cmd[8] = 16;
394: sr_cmd[9] = 0;
395:
396: buffer = (unsigned char*) scsi_malloc(512);
397: if(!buffer) return -ENOMEM;
398:
399: result = do_ioctl(target, sr_cmd, buffer, 16);
400:
401: subchnl.cdsc_audiostatus = buffer[1];
402: subchnl.cdsc_format = CDROM_MSF;
403: subchnl.cdsc_ctrl = buffer[5] & 0xf;
404: subchnl.cdsc_trk = buffer[6];
405: subchnl.cdsc_ind = buffer[7];
406:
407: subchnl.cdsc_reladdr.msf.minute = buffer[13];
408: subchnl.cdsc_reladdr.msf.second = buffer[14];
409: subchnl.cdsc_reladdr.msf.frame = buffer[15];
410: subchnl.cdsc_absaddr.msf.minute = buffer[9];
411: subchnl.cdsc_absaddr.msf.second = buffer[10];
412: subchnl.cdsc_absaddr.msf.frame = buffer[11];
413:
414: scsi_free(buffer, 512);
415:
416: err = verify_area (VERIFY_WRITE, (void *) arg, sizeof (struct cdrom_subchnl));
417: if (err)
418: return err;
419: memcpy_tofs ((void *) arg, &subchnl, sizeof (struct cdrom_subchnl));
420: return result;
421: }
422:
423: case CDROMREADMODE2:
424: return -EINVAL;
425: case CDROMREADMODE1:
426: return -EINVAL;
427:
428: /* block-copy from ../block/sbpcd.c with some adjustments... */
429: case CDROMMULTISESSION: /* tell start-of-last-session to user */
430: {
431: struct cdrom_multisession ms_info;
432: long lba;
433:
434: err = verify_area(VERIFY_READ, (void *) arg,
435: sizeof(struct cdrom_multisession));
436: if (err) return (err);
437:
438: memcpy_fromfs(&ms_info, (void *) arg, sizeof(struct cdrom_multisession));
439:
440: if (ms_info.addr_format==CDROM_MSF) { /* MSF-bin requested */
441: lba = scsi_CDs[target].mpcd_sector+CD_BLOCK_OFFSET;
442: ms_info.addr.msf.minute = lba / (CD_SECS*CD_FRAMES);
443: lba %= CD_SECS*CD_FRAMES;
444: ms_info.addr.msf.second = lba / CD_FRAMES;
445: ms_info.addr.msf.frame = lba % CD_FRAMES;
446: } else if (ms_info.addr_format==CDROM_LBA) /* lba requested */
447: ms_info.addr.lba=scsi_CDs[target].mpcd_sector;
448: else return (-EINVAL);
449:
450: ms_info.xa_flag=scsi_CDs[target].xa_flags & 0x01;
451:
452: err=verify_area(VERIFY_WRITE,(void *) arg,
453: sizeof(struct cdrom_multisession));
454: if (err) return (err);
455:
456: memcpy_tofs((void *) arg, &ms_info, sizeof(struct cdrom_multisession));
457: return (0);
458: }
459:
460: case BLKRASET:
461: if(!suser()) return -EACCES;
462: if(!(inode->i_rdev)) return -EINVAL;
463: if(arg > 0xff) return -EINVAL;
464: read_ahead[MAJOR(inode->i_rdev)] = arg;
465: return 0;
466: RO_IOCTLS(dev,arg);
467: default:
468: return scsi_ioctl(scsi_CDs[target].device,cmd,(void *) arg);
469: }
470: }
471:
472: /*
473: * Overrides for Emacs so that we follow Linus's tabbing style.
474: * Emacs will notice this stuff at the end of the file and automatically
475: * adjust the settings for this buffer only. This must remain at the end
476: * of the file.
477: * ---------------------------------------------------------------------------
478: * Local variables:
479: * c-indent-level: 4
480: * c-brace-imaginary-offset: 0
481: * c-brace-offset: -4
482: * c-argdecl-indent: 4
483: * c-label-offset: -4
484: * c-continued-statement-offset: 4
485: * c-continued-brace-offset: 0
486: * indent-tabs-mode: nil
487: * tab-width: 8
488: * End:
489: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.