2 * SCSI Media Changer device driver for Linux 2.6
4 * (c) 1996-2003 Gerd Knorr <kraxel@bytesex.org>
10 #include <linux/module.h>
11 #include <linux/init.h>
13 #include <linux/kernel.h>
15 #include <linux/major.h>
16 #include <linux/string.h>
17 #include <linux/errno.h>
18 #include <linux/interrupt.h>
19 #include <linux/blkdev.h>
20 #include <linux/completion.h>
21 #include <linux/compat.h>
22 #include <linux/chio.h> /* here are all the ioctls */
23 #include <linux/mutex.h>
24 #include <linux/idr.h>
25 #include <linux/slab.h>
27 #include <scsi/scsi.h>
28 #include <scsi/scsi_cmnd.h>
29 #include <scsi/scsi_driver.h>
30 #include <scsi/scsi_ioctl.h>
31 #include <scsi/scsi_host.h>
32 #include <scsi/scsi_device.h>
33 #include <scsi/scsi_eh.h>
34 #include <scsi/scsi_dbg.h>
38 #define CH_MAX_DEVS 128
40 MODULE_DESCRIPTION("device driver for scsi media changer devices");
41 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org>");
42 MODULE_LICENSE("GPL");
43 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_CHANGER_MAJOR
);
44 MODULE_ALIAS_SCSI_DEVICE(TYPE_MEDIUM_CHANGER
);
46 static DEFINE_MUTEX(ch_mutex
);
48 module_param(init
, int, 0444);
49 MODULE_PARM_DESC(init
, \
50 "initialize element status on driver load (default: on)");
52 static int timeout_move
= 300;
53 module_param(timeout_move
, int, 0644);
54 MODULE_PARM_DESC(timeout_move
,"timeout for move commands "
55 "(default: 300 seconds)");
57 static int timeout_init
= 3600;
58 module_param(timeout_init
, int, 0644);
59 MODULE_PARM_DESC(timeout_init
,"timeout for INITIALIZE ELEMENT STATUS "
60 "(default: 3600 seconds)");
62 static int verbose
= 1;
63 module_param(verbose
, int, 0644);
64 MODULE_PARM_DESC(verbose
,"be verbose (default: on)");
67 module_param(debug
, int, 0644);
68 MODULE_PARM_DESC(debug
,"enable/disable debug messages, also prints more "
69 "detailed sense codes on scsi errors (default: off)");
71 static int dt_id
[CH_DT_MAX
] = { [ 0 ... (CH_DT_MAX
-1) ] = -1 };
72 static int dt_lun
[CH_DT_MAX
];
73 module_param_array(dt_id
, int, NULL
, 0444);
74 module_param_array(dt_lun
, int, NULL
, 0444);
76 /* tell the driver about vendor-specific slots */
77 static int vendor_firsts
[CH_TYPES
-4];
78 static int vendor_counts
[CH_TYPES
-4];
79 module_param_array(vendor_firsts
, int, NULL
, 0444);
80 module_param_array(vendor_counts
, int, NULL
, 0444);
82 static const char * vendor_labels
[CH_TYPES
-4] = {
83 "v0", "v1", "v2", "v3"
85 // module_param_string_array(vendor_labels, NULL, 0444);
87 #define ch_printk(prefix, ch, fmt, a...) \
88 sdev_prefix_printk(prefix, (ch)->device, (ch)->name, fmt, ##a)
90 #define DPRINTK(fmt, arg...) \
93 ch_printk(KERN_DEBUG, ch, fmt, ##arg); \
95 #define VPRINTK(level, fmt, arg...) \
98 ch_printk(level, ch, fmt, ##arg); \
101 /* ------------------------------------------------------------------- */
103 #define MAX_RETRIES 1
105 static struct class * ch_sysfs_class
;
109 struct list_head list
;
112 struct scsi_device
*device
;
113 struct scsi_device
**dt
; /* ptrs to data transfer elements */
114 u_int firsts
[CH_TYPES
];
115 u_int counts
[CH_TYPES
];
116 u_int unit_attention
;
121 static DEFINE_IDR(ch_index_idr
);
122 static DEFINE_SPINLOCK(ch_index_lock
);
124 static const struct {
130 /* Just filled in what looks right. Hav'nt checked any standard paper for
131 these errno assignments, so they may be wrong... */
133 .sense
= ILLEGAL_REQUEST
,
136 .errno
= EBADSLT
, /* Invalid element address */
138 .sense
= ILLEGAL_REQUEST
,
141 .errno
= EBADE
, /* Import or export element accessed */
143 .sense
= ILLEGAL_REQUEST
,
146 .errno
= EXFULL
, /* Medium destination element full */
148 .sense
= ILLEGAL_REQUEST
,
151 .errno
= EBADE
, /* Medium source element empty */
153 .sense
= ILLEGAL_REQUEST
,
156 .errno
= EBADRQC
, /* Invalid command operation code */
162 /* ------------------------------------------------------------------- */
164 static int ch_find_errno(struct scsi_sense_hdr
*sshdr
)
168 /* Check to see if additional sense information is available */
169 if (scsi_sense_valid(sshdr
) &&
171 for (i
= 0; ch_err
[i
].errno
!= 0; i
++) {
172 if (ch_err
[i
].sense
== sshdr
->sense_key
&&
173 ch_err
[i
].asc
== sshdr
->asc
&&
174 ch_err
[i
].ascq
== sshdr
->ascq
) {
175 errno
= -ch_err
[i
].errno
;
186 ch_do_scsi(scsi_changer
*ch
, unsigned char *cmd
, int cmd_len
,
187 void *buffer
, unsigned buflength
,
188 enum dma_data_direction direction
)
190 int errno
, retries
= 0, timeout
, result
;
191 struct scsi_sense_hdr sshdr
;
193 timeout
= (cmd
[0] == INITIALIZE_ELEMENT_STATUS
)
194 ? timeout_init
: timeout_move
;
198 result
= scsi_execute_req(ch
->device
, cmd
, direction
, buffer
,
199 buflength
, &sshdr
, timeout
* HZ
,
202 if (driver_byte(result
) == DRIVER_SENSE
) {
204 scsi_print_sense_hdr(ch
->device
, ch
->name
, &sshdr
);
205 errno
= ch_find_errno(&sshdr
);
207 switch(sshdr
.sense_key
) {
209 ch
->unit_attention
= 1;
218 /* ------------------------------------------------------------------------ */
221 ch_elem_to_typecode(scsi_changer
*ch
, u_int elem
)
225 for (i
= 0; i
< CH_TYPES
; i
++) {
226 if (elem
>= ch
->firsts
[i
] &&
227 elem
< ch
->firsts
[i
] +
235 ch_read_element_status(scsi_changer
*ch
, u_int elem
, char *data
)
241 buffer
= kmalloc(512, GFP_KERNEL
| GFP_DMA
);
246 memset(cmd
,0,sizeof(cmd
));
247 cmd
[0] = READ_ELEMENT_STATUS
;
248 cmd
[1] = ((ch
->device
->lun
& 0x7) << 5) |
249 (ch
->voltags
? 0x10 : 0) |
250 ch_elem_to_typecode(ch
,elem
);
251 cmd
[2] = (elem
>> 8) & 0xff;
252 cmd
[3] = elem
& 0xff;
255 if (0 == (result
= ch_do_scsi(ch
, cmd
, 12,
256 buffer
, 256, DMA_FROM_DEVICE
))) {
257 if (((buffer
[16] << 8) | buffer
[17]) != elem
) {
258 DPRINTK("asked for element 0x%02x, got 0x%02x\n",
259 elem
,(buffer
[16] << 8) | buffer
[17]);
263 memcpy(data
,buffer
+16,16);
267 VPRINTK(KERN_INFO
, "device has no volume tag support\n");
270 DPRINTK("READ ELEMENT STATUS for element 0x%x failed\n",elem
);
277 ch_init_elem(scsi_changer
*ch
)
282 VPRINTK(KERN_INFO
, "INITIALIZE ELEMENT STATUS, may take some time ...\n");
283 memset(cmd
,0,sizeof(cmd
));
284 cmd
[0] = INITIALIZE_ELEMENT_STATUS
;
285 cmd
[1] = (ch
->device
->lun
& 0x7) << 5;
286 err
= ch_do_scsi(ch
, cmd
, 6, NULL
, 0, DMA_NONE
);
287 VPRINTK(KERN_INFO
, "... finished\n");
292 ch_readconfig(scsi_changer
*ch
)
294 u_char cmd
[10], data
[16];
299 buffer
= kzalloc(512, GFP_KERNEL
| GFP_DMA
);
303 memset(cmd
,0,sizeof(cmd
));
305 cmd
[1] = (ch
->device
->lun
& 0x7) << 5;
308 result
= ch_do_scsi(ch
, cmd
, 10, buffer
, 255, DMA_FROM_DEVICE
);
311 result
= ch_do_scsi(ch
, cmd
, 10, buffer
, 255, DMA_FROM_DEVICE
);
314 ch
->firsts
[CHET_MT
] =
315 (buffer
[buffer
[3]+ 6] << 8) | buffer
[buffer
[3]+ 7];
316 ch
->counts
[CHET_MT
] =
317 (buffer
[buffer
[3]+ 8] << 8) | buffer
[buffer
[3]+ 9];
318 ch
->firsts
[CHET_ST
] =
319 (buffer
[buffer
[3]+10] << 8) | buffer
[buffer
[3]+11];
320 ch
->counts
[CHET_ST
] =
321 (buffer
[buffer
[3]+12] << 8) | buffer
[buffer
[3]+13];
322 ch
->firsts
[CHET_IE
] =
323 (buffer
[buffer
[3]+14] << 8) | buffer
[buffer
[3]+15];
324 ch
->counts
[CHET_IE
] =
325 (buffer
[buffer
[3]+16] << 8) | buffer
[buffer
[3]+17];
326 ch
->firsts
[CHET_DT
] =
327 (buffer
[buffer
[3]+18] << 8) | buffer
[buffer
[3]+19];
328 ch
->counts
[CHET_DT
] =
329 (buffer
[buffer
[3]+20] << 8) | buffer
[buffer
[3]+21];
330 VPRINTK(KERN_INFO
, "type #1 (mt): 0x%x+%d [medium transport]\n",
332 ch
->counts
[CHET_MT
]);
333 VPRINTK(KERN_INFO
, "type #2 (st): 0x%x+%d [storage]\n",
335 ch
->counts
[CHET_ST
]);
336 VPRINTK(KERN_INFO
, "type #3 (ie): 0x%x+%d [import/export]\n",
338 ch
->counts
[CHET_IE
]);
339 VPRINTK(KERN_INFO
, "type #4 (dt): 0x%x+%d [data transfer]\n",
341 ch
->counts
[CHET_DT
]);
343 VPRINTK(KERN_INFO
, "reading element address assignment page failed!\n");
346 /* vendor specific element types */
347 for (i
= 0; i
< 4; i
++) {
348 if (0 == vendor_counts
[i
])
350 if (NULL
== vendor_labels
[i
])
352 ch
->firsts
[CHET_V1
+i
] = vendor_firsts
[i
];
353 ch
->counts
[CHET_V1
+i
] = vendor_counts
[i
];
354 VPRINTK(KERN_INFO
, "type #%d (v%d): 0x%x+%d [%s, vendor specific]\n",
355 i
+5,i
+1,vendor_firsts
[i
],vendor_counts
[i
],
359 /* look up the devices of the data transfer elements */
360 ch
->dt
= kcalloc(ch
->counts
[CHET_DT
], sizeof(*ch
->dt
),
368 for (elem
= 0; elem
< ch
->counts
[CHET_DT
]; elem
++) {
371 if (elem
< CH_DT_MAX
&& -1 != dt_id
[elem
]) {
374 VPRINTK(KERN_INFO
, "dt 0x%x: [insmod option] ",
375 elem
+ch
->firsts
[CHET_DT
]);
376 } else if (0 != ch_read_element_status
377 (ch
,elem
+ch
->firsts
[CHET_DT
],data
)) {
378 VPRINTK(KERN_INFO
, "dt 0x%x: READ ELEMENT STATUS failed\n",
379 elem
+ch
->firsts
[CHET_DT
]);
381 VPRINTK(KERN_INFO
, "dt 0x%x: ",elem
+ch
->firsts
[CHET_DT
]);
382 if (data
[6] & 0x80) {
383 VPRINTK(KERN_CONT
, "not this SCSI bus\n");
385 } else if (0 == (data
[6] & 0x30)) {
386 VPRINTK(KERN_CONT
, "ID/LUN unknown\n");
391 if (data
[6] & 0x20) id
= data
[7];
392 if (data
[6] & 0x10) lun
= data
[6] & 7;
396 VPRINTK(KERN_CONT
, "ID %i, LUN %i, ",id
,lun
);
398 scsi_device_lookup(ch
->device
->host
,
402 /* should not happen */
403 VPRINTK(KERN_CONT
, "Huh? device not found!\n");
405 VPRINTK(KERN_CONT
, "name: %8.8s %16.16s %4.4s\n",
406 ch
->dt
[elem
]->vendor
,
418 /* ------------------------------------------------------------------------ */
421 ch_position(scsi_changer
*ch
, u_int trans
, u_int elem
, int rotate
)
425 DPRINTK("position: 0x%x\n",elem
);
427 trans
= ch
->firsts
[CHET_MT
];
428 memset(cmd
,0,sizeof(cmd
));
429 cmd
[0] = POSITION_TO_ELEMENT
;
430 cmd
[1] = (ch
->device
->lun
& 0x7) << 5;
431 cmd
[2] = (trans
>> 8) & 0xff;
432 cmd
[3] = trans
& 0xff;
433 cmd
[4] = (elem
>> 8) & 0xff;
434 cmd
[5] = elem
& 0xff;
435 cmd
[8] = rotate
? 1 : 0;
436 return ch_do_scsi(ch
, cmd
, 10, NULL
, 0, DMA_NONE
);
440 ch_move(scsi_changer
*ch
, u_int trans
, u_int src
, u_int dest
, int rotate
)
444 DPRINTK("move: 0x%x => 0x%x\n",src
,dest
);
446 trans
= ch
->firsts
[CHET_MT
];
447 memset(cmd
,0,sizeof(cmd
));
448 cmd
[0] = MOVE_MEDIUM
;
449 cmd
[1] = (ch
->device
->lun
& 0x7) << 5;
450 cmd
[2] = (trans
>> 8) & 0xff;
451 cmd
[3] = trans
& 0xff;
452 cmd
[4] = (src
>> 8) & 0xff;
454 cmd
[6] = (dest
>> 8) & 0xff;
455 cmd
[7] = dest
& 0xff;
456 cmd
[10] = rotate
? 1 : 0;
457 return ch_do_scsi(ch
, cmd
, 12, NULL
,0, DMA_NONE
);
461 ch_exchange(scsi_changer
*ch
, u_int trans
, u_int src
,
462 u_int dest1
, u_int dest2
, int rotate1
, int rotate2
)
466 DPRINTK("exchange: 0x%x => 0x%x => 0x%x\n",
469 trans
= ch
->firsts
[CHET_MT
];
470 memset(cmd
,0,sizeof(cmd
));
471 cmd
[0] = EXCHANGE_MEDIUM
;
472 cmd
[1] = (ch
->device
->lun
& 0x7) << 5;
473 cmd
[2] = (trans
>> 8) & 0xff;
474 cmd
[3] = trans
& 0xff;
475 cmd
[4] = (src
>> 8) & 0xff;
477 cmd
[6] = (dest1
>> 8) & 0xff;
478 cmd
[7] = dest1
& 0xff;
479 cmd
[8] = (dest2
>> 8) & 0xff;
480 cmd
[9] = dest2
& 0xff;
481 cmd
[10] = (rotate1
? 1 : 0) | (rotate2
? 2 : 0);
483 return ch_do_scsi(ch
, cmd
, 12, NULL
, 0, DMA_NONE
);
487 ch_check_voltag(char *tag
)
491 for (i
= 0; i
< 32; i
++) {
492 /* restrict to ascii */
493 if (tag
[i
] >= 0x7f || tag
[i
] < 0x20)
495 /* don't allow search wildcards */
503 ch_set_voltag(scsi_changer
*ch
, u_int elem
,
504 int alternate
, int clear
, u_char
*tag
)
510 buffer
= kzalloc(512, GFP_KERNEL
);
514 DPRINTK("%s %s voltag: 0x%x => \"%s\"\n",
515 clear
? "clear" : "set",
516 alternate
? "alternate" : "primary",
518 memset(cmd
,0,sizeof(cmd
));
519 cmd
[0] = SEND_VOLUME_TAG
;
520 cmd
[1] = ((ch
->device
->lun
& 0x7) << 5) |
521 ch_elem_to_typecode(ch
,elem
);
522 cmd
[2] = (elem
>> 8) & 0xff;
523 cmd
[3] = elem
& 0xff;
525 ? (alternate
? 0x0d : 0x0c)
526 : (alternate
? 0x0b : 0x0a);
530 memcpy(buffer
,tag
,32);
531 ch_check_voltag(buffer
);
533 result
= ch_do_scsi(ch
, cmd
, 12, buffer
, 256, DMA_TO_DEVICE
);
538 static int ch_gstatus(scsi_changer
*ch
, int type
, unsigned char __user
*dest
)
544 mutex_lock(&ch
->lock
);
545 for (i
= 0; i
< ch
->counts
[type
]; i
++) {
546 if (0 != ch_read_element_status
547 (ch
, ch
->firsts
[type
]+i
,data
)) {
551 put_user(data
[2], dest
+i
);
552 if (data
[2] & CESTATUS_EXCEPT
)
553 VPRINTK(KERN_INFO
, "element 0x%x: asc=0x%x, ascq=0x%x\n",
555 (int)data
[4],(int)data
[5]);
556 retval
= ch_read_element_status
557 (ch
, ch
->firsts
[type
]+i
,data
);
561 mutex_unlock(&ch
->lock
);
565 /* ------------------------------------------------------------------------ */
567 static void ch_destroy(struct kref
*ref
)
569 scsi_changer
*ch
= container_of(ref
, scsi_changer
, ref
);
576 ch_release(struct inode
*inode
, struct file
*file
)
578 scsi_changer
*ch
= file
->private_data
;
580 scsi_device_put(ch
->device
);
582 file
->private_data
= NULL
;
583 kref_put(&ch
->ref
, ch_destroy
);
588 ch_open(struct inode
*inode
, struct file
*file
)
591 int minor
= iminor(inode
);
593 mutex_lock(&ch_mutex
);
594 spin_lock(&ch_index_lock
);
595 ch
= idr_find(&ch_index_idr
, minor
);
597 if (NULL
== ch
|| scsi_device_get(ch
->device
)) {
598 spin_unlock(&ch_index_lock
);
599 mutex_unlock(&ch_mutex
);
603 spin_unlock(&ch_index_lock
);
605 file
->private_data
= ch
;
606 mutex_unlock(&ch_mutex
);
611 ch_checkrange(scsi_changer
*ch
, unsigned int type
, unsigned int unit
)
613 if (type
>= CH_TYPES
|| unit
>= ch
->counts
[type
])
618 static long ch_ioctl(struct file
*file
,
619 unsigned int cmd
, unsigned long arg
)
621 scsi_changer
*ch
= file
->private_data
;
623 void __user
*argp
= (void __user
*)arg
;
625 retval
= scsi_ioctl_block_when_processing_errors(ch
->device
, cmd
,
626 file
->f_flags
& O_NDELAY
);
633 struct changer_params params
;
635 params
.cp_curpicker
= 0;
636 params
.cp_npickers
= ch
->counts
[CHET_MT
];
637 params
.cp_nslots
= ch
->counts
[CHET_ST
];
638 params
.cp_nportals
= ch
->counts
[CHET_IE
];
639 params
.cp_ndrives
= ch
->counts
[CHET_DT
];
641 if (copy_to_user(argp
, ¶ms
, sizeof(params
)))
647 struct changer_vendor_params vparams
;
649 memset(&vparams
,0,sizeof(vparams
));
650 if (ch
->counts
[CHET_V1
]) {
651 vparams
.cvp_n1
= ch
->counts
[CHET_V1
];
652 strncpy(vparams
.cvp_label1
,vendor_labels
[0],16);
654 if (ch
->counts
[CHET_V2
]) {
655 vparams
.cvp_n2
= ch
->counts
[CHET_V2
];
656 strncpy(vparams
.cvp_label2
,vendor_labels
[1],16);
658 if (ch
->counts
[CHET_V3
]) {
659 vparams
.cvp_n3
= ch
->counts
[CHET_V3
];
660 strncpy(vparams
.cvp_label3
,vendor_labels
[2],16);
662 if (ch
->counts
[CHET_V4
]) {
663 vparams
.cvp_n4
= ch
->counts
[CHET_V4
];
664 strncpy(vparams
.cvp_label4
,vendor_labels
[3],16);
666 if (copy_to_user(argp
, &vparams
, sizeof(vparams
)))
673 struct changer_position pos
;
675 if (copy_from_user(&pos
, argp
, sizeof (pos
)))
678 if (0 != ch_checkrange(ch
, pos
.cp_type
, pos
.cp_unit
)) {
679 DPRINTK("CHIOPOSITION: invalid parameter\n");
682 mutex_lock(&ch
->lock
);
683 retval
= ch_position(ch
,0,
684 ch
->firsts
[pos
.cp_type
] + pos
.cp_unit
,
685 pos
.cp_flags
& CP_INVERT
);
686 mutex_unlock(&ch
->lock
);
692 struct changer_move mv
;
694 if (copy_from_user(&mv
, argp
, sizeof (mv
)))
697 if (0 != ch_checkrange(ch
, mv
.cm_fromtype
, mv
.cm_fromunit
) ||
698 0 != ch_checkrange(ch
, mv
.cm_totype
, mv
.cm_tounit
)) {
699 DPRINTK("CHIOMOVE: invalid parameter\n");
703 mutex_lock(&ch
->lock
);
704 retval
= ch_move(ch
,0,
705 ch
->firsts
[mv
.cm_fromtype
] + mv
.cm_fromunit
,
706 ch
->firsts
[mv
.cm_totype
] + mv
.cm_tounit
,
707 mv
.cm_flags
& CM_INVERT
);
708 mutex_unlock(&ch
->lock
);
714 struct changer_exchange mv
;
716 if (copy_from_user(&mv
, argp
, sizeof (mv
)))
719 if (0 != ch_checkrange(ch
, mv
.ce_srctype
, mv
.ce_srcunit
) ||
720 0 != ch_checkrange(ch
, mv
.ce_fdsttype
, mv
.ce_fdstunit
) ||
721 0 != ch_checkrange(ch
, mv
.ce_sdsttype
, mv
.ce_sdstunit
)) {
722 DPRINTK("CHIOEXCHANGE: invalid parameter\n");
726 mutex_lock(&ch
->lock
);
729 ch
->firsts
[mv
.ce_srctype
] + mv
.ce_srcunit
,
730 ch
->firsts
[mv
.ce_fdsttype
] + mv
.ce_fdstunit
,
731 ch
->firsts
[mv
.ce_sdsttype
] + mv
.ce_sdstunit
,
732 mv
.ce_flags
& CE_INVERT1
, mv
.ce_flags
& CE_INVERT2
);
733 mutex_unlock(&ch
->lock
);
739 struct changer_element_status ces
;
741 if (copy_from_user(&ces
, argp
, sizeof (ces
)))
743 if (ces
.ces_type
< 0 || ces
.ces_type
>= CH_TYPES
)
746 return ch_gstatus(ch
, ces
.ces_type
, ces
.ces_data
);
751 struct changer_get_element cge
;
757 if (copy_from_user(&cge
, argp
, sizeof (cge
)))
760 if (0 != ch_checkrange(ch
, cge
.cge_type
, cge
.cge_unit
))
762 elem
= ch
->firsts
[cge
.cge_type
] + cge
.cge_unit
;
764 buffer
= kmalloc(512, GFP_KERNEL
| GFP_DMA
);
767 mutex_lock(&ch
->lock
);
770 memset(ch_cmd
, 0, sizeof(ch_cmd
));
771 ch_cmd
[0] = READ_ELEMENT_STATUS
;
772 ch_cmd
[1] = ((ch
->device
->lun
& 0x7) << 5) |
773 (ch
->voltags
? 0x10 : 0) |
774 ch_elem_to_typecode(ch
,elem
);
775 ch_cmd
[2] = (elem
>> 8) & 0xff;
776 ch_cmd
[3] = elem
& 0xff;
780 result
= ch_do_scsi(ch
, ch_cmd
, 12,
781 buffer
, 256, DMA_FROM_DEVICE
);
783 cge
.cge_status
= buffer
[18];
785 if (buffer
[18] & CESTATUS_EXCEPT
) {
788 if (buffer
[25] & 0x80) {
789 cge
.cge_flags
|= CGE_SRC
;
790 if (buffer
[25] & 0x40)
791 cge
.cge_flags
|= CGE_INVERT
;
792 elem
= (buffer
[26]<<8) | buffer
[27];
793 for (i
= 0; i
< 4; i
++) {
794 if (elem
>= ch
->firsts
[i
] &&
795 elem
< ch
->firsts
[i
] + ch
->counts
[i
]) {
797 cge
.cge_srcunit
= elem
-ch
->firsts
[i
];
801 if ((buffer
[22] & 0x30) == 0x30) {
802 cge
.cge_flags
|= CGE_IDLUN
;
803 cge
.cge_id
= buffer
[23];
804 cge
.cge_lun
= buffer
[22] & 7;
806 if (buffer
[9] & 0x80) {
807 cge
.cge_flags
|= CGE_PVOLTAG
;
808 memcpy(cge
.cge_pvoltag
,buffer
+28,36);
810 if (buffer
[9] & 0x40) {
811 cge
.cge_flags
|= CGE_AVOLTAG
;
812 memcpy(cge
.cge_avoltag
,buffer
+64,36);
814 } else if (ch
->voltags
) {
816 VPRINTK(KERN_INFO
, "device has no volume tag support\n");
820 mutex_unlock(&ch
->lock
);
822 if (copy_to_user(argp
, &cge
, sizeof (cge
)))
829 mutex_lock(&ch
->lock
);
830 retval
= ch_init_elem(ch
);
831 mutex_unlock(&ch
->lock
);
837 struct changer_set_voltag csv
;
840 if (copy_from_user(&csv
, argp
, sizeof(csv
)))
843 if (0 != ch_checkrange(ch
, csv
.csv_type
, csv
.csv_unit
)) {
844 DPRINTK("CHIOSVOLTAG: invalid parameter\n");
847 elem
= ch
->firsts
[csv
.csv_type
] + csv
.csv_unit
;
848 mutex_lock(&ch
->lock
);
849 retval
= ch_set_voltag(ch
, elem
,
850 csv
.csv_flags
& CSV_AVOLTAG
,
851 csv
.csv_flags
& CSV_CLEARTAG
,
853 mutex_unlock(&ch
->lock
);
858 return scsi_ioctl(ch
->device
, cmd
, argp
);
865 struct changer_element_status32
{
867 compat_uptr_t ces_data
;
869 #define CHIOGSTATUS32 _IOW('c', 8,struct changer_element_status32)
871 static long ch_ioctl_compat(struct file
* file
,
872 unsigned int cmd
, unsigned long arg
)
874 scsi_changer
*ch
= file
->private_data
;
886 return ch_ioctl(file
, cmd
, arg
);
889 struct changer_element_status32 ces32
;
890 unsigned char __user
*data
;
892 if (copy_from_user(&ces32
, (void __user
*)arg
, sizeof (ces32
)))
894 if (ces32
.ces_type
< 0 || ces32
.ces_type
>= CH_TYPES
)
897 data
= compat_ptr(ces32
.ces_data
);
898 return ch_gstatus(ch
, ces32
.ces_type
, data
);
901 // return scsi_ioctl_compat(ch->device, cmd, (void*)arg);
908 /* ------------------------------------------------------------------------ */
910 static int ch_probe(struct device
*dev
)
912 struct scsi_device
*sd
= to_scsi_device(dev
);
913 struct device
*class_dev
;
917 if (sd
->type
!= TYPE_MEDIUM_CHANGER
)
920 ch
= kzalloc(sizeof(*ch
), GFP_KERNEL
);
924 idr_preload(GFP_KERNEL
);
925 spin_lock(&ch_index_lock
);
926 ret
= idr_alloc(&ch_index_idr
, ch
, 0, CH_MAX_DEVS
+ 1, GFP_NOWAIT
);
927 spin_unlock(&ch_index_lock
);
937 sprintf(ch
->name
,"ch%d",ch
->minor
);
939 class_dev
= device_create(ch_sysfs_class
, dev
,
940 MKDEV(SCSI_CHANGER_MAJOR
, ch
->minor
), ch
,
942 if (IS_ERR(class_dev
)) {
943 sdev_printk(KERN_WARNING
, sd
, "ch%d: device_create failed\n",
945 ret
= PTR_ERR(class_dev
);
949 mutex_init(&ch
->lock
);
952 ret
= ch_readconfig(ch
);
958 dev_set_drvdata(dev
, ch
);
959 sdev_printk(KERN_INFO
, sd
, "Attached scsi changer %s\n", ch
->name
);
963 device_destroy(ch_sysfs_class
, MKDEV(SCSI_CHANGER_MAJOR
, ch
->minor
));
965 idr_remove(&ch_index_idr
, ch
->minor
);
971 static int ch_remove(struct device
*dev
)
973 scsi_changer
*ch
= dev_get_drvdata(dev
);
975 spin_lock(&ch_index_lock
);
976 idr_remove(&ch_index_idr
, ch
->minor
);
977 spin_unlock(&ch_index_lock
);
979 device_destroy(ch_sysfs_class
, MKDEV(SCSI_CHANGER_MAJOR
,ch
->minor
));
980 kref_put(&ch
->ref
, ch_destroy
);
984 static struct scsi_driver ch_template
= {
987 .owner
= THIS_MODULE
,
993 static const struct file_operations changer_fops
= {
994 .owner
= THIS_MODULE
,
996 .release
= ch_release
,
997 .unlocked_ioctl
= ch_ioctl
,
999 .compat_ioctl
= ch_ioctl_compat
,
1001 .llseek
= noop_llseek
,
1004 static int __init
init_ch_module(void)
1008 printk(KERN_INFO
"SCSI Media Changer driver v" VERSION
" \n");
1009 ch_sysfs_class
= class_create(THIS_MODULE
, "scsi_changer");
1010 if (IS_ERR(ch_sysfs_class
)) {
1011 rc
= PTR_ERR(ch_sysfs_class
);
1014 rc
= register_chrdev(SCSI_CHANGER_MAJOR
,"ch",&changer_fops
);
1016 printk("Unable to get major %d for SCSI-Changer\n",
1017 SCSI_CHANGER_MAJOR
);
1020 rc
= scsi_register_driver(&ch_template
.gendrv
);
1026 unregister_chrdev(SCSI_CHANGER_MAJOR
, "ch");
1028 class_destroy(ch_sysfs_class
);
1032 static void __exit
exit_ch_module(void)
1034 scsi_unregister_driver(&ch_template
.gendrv
);
1035 unregister_chrdev(SCSI_CHANGER_MAJOR
, "ch");
1036 class_destroy(ch_sysfs_class
);
1037 idr_destroy(&ch_index_idr
);
1040 module_init(init_ch_module
);
1041 module_exit(exit_ch_module
);