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
);
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
,
203 if (scsi_sense_valid(&sshdr
)) {
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
);
578 ch_release(struct inode
*inode
, struct file
*file
)
580 scsi_changer
*ch
= file
->private_data
;
582 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 spin_lock(&ch_index_lock
);
595 ch
= idr_find(&ch_index_idr
, minor
);
597 if (ch
== NULL
|| !kref_get_unless_zero(&ch
->ref
)) {
598 spin_unlock(&ch_index_lock
);
601 spin_unlock(&ch_index_lock
);
602 if (scsi_device_get(ch
->device
)) {
603 kref_put(&ch
->ref
, ch_destroy
);
606 /* Synchronize with ch_probe() */
607 mutex_lock(&ch
->lock
);
608 file
->private_data
= ch
;
609 mutex_unlock(&ch
->lock
);
614 ch_checkrange(scsi_changer
*ch
, unsigned int type
, unsigned int unit
)
616 if (type
>= CH_TYPES
|| unit
>= ch
->counts
[type
])
621 struct changer_element_status32
{
623 compat_uptr_t ces_data
;
625 #define CHIOGSTATUS32 _IOW('c', 8, struct changer_element_status32)
627 static long ch_ioctl(struct file
*file
,
628 unsigned int cmd
, unsigned long arg
)
630 scsi_changer
*ch
= file
->private_data
;
632 void __user
*argp
= (void __user
*)arg
;
634 retval
= scsi_ioctl_block_when_processing_errors(ch
->device
, cmd
,
635 file
->f_flags
& O_NDELAY
);
642 struct changer_params params
;
644 params
.cp_curpicker
= 0;
645 params
.cp_npickers
= ch
->counts
[CHET_MT
];
646 params
.cp_nslots
= ch
->counts
[CHET_ST
];
647 params
.cp_nportals
= ch
->counts
[CHET_IE
];
648 params
.cp_ndrives
= ch
->counts
[CHET_DT
];
650 if (copy_to_user(argp
, ¶ms
, sizeof(params
)))
656 struct changer_vendor_params vparams
;
658 memset(&vparams
,0,sizeof(vparams
));
659 if (ch
->counts
[CHET_V1
]) {
660 vparams
.cvp_n1
= ch
->counts
[CHET_V1
];
661 strncpy(vparams
.cvp_label1
,vendor_labels
[0],16);
663 if (ch
->counts
[CHET_V2
]) {
664 vparams
.cvp_n2
= ch
->counts
[CHET_V2
];
665 strncpy(vparams
.cvp_label2
,vendor_labels
[1],16);
667 if (ch
->counts
[CHET_V3
]) {
668 vparams
.cvp_n3
= ch
->counts
[CHET_V3
];
669 strncpy(vparams
.cvp_label3
,vendor_labels
[2],16);
671 if (ch
->counts
[CHET_V4
]) {
672 vparams
.cvp_n4
= ch
->counts
[CHET_V4
];
673 strncpy(vparams
.cvp_label4
,vendor_labels
[3],16);
675 if (copy_to_user(argp
, &vparams
, sizeof(vparams
)))
682 struct changer_position pos
;
684 if (copy_from_user(&pos
, argp
, sizeof (pos
)))
687 if (0 != ch_checkrange(ch
, pos
.cp_type
, pos
.cp_unit
)) {
688 DPRINTK("CHIOPOSITION: invalid parameter\n");
691 mutex_lock(&ch
->lock
);
692 retval
= ch_position(ch
,0,
693 ch
->firsts
[pos
.cp_type
] + pos
.cp_unit
,
694 pos
.cp_flags
& CP_INVERT
);
695 mutex_unlock(&ch
->lock
);
701 struct changer_move mv
;
703 if (copy_from_user(&mv
, argp
, sizeof (mv
)))
706 if (0 != ch_checkrange(ch
, mv
.cm_fromtype
, mv
.cm_fromunit
) ||
707 0 != ch_checkrange(ch
, mv
.cm_totype
, mv
.cm_tounit
)) {
708 DPRINTK("CHIOMOVE: invalid parameter\n");
712 mutex_lock(&ch
->lock
);
713 retval
= ch_move(ch
,0,
714 ch
->firsts
[mv
.cm_fromtype
] + mv
.cm_fromunit
,
715 ch
->firsts
[mv
.cm_totype
] + mv
.cm_tounit
,
716 mv
.cm_flags
& CM_INVERT
);
717 mutex_unlock(&ch
->lock
);
723 struct changer_exchange mv
;
725 if (copy_from_user(&mv
, argp
, sizeof (mv
)))
728 if (0 != ch_checkrange(ch
, mv
.ce_srctype
, mv
.ce_srcunit
) ||
729 0 != ch_checkrange(ch
, mv
.ce_fdsttype
, mv
.ce_fdstunit
) ||
730 0 != ch_checkrange(ch
, mv
.ce_sdsttype
, mv
.ce_sdstunit
)) {
731 DPRINTK("CHIOEXCHANGE: invalid parameter\n");
735 mutex_lock(&ch
->lock
);
738 ch
->firsts
[mv
.ce_srctype
] + mv
.ce_srcunit
,
739 ch
->firsts
[mv
.ce_fdsttype
] + mv
.ce_fdstunit
,
740 ch
->firsts
[mv
.ce_sdsttype
] + mv
.ce_sdstunit
,
741 mv
.ce_flags
& CE_INVERT1
, mv
.ce_flags
& CE_INVERT2
);
742 mutex_unlock(&ch
->lock
);
748 struct changer_element_status ces
;
750 if (copy_from_user(&ces
, argp
, sizeof (ces
)))
752 if (ces
.ces_type
< 0 || ces
.ces_type
>= CH_TYPES
)
755 return ch_gstatus(ch
, ces
.ces_type
, ces
.ces_data
);
760 struct changer_element_status32 ces32
;
762 if (copy_from_user(&ces32
, argp
, sizeof(ces32
)))
764 if (ces32
.ces_type
< 0 || ces32
.ces_type
>= CH_TYPES
)
767 return ch_gstatus(ch
, ces32
.ces_type
,
768 compat_ptr(ces32
.ces_data
));
773 struct changer_get_element cge
;
779 if (copy_from_user(&cge
, argp
, sizeof (cge
)))
782 if (0 != ch_checkrange(ch
, cge
.cge_type
, cge
.cge_unit
))
784 elem
= ch
->firsts
[cge
.cge_type
] + cge
.cge_unit
;
786 buffer
= kmalloc(512, GFP_KERNEL
| GFP_DMA
);
789 mutex_lock(&ch
->lock
);
792 memset(ch_cmd
, 0, sizeof(ch_cmd
));
793 ch_cmd
[0] = READ_ELEMENT_STATUS
;
794 ch_cmd
[1] = ((ch
->device
->lun
& 0x7) << 5) |
795 (ch
->voltags
? 0x10 : 0) |
796 ch_elem_to_typecode(ch
,elem
);
797 ch_cmd
[2] = (elem
>> 8) & 0xff;
798 ch_cmd
[3] = elem
& 0xff;
802 result
= ch_do_scsi(ch
, ch_cmd
, 12,
803 buffer
, 256, DMA_FROM_DEVICE
);
805 cge
.cge_status
= buffer
[18];
807 if (buffer
[18] & CESTATUS_EXCEPT
) {
810 if (buffer
[25] & 0x80) {
811 cge
.cge_flags
|= CGE_SRC
;
812 if (buffer
[25] & 0x40)
813 cge
.cge_flags
|= CGE_INVERT
;
814 elem
= (buffer
[26]<<8) | buffer
[27];
815 for (i
= 0; i
< 4; i
++) {
816 if (elem
>= ch
->firsts
[i
] &&
817 elem
< ch
->firsts
[i
] + ch
->counts
[i
]) {
819 cge
.cge_srcunit
= elem
-ch
->firsts
[i
];
823 if ((buffer
[22] & 0x30) == 0x30) {
824 cge
.cge_flags
|= CGE_IDLUN
;
825 cge
.cge_id
= buffer
[23];
826 cge
.cge_lun
= buffer
[22] & 7;
828 if (buffer
[9] & 0x80) {
829 cge
.cge_flags
|= CGE_PVOLTAG
;
830 memcpy(cge
.cge_pvoltag
,buffer
+28,36);
832 if (buffer
[9] & 0x40) {
833 cge
.cge_flags
|= CGE_AVOLTAG
;
834 memcpy(cge
.cge_avoltag
,buffer
+64,36);
836 } else if (ch
->voltags
) {
838 VPRINTK(KERN_INFO
, "device has no volume tag support\n");
842 mutex_unlock(&ch
->lock
);
844 if (copy_to_user(argp
, &cge
, sizeof (cge
)))
851 mutex_lock(&ch
->lock
);
852 retval
= ch_init_elem(ch
);
853 mutex_unlock(&ch
->lock
);
859 struct changer_set_voltag csv
;
862 if (copy_from_user(&csv
, argp
, sizeof(csv
)))
865 if (0 != ch_checkrange(ch
, csv
.csv_type
, csv
.csv_unit
)) {
866 DPRINTK("CHIOSVOLTAG: invalid parameter\n");
869 elem
= ch
->firsts
[csv
.csv_type
] + csv
.csv_unit
;
870 mutex_lock(&ch
->lock
);
871 retval
= ch_set_voltag(ch
, elem
,
872 csv
.csv_flags
& CSV_AVOLTAG
,
873 csv
.csv_flags
& CSV_CLEARTAG
,
875 mutex_unlock(&ch
->lock
);
880 return scsi_ioctl(ch
->device
, NULL
, file
->f_mode
, cmd
, argp
);
885 /* ------------------------------------------------------------------------ */
887 static int ch_probe(struct device
*dev
)
889 struct scsi_device
*sd
= to_scsi_device(dev
);
890 struct device
*class_dev
;
894 if (sd
->type
!= TYPE_MEDIUM_CHANGER
)
897 ch
= kzalloc(sizeof(*ch
), GFP_KERNEL
);
901 idr_preload(GFP_KERNEL
);
902 spin_lock(&ch_index_lock
);
903 ret
= idr_alloc(&ch_index_idr
, ch
, 0, CH_MAX_DEVS
+ 1, GFP_NOWAIT
);
904 spin_unlock(&ch_index_lock
);
914 sprintf(ch
->name
,"ch%d",ch
->minor
);
915 ret
= scsi_device_get(sd
);
917 sdev_printk(KERN_WARNING
, sd
, "ch%d: failed to get device\n",
922 mutex_init(&ch
->lock
);
925 class_dev
= device_create(ch_sysfs_class
, dev
,
926 MKDEV(SCSI_CHANGER_MAJOR
, ch
->minor
), ch
,
928 if (IS_ERR(class_dev
)) {
929 sdev_printk(KERN_WARNING
, sd
, "ch%d: device_create failed\n",
931 ret
= PTR_ERR(class_dev
);
935 mutex_lock(&ch
->lock
);
936 ret
= ch_readconfig(ch
);
938 mutex_unlock(&ch
->lock
);
944 mutex_unlock(&ch
->lock
);
945 dev_set_drvdata(dev
, ch
);
946 sdev_printk(KERN_INFO
, sd
, "Attached scsi changer %s\n", ch
->name
);
950 device_destroy(ch_sysfs_class
, MKDEV(SCSI_CHANGER_MAJOR
, ch
->minor
));
954 idr_remove(&ch_index_idr
, ch
->minor
);
960 static int ch_remove(struct device
*dev
)
962 scsi_changer
*ch
= dev_get_drvdata(dev
);
964 spin_lock(&ch_index_lock
);
965 idr_remove(&ch_index_idr
, ch
->minor
);
966 dev_set_drvdata(dev
, NULL
);
967 spin_unlock(&ch_index_lock
);
969 device_destroy(ch_sysfs_class
, MKDEV(SCSI_CHANGER_MAJOR
,ch
->minor
));
970 scsi_device_put(ch
->device
);
971 kref_put(&ch
->ref
, ch_destroy
);
975 static struct scsi_driver ch_template
= {
978 .owner
= THIS_MODULE
,
984 static const struct file_operations changer_fops
= {
985 .owner
= THIS_MODULE
,
987 .release
= ch_release
,
988 .unlocked_ioctl
= ch_ioctl
,
989 .compat_ioctl
= compat_ptr_ioctl
,
990 .llseek
= noop_llseek
,
993 static int __init
init_ch_module(void)
997 printk(KERN_INFO
"SCSI Media Changer driver v" VERSION
" \n");
998 ch_sysfs_class
= class_create(THIS_MODULE
, "scsi_changer");
999 if (IS_ERR(ch_sysfs_class
)) {
1000 rc
= PTR_ERR(ch_sysfs_class
);
1003 rc
= register_chrdev(SCSI_CHANGER_MAJOR
,"ch",&changer_fops
);
1005 printk("Unable to get major %d for SCSI-Changer\n",
1006 SCSI_CHANGER_MAJOR
);
1009 rc
= scsi_register_driver(&ch_template
.gendrv
);
1015 unregister_chrdev(SCSI_CHANGER_MAJOR
, "ch");
1017 class_destroy(ch_sysfs_class
);
1021 static void __exit
exit_ch_module(void)
1023 scsi_unregister_driver(&ch_template
.gendrv
);
1024 unregister_chrdev(SCSI_CHANGER_MAJOR
, "ch");
1025 class_destroy(ch_sysfs_class
);
1026 idr_destroy(&ch_index_idr
);
1029 module_init(init_ch_module
);
1030 module_exit(exit_ch_module
);