1 // SPDX-License-Identifier: GPL-2.0-only
3 * SCSI Media Changer device driver for Linux 2.6
5 * (c) 1996-2003 Gerd Knorr <kraxel@bytesex.org>
11 #include <linux/module.h>
12 #include <linux/init.h>
14 #include <linux/kernel.h>
16 #include <linux/major.h>
17 #include <linux/string.h>
18 #include <linux/errno.h>
19 #include <linux/interrupt.h>
20 #include <linux/blkdev.h>
21 #include <linux/completion.h>
22 #include <linux/compat.h>
23 #include <linux/chio.h> /* here are all the ioctls */
24 #include <linux/mutex.h>
25 #include <linux/idr.h>
26 #include <linux/slab.h>
28 #include <scsi/scsi.h>
29 #include <scsi/scsi_cmnd.h>
30 #include <scsi/scsi_driver.h>
31 #include <scsi/scsi_ioctl.h>
32 #include <scsi/scsi_host.h>
33 #include <scsi/scsi_device.h>
34 #include <scsi/scsi_eh.h>
35 #include <scsi/scsi_dbg.h>
39 #define CH_MAX_DEVS 128
41 MODULE_DESCRIPTION("device driver for scsi media changer devices");
42 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org>");
43 MODULE_LICENSE("GPL");
44 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_CHANGER_MAJOR
);
45 MODULE_ALIAS_SCSI_DEVICE(TYPE_MEDIUM_CHANGER
);
47 static DEFINE_MUTEX(ch_mutex
);
49 module_param(init
, int, 0444);
50 MODULE_PARM_DESC(init
, \
51 "initialize element status on driver load (default: on)");
53 static int timeout_move
= 300;
54 module_param(timeout_move
, int, 0644);
55 MODULE_PARM_DESC(timeout_move
,"timeout for move commands "
56 "(default: 300 seconds)");
58 static int timeout_init
= 3600;
59 module_param(timeout_init
, int, 0644);
60 MODULE_PARM_DESC(timeout_init
,"timeout for INITIALIZE ELEMENT STATUS "
61 "(default: 3600 seconds)");
63 static int verbose
= 1;
64 module_param(verbose
, int, 0644);
65 MODULE_PARM_DESC(verbose
,"be verbose (default: on)");
68 module_param(debug
, int, 0644);
69 MODULE_PARM_DESC(debug
,"enable/disable debug messages, also prints more "
70 "detailed sense codes on scsi errors (default: off)");
72 static int dt_id
[CH_DT_MAX
] = { [ 0 ... (CH_DT_MAX
-1) ] = -1 };
73 static int dt_lun
[CH_DT_MAX
];
74 module_param_array(dt_id
, int, NULL
, 0444);
75 module_param_array(dt_lun
, int, NULL
, 0444);
77 /* tell the driver about vendor-specific slots */
78 static int vendor_firsts
[CH_TYPES
-4];
79 static int vendor_counts
[CH_TYPES
-4];
80 module_param_array(vendor_firsts
, int, NULL
, 0444);
81 module_param_array(vendor_counts
, int, NULL
, 0444);
83 static const char * vendor_labels
[CH_TYPES
-4] = {
84 "v0", "v1", "v2", "v3"
86 // module_param_string_array(vendor_labels, NULL, 0444);
88 #define ch_printk(prefix, ch, fmt, a...) \
89 sdev_prefix_printk(prefix, (ch)->device, (ch)->name, fmt, ##a)
91 #define DPRINTK(fmt, arg...) \
94 ch_printk(KERN_DEBUG, ch, fmt, ##arg); \
96 #define VPRINTK(level, fmt, arg...) \
99 ch_printk(level, ch, fmt, ##arg); \
102 /* ------------------------------------------------------------------- */
104 #define MAX_RETRIES 1
106 static struct class * ch_sysfs_class
;
110 struct list_head list
;
113 struct scsi_device
*device
;
114 struct scsi_device
**dt
; /* ptrs to data transfer elements */
115 u_int firsts
[CH_TYPES
];
116 u_int counts
[CH_TYPES
];
117 u_int unit_attention
;
122 static DEFINE_IDR(ch_index_idr
);
123 static DEFINE_SPINLOCK(ch_index_lock
);
125 static const struct {
131 /* Just filled in what looks right. Hav'nt checked any standard paper for
132 these errno assignments, so they may be wrong... */
134 .sense
= ILLEGAL_REQUEST
,
137 .errno
= EBADSLT
, /* Invalid element address */
139 .sense
= ILLEGAL_REQUEST
,
142 .errno
= EBADE
, /* Import or export element accessed */
144 .sense
= ILLEGAL_REQUEST
,
147 .errno
= EXFULL
, /* Medium destination element full */
149 .sense
= ILLEGAL_REQUEST
,
152 .errno
= EBADE
, /* Medium source element empty */
154 .sense
= ILLEGAL_REQUEST
,
157 .errno
= EBADRQC
, /* Invalid command operation code */
163 /* ------------------------------------------------------------------- */
165 static int ch_find_errno(struct scsi_sense_hdr
*sshdr
)
169 /* Check to see if additional sense information is available */
170 if (scsi_sense_valid(sshdr
) &&
172 for (i
= 0; ch_err
[i
].errno
!= 0; i
++) {
173 if (ch_err
[i
].sense
== sshdr
->sense_key
&&
174 ch_err
[i
].asc
== sshdr
->asc
&&
175 ch_err
[i
].ascq
== sshdr
->ascq
) {
176 errno
= -ch_err
[i
].errno
;
187 ch_do_scsi(scsi_changer
*ch
, unsigned char *cmd
, int cmd_len
,
188 void *buffer
, unsigned buflength
,
189 enum dma_data_direction direction
)
191 int errno
, retries
= 0, timeout
, result
;
192 struct scsi_sense_hdr sshdr
;
194 timeout
= (cmd
[0] == INITIALIZE_ELEMENT_STATUS
)
195 ? timeout_init
: timeout_move
;
199 result
= scsi_execute_req(ch
->device
, cmd
, direction
, buffer
,
200 buflength
, &sshdr
, timeout
* HZ
,
203 if (driver_byte(result
) == DRIVER_SENSE
) {
205 scsi_print_sense_hdr(ch
->device
, ch
->name
, &sshdr
);
206 errno
= ch_find_errno(&sshdr
);
208 switch(sshdr
.sense_key
) {
210 ch
->unit_attention
= 1;
219 /* ------------------------------------------------------------------------ */
222 ch_elem_to_typecode(scsi_changer
*ch
, u_int elem
)
226 for (i
= 0; i
< CH_TYPES
; i
++) {
227 if (elem
>= ch
->firsts
[i
] &&
228 elem
< ch
->firsts
[i
] +
236 ch_read_element_status(scsi_changer
*ch
, u_int elem
, char *data
)
242 buffer
= kmalloc(512, GFP_KERNEL
| GFP_DMA
);
247 memset(cmd
,0,sizeof(cmd
));
248 cmd
[0] = READ_ELEMENT_STATUS
;
249 cmd
[1] = ((ch
->device
->lun
& 0x7) << 5) |
250 (ch
->voltags
? 0x10 : 0) |
251 ch_elem_to_typecode(ch
,elem
);
252 cmd
[2] = (elem
>> 8) & 0xff;
253 cmd
[3] = elem
& 0xff;
256 if (0 == (result
= ch_do_scsi(ch
, cmd
, 12,
257 buffer
, 256, DMA_FROM_DEVICE
))) {
258 if (((buffer
[16] << 8) | buffer
[17]) != elem
) {
259 DPRINTK("asked for element 0x%02x, got 0x%02x\n",
260 elem
,(buffer
[16] << 8) | buffer
[17]);
264 memcpy(data
,buffer
+16,16);
268 VPRINTK(KERN_INFO
, "device has no volume tag support\n");
271 DPRINTK("READ ELEMENT STATUS for element 0x%x failed\n",elem
);
278 ch_init_elem(scsi_changer
*ch
)
283 VPRINTK(KERN_INFO
, "INITIALIZE ELEMENT STATUS, may take some time ...\n");
284 memset(cmd
,0,sizeof(cmd
));
285 cmd
[0] = INITIALIZE_ELEMENT_STATUS
;
286 cmd
[1] = (ch
->device
->lun
& 0x7) << 5;
287 err
= ch_do_scsi(ch
, cmd
, 6, NULL
, 0, DMA_NONE
);
288 VPRINTK(KERN_INFO
, "... finished\n");
293 ch_readconfig(scsi_changer
*ch
)
295 u_char cmd
[10], data
[16];
300 buffer
= kzalloc(512, GFP_KERNEL
| GFP_DMA
);
304 memset(cmd
,0,sizeof(cmd
));
306 cmd
[1] = (ch
->device
->lun
& 0x7) << 5;
309 result
= ch_do_scsi(ch
, cmd
, 10, buffer
, 255, DMA_FROM_DEVICE
);
312 result
= ch_do_scsi(ch
, cmd
, 10, buffer
, 255, DMA_FROM_DEVICE
);
315 ch
->firsts
[CHET_MT
] =
316 (buffer
[buffer
[3]+ 6] << 8) | buffer
[buffer
[3]+ 7];
317 ch
->counts
[CHET_MT
] =
318 (buffer
[buffer
[3]+ 8] << 8) | buffer
[buffer
[3]+ 9];
319 ch
->firsts
[CHET_ST
] =
320 (buffer
[buffer
[3]+10] << 8) | buffer
[buffer
[3]+11];
321 ch
->counts
[CHET_ST
] =
322 (buffer
[buffer
[3]+12] << 8) | buffer
[buffer
[3]+13];
323 ch
->firsts
[CHET_IE
] =
324 (buffer
[buffer
[3]+14] << 8) | buffer
[buffer
[3]+15];
325 ch
->counts
[CHET_IE
] =
326 (buffer
[buffer
[3]+16] << 8) | buffer
[buffer
[3]+17];
327 ch
->firsts
[CHET_DT
] =
328 (buffer
[buffer
[3]+18] << 8) | buffer
[buffer
[3]+19];
329 ch
->counts
[CHET_DT
] =
330 (buffer
[buffer
[3]+20] << 8) | buffer
[buffer
[3]+21];
331 VPRINTK(KERN_INFO
, "type #1 (mt): 0x%x+%d [medium transport]\n",
333 ch
->counts
[CHET_MT
]);
334 VPRINTK(KERN_INFO
, "type #2 (st): 0x%x+%d [storage]\n",
336 ch
->counts
[CHET_ST
]);
337 VPRINTK(KERN_INFO
, "type #3 (ie): 0x%x+%d [import/export]\n",
339 ch
->counts
[CHET_IE
]);
340 VPRINTK(KERN_INFO
, "type #4 (dt): 0x%x+%d [data transfer]\n",
342 ch
->counts
[CHET_DT
]);
344 VPRINTK(KERN_INFO
, "reading element address assignment page failed!\n");
347 /* vendor specific element types */
348 for (i
= 0; i
< 4; i
++) {
349 if (0 == vendor_counts
[i
])
351 if (NULL
== vendor_labels
[i
])
353 ch
->firsts
[CHET_V1
+i
] = vendor_firsts
[i
];
354 ch
->counts
[CHET_V1
+i
] = vendor_counts
[i
];
355 VPRINTK(KERN_INFO
, "type #%d (v%d): 0x%x+%d [%s, vendor specific]\n",
356 i
+5,i
+1,vendor_firsts
[i
],vendor_counts
[i
],
360 /* look up the devices of the data transfer elements */
361 ch
->dt
= kcalloc(ch
->counts
[CHET_DT
], sizeof(*ch
->dt
),
369 for (elem
= 0; elem
< ch
->counts
[CHET_DT
]; elem
++) {
372 if (elem
< CH_DT_MAX
&& -1 != dt_id
[elem
]) {
375 VPRINTK(KERN_INFO
, "dt 0x%x: [insmod option] ",
376 elem
+ch
->firsts
[CHET_DT
]);
377 } else if (0 != ch_read_element_status
378 (ch
,elem
+ch
->firsts
[CHET_DT
],data
)) {
379 VPRINTK(KERN_INFO
, "dt 0x%x: READ ELEMENT STATUS failed\n",
380 elem
+ch
->firsts
[CHET_DT
]);
382 VPRINTK(KERN_INFO
, "dt 0x%x: ",elem
+ch
->firsts
[CHET_DT
]);
383 if (data
[6] & 0x80) {
384 VPRINTK(KERN_CONT
, "not this SCSI bus\n");
386 } else if (0 == (data
[6] & 0x30)) {
387 VPRINTK(KERN_CONT
, "ID/LUN unknown\n");
392 if (data
[6] & 0x20) id
= data
[7];
393 if (data
[6] & 0x10) lun
= data
[6] & 7;
397 VPRINTK(KERN_CONT
, "ID %i, LUN %i, ",id
,lun
);
399 scsi_device_lookup(ch
->device
->host
,
403 /* should not happen */
404 VPRINTK(KERN_CONT
, "Huh? device not found!\n");
406 VPRINTK(KERN_CONT
, "name: %8.8s %16.16s %4.4s\n",
407 ch
->dt
[elem
]->vendor
,
419 /* ------------------------------------------------------------------------ */
422 ch_position(scsi_changer
*ch
, u_int trans
, u_int elem
, int rotate
)
426 DPRINTK("position: 0x%x\n",elem
);
428 trans
= ch
->firsts
[CHET_MT
];
429 memset(cmd
,0,sizeof(cmd
));
430 cmd
[0] = POSITION_TO_ELEMENT
;
431 cmd
[1] = (ch
->device
->lun
& 0x7) << 5;
432 cmd
[2] = (trans
>> 8) & 0xff;
433 cmd
[3] = trans
& 0xff;
434 cmd
[4] = (elem
>> 8) & 0xff;
435 cmd
[5] = elem
& 0xff;
436 cmd
[8] = rotate
? 1 : 0;
437 return ch_do_scsi(ch
, cmd
, 10, NULL
, 0, DMA_NONE
);
441 ch_move(scsi_changer
*ch
, u_int trans
, u_int src
, u_int dest
, int rotate
)
445 DPRINTK("move: 0x%x => 0x%x\n",src
,dest
);
447 trans
= ch
->firsts
[CHET_MT
];
448 memset(cmd
,0,sizeof(cmd
));
449 cmd
[0] = MOVE_MEDIUM
;
450 cmd
[1] = (ch
->device
->lun
& 0x7) << 5;
451 cmd
[2] = (trans
>> 8) & 0xff;
452 cmd
[3] = trans
& 0xff;
453 cmd
[4] = (src
>> 8) & 0xff;
455 cmd
[6] = (dest
>> 8) & 0xff;
456 cmd
[7] = dest
& 0xff;
457 cmd
[10] = rotate
? 1 : 0;
458 return ch_do_scsi(ch
, cmd
, 12, NULL
,0, DMA_NONE
);
462 ch_exchange(scsi_changer
*ch
, u_int trans
, u_int src
,
463 u_int dest1
, u_int dest2
, int rotate1
, int rotate2
)
467 DPRINTK("exchange: 0x%x => 0x%x => 0x%x\n",
470 trans
= ch
->firsts
[CHET_MT
];
471 memset(cmd
,0,sizeof(cmd
));
472 cmd
[0] = EXCHANGE_MEDIUM
;
473 cmd
[1] = (ch
->device
->lun
& 0x7) << 5;
474 cmd
[2] = (trans
>> 8) & 0xff;
475 cmd
[3] = trans
& 0xff;
476 cmd
[4] = (src
>> 8) & 0xff;
478 cmd
[6] = (dest1
>> 8) & 0xff;
479 cmd
[7] = dest1
& 0xff;
480 cmd
[8] = (dest2
>> 8) & 0xff;
481 cmd
[9] = dest2
& 0xff;
482 cmd
[10] = (rotate1
? 1 : 0) | (rotate2
? 2 : 0);
484 return ch_do_scsi(ch
, cmd
, 12, NULL
, 0, DMA_NONE
);
488 ch_check_voltag(char *tag
)
492 for (i
= 0; i
< 32; i
++) {
493 /* restrict to ascii */
494 if (tag
[i
] >= 0x7f || tag
[i
] < 0x20)
496 /* don't allow search wildcards */
504 ch_set_voltag(scsi_changer
*ch
, u_int elem
,
505 int alternate
, int clear
, u_char
*tag
)
511 buffer
= kzalloc(512, GFP_KERNEL
);
515 DPRINTK("%s %s voltag: 0x%x => \"%s\"\n",
516 clear
? "clear" : "set",
517 alternate
? "alternate" : "primary",
519 memset(cmd
,0,sizeof(cmd
));
520 cmd
[0] = SEND_VOLUME_TAG
;
521 cmd
[1] = ((ch
->device
->lun
& 0x7) << 5) |
522 ch_elem_to_typecode(ch
,elem
);
523 cmd
[2] = (elem
>> 8) & 0xff;
524 cmd
[3] = elem
& 0xff;
526 ? (alternate
? 0x0d : 0x0c)
527 : (alternate
? 0x0b : 0x0a);
531 memcpy(buffer
,tag
,32);
532 ch_check_voltag(buffer
);
534 result
= ch_do_scsi(ch
, cmd
, 12, buffer
, 256, DMA_TO_DEVICE
);
539 static int ch_gstatus(scsi_changer
*ch
, int type
, unsigned char __user
*dest
)
545 mutex_lock(&ch
->lock
);
546 for (i
= 0; i
< ch
->counts
[type
]; i
++) {
547 if (0 != ch_read_element_status
548 (ch
, ch
->firsts
[type
]+i
,data
)) {
552 put_user(data
[2], dest
+i
);
553 if (data
[2] & CESTATUS_EXCEPT
)
554 VPRINTK(KERN_INFO
, "element 0x%x: asc=0x%x, ascq=0x%x\n",
556 (int)data
[4],(int)data
[5]);
557 retval
= ch_read_element_status
558 (ch
, ch
->firsts
[type
]+i
,data
);
562 mutex_unlock(&ch
->lock
);
566 /* ------------------------------------------------------------------------ */
568 static void ch_destroy(struct kref
*ref
)
570 scsi_changer
*ch
= container_of(ref
, scsi_changer
, ref
);
577 ch_release(struct inode
*inode
, struct file
*file
)
579 scsi_changer
*ch
= file
->private_data
;
581 scsi_device_put(ch
->device
);
583 file
->private_data
= NULL
;
584 kref_put(&ch
->ref
, ch_destroy
);
589 ch_open(struct inode
*inode
, struct file
*file
)
592 int minor
= iminor(inode
);
594 mutex_lock(&ch_mutex
);
595 spin_lock(&ch_index_lock
);
596 ch
= idr_find(&ch_index_idr
, minor
);
598 if (NULL
== ch
|| scsi_device_get(ch
->device
)) {
599 spin_unlock(&ch_index_lock
);
600 mutex_unlock(&ch_mutex
);
604 spin_unlock(&ch_index_lock
);
606 file
->private_data
= ch
;
607 mutex_unlock(&ch_mutex
);
612 ch_checkrange(scsi_changer
*ch
, unsigned int type
, unsigned int unit
)
614 if (type
>= CH_TYPES
|| unit
>= ch
->counts
[type
])
619 static long ch_ioctl(struct file
*file
,
620 unsigned int cmd
, unsigned long arg
)
622 scsi_changer
*ch
= file
->private_data
;
624 void __user
*argp
= (void __user
*)arg
;
626 retval
= scsi_ioctl_block_when_processing_errors(ch
->device
, cmd
,
627 file
->f_flags
& O_NDELAY
);
634 struct changer_params params
;
636 params
.cp_curpicker
= 0;
637 params
.cp_npickers
= ch
->counts
[CHET_MT
];
638 params
.cp_nslots
= ch
->counts
[CHET_ST
];
639 params
.cp_nportals
= ch
->counts
[CHET_IE
];
640 params
.cp_ndrives
= ch
->counts
[CHET_DT
];
642 if (copy_to_user(argp
, ¶ms
, sizeof(params
)))
648 struct changer_vendor_params vparams
;
650 memset(&vparams
,0,sizeof(vparams
));
651 if (ch
->counts
[CHET_V1
]) {
652 vparams
.cvp_n1
= ch
->counts
[CHET_V1
];
653 strncpy(vparams
.cvp_label1
,vendor_labels
[0],16);
655 if (ch
->counts
[CHET_V2
]) {
656 vparams
.cvp_n2
= ch
->counts
[CHET_V2
];
657 strncpy(vparams
.cvp_label2
,vendor_labels
[1],16);
659 if (ch
->counts
[CHET_V3
]) {
660 vparams
.cvp_n3
= ch
->counts
[CHET_V3
];
661 strncpy(vparams
.cvp_label3
,vendor_labels
[2],16);
663 if (ch
->counts
[CHET_V4
]) {
664 vparams
.cvp_n4
= ch
->counts
[CHET_V4
];
665 strncpy(vparams
.cvp_label4
,vendor_labels
[3],16);
667 if (copy_to_user(argp
, &vparams
, sizeof(vparams
)))
674 struct changer_position pos
;
676 if (copy_from_user(&pos
, argp
, sizeof (pos
)))
679 if (0 != ch_checkrange(ch
, pos
.cp_type
, pos
.cp_unit
)) {
680 DPRINTK("CHIOPOSITION: invalid parameter\n");
683 mutex_lock(&ch
->lock
);
684 retval
= ch_position(ch
,0,
685 ch
->firsts
[pos
.cp_type
] + pos
.cp_unit
,
686 pos
.cp_flags
& CP_INVERT
);
687 mutex_unlock(&ch
->lock
);
693 struct changer_move mv
;
695 if (copy_from_user(&mv
, argp
, sizeof (mv
)))
698 if (0 != ch_checkrange(ch
, mv
.cm_fromtype
, mv
.cm_fromunit
) ||
699 0 != ch_checkrange(ch
, mv
.cm_totype
, mv
.cm_tounit
)) {
700 DPRINTK("CHIOMOVE: invalid parameter\n");
704 mutex_lock(&ch
->lock
);
705 retval
= ch_move(ch
,0,
706 ch
->firsts
[mv
.cm_fromtype
] + mv
.cm_fromunit
,
707 ch
->firsts
[mv
.cm_totype
] + mv
.cm_tounit
,
708 mv
.cm_flags
& CM_INVERT
);
709 mutex_unlock(&ch
->lock
);
715 struct changer_exchange mv
;
717 if (copy_from_user(&mv
, argp
, sizeof (mv
)))
720 if (0 != ch_checkrange(ch
, mv
.ce_srctype
, mv
.ce_srcunit
) ||
721 0 != ch_checkrange(ch
, mv
.ce_fdsttype
, mv
.ce_fdstunit
) ||
722 0 != ch_checkrange(ch
, mv
.ce_sdsttype
, mv
.ce_sdstunit
)) {
723 DPRINTK("CHIOEXCHANGE: invalid parameter\n");
727 mutex_lock(&ch
->lock
);
730 ch
->firsts
[mv
.ce_srctype
] + mv
.ce_srcunit
,
731 ch
->firsts
[mv
.ce_fdsttype
] + mv
.ce_fdstunit
,
732 ch
->firsts
[mv
.ce_sdsttype
] + mv
.ce_sdstunit
,
733 mv
.ce_flags
& CE_INVERT1
, mv
.ce_flags
& CE_INVERT2
);
734 mutex_unlock(&ch
->lock
);
740 struct changer_element_status ces
;
742 if (copy_from_user(&ces
, argp
, sizeof (ces
)))
744 if (ces
.ces_type
< 0 || ces
.ces_type
>= CH_TYPES
)
747 return ch_gstatus(ch
, ces
.ces_type
, ces
.ces_data
);
752 struct changer_get_element cge
;
758 if (copy_from_user(&cge
, argp
, sizeof (cge
)))
761 if (0 != ch_checkrange(ch
, cge
.cge_type
, cge
.cge_unit
))
763 elem
= ch
->firsts
[cge
.cge_type
] + cge
.cge_unit
;
765 buffer
= kmalloc(512, GFP_KERNEL
| GFP_DMA
);
768 mutex_lock(&ch
->lock
);
771 memset(ch_cmd
, 0, sizeof(ch_cmd
));
772 ch_cmd
[0] = READ_ELEMENT_STATUS
;
773 ch_cmd
[1] = ((ch
->device
->lun
& 0x7) << 5) |
774 (ch
->voltags
? 0x10 : 0) |
775 ch_elem_to_typecode(ch
,elem
);
776 ch_cmd
[2] = (elem
>> 8) & 0xff;
777 ch_cmd
[3] = elem
& 0xff;
781 result
= ch_do_scsi(ch
, ch_cmd
, 12,
782 buffer
, 256, DMA_FROM_DEVICE
);
784 cge
.cge_status
= buffer
[18];
786 if (buffer
[18] & CESTATUS_EXCEPT
) {
789 if (buffer
[25] & 0x80) {
790 cge
.cge_flags
|= CGE_SRC
;
791 if (buffer
[25] & 0x40)
792 cge
.cge_flags
|= CGE_INVERT
;
793 elem
= (buffer
[26]<<8) | buffer
[27];
794 for (i
= 0; i
< 4; i
++) {
795 if (elem
>= ch
->firsts
[i
] &&
796 elem
< ch
->firsts
[i
] + ch
->counts
[i
]) {
798 cge
.cge_srcunit
= elem
-ch
->firsts
[i
];
802 if ((buffer
[22] & 0x30) == 0x30) {
803 cge
.cge_flags
|= CGE_IDLUN
;
804 cge
.cge_id
= buffer
[23];
805 cge
.cge_lun
= buffer
[22] & 7;
807 if (buffer
[9] & 0x80) {
808 cge
.cge_flags
|= CGE_PVOLTAG
;
809 memcpy(cge
.cge_pvoltag
,buffer
+28,36);
811 if (buffer
[9] & 0x40) {
812 cge
.cge_flags
|= CGE_AVOLTAG
;
813 memcpy(cge
.cge_avoltag
,buffer
+64,36);
815 } else if (ch
->voltags
) {
817 VPRINTK(KERN_INFO
, "device has no volume tag support\n");
821 mutex_unlock(&ch
->lock
);
823 if (copy_to_user(argp
, &cge
, sizeof (cge
)))
830 mutex_lock(&ch
->lock
);
831 retval
= ch_init_elem(ch
);
832 mutex_unlock(&ch
->lock
);
838 struct changer_set_voltag csv
;
841 if (copy_from_user(&csv
, argp
, sizeof(csv
)))
844 if (0 != ch_checkrange(ch
, csv
.csv_type
, csv
.csv_unit
)) {
845 DPRINTK("CHIOSVOLTAG: invalid parameter\n");
848 elem
= ch
->firsts
[csv
.csv_type
] + csv
.csv_unit
;
849 mutex_lock(&ch
->lock
);
850 retval
= ch_set_voltag(ch
, elem
,
851 csv
.csv_flags
& CSV_AVOLTAG
,
852 csv
.csv_flags
& CSV_CLEARTAG
,
854 mutex_unlock(&ch
->lock
);
859 return scsi_ioctl(ch
->device
, cmd
, argp
);
866 struct changer_element_status32
{
868 compat_uptr_t ces_data
;
870 #define CHIOGSTATUS32 _IOW('c', 8,struct changer_element_status32)
872 static long ch_ioctl_compat(struct file
* file
,
873 unsigned int cmd
, unsigned long arg
)
875 scsi_changer
*ch
= file
->private_data
;
887 return ch_ioctl(file
, cmd
, arg
);
890 struct changer_element_status32 ces32
;
891 unsigned char __user
*data
;
893 if (copy_from_user(&ces32
, (void __user
*)arg
, sizeof (ces32
)))
895 if (ces32
.ces_type
< 0 || ces32
.ces_type
>= CH_TYPES
)
898 data
= compat_ptr(ces32
.ces_data
);
899 return ch_gstatus(ch
, ces32
.ces_type
, data
);
902 // return scsi_ioctl_compat(ch->device, cmd, (void*)arg);
909 /* ------------------------------------------------------------------------ */
911 static int ch_probe(struct device
*dev
)
913 struct scsi_device
*sd
= to_scsi_device(dev
);
914 struct device
*class_dev
;
918 if (sd
->type
!= TYPE_MEDIUM_CHANGER
)
921 ch
= kzalloc(sizeof(*ch
), GFP_KERNEL
);
925 idr_preload(GFP_KERNEL
);
926 spin_lock(&ch_index_lock
);
927 ret
= idr_alloc(&ch_index_idr
, ch
, 0, CH_MAX_DEVS
+ 1, GFP_NOWAIT
);
928 spin_unlock(&ch_index_lock
);
938 sprintf(ch
->name
,"ch%d",ch
->minor
);
940 class_dev
= device_create(ch_sysfs_class
, dev
,
941 MKDEV(SCSI_CHANGER_MAJOR
, ch
->minor
), ch
,
943 if (IS_ERR(class_dev
)) {
944 sdev_printk(KERN_WARNING
, sd
, "ch%d: device_create failed\n",
946 ret
= PTR_ERR(class_dev
);
950 mutex_init(&ch
->lock
);
953 ret
= ch_readconfig(ch
);
959 dev_set_drvdata(dev
, ch
);
960 sdev_printk(KERN_INFO
, sd
, "Attached scsi changer %s\n", ch
->name
);
964 device_destroy(ch_sysfs_class
, MKDEV(SCSI_CHANGER_MAJOR
, ch
->minor
));
966 idr_remove(&ch_index_idr
, ch
->minor
);
972 static int ch_remove(struct device
*dev
)
974 scsi_changer
*ch
= dev_get_drvdata(dev
);
976 spin_lock(&ch_index_lock
);
977 idr_remove(&ch_index_idr
, ch
->minor
);
978 spin_unlock(&ch_index_lock
);
980 device_destroy(ch_sysfs_class
, MKDEV(SCSI_CHANGER_MAJOR
,ch
->minor
));
981 kref_put(&ch
->ref
, ch_destroy
);
985 static struct scsi_driver ch_template
= {
988 .owner
= THIS_MODULE
,
994 static const struct file_operations changer_fops
= {
995 .owner
= THIS_MODULE
,
997 .release
= ch_release
,
998 .unlocked_ioctl
= ch_ioctl
,
1000 .compat_ioctl
= ch_ioctl_compat
,
1002 .llseek
= noop_llseek
,
1005 static int __init
init_ch_module(void)
1009 printk(KERN_INFO
"SCSI Media Changer driver v" VERSION
" \n");
1010 ch_sysfs_class
= class_create(THIS_MODULE
, "scsi_changer");
1011 if (IS_ERR(ch_sysfs_class
)) {
1012 rc
= PTR_ERR(ch_sysfs_class
);
1015 rc
= register_chrdev(SCSI_CHANGER_MAJOR
,"ch",&changer_fops
);
1017 printk("Unable to get major %d for SCSI-Changer\n",
1018 SCSI_CHANGER_MAJOR
);
1021 rc
= scsi_register_driver(&ch_template
.gendrv
);
1027 unregister_chrdev(SCSI_CHANGER_MAJOR
, "ch");
1029 class_destroy(ch_sysfs_class
);
1033 static void __exit
exit_ch_module(void)
1035 scsi_unregister_driver(&ch_template
.gendrv
);
1036 unregister_chrdev(SCSI_CHANGER_MAJOR
, "ch");
1037 class_destroy(ch_sysfs_class
);
1038 idr_destroy(&ch_index_idr
);
1041 module_init(init_ch_module
);
1042 module_exit(exit_ch_module
);