Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ch.c
Go to the documentation of this file.
1 /*
2  * SCSI Media Changer device driver for Linux 2.6
3  *
4  * (c) 1996-2003 Gerd Knorr <[email protected]>
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 <[email protected]>");
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  */
Generated on Thu Jan 10 2013 14:20:07 for Linux Kernel by   doxygen 1.8.2