[SCSI] megaraid_sas: Fix FastPath I/O to work on degraded raid 1
[linux-2.6.git] / drivers / scsi / ch.c
1 /*
2  * SCSI Media Changer device driver for Linux 2.6
3  *
4  *     (c) 1996-2003 Gerd Knorr <kraxel@bytesex.org>
5  *
6  */
7
8 #define VERSION "0.25"
9
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/fs.h>
13 #include <linux/kernel.h>
14 #include <linux/mm.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>
26
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>
35
36 #define CH_DT_MAX       16
37 #define CH_TYPES        8
38 #define CH_MAX_DEVS     128
39
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);
45
46 static DEFINE_MUTEX(ch_mutex);
47 static int init = 1;
48 module_param(init, int, 0444);
49 MODULE_PARM_DESC(init, \
50     "initialize element status on driver load (default: on)");
51
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)");
56
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)");
61
62 static int verbose = 1;
63 module_param(verbose, int, 0644);
64 MODULE_PARM_DESC(verbose,"be verbose (default: on)");
65
66 static int debug = 0;
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)");
70
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);
75
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);
81
82 static const char * vendor_labels[CH_TYPES-4] = {
83         "v0", "v1", "v2", "v3"
84 };
85 // module_param_string_array(vendor_labels, NULL, 0444);
86
87 #define DPRINTK(fmt, arg...)                                            \
88 do {                                                                    \
89         if (debug)                                                      \
90                 printk(KERN_DEBUG "%s: " fmt, ch->name, ##arg);         \
91 } while (0)
92 #define VPRINTK(level, fmt, arg...)                                     \
93 do {                                                                    \
94         if (verbose)                                                    \
95                 printk(level "%s: " fmt, ch->name, ##arg);              \
96 } while (0)
97
98 /* ------------------------------------------------------------------- */
99
100 #define MAX_RETRIES   1
101
102 static struct class * ch_sysfs_class;
103
104 typedef struct {
105         struct list_head    list;
106         int                 minor;
107         char                name[8];
108         struct scsi_device  *device;
109         struct scsi_device  **dt;        /* ptrs to data transfer elements */
110         u_int               firsts[CH_TYPES];
111         u_int               counts[CH_TYPES];
112         u_int               unit_attention;
113         u_int               voltags;
114         struct mutex        lock;
115 } scsi_changer;
116
117 static DEFINE_IDR(ch_index_idr);
118 static DEFINE_SPINLOCK(ch_index_lock);
119
120 static const struct {
121         unsigned char  sense;
122         unsigned char  asc;
123         unsigned char  ascq;
124         int            errno;
125 } ch_err[] = {
126 /* Just filled in what looks right. Hav'nt checked any standard paper for
127    these errno assignments, so they may be wrong... */
128         {
129                 .sense  = ILLEGAL_REQUEST,
130                 .asc    = 0x21,
131                 .ascq   = 0x01,
132                 .errno  = EBADSLT, /* Invalid element address */
133         },{
134                 .sense  = ILLEGAL_REQUEST,
135                 .asc    = 0x28,
136                 .ascq   = 0x01,
137                 .errno  = EBADE,   /* Import or export element accessed */
138         },{
139                 .sense  = ILLEGAL_REQUEST,
140                 .asc    = 0x3B,
141                 .ascq   = 0x0D,
142                 .errno  = EXFULL,  /* Medium destination element full */
143         },{
144                 .sense  = ILLEGAL_REQUEST,
145                 .asc    = 0x3B,
146                 .ascq   = 0x0E,
147                 .errno  = EBADE,   /* Medium source element empty */
148         },{
149                 .sense  = ILLEGAL_REQUEST,
150                 .asc    = 0x20,
151                 .ascq   = 0x00,
152                 .errno  = EBADRQC, /* Invalid command operation code */
153         },{
154                 /* end of list */
155         }
156 };
157
158 /* ------------------------------------------------------------------- */
159
160 static int ch_find_errno(struct scsi_sense_hdr *sshdr)
161 {
162         int i,errno = 0;
163
164         /* Check to see if additional sense information is available */
165         if (scsi_sense_valid(sshdr) &&
166             sshdr->asc != 0) {
167                 for (i = 0; ch_err[i].errno != 0; i++) {
168                         if (ch_err[i].sense == sshdr->sense_key &&
169                             ch_err[i].asc   == sshdr->asc &&
170                             ch_err[i].ascq  == sshdr->ascq) {
171                                 errno = -ch_err[i].errno;
172                                 break;
173                         }
174                 }
175         }
176         if (errno == 0)
177                 errno = -EIO;
178         return errno;
179 }
180
181 static int
182 ch_do_scsi(scsi_changer *ch, unsigned char *cmd,
183            void *buffer, unsigned buflength,
184            enum dma_data_direction direction)
185 {
186         int errno, retries = 0, timeout, result;
187         struct scsi_sense_hdr sshdr;
188
189         timeout = (cmd[0] == INITIALIZE_ELEMENT_STATUS)
190                 ? timeout_init : timeout_move;
191
192  retry:
193         errno = 0;
194         if (debug) {
195                 DPRINTK("command: ");
196                 __scsi_print_command(cmd);
197         }
198
199         result = scsi_execute_req(ch->device, cmd, direction, buffer,
200                                   buflength, &sshdr, timeout * HZ,
201                                   MAX_RETRIES, NULL);
202
203         DPRINTK("result: 0x%x\n",result);
204         if (driver_byte(result) & DRIVER_SENSE) {
205                 if (debug)
206                         scsi_print_sense_hdr(ch->name, &sshdr);
207                 errno = ch_find_errno(&sshdr);
208
209                 switch(sshdr.sense_key) {
210                 case UNIT_ATTENTION:
211                         ch->unit_attention = 1;
212                         if (retries++ < 3)
213                                 goto retry;
214                         break;
215                 }
216         }
217         return errno;
218 }
219
220 /* ------------------------------------------------------------------------ */
221
222 static int
223 ch_elem_to_typecode(scsi_changer *ch, u_int elem)
224 {
225         int i;
226
227         for (i = 0; i < CH_TYPES; i++) {
228                 if (elem >= ch->firsts[i]  &&
229                     elem <  ch->firsts[i] +
230                     ch->counts[i])
231                         return i+1;
232         }
233         return 0;
234 }
235
236 static int
237 ch_read_element_status(scsi_changer *ch, u_int elem, char *data)
238 {
239         u_char  cmd[12];
240         u_char  *buffer;
241         int     result;
242
243         buffer = kmalloc(512, GFP_KERNEL | GFP_DMA);
244         if(!buffer)
245                 return -ENOMEM;
246
247  retry:
248         memset(cmd,0,sizeof(cmd));
249         cmd[0] = READ_ELEMENT_STATUS;
250         cmd[1] = (ch->device->lun << 5) |
251                 (ch->voltags ? 0x10 : 0) |
252                 ch_elem_to_typecode(ch,elem);
253         cmd[2] = (elem >> 8) & 0xff;
254         cmd[3] = elem        & 0xff;
255         cmd[5] = 1;
256         cmd[9] = 255;
257         if (0 == (result = ch_do_scsi(ch, cmd, 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]);
261                         kfree(buffer);
262                         return -EIO;
263                 }
264                 memcpy(data,buffer+16,16);
265         } else {
266                 if (ch->voltags) {
267                         ch->voltags = 0;
268                         VPRINTK(KERN_INFO, "device has no volume tag support\n");
269                         goto retry;
270                 }
271                 DPRINTK("READ ELEMENT STATUS for element 0x%x failed\n",elem);
272         }
273         kfree(buffer);
274         return result;
275 }
276
277 static int
278 ch_init_elem(scsi_changer *ch)
279 {
280         int err;
281         u_char cmd[6];
282
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 << 5;
287         err = ch_do_scsi(ch, cmd, NULL, 0, DMA_NONE);
288         VPRINTK(KERN_INFO, "... finished\n");
289         return err;
290 }
291
292 static int
293 ch_readconfig(scsi_changer *ch)
294 {
295         u_char  cmd[10], data[16];
296         u_char  *buffer;
297         int     result,id,lun,i;
298         u_int   elem;
299
300         buffer = kzalloc(512, GFP_KERNEL | GFP_DMA);
301         if (!buffer)
302                 return -ENOMEM;
303
304         memset(cmd,0,sizeof(cmd));
305         cmd[0] = MODE_SENSE;
306         cmd[1] = ch->device->lun << 5;
307         cmd[2] = 0x1d;
308         cmd[4] = 255;
309         result = ch_do_scsi(ch, cmd, buffer, 255, DMA_FROM_DEVICE);
310         if (0 != result) {
311                 cmd[1] |= (1<<3);
312                 result  = ch_do_scsi(ch, cmd, buffer, 255, DMA_FROM_DEVICE);
313         }
314         if (0 == result) {
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",
332                         ch->firsts[CHET_MT],
333                         ch->counts[CHET_MT]);
334                 VPRINTK(KERN_INFO, "type #2 (st): 0x%x+%d [storage]\n",
335                         ch->firsts[CHET_ST],
336                         ch->counts[CHET_ST]);
337                 VPRINTK(KERN_INFO, "type #3 (ie): 0x%x+%d [import/export]\n",
338                         ch->firsts[CHET_IE],
339                         ch->counts[CHET_IE]);
340                 VPRINTK(KERN_INFO, "type #4 (dt): 0x%x+%d [data transfer]\n",
341                         ch->firsts[CHET_DT],
342                         ch->counts[CHET_DT]);
343         } else {
344                 VPRINTK(KERN_INFO, "reading element address assigment page failed!\n");
345         }
346
347         /* vendor specific element types */
348         for (i = 0; i < 4; i++) {
349                 if (0 == vendor_counts[i])
350                         continue;
351                 if (NULL == vendor_labels[i])
352                         continue;
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],
357                         vendor_labels[i]);
358         }
359
360         /* look up the devices of the data transfer elements */
361         ch->dt = kcalloc(ch->counts[CHET_DT], sizeof(*ch->dt),
362                          GFP_KERNEL);
363
364         if (!ch->dt) {
365                 kfree(buffer);
366                 return -ENOMEM;
367         }
368
369         for (elem = 0; elem < ch->counts[CHET_DT]; elem++) {
370                 id  = -1;
371                 lun = 0;
372                 if (elem < CH_DT_MAX  &&  -1 != dt_id[elem]) {
373                         id  = dt_id[elem];
374                         lun = dt_lun[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]);
381                 } else {
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");
385                                 ch->dt[elem] = NULL;
386                         } else if (0 == (data[6] & 0x30)) {
387                                 VPRINTK(KERN_CONT, "ID/LUN unknown\n");
388                                 ch->dt[elem] = NULL;
389                         } else {
390                                 id  = ch->device->id;
391                                 lun = 0;
392                                 if (data[6] & 0x20) id  = data[7];
393                                 if (data[6] & 0x10) lun = data[6] & 7;
394                         }
395                 }
396                 if (-1 != id) {
397                         VPRINTK(KERN_CONT, "ID %i, LUN %i, ",id,lun);
398                         ch->dt[elem] =
399                                 scsi_device_lookup(ch->device->host,
400                                                    ch->device->channel,
401                                                    id,lun);
402                         if (!ch->dt[elem]) {
403                                 /* should not happen */
404                                 VPRINTK(KERN_CONT, "Huh? device not found!\n");
405                         } else {
406                                 VPRINTK(KERN_CONT, "name: %8.8s %16.16s %4.4s\n",
407                                         ch->dt[elem]->vendor,
408                                         ch->dt[elem]->model,
409                                         ch->dt[elem]->rev);
410                         }
411                 }
412         }
413         ch->voltags = 1;
414         kfree(buffer);
415
416         return 0;
417 }
418
419 /* ------------------------------------------------------------------------ */
420
421 static int
422 ch_position(scsi_changer *ch, u_int trans, u_int elem, int rotate)
423 {
424         u_char  cmd[10];
425
426         DPRINTK("position: 0x%x\n",elem);
427         if (0 == trans)
428                 trans = ch->firsts[CHET_MT];
429         memset(cmd,0,sizeof(cmd));
430         cmd[0]  = POSITION_TO_ELEMENT;
431         cmd[1]  = ch->device->lun << 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, NULL, 0, DMA_NONE);
438 }
439
440 static int
441 ch_move(scsi_changer *ch, u_int trans, u_int src, u_int dest, int rotate)
442 {
443         u_char  cmd[12];
444
445         DPRINTK("move: 0x%x => 0x%x\n",src,dest);
446         if (0 == trans)
447                 trans = ch->firsts[CHET_MT];
448         memset(cmd,0,sizeof(cmd));
449         cmd[0]  = MOVE_MEDIUM;
450         cmd[1]  = ch->device->lun << 5;
451         cmd[2]  = (trans >> 8) & 0xff;
452         cmd[3]  =  trans       & 0xff;
453         cmd[4]  = (src   >> 8) & 0xff;
454         cmd[5]  =  src         & 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, NULL,0, DMA_NONE);
459 }
460
461 static int
462 ch_exchange(scsi_changer *ch, u_int trans, u_int src,
463             u_int dest1, u_int dest2, int rotate1, int rotate2)
464 {
465         u_char  cmd[12];
466
467         DPRINTK("exchange: 0x%x => 0x%x => 0x%x\n",
468                 src,dest1,dest2);
469         if (0 == trans)
470                 trans = ch->firsts[CHET_MT];
471         memset(cmd,0,sizeof(cmd));
472         cmd[0]  = EXCHANGE_MEDIUM;
473         cmd[1]  = ch->device->lun << 5;
474         cmd[2]  = (trans >> 8) & 0xff;
475         cmd[3]  =  trans       & 0xff;
476         cmd[4]  = (src   >> 8) & 0xff;
477         cmd[5]  =  src         & 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);
483
484         return ch_do_scsi(ch, cmd, NULL,0, DMA_NONE);
485 }
486
487 static void
488 ch_check_voltag(char *tag)
489 {
490         int i;
491
492         for (i = 0; i < 32; i++) {
493                 /* restrict to ascii */
494                 if (tag[i] >= 0x7f || tag[i] < 0x20)
495                         tag[i] = ' ';
496                 /* don't allow search wildcards */
497                 if (tag[i] == '?' ||
498                     tag[i] == '*')
499                         tag[i] = ' ';
500         }
501 }
502
503 static int
504 ch_set_voltag(scsi_changer *ch, u_int elem,
505               int alternate, int clear, u_char *tag)
506 {
507         u_char  cmd[12];
508         u_char  *buffer;
509         int result;
510
511         buffer = kzalloc(512, GFP_KERNEL);
512         if (!buffer)
513                 return -ENOMEM;
514
515         DPRINTK("%s %s voltag: 0x%x => \"%s\"\n",
516                 clear     ? "clear"     : "set",
517                 alternate ? "alternate" : "primary",
518                 elem, tag);
519         memset(cmd,0,sizeof(cmd));
520         cmd[0]  = SEND_VOLUME_TAG;
521         cmd[1] = (ch->device->lun << 5) |
522                 ch_elem_to_typecode(ch,elem);
523         cmd[2] = (elem >> 8) & 0xff;
524         cmd[3] = elem        & 0xff;
525         cmd[5] = clear
526                 ? (alternate ? 0x0d : 0x0c)
527                 : (alternate ? 0x0b : 0x0a);
528
529         cmd[9] = 255;
530
531         memcpy(buffer,tag,32);
532         ch_check_voltag(buffer);
533
534         result = ch_do_scsi(ch, cmd, buffer, 256, DMA_TO_DEVICE);
535         kfree(buffer);
536         return result;
537 }
538
539 static int ch_gstatus(scsi_changer *ch, int type, unsigned char __user *dest)
540 {
541         int retval = 0;
542         u_char data[16];
543         unsigned int i;
544
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)) {
549                         retval = -EIO;
550                         break;
551                 }
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",
555                                 ch->firsts[type]+i,
556                                 (int)data[4],(int)data[5]);
557                 retval = ch_read_element_status
558                         (ch, ch->firsts[type]+i,data);
559                 if (0 != retval)
560                         break;
561         }
562         mutex_unlock(&ch->lock);
563         return retval;
564 }
565
566 /* ------------------------------------------------------------------------ */
567
568 static int
569 ch_release(struct inode *inode, struct file *file)
570 {
571         scsi_changer *ch = file->private_data;
572
573         scsi_device_put(ch->device);
574         file->private_data = NULL;
575         return 0;
576 }
577
578 static int
579 ch_open(struct inode *inode, struct file *file)
580 {
581         scsi_changer *ch;
582         int minor = iminor(inode);
583
584         mutex_lock(&ch_mutex);
585         spin_lock(&ch_index_lock);
586         ch = idr_find(&ch_index_idr, minor);
587
588         if (NULL == ch || scsi_device_get(ch->device)) {
589                 spin_unlock(&ch_index_lock);
590                 mutex_unlock(&ch_mutex);
591                 return -ENXIO;
592         }
593         spin_unlock(&ch_index_lock);
594
595         file->private_data = ch;
596         mutex_unlock(&ch_mutex);
597         return 0;
598 }
599
600 static int
601 ch_checkrange(scsi_changer *ch, unsigned int type, unsigned int unit)
602 {
603         if (type >= CH_TYPES  ||  unit >= ch->counts[type])
604                 return -1;
605         return 0;
606 }
607
608 static long ch_ioctl(struct file *file,
609                     unsigned int cmd, unsigned long arg)
610 {
611         scsi_changer *ch = file->private_data;
612         int retval;
613         void __user *argp = (void __user *)arg;
614
615         switch (cmd) {
616         case CHIOGPARAMS:
617         {
618                 struct changer_params params;
619
620                 params.cp_curpicker = 0;
621                 params.cp_npickers  = ch->counts[CHET_MT];
622                 params.cp_nslots    = ch->counts[CHET_ST];
623                 params.cp_nportals  = ch->counts[CHET_IE];
624                 params.cp_ndrives   = ch->counts[CHET_DT];
625
626                 if (copy_to_user(argp, &params, sizeof(params)))
627                         return -EFAULT;
628                 return 0;
629         }
630         case CHIOGVPARAMS:
631         {
632                 struct changer_vendor_params vparams;
633
634                 memset(&vparams,0,sizeof(vparams));
635                 if (ch->counts[CHET_V1]) {
636                         vparams.cvp_n1  = ch->counts[CHET_V1];
637                         strncpy(vparams.cvp_label1,vendor_labels[0],16);
638                 }
639                 if (ch->counts[CHET_V2]) {
640                         vparams.cvp_n2  = ch->counts[CHET_V2];
641                         strncpy(vparams.cvp_label2,vendor_labels[1],16);
642                 }
643                 if (ch->counts[CHET_V3]) {
644                         vparams.cvp_n3  = ch->counts[CHET_V3];
645                         strncpy(vparams.cvp_label3,vendor_labels[2],16);
646                 }
647                 if (ch->counts[CHET_V4]) {
648                         vparams.cvp_n4  = ch->counts[CHET_V4];
649                         strncpy(vparams.cvp_label4,vendor_labels[3],16);
650                 }
651                 if (copy_to_user(argp, &vparams, sizeof(vparams)))
652                         return -EFAULT;
653                 return 0;
654         }
655
656         case CHIOPOSITION:
657         {
658                 struct changer_position pos;
659
660                 if (copy_from_user(&pos, argp, sizeof (pos)))
661                         return -EFAULT;
662
663                 if (0 != ch_checkrange(ch, pos.cp_type, pos.cp_unit)) {
664                         DPRINTK("CHIOPOSITION: invalid parameter\n");
665                         return -EBADSLT;
666                 }
667                 mutex_lock(&ch->lock);
668                 retval = ch_position(ch,0,
669                                      ch->firsts[pos.cp_type] + pos.cp_unit,
670                                      pos.cp_flags & CP_INVERT);
671                 mutex_unlock(&ch->lock);
672                 return retval;
673         }
674
675         case CHIOMOVE:
676         {
677                 struct changer_move mv;
678
679                 if (copy_from_user(&mv, argp, sizeof (mv)))
680                         return -EFAULT;
681
682                 if (0 != ch_checkrange(ch, mv.cm_fromtype, mv.cm_fromunit) ||
683                     0 != ch_checkrange(ch, mv.cm_totype,   mv.cm_tounit  )) {
684                         DPRINTK("CHIOMOVE: invalid parameter\n");
685                         return -EBADSLT;
686                 }
687
688                 mutex_lock(&ch->lock);
689                 retval = ch_move(ch,0,
690                                  ch->firsts[mv.cm_fromtype] + mv.cm_fromunit,
691                                  ch->firsts[mv.cm_totype]   + mv.cm_tounit,
692                                  mv.cm_flags & CM_INVERT);
693                 mutex_unlock(&ch->lock);
694                 return retval;
695         }
696
697         case CHIOEXCHANGE:
698         {
699                 struct changer_exchange mv;
700
701                 if (copy_from_user(&mv, argp, sizeof (mv)))
702                         return -EFAULT;
703
704                 if (0 != ch_checkrange(ch, mv.ce_srctype,  mv.ce_srcunit ) ||
705                     0 != ch_checkrange(ch, mv.ce_fdsttype, mv.ce_fdstunit) ||
706                     0 != ch_checkrange(ch, mv.ce_sdsttype, mv.ce_sdstunit)) {
707                         DPRINTK("CHIOEXCHANGE: invalid parameter\n");
708                         return -EBADSLT;
709                 }
710
711                 mutex_lock(&ch->lock);
712                 retval = ch_exchange
713                         (ch,0,
714                          ch->firsts[mv.ce_srctype]  + mv.ce_srcunit,
715                          ch->firsts[mv.ce_fdsttype] + mv.ce_fdstunit,
716                          ch->firsts[mv.ce_sdsttype] + mv.ce_sdstunit,
717                          mv.ce_flags & CE_INVERT1, mv.ce_flags & CE_INVERT2);
718                 mutex_unlock(&ch->lock);
719                 return retval;
720         }
721
722         case CHIOGSTATUS:
723         {
724                 struct changer_element_status ces;
725
726                 if (copy_from_user(&ces, argp, sizeof (ces)))
727                         return -EFAULT;
728                 if (ces.ces_type < 0 || ces.ces_type >= CH_TYPES)
729                         return -EINVAL;
730
731                 return ch_gstatus(ch, ces.ces_type, ces.ces_data);
732         }
733
734         case CHIOGELEM:
735         {
736                 struct changer_get_element cge;
737                 u_char ch_cmd[12];
738                 u_char *buffer;
739                 unsigned int elem;
740                 int     result,i;
741
742                 if (copy_from_user(&cge, argp, sizeof (cge)))
743                         return -EFAULT;
744
745                 if (0 != ch_checkrange(ch, cge.cge_type, cge.cge_unit))
746                         return -EINVAL;
747                 elem = ch->firsts[cge.cge_type] + cge.cge_unit;
748
749                 buffer = kmalloc(512, GFP_KERNEL | GFP_DMA);
750                 if (!buffer)
751                         return -ENOMEM;
752                 mutex_lock(&ch->lock);
753
754         voltag_retry:
755                 memset(ch_cmd, 0, sizeof(ch_cmd));
756                 ch_cmd[0] = READ_ELEMENT_STATUS;
757                 ch_cmd[1] = (ch->device->lun << 5) |
758                         (ch->voltags ? 0x10 : 0) |
759                         ch_elem_to_typecode(ch,elem);
760                 ch_cmd[2] = (elem >> 8) & 0xff;
761                 ch_cmd[3] = elem        & 0xff;
762                 ch_cmd[5] = 1;
763                 ch_cmd[9] = 255;
764
765                 result = ch_do_scsi(ch, ch_cmd, buffer, 256, DMA_FROM_DEVICE);
766                 if (!result) {
767                         cge.cge_status = buffer[18];
768                         cge.cge_flags = 0;
769                         if (buffer[18] & CESTATUS_EXCEPT) {
770                                 cge.cge_errno = EIO;
771                         }
772                         if (buffer[25] & 0x80) {
773                                 cge.cge_flags |= CGE_SRC;
774                                 if (buffer[25] & 0x40)
775                                         cge.cge_flags |= CGE_INVERT;
776                                 elem = (buffer[26]<<8) | buffer[27];
777                                 for (i = 0; i < 4; i++) {
778                                         if (elem >= ch->firsts[i] &&
779                                             elem <  ch->firsts[i] + ch->counts[i]) {
780                                                 cge.cge_srctype = i;
781                                                 cge.cge_srcunit = elem-ch->firsts[i];
782                                         }
783                                 }
784                         }
785                         if ((buffer[22] & 0x30) == 0x30) {
786                                 cge.cge_flags |= CGE_IDLUN;
787                                 cge.cge_id  = buffer[23];
788                                 cge.cge_lun = buffer[22] & 7;
789                         }
790                         if (buffer[9] & 0x80) {
791                                 cge.cge_flags |= CGE_PVOLTAG;
792                                 memcpy(cge.cge_pvoltag,buffer+28,36);
793                         }
794                         if (buffer[9] & 0x40) {
795                                 cge.cge_flags |= CGE_AVOLTAG;
796                                 memcpy(cge.cge_avoltag,buffer+64,36);
797                         }
798                 } else if (ch->voltags) {
799                         ch->voltags = 0;
800                         VPRINTK(KERN_INFO, "device has no volume tag support\n");
801                         goto voltag_retry;
802                 }
803                 kfree(buffer);
804                 mutex_unlock(&ch->lock);
805
806                 if (copy_to_user(argp, &cge, sizeof (cge)))
807                         return -EFAULT;
808                 return result;
809         }
810
811         case CHIOINITELEM:
812         {
813                 mutex_lock(&ch->lock);
814                 retval = ch_init_elem(ch);
815                 mutex_unlock(&ch->lock);
816                 return retval;
817         }
818
819         case CHIOSVOLTAG:
820         {
821                 struct changer_set_voltag csv;
822                 int elem;
823
824                 if (copy_from_user(&csv, argp, sizeof(csv)))
825                         return -EFAULT;
826
827                 if (0 != ch_checkrange(ch, csv.csv_type, csv.csv_unit)) {
828                         DPRINTK("CHIOSVOLTAG: invalid parameter\n");
829                         return -EBADSLT;
830                 }
831                 elem = ch->firsts[csv.csv_type] + csv.csv_unit;
832                 mutex_lock(&ch->lock);
833                 retval = ch_set_voltag(ch, elem,
834                                        csv.csv_flags & CSV_AVOLTAG,
835                                        csv.csv_flags & CSV_CLEARTAG,
836                                        csv.csv_voltag);
837                 mutex_unlock(&ch->lock);
838                 return retval;
839         }
840
841         default:
842                 return scsi_ioctl(ch->device, cmd, argp);
843
844         }
845 }
846
847 #ifdef CONFIG_COMPAT
848
849 struct changer_element_status32 {
850         int             ces_type;
851         compat_uptr_t   ces_data;
852 };
853 #define CHIOGSTATUS32  _IOW('c', 8,struct changer_element_status32)
854
855 static long ch_ioctl_compat(struct file * file,
856                             unsigned int cmd, unsigned long arg)
857 {
858         scsi_changer *ch = file->private_data;
859
860         switch (cmd) {
861         case CHIOGPARAMS:
862         case CHIOGVPARAMS:
863         case CHIOPOSITION:
864         case CHIOMOVE:
865         case CHIOEXCHANGE:
866         case CHIOGELEM:
867         case CHIOINITELEM:
868         case CHIOSVOLTAG:
869                 /* compatible */
870                 return ch_ioctl(file, cmd, arg);
871         case CHIOGSTATUS32:
872         {
873                 struct changer_element_status32 ces32;
874                 unsigned char __user *data;
875
876                 if (copy_from_user(&ces32, (void __user *)arg, sizeof (ces32)))
877                         return -EFAULT;
878                 if (ces32.ces_type < 0 || ces32.ces_type >= CH_TYPES)
879                         return -EINVAL;
880
881                 data = compat_ptr(ces32.ces_data);
882                 return ch_gstatus(ch, ces32.ces_type, data);
883         }
884         default:
885                 // return scsi_ioctl_compat(ch->device, cmd, (void*)arg);
886                 return -ENOIOCTLCMD;
887
888         }
889 }
890 #endif
891
892 /* ------------------------------------------------------------------------ */
893
894 static int ch_probe(struct device *dev)
895 {
896         struct scsi_device *sd = to_scsi_device(dev);
897         struct device *class_dev;
898         int minor, ret = -ENOMEM;
899         scsi_changer *ch;
900
901         if (sd->type != TYPE_MEDIUM_CHANGER)
902                 return -ENODEV;
903
904         ch = kzalloc(sizeof(*ch), GFP_KERNEL);
905         if (NULL == ch)
906                 return -ENOMEM;
907
908         if (!idr_pre_get(&ch_index_idr, GFP_KERNEL))
909                 goto free_ch;
910
911         spin_lock(&ch_index_lock);
912         ret = idr_get_new(&ch_index_idr, ch, &minor);
913         spin_unlock(&ch_index_lock);
914
915         if (ret)
916                 goto free_ch;
917
918         if (minor > CH_MAX_DEVS) {
919                 ret = -ENODEV;
920                 goto remove_idr;
921         }
922
923         ch->minor = minor;
924         sprintf(ch->name,"ch%d",ch->minor);
925
926         class_dev = device_create(ch_sysfs_class, dev,
927                                   MKDEV(SCSI_CHANGER_MAJOR, ch->minor), ch,
928                                   "s%s", ch->name);
929         if (IS_ERR(class_dev)) {
930                 printk(KERN_WARNING "ch%d: device_create failed\n",
931                        ch->minor);
932                 ret = PTR_ERR(class_dev);
933                 goto remove_idr;
934         }
935
936         mutex_init(&ch->lock);
937         ch->device = sd;
938         ch_readconfig(ch);
939         if (init)
940                 ch_init_elem(ch);
941
942         dev_set_drvdata(dev, ch);
943         sdev_printk(KERN_INFO, sd, "Attached scsi changer %s\n", ch->name);
944
945         return 0;
946 remove_idr:
947         idr_remove(&ch_index_idr, minor);
948 free_ch:
949         kfree(ch);
950         return ret;
951 }
952
953 static int ch_remove(struct device *dev)
954 {
955         scsi_changer *ch = dev_get_drvdata(dev);
956
957         spin_lock(&ch_index_lock);
958         idr_remove(&ch_index_idr, ch->minor);
959         spin_unlock(&ch_index_lock);
960
961         device_destroy(ch_sysfs_class, MKDEV(SCSI_CHANGER_MAJOR,ch->minor));
962         kfree(ch->dt);
963         kfree(ch);
964         return 0;
965 }
966
967 static struct scsi_driver ch_template = {
968         .owner          = THIS_MODULE,
969         .gendrv         = {
970                 .name   = "ch",
971                 .probe  = ch_probe,
972                 .remove = ch_remove,
973         },
974 };
975
976 static const struct file_operations changer_fops = {
977         .owner          = THIS_MODULE,
978         .open           = ch_open,
979         .release        = ch_release,
980         .unlocked_ioctl = ch_ioctl,
981 #ifdef CONFIG_COMPAT
982         .compat_ioctl   = ch_ioctl_compat,
983 #endif
984         .llseek         = noop_llseek,
985 };
986
987 static int __init init_ch_module(void)
988 {
989         int rc;
990
991         printk(KERN_INFO "SCSI Media Changer driver v" VERSION " \n");
992         ch_sysfs_class = class_create(THIS_MODULE, "scsi_changer");
993         if (IS_ERR(ch_sysfs_class)) {
994                 rc = PTR_ERR(ch_sysfs_class);
995                 return rc;
996         }
997         rc = register_chrdev(SCSI_CHANGER_MAJOR,"ch",&changer_fops);
998         if (rc < 0) {
999                 printk("Unable to get major %d for SCSI-Changer\n",
1000                        SCSI_CHANGER_MAJOR);
1001                 goto fail1;
1002         }
1003         rc = scsi_register_driver(&ch_template.gendrv);
1004         if (rc < 0)
1005                 goto fail2;
1006         return 0;
1007
1008  fail2:
1009         unregister_chrdev(SCSI_CHANGER_MAJOR, "ch");
1010  fail1:
1011         class_destroy(ch_sysfs_class);
1012         return rc;
1013 }
1014
1015 static void __exit exit_ch_module(void)
1016 {
1017         scsi_unregister_driver(&ch_template.gendrv);
1018         unregister_chrdev(SCSI_CHANGER_MAJOR, "ch");
1019         class_destroy(ch_sysfs_class);
1020         idr_destroy(&ch_index_idr);
1021 }
1022
1023 module_init(init_ch_module);
1024 module_exit(exit_ch_module);
1025
1026 /*
1027  * Local variables:
1028  * c-basic-offset: 8
1029  * End:
1030  */