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_printk(prefix, (ch)->device, "[%s] " fmt, \
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
;
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
,
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
;
199 DPRINTK("command: ");
200 __scsi_print_command(cmd
);
203 result
= scsi_execute_req(ch
->device
, cmd
, direction
, buffer
,
204 buflength
, &sshdr
, timeout
* HZ
,
207 DPRINTK("result: 0x%x\n",result
);
208 if (driver_byte(result
) & DRIVER_SENSE
) {
210 scsi_print_sense_hdr(ch
->name
, &sshdr
);
211 errno
= ch_find_errno(&sshdr
);
213 switch(sshdr
.sense_key
) {
215 ch
->unit_attention
= 1;
224 /* ------------------------------------------------------------------------ */
227 ch_elem_to_typecode(scsi_changer
*ch
, u_int elem
)
231 for (i
= 0; i
< CH_TYPES
; i
++) {
232 if (elem
>= ch
->firsts
[i
] &&
233 elem
< ch
->firsts
[i
] +
241 ch_read_element_status(scsi_changer
*ch
, u_int elem
, char *data
)
247 buffer
= kmalloc(512, GFP_KERNEL
| GFP_DMA
);
252 memset(cmd
,0,sizeof(cmd
));
253 cmd
[0] = READ_ELEMENT_STATUS
;
254 cmd
[1] = ((ch
->device
->lun
& 0x7) << 5) |
255 (ch
->voltags
? 0x10 : 0) |
256 ch_elem_to_typecode(ch
,elem
);
257 cmd
[2] = (elem
>> 8) & 0xff;
258 cmd
[3] = elem
& 0xff;
261 if (0 == (result
= ch_do_scsi(ch
, cmd
, buffer
, 256, DMA_FROM_DEVICE
))) {
262 if (((buffer
[16] << 8) | buffer
[17]) != elem
) {
263 DPRINTK("asked for element 0x%02x, got 0x%02x\n",
264 elem
,(buffer
[16] << 8) | buffer
[17]);
268 memcpy(data
,buffer
+16,16);
272 VPRINTK(KERN_INFO
, "device has no volume tag support\n");
275 DPRINTK("READ ELEMENT STATUS for element 0x%x failed\n",elem
);
282 ch_init_elem(scsi_changer
*ch
)
287 VPRINTK(KERN_INFO
, "INITIALIZE ELEMENT STATUS, may take some time ...\n");
288 memset(cmd
,0,sizeof(cmd
));
289 cmd
[0] = INITIALIZE_ELEMENT_STATUS
;
290 cmd
[1] = (ch
->device
->lun
& 0x7) << 5;
291 err
= ch_do_scsi(ch
, cmd
, NULL
, 0, DMA_NONE
);
292 VPRINTK(KERN_INFO
, "... finished\n");
297 ch_readconfig(scsi_changer
*ch
)
299 u_char cmd
[10], data
[16];
304 buffer
= kzalloc(512, GFP_KERNEL
| GFP_DMA
);
308 memset(cmd
,0,sizeof(cmd
));
310 cmd
[1] = (ch
->device
->lun
& 0x7) << 5;
313 result
= ch_do_scsi(ch
, cmd
, buffer
, 255, DMA_FROM_DEVICE
);
316 result
= ch_do_scsi(ch
, cmd
, buffer
, 255, DMA_FROM_DEVICE
);
319 ch
->firsts
[CHET_MT
] =
320 (buffer
[buffer
[3]+ 6] << 8) | buffer
[buffer
[3]+ 7];
321 ch
->counts
[CHET_MT
] =
322 (buffer
[buffer
[3]+ 8] << 8) | buffer
[buffer
[3]+ 9];
323 ch
->firsts
[CHET_ST
] =
324 (buffer
[buffer
[3]+10] << 8) | buffer
[buffer
[3]+11];
325 ch
->counts
[CHET_ST
] =
326 (buffer
[buffer
[3]+12] << 8) | buffer
[buffer
[3]+13];
327 ch
->firsts
[CHET_IE
] =
328 (buffer
[buffer
[3]+14] << 8) | buffer
[buffer
[3]+15];
329 ch
->counts
[CHET_IE
] =
330 (buffer
[buffer
[3]+16] << 8) | buffer
[buffer
[3]+17];
331 ch
->firsts
[CHET_DT
] =
332 (buffer
[buffer
[3]+18] << 8) | buffer
[buffer
[3]+19];
333 ch
->counts
[CHET_DT
] =
334 (buffer
[buffer
[3]+20] << 8) | buffer
[buffer
[3]+21];
335 VPRINTK(KERN_INFO
, "type #1 (mt): 0x%x+%d [medium transport]\n",
337 ch
->counts
[CHET_MT
]);
338 VPRINTK(KERN_INFO
, "type #2 (st): 0x%x+%d [storage]\n",
340 ch
->counts
[CHET_ST
]);
341 VPRINTK(KERN_INFO
, "type #3 (ie): 0x%x+%d [import/export]\n",
343 ch
->counts
[CHET_IE
]);
344 VPRINTK(KERN_INFO
, "type #4 (dt): 0x%x+%d [data transfer]\n",
346 ch
->counts
[CHET_DT
]);
348 VPRINTK(KERN_INFO
, "reading element address assigment page failed!\n");
351 /* vendor specific element types */
352 for (i
= 0; i
< 4; i
++) {
353 if (0 == vendor_counts
[i
])
355 if (NULL
== vendor_labels
[i
])
357 ch
->firsts
[CHET_V1
+i
] = vendor_firsts
[i
];
358 ch
->counts
[CHET_V1
+i
] = vendor_counts
[i
];
359 VPRINTK(KERN_INFO
, "type #%d (v%d): 0x%x+%d [%s, vendor specific]\n",
360 i
+5,i
+1,vendor_firsts
[i
],vendor_counts
[i
],
364 /* look up the devices of the data transfer elements */
365 ch
->dt
= kcalloc(ch
->counts
[CHET_DT
], sizeof(*ch
->dt
),
373 for (elem
= 0; elem
< ch
->counts
[CHET_DT
]; elem
++) {
376 if (elem
< CH_DT_MAX
&& -1 != dt_id
[elem
]) {
379 VPRINTK(KERN_INFO
, "dt 0x%x: [insmod option] ",
380 elem
+ch
->firsts
[CHET_DT
]);
381 } else if (0 != ch_read_element_status
382 (ch
,elem
+ch
->firsts
[CHET_DT
],data
)) {
383 VPRINTK(KERN_INFO
, "dt 0x%x: READ ELEMENT STATUS failed\n",
384 elem
+ch
->firsts
[CHET_DT
]);
386 VPRINTK(KERN_INFO
, "dt 0x%x: ",elem
+ch
->firsts
[CHET_DT
]);
387 if (data
[6] & 0x80) {
388 VPRINTK(KERN_CONT
, "not this SCSI bus\n");
390 } else if (0 == (data
[6] & 0x30)) {
391 VPRINTK(KERN_CONT
, "ID/LUN unknown\n");
396 if (data
[6] & 0x20) id
= data
[7];
397 if (data
[6] & 0x10) lun
= data
[6] & 7;
401 VPRINTK(KERN_CONT
, "ID %i, LUN %i, ",id
,lun
);
403 scsi_device_lookup(ch
->device
->host
,
407 /* should not happen */
408 VPRINTK(KERN_CONT
, "Huh? device not found!\n");
410 VPRINTK(KERN_CONT
, "name: %8.8s %16.16s %4.4s\n",
411 ch
->dt
[elem
]->vendor
,
423 /* ------------------------------------------------------------------------ */
426 ch_position(scsi_changer
*ch
, u_int trans
, u_int elem
, int rotate
)
430 DPRINTK("position: 0x%x\n",elem
);
432 trans
= ch
->firsts
[CHET_MT
];
433 memset(cmd
,0,sizeof(cmd
));
434 cmd
[0] = POSITION_TO_ELEMENT
;
435 cmd
[1] = (ch
->device
->lun
& 0x7) << 5;
436 cmd
[2] = (trans
>> 8) & 0xff;
437 cmd
[3] = trans
& 0xff;
438 cmd
[4] = (elem
>> 8) & 0xff;
439 cmd
[5] = elem
& 0xff;
440 cmd
[8] = rotate
? 1 : 0;
441 return ch_do_scsi(ch
, cmd
, NULL
, 0, DMA_NONE
);
445 ch_move(scsi_changer
*ch
, u_int trans
, u_int src
, u_int dest
, int rotate
)
449 DPRINTK("move: 0x%x => 0x%x\n",src
,dest
);
451 trans
= ch
->firsts
[CHET_MT
];
452 memset(cmd
,0,sizeof(cmd
));
453 cmd
[0] = MOVE_MEDIUM
;
454 cmd
[1] = (ch
->device
->lun
& 0x7) << 5;
455 cmd
[2] = (trans
>> 8) & 0xff;
456 cmd
[3] = trans
& 0xff;
457 cmd
[4] = (src
>> 8) & 0xff;
459 cmd
[6] = (dest
>> 8) & 0xff;
460 cmd
[7] = dest
& 0xff;
461 cmd
[10] = rotate
? 1 : 0;
462 return ch_do_scsi(ch
, cmd
, NULL
,0, DMA_NONE
);
466 ch_exchange(scsi_changer
*ch
, u_int trans
, u_int src
,
467 u_int dest1
, u_int dest2
, int rotate1
, int rotate2
)
471 DPRINTK("exchange: 0x%x => 0x%x => 0x%x\n",
474 trans
= ch
->firsts
[CHET_MT
];
475 memset(cmd
,0,sizeof(cmd
));
476 cmd
[0] = EXCHANGE_MEDIUM
;
477 cmd
[1] = (ch
->device
->lun
& 0x7) << 5;
478 cmd
[2] = (trans
>> 8) & 0xff;
479 cmd
[3] = trans
& 0xff;
480 cmd
[4] = (src
>> 8) & 0xff;
482 cmd
[6] = (dest1
>> 8) & 0xff;
483 cmd
[7] = dest1
& 0xff;
484 cmd
[8] = (dest2
>> 8) & 0xff;
485 cmd
[9] = dest2
& 0xff;
486 cmd
[10] = (rotate1
? 1 : 0) | (rotate2
? 2 : 0);
488 return ch_do_scsi(ch
, cmd
, NULL
,0, DMA_NONE
);
492 ch_check_voltag(char *tag
)
496 for (i
= 0; i
< 32; i
++) {
497 /* restrict to ascii */
498 if (tag
[i
] >= 0x7f || tag
[i
] < 0x20)
500 /* don't allow search wildcards */
508 ch_set_voltag(scsi_changer
*ch
, u_int elem
,
509 int alternate
, int clear
, u_char
*tag
)
515 buffer
= kzalloc(512, GFP_KERNEL
);
519 DPRINTK("%s %s voltag: 0x%x => \"%s\"\n",
520 clear
? "clear" : "set",
521 alternate
? "alternate" : "primary",
523 memset(cmd
,0,sizeof(cmd
));
524 cmd
[0] = SEND_VOLUME_TAG
;
525 cmd
[1] = ((ch
->device
->lun
& 0x7) << 5) |
526 ch_elem_to_typecode(ch
,elem
);
527 cmd
[2] = (elem
>> 8) & 0xff;
528 cmd
[3] = elem
& 0xff;
530 ? (alternate
? 0x0d : 0x0c)
531 : (alternate
? 0x0b : 0x0a);
535 memcpy(buffer
,tag
,32);
536 ch_check_voltag(buffer
);
538 result
= ch_do_scsi(ch
, cmd
, buffer
, 256, DMA_TO_DEVICE
);
543 static int ch_gstatus(scsi_changer
*ch
, int type
, unsigned char __user
*dest
)
549 mutex_lock(&ch
->lock
);
550 for (i
= 0; i
< ch
->counts
[type
]; i
++) {
551 if (0 != ch_read_element_status
552 (ch
, ch
->firsts
[type
]+i
,data
)) {
556 put_user(data
[2], dest
+i
);
557 if (data
[2] & CESTATUS_EXCEPT
)
558 VPRINTK(KERN_INFO
, "element 0x%x: asc=0x%x, ascq=0x%x\n",
560 (int)data
[4],(int)data
[5]);
561 retval
= ch_read_element_status
562 (ch
, ch
->firsts
[type
]+i
,data
);
566 mutex_unlock(&ch
->lock
);
570 /* ------------------------------------------------------------------------ */
573 ch_release(struct inode
*inode
, struct file
*file
)
575 scsi_changer
*ch
= file
->private_data
;
577 scsi_device_put(ch
->device
);
578 file
->private_data
= NULL
;
583 ch_open(struct inode
*inode
, struct file
*file
)
586 int minor
= iminor(inode
);
588 mutex_lock(&ch_mutex
);
589 spin_lock(&ch_index_lock
);
590 ch
= idr_find(&ch_index_idr
, minor
);
592 if (NULL
== ch
|| scsi_device_get(ch
->device
)) {
593 spin_unlock(&ch_index_lock
);
594 mutex_unlock(&ch_mutex
);
597 spin_unlock(&ch_index_lock
);
599 file
->private_data
= ch
;
600 mutex_unlock(&ch_mutex
);
605 ch_checkrange(scsi_changer
*ch
, unsigned int type
, unsigned int unit
)
607 if (type
>= CH_TYPES
|| unit
>= ch
->counts
[type
])
612 static long ch_ioctl(struct file
*file
,
613 unsigned int cmd
, unsigned long arg
)
615 scsi_changer
*ch
= file
->private_data
;
617 void __user
*argp
= (void __user
*)arg
;
622 struct changer_params params
;
624 params
.cp_curpicker
= 0;
625 params
.cp_npickers
= ch
->counts
[CHET_MT
];
626 params
.cp_nslots
= ch
->counts
[CHET_ST
];
627 params
.cp_nportals
= ch
->counts
[CHET_IE
];
628 params
.cp_ndrives
= ch
->counts
[CHET_DT
];
630 if (copy_to_user(argp
, ¶ms
, sizeof(params
)))
636 struct changer_vendor_params vparams
;
638 memset(&vparams
,0,sizeof(vparams
));
639 if (ch
->counts
[CHET_V1
]) {
640 vparams
.cvp_n1
= ch
->counts
[CHET_V1
];
641 strncpy(vparams
.cvp_label1
,vendor_labels
[0],16);
643 if (ch
->counts
[CHET_V2
]) {
644 vparams
.cvp_n2
= ch
->counts
[CHET_V2
];
645 strncpy(vparams
.cvp_label2
,vendor_labels
[1],16);
647 if (ch
->counts
[CHET_V3
]) {
648 vparams
.cvp_n3
= ch
->counts
[CHET_V3
];
649 strncpy(vparams
.cvp_label3
,vendor_labels
[2],16);
651 if (ch
->counts
[CHET_V4
]) {
652 vparams
.cvp_n4
= ch
->counts
[CHET_V4
];
653 strncpy(vparams
.cvp_label4
,vendor_labels
[3],16);
655 if (copy_to_user(argp
, &vparams
, sizeof(vparams
)))
662 struct changer_position pos
;
664 if (copy_from_user(&pos
, argp
, sizeof (pos
)))
667 if (0 != ch_checkrange(ch
, pos
.cp_type
, pos
.cp_unit
)) {
668 DPRINTK("CHIOPOSITION: invalid parameter\n");
671 mutex_lock(&ch
->lock
);
672 retval
= ch_position(ch
,0,
673 ch
->firsts
[pos
.cp_type
] + pos
.cp_unit
,
674 pos
.cp_flags
& CP_INVERT
);
675 mutex_unlock(&ch
->lock
);
681 struct changer_move mv
;
683 if (copy_from_user(&mv
, argp
, sizeof (mv
)))
686 if (0 != ch_checkrange(ch
, mv
.cm_fromtype
, mv
.cm_fromunit
) ||
687 0 != ch_checkrange(ch
, mv
.cm_totype
, mv
.cm_tounit
)) {
688 DPRINTK("CHIOMOVE: invalid parameter\n");
692 mutex_lock(&ch
->lock
);
693 retval
= ch_move(ch
,0,
694 ch
->firsts
[mv
.cm_fromtype
] + mv
.cm_fromunit
,
695 ch
->firsts
[mv
.cm_totype
] + mv
.cm_tounit
,
696 mv
.cm_flags
& CM_INVERT
);
697 mutex_unlock(&ch
->lock
);
703 struct changer_exchange mv
;
705 if (copy_from_user(&mv
, argp
, sizeof (mv
)))
708 if (0 != ch_checkrange(ch
, mv
.ce_srctype
, mv
.ce_srcunit
) ||
709 0 != ch_checkrange(ch
, mv
.ce_fdsttype
, mv
.ce_fdstunit
) ||
710 0 != ch_checkrange(ch
, mv
.ce_sdsttype
, mv
.ce_sdstunit
)) {
711 DPRINTK("CHIOEXCHANGE: invalid parameter\n");
715 mutex_lock(&ch
->lock
);
718 ch
->firsts
[mv
.ce_srctype
] + mv
.ce_srcunit
,
719 ch
->firsts
[mv
.ce_fdsttype
] + mv
.ce_fdstunit
,
720 ch
->firsts
[mv
.ce_sdsttype
] + mv
.ce_sdstunit
,
721 mv
.ce_flags
& CE_INVERT1
, mv
.ce_flags
& CE_INVERT2
);
722 mutex_unlock(&ch
->lock
);
728 struct changer_element_status ces
;
730 if (copy_from_user(&ces
, argp
, sizeof (ces
)))
732 if (ces
.ces_type
< 0 || ces
.ces_type
>= CH_TYPES
)
735 return ch_gstatus(ch
, ces
.ces_type
, ces
.ces_data
);
740 struct changer_get_element cge
;
746 if (copy_from_user(&cge
, argp
, sizeof (cge
)))
749 if (0 != ch_checkrange(ch
, cge
.cge_type
, cge
.cge_unit
))
751 elem
= ch
->firsts
[cge
.cge_type
] + cge
.cge_unit
;
753 buffer
= kmalloc(512, GFP_KERNEL
| GFP_DMA
);
756 mutex_lock(&ch
->lock
);
759 memset(ch_cmd
, 0, sizeof(ch_cmd
));
760 ch_cmd
[0] = READ_ELEMENT_STATUS
;
761 ch_cmd
[1] = ((ch
->device
->lun
& 0x7) << 5) |
762 (ch
->voltags
? 0x10 : 0) |
763 ch_elem_to_typecode(ch
,elem
);
764 ch_cmd
[2] = (elem
>> 8) & 0xff;
765 ch_cmd
[3] = elem
& 0xff;
769 result
= ch_do_scsi(ch
, ch_cmd
, buffer
, 256, DMA_FROM_DEVICE
);
771 cge
.cge_status
= buffer
[18];
773 if (buffer
[18] & CESTATUS_EXCEPT
) {
776 if (buffer
[25] & 0x80) {
777 cge
.cge_flags
|= CGE_SRC
;
778 if (buffer
[25] & 0x40)
779 cge
.cge_flags
|= CGE_INVERT
;
780 elem
= (buffer
[26]<<8) | buffer
[27];
781 for (i
= 0; i
< 4; i
++) {
782 if (elem
>= ch
->firsts
[i
] &&
783 elem
< ch
->firsts
[i
] + ch
->counts
[i
]) {
785 cge
.cge_srcunit
= elem
-ch
->firsts
[i
];
789 if ((buffer
[22] & 0x30) == 0x30) {
790 cge
.cge_flags
|= CGE_IDLUN
;
791 cge
.cge_id
= buffer
[23];
792 cge
.cge_lun
= buffer
[22] & 7;
794 if (buffer
[9] & 0x80) {
795 cge
.cge_flags
|= CGE_PVOLTAG
;
796 memcpy(cge
.cge_pvoltag
,buffer
+28,36);
798 if (buffer
[9] & 0x40) {
799 cge
.cge_flags
|= CGE_AVOLTAG
;
800 memcpy(cge
.cge_avoltag
,buffer
+64,36);
802 } else if (ch
->voltags
) {
804 VPRINTK(KERN_INFO
, "device has no volume tag support\n");
808 mutex_unlock(&ch
->lock
);
810 if (copy_to_user(argp
, &cge
, sizeof (cge
)))
817 mutex_lock(&ch
->lock
);
818 retval
= ch_init_elem(ch
);
819 mutex_unlock(&ch
->lock
);
825 struct changer_set_voltag csv
;
828 if (copy_from_user(&csv
, argp
, sizeof(csv
)))
831 if (0 != ch_checkrange(ch
, csv
.csv_type
, csv
.csv_unit
)) {
832 DPRINTK("CHIOSVOLTAG: invalid parameter\n");
835 elem
= ch
->firsts
[csv
.csv_type
] + csv
.csv_unit
;
836 mutex_lock(&ch
->lock
);
837 retval
= ch_set_voltag(ch
, elem
,
838 csv
.csv_flags
& CSV_AVOLTAG
,
839 csv
.csv_flags
& CSV_CLEARTAG
,
841 mutex_unlock(&ch
->lock
);
846 return scsi_ioctl(ch
->device
, cmd
, argp
);
853 struct changer_element_status32
{
855 compat_uptr_t ces_data
;
857 #define CHIOGSTATUS32 _IOW('c', 8,struct changer_element_status32)
859 static long ch_ioctl_compat(struct file
* file
,
860 unsigned int cmd
, unsigned long arg
)
862 scsi_changer
*ch
= file
->private_data
;
874 return ch_ioctl(file
, cmd
, arg
);
877 struct changer_element_status32 ces32
;
878 unsigned char __user
*data
;
880 if (copy_from_user(&ces32
, (void __user
*)arg
, sizeof (ces32
)))
882 if (ces32
.ces_type
< 0 || ces32
.ces_type
>= CH_TYPES
)
885 data
= compat_ptr(ces32
.ces_data
);
886 return ch_gstatus(ch
, ces32
.ces_type
, data
);
889 // return scsi_ioctl_compat(ch->device, cmd, (void*)arg);
896 /* ------------------------------------------------------------------------ */
898 static int ch_probe(struct device
*dev
)
900 struct scsi_device
*sd
= to_scsi_device(dev
);
901 struct device
*class_dev
;
905 if (sd
->type
!= TYPE_MEDIUM_CHANGER
)
908 ch
= kzalloc(sizeof(*ch
), GFP_KERNEL
);
912 idr_preload(GFP_KERNEL
);
913 spin_lock(&ch_index_lock
);
914 ret
= idr_alloc(&ch_index_idr
, ch
, 0, CH_MAX_DEVS
+ 1, GFP_NOWAIT
);
915 spin_unlock(&ch_index_lock
);
925 sprintf(ch
->name
,"ch%d",ch
->minor
);
927 class_dev
= device_create(ch_sysfs_class
, dev
,
928 MKDEV(SCSI_CHANGER_MAJOR
, ch
->minor
), ch
,
930 if (IS_ERR(class_dev
)) {
931 sdev_printk(KERN_WARNING
, sd
, "ch%d: device_create failed\n",
933 ret
= PTR_ERR(class_dev
);
937 mutex_init(&ch
->lock
);
943 dev_set_drvdata(dev
, ch
);
944 sdev_printk(KERN_INFO
, sd
, "Attached scsi changer %s\n", ch
->name
);
948 idr_remove(&ch_index_idr
, ch
->minor
);
954 static int ch_remove(struct device
*dev
)
956 scsi_changer
*ch
= dev_get_drvdata(dev
);
958 spin_lock(&ch_index_lock
);
959 idr_remove(&ch_index_idr
, ch
->minor
);
960 spin_unlock(&ch_index_lock
);
962 device_destroy(ch_sysfs_class
, MKDEV(SCSI_CHANGER_MAJOR
,ch
->minor
));
968 static struct scsi_driver ch_template
= {
969 .owner
= THIS_MODULE
,
977 static const struct file_operations changer_fops
= {
978 .owner
= THIS_MODULE
,
980 .release
= ch_release
,
981 .unlocked_ioctl
= ch_ioctl
,
983 .compat_ioctl
= ch_ioctl_compat
,
985 .llseek
= noop_llseek
,
988 static int __init
init_ch_module(void)
992 printk(KERN_INFO
"SCSI Media Changer driver v" VERSION
" \n");
993 ch_sysfs_class
= class_create(THIS_MODULE
, "scsi_changer");
994 if (IS_ERR(ch_sysfs_class
)) {
995 rc
= PTR_ERR(ch_sysfs_class
);
998 rc
= register_chrdev(SCSI_CHANGER_MAJOR
,"ch",&changer_fops
);
1000 printk("Unable to get major %d for SCSI-Changer\n",
1001 SCSI_CHANGER_MAJOR
);
1004 rc
= scsi_register_driver(&ch_template
.gendrv
);
1010 unregister_chrdev(SCSI_CHANGER_MAJOR
, "ch");
1012 class_destroy(ch_sysfs_class
);
1016 static void __exit
exit_ch_module(void)
1018 scsi_unregister_driver(&ch_template
.gendrv
);
1019 unregister_chrdev(SCSI_CHANGER_MAJOR
, "ch");
1020 class_destroy(ch_sysfs_class
);
1021 idr_destroy(&ch_index_idr
);
1024 module_init(init_ch_module
);
1025 module_exit(exit_ch_module
);