ch.c 24.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 * SCSI Media Changer device driver for Linux 2.6
 *
 *     (c) 1996-2003 Gerd Knorr <kraxel@bytesex.org>
 *
 */

#define VERSION "0.25"

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/major.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/blkdev.h>
#include <linux/completion.h>
#include <linux/compat.h>
#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 28 29 30 31 32

#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_driver.h>
#include <scsi/scsi_ioctl.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_device.h>
33
#include <scsi/scsi_eh.h>
34 35 36 37
#include <scsi/scsi_dbg.h>

#define CH_DT_MAX       16
#define CH_TYPES        8
38
#define CH_MAX_DEVS     128
39 40 41 42

MODULE_DESCRIPTION("device driver for scsi media changer devices");
MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org>");
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 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
static int init = 1;
module_param(init, int, 0444);
MODULE_PARM_DESC(init, \
    "initialize element status on driver load (default: on)");

static int timeout_move = 300;
module_param(timeout_move, int, 0644);
MODULE_PARM_DESC(timeout_move,"timeout for move commands "
		 "(default: 300 seconds)");

static int timeout_init = 3600;
module_param(timeout_init, int, 0644);
MODULE_PARM_DESC(timeout_init,"timeout for INITIALIZE ELEMENT STATUS "
		 "(default: 3600 seconds)");

static int verbose = 1;
module_param(verbose, int, 0644);
MODULE_PARM_DESC(verbose,"be verbose (default: on)");

static int debug = 0;
module_param(debug, int, 0644);
MODULE_PARM_DESC(debug,"enable/disable debug messages, also prints more "
		 "detailed sense codes on scsi errors (default: off)");

static int dt_id[CH_DT_MAX] = { [ 0 ... (CH_DT_MAX-1) ] = -1 };
static int dt_lun[CH_DT_MAX];
module_param_array(dt_id,  int, NULL, 0444);
module_param_array(dt_lun, int, NULL, 0444);

/* tell the driver about vendor-specific slots */
static int vendor_firsts[CH_TYPES-4];
static int vendor_counts[CH_TYPES-4];
module_param_array(vendor_firsts, int, NULL, 0444);
module_param_array(vendor_counts, int, NULL, 0444);

82
static const char * vendor_labels[CH_TYPES-4] = {
83 84 85 86
	"v0", "v1", "v2", "v3"
};
// module_param_string_array(vendor_labels, NULL, 0444);

87 88 89 90 91 92 93 94 95 96
#define DPRINTK(fmt, arg...)						\
do {									\
	if (debug)							\
		printk(KERN_DEBUG "%s: " fmt, ch->name, ##arg);		\
} while (0)
#define VPRINTK(level, fmt, arg...)					\
do {									\
	if (verbose)							\
		printk(level "%s: " fmt, ch->name, ##arg);		\
} while (0)
97 98 99 100 101

/* ------------------------------------------------------------------- */

#define MAX_RETRIES   1

102
static struct class * ch_sysfs_class;
103 104 105 106 107 108 109 110 111 112 113

typedef struct {
	struct list_head    list;
	int                 minor;
	char                name[8];
	struct scsi_device  *device;
	struct scsi_device  **dt;        /* ptrs to data transfer elements */
	u_int               firsts[CH_TYPES];
	u_int               counts[CH_TYPES];
	u_int               unit_attention;
	u_int		    voltags;
114
	struct mutex	    lock;
115 116
} scsi_changer;

117 118
static DEFINE_IDR(ch_index_idr);
static DEFINE_SPINLOCK(ch_index_lock);
119

120
static const struct {
121 122 123 124
	unsigned char  sense;
	unsigned char  asc;
	unsigned char  ascq;
	int	       errno;
125
} ch_err[] = {
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
/* Just filled in what looks right. Hav'nt checked any standard paper for
   these errno assignments, so they may be wrong... */
	{
		.sense  = ILLEGAL_REQUEST,
		.asc    = 0x21,
		.ascq   = 0x01,
		.errno  = EBADSLT, /* Invalid element address */
	},{
		.sense  = ILLEGAL_REQUEST,
		.asc    = 0x28,
		.ascq   = 0x01,
		.errno  = EBADE,   /* Import or export element accessed */
	},{
		.sense  = ILLEGAL_REQUEST,
		.asc    = 0x3B,
		.ascq   = 0x0D,
		.errno  = EXFULL,  /* Medium destination element full */
	},{
		.sense  = ILLEGAL_REQUEST,
		.asc    = 0x3B,
		.ascq   = 0x0E,
		.errno  = EBADE,   /* Medium source element empty */
	},{
		.sense  = ILLEGAL_REQUEST,
		.asc    = 0x20,
		.ascq   = 0x00,
		.errno  = EBADRQC, /* Invalid command operation code */
	},{
	        /* end of list */
	}
};

/* ------------------------------------------------------------------- */

160
static int ch_find_errno(struct scsi_sense_hdr *sshdr)
161 162 163 164
{
	int i,errno = 0;

	/* Check to see if additional sense information is available */
165 166
	if (scsi_sense_valid(sshdr) &&
	    sshdr->asc != 0) {
167 168 169 170 171
		for (i = 0; ch_err[i].errno != 0; i++) {
			if (ch_err[i].sense == sshdr->sense_key &&
			    ch_err[i].asc   == sshdr->asc &&
			    ch_err[i].ascq  == sshdr->ascq) {
				errno = -ch_err[i].errno;
172 173 174 175 176 177 178 179 180 181 182 183 184 185
				break;
			}
		}
	}
	if (errno == 0)
		errno = -EIO;
	return errno;
}

static int
ch_do_scsi(scsi_changer *ch, unsigned char *cmd,
	   void *buffer, unsigned buflength,
	   enum dma_data_direction direction)
{
186 187
	int errno, retries = 0, timeout, result;
	struct scsi_sense_hdr sshdr;
188

189 190 191 192 193 194
	timeout = (cmd[0] == INITIALIZE_ELEMENT_STATUS)
		? timeout_init : timeout_move;

 retry:
	errno = 0;
	if (debug) {
195
		DPRINTK("command: ");
196 197 198
		__scsi_print_command(cmd);
	}

199 200
        result = scsi_execute_req(ch->device, cmd, direction, buffer,
				  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 207
			scsi_print_sense_hdr(ch->name, &sshdr);
		errno = ch_find_errno(&sshdr);
208

209
		switch(sshdr.sense_key) {
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
		case UNIT_ATTENTION:
			ch->unit_attention = 1;
			if (retries++ < 3)
				goto retry;
			break;
		}
	}
	return errno;
}

/* ------------------------------------------------------------------------ */

static int
ch_elem_to_typecode(scsi_changer *ch, u_int elem)
{
	int i;
226

227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
	for (i = 0; i < CH_TYPES; i++) {
		if (elem >= ch->firsts[i]  &&
		    elem <  ch->firsts[i] +
	            ch->counts[i])
			return i+1;
	}
	return 0;
}

static int
ch_read_element_status(scsi_changer *ch, u_int elem, char *data)
{
	u_char  cmd[12];
	u_char  *buffer;
	int     result;
242

243 244 245
	buffer = kmalloc(512, GFP_KERNEL | GFP_DMA);
	if(!buffer)
		return -ENOMEM;
246

247 248 249
 retry:
	memset(cmd,0,sizeof(cmd));
	cmd[0] = READ_ELEMENT_STATUS;
250
	cmd[1] = (ch->device->lun << 5) |
251 252 253 254 255 256 257 258
		(ch->voltags ? 0x10 : 0) |
		ch_elem_to_typecode(ch,elem);
	cmd[2] = (elem >> 8) & 0xff;
	cmd[3] = elem        & 0xff;
	cmd[5] = 1;
	cmd[9] = 255;
	if (0 == (result = ch_do_scsi(ch, cmd, buffer, 256, DMA_FROM_DEVICE))) {
		if (((buffer[16] << 8) | buffer[17]) != elem) {
259
			DPRINTK("asked for element 0x%02x, got 0x%02x\n",
260 261 262 263 264 265 266 267
				elem,(buffer[16] << 8) | buffer[17]);
			kfree(buffer);
			return -EIO;
		}
		memcpy(data,buffer+16,16);
	} else {
		if (ch->voltags) {
			ch->voltags = 0;
268
			VPRINTK(KERN_INFO, "device has no volume tag support\n");
269 270
			goto retry;
		}
271
		DPRINTK("READ ELEMENT STATUS for element 0x%x failed\n",elem);
272 273 274 275 276
	}
	kfree(buffer);
	return result;
}

277
static int
278 279 280 281 282
ch_init_elem(scsi_changer *ch)
{
	int err;
	u_char cmd[6];

283
	VPRINTK(KERN_INFO, "INITIALIZE ELEMENT STATUS, may take some time ...\n");
284 285 286 287
	memset(cmd,0,sizeof(cmd));
	cmd[0] = INITIALIZE_ELEMENT_STATUS;
	cmd[1] = ch->device->lun << 5;
	err = ch_do_scsi(ch, cmd, NULL, 0, DMA_NONE);
288
	VPRINTK(KERN_INFO, "... finished\n");
289 290 291 292 293 294 295 296 297 298 299
	return err;
}

static int
ch_readconfig(scsi_changer *ch)
{
	u_char  cmd[10], data[16];
	u_char  *buffer;
	int     result,id,lun,i;
	u_int   elem;

300
	buffer = kzalloc(512, GFP_KERNEL | GFP_DMA);
301 302
	if (!buffer)
		return -ENOMEM;
303

304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
	memset(cmd,0,sizeof(cmd));
	cmd[0] = MODE_SENSE;
	cmd[1] = ch->device->lun << 5;
	cmd[2] = 0x1d;
	cmd[4] = 255;
	result = ch_do_scsi(ch, cmd, buffer, 255, DMA_FROM_DEVICE);
	if (0 != result) {
		cmd[1] |= (1<<3);
		result  = ch_do_scsi(ch, cmd, buffer, 255, DMA_FROM_DEVICE);
	}
	if (0 == result) {
		ch->firsts[CHET_MT] =
			(buffer[buffer[3]+ 6] << 8) | buffer[buffer[3]+ 7];
		ch->counts[CHET_MT] =
			(buffer[buffer[3]+ 8] << 8) | buffer[buffer[3]+ 9];
		ch->firsts[CHET_ST] =
			(buffer[buffer[3]+10] << 8) | buffer[buffer[3]+11];
		ch->counts[CHET_ST] =
			(buffer[buffer[3]+12] << 8) | buffer[buffer[3]+13];
		ch->firsts[CHET_IE] =
			(buffer[buffer[3]+14] << 8) | buffer[buffer[3]+15];
		ch->counts[CHET_IE] =
			(buffer[buffer[3]+16] << 8) | buffer[buffer[3]+17];
		ch->firsts[CHET_DT] =
			(buffer[buffer[3]+18] << 8) | buffer[buffer[3]+19];
		ch->counts[CHET_DT] =
			(buffer[buffer[3]+20] << 8) | buffer[buffer[3]+21];
331
		VPRINTK(KERN_INFO, "type #1 (mt): 0x%x+%d [medium transport]\n",
332 333
			ch->firsts[CHET_MT],
			ch->counts[CHET_MT]);
334
		VPRINTK(KERN_INFO, "type #2 (st): 0x%x+%d [storage]\n",
335 336
			ch->firsts[CHET_ST],
			ch->counts[CHET_ST]);
337
		VPRINTK(KERN_INFO, "type #3 (ie): 0x%x+%d [import/export]\n",
338 339
			ch->firsts[CHET_IE],
			ch->counts[CHET_IE]);
340
		VPRINTK(KERN_INFO, "type #4 (dt): 0x%x+%d [data transfer]\n",
341 342 343
			ch->firsts[CHET_DT],
			ch->counts[CHET_DT]);
	} else {
344
		VPRINTK(KERN_INFO, "reading element address assigment page failed!\n");
345
	}
346

347 348 349 350 351 352 353 354
	/* vendor specific element types */
	for (i = 0; i < 4; i++) {
		if (0 == vendor_counts[i])
			continue;
		if (NULL == vendor_labels[i])
			continue;
		ch->firsts[CHET_V1+i] = vendor_firsts[i];
		ch->counts[CHET_V1+i] = vendor_counts[i];
355
		VPRINTK(KERN_INFO, "type #%d (v%d): 0x%x+%d [%s, vendor specific]\n",
356 357 358 359 360
			i+5,i+1,vendor_firsts[i],vendor_counts[i],
			vendor_labels[i]);
	}

	/* 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 365 366 367 368

	if (!ch->dt) {
		kfree(buffer);
		return -ENOMEM;
	}

369 370 371 372 373 374
	for (elem = 0; elem < ch->counts[CHET_DT]; elem++) {
		id  = -1;
		lun = 0;
		if (elem < CH_DT_MAX  &&  -1 != dt_id[elem]) {
			id  = dt_id[elem];
			lun = dt_lun[elem];
375
			VPRINTK(KERN_INFO, "dt 0x%x: [insmod option] ",
376 377 378
				elem+ch->firsts[CHET_DT]);
		} else if (0 != ch_read_element_status
			   (ch,elem+ch->firsts[CHET_DT],data)) {
379
			VPRINTK(KERN_INFO, "dt 0x%x: READ ELEMENT STATUS failed\n",
380 381
				elem+ch->firsts[CHET_DT]);
		} 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 386
				ch->dt[elem] = NULL;
			} else if (0 == (data[6] & 0x30)) {
387
				VPRINTK(KERN_CONT, "ID/LUN unknown\n");
388 389 390 391 392 393 394 395 396
				ch->dt[elem] = NULL;
			} else {
				id  = ch->device->id;
				lun = 0;
				if (data[6] & 0x20) id  = data[7];
				if (data[6] & 0x10) lun = data[6] & 7;
			}
		}
		if (-1 != id) {
397
			VPRINTK(KERN_CONT, "ID %i, LUN %i, ",id,lun);
398 399 400 401 402 403
			ch->dt[elem] =
				scsi_device_lookup(ch->device->host,
						   ch->device->channel,
						   id,lun);
			if (!ch->dt[elem]) {
				/* should not happen */
404
				VPRINTK(KERN_CONT, "Huh? device not found!\n");
405
			} else {
406 407 408 409
				VPRINTK(KERN_CONT, "name: %8.8s %16.16s %4.4s\n",
					ch->dt[elem]->vendor,
					ch->dt[elem]->model,
					ch->dt[elem]->rev);
410 411 412 413 414 415 416 417 418 419 420 421 422 423 424
			}
		}
	}
	ch->voltags = 1;
	kfree(buffer);

	return 0;
}

/* ------------------------------------------------------------------------ */

static int
ch_position(scsi_changer *ch, u_int trans, u_int elem, int rotate)
{
	u_char  cmd[10];
425

426
	DPRINTK("position: 0x%x\n",elem);
427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443
	if (0 == trans)
		trans = ch->firsts[CHET_MT];
	memset(cmd,0,sizeof(cmd));
	cmd[0]  = POSITION_TO_ELEMENT;
	cmd[1]  = ch->device->lun << 5;
	cmd[2]  = (trans >> 8) & 0xff;
	cmd[3]  =  trans       & 0xff;
	cmd[4]  = (elem  >> 8) & 0xff;
	cmd[5]  =  elem        & 0xff;
	cmd[8]  = rotate ? 1 : 0;
	return ch_do_scsi(ch, cmd, NULL, 0, DMA_NONE);
}

static int
ch_move(scsi_changer *ch, u_int trans, u_int src, u_int dest, int rotate)
{
	u_char  cmd[12];
444

445
	DPRINTK("move: 0x%x => 0x%x\n",src,dest);
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465
	if (0 == trans)
		trans = ch->firsts[CHET_MT];
	memset(cmd,0,sizeof(cmd));
	cmd[0]  = MOVE_MEDIUM;
	cmd[1]  = ch->device->lun << 5;
	cmd[2]  = (trans >> 8) & 0xff;
	cmd[3]  =  trans       & 0xff;
	cmd[4]  = (src   >> 8) & 0xff;
	cmd[5]  =  src         & 0xff;
	cmd[6]  = (dest  >> 8) & 0xff;
	cmd[7]  =  dest        & 0xff;
	cmd[10] = rotate ? 1 : 0;
	return ch_do_scsi(ch, cmd, NULL,0, DMA_NONE);
}

static int
ch_exchange(scsi_changer *ch, u_int trans, u_int src,
	    u_int dest1, u_int dest2, int rotate1, int rotate2)
{
	u_char  cmd[12];
466

467
	DPRINTK("exchange: 0x%x => 0x%x => 0x%x\n",
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
		src,dest1,dest2);
	if (0 == trans)
		trans = ch->firsts[CHET_MT];
	memset(cmd,0,sizeof(cmd));
	cmd[0]  = EXCHANGE_MEDIUM;
	cmd[1]  = ch->device->lun << 5;
	cmd[2]  = (trans >> 8) & 0xff;
	cmd[3]  =  trans       & 0xff;
	cmd[4]  = (src   >> 8) & 0xff;
	cmd[5]  =  src         & 0xff;
	cmd[6]  = (dest1 >> 8) & 0xff;
	cmd[7]  =  dest1       & 0xff;
	cmd[8]  = (dest2 >> 8) & 0xff;
	cmd[9]  =  dest2       & 0xff;
	cmd[10] = (rotate1 ? 1 : 0) | (rotate2 ? 2 : 0);
483

484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
	return ch_do_scsi(ch, cmd, NULL,0, DMA_NONE);
}

static void
ch_check_voltag(char *tag)
{
	int i;

	for (i = 0; i < 32; i++) {
		/* restrict to ascii */
		if (tag[i] >= 0x7f || tag[i] < 0x20)
			tag[i] = ' ';
		/* don't allow search wildcards */
		if (tag[i] == '?' ||
		    tag[i] == '*')
			tag[i] = ' ';
	}
}

static int
ch_set_voltag(scsi_changer *ch, u_int elem,
	      int alternate, int clear, u_char *tag)
{
	u_char  cmd[12];
	u_char  *buffer;
	int result;

511
	buffer = kzalloc(512, GFP_KERNEL);
512 513 514
	if (!buffer)
		return -ENOMEM;

515
	DPRINTK("%s %s voltag: 0x%x => \"%s\"\n",
516 517 518 519 520
		clear     ? "clear"     : "set",
		alternate ? "alternate" : "primary",
		elem, tag);
	memset(cmd,0,sizeof(cmd));
	cmd[0]  = SEND_VOLUME_TAG;
521
	cmd[1] = (ch->device->lun << 5) |
522 523 524 525 526 527
		ch_elem_to_typecode(ch,elem);
	cmd[2] = (elem >> 8) & 0xff;
	cmd[3] = elem        & 0xff;
	cmd[5] = clear
		? (alternate ? 0x0d : 0x0c)
		: (alternate ? 0x0b : 0x0a);
528

529 530 531 532 533 534 535 536 537 538
	cmd[9] = 255;

	memcpy(buffer,tag,32);
	ch_check_voltag(buffer);

	result = ch_do_scsi(ch, cmd, buffer, 256, DMA_TO_DEVICE);
	kfree(buffer);
	return result;
}

539
static int ch_gstatus(scsi_changer *ch, int type, unsigned char __user *dest)
540 541 542 543
{
	int retval = 0;
	u_char data[16];
	unsigned int i;
544

545
	mutex_lock(&ch->lock);
546 547 548 549 550 551 552 553
	for (i = 0; i < ch->counts[type]; i++) {
		if (0 != ch_read_element_status
		    (ch, ch->firsts[type]+i,data)) {
			retval = -EIO;
			break;
		}
		put_user(data[2], dest+i);
		if (data[2] & CESTATUS_EXCEPT)
554
			VPRINTK(KERN_INFO, "element 0x%x: asc=0x%x, ascq=0x%x\n",
555 556 557 558 559 560 561
				ch->firsts[type]+i,
				(int)data[4],(int)data[5]);
		retval = ch_read_element_status
			(ch, ch->firsts[type]+i,data);
		if (0 != retval)
			break;
	}
562
	mutex_unlock(&ch->lock);
563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
	return retval;
}

/* ------------------------------------------------------------------------ */

static int
ch_release(struct inode *inode, struct file *file)
{
	scsi_changer *ch = file->private_data;

	scsi_device_put(ch->device);
	file->private_data = NULL;
	return 0;
}

static int
ch_open(struct inode *inode, struct file *file)
{
581
	scsi_changer *ch;
582 583
	int minor = iminor(inode);

584
	mutex_lock(&ch_mutex);
585 586 587
	spin_lock(&ch_index_lock);
	ch = idr_find(&ch_index_idr, minor);

588
	if (NULL == ch || scsi_device_get(ch->device)) {
589
		spin_unlock(&ch_index_lock);
590
		mutex_unlock(&ch_mutex);
591 592
		return -ENXIO;
	}
593
	spin_unlock(&ch_index_lock);
594 595

	file->private_data = ch;
596
	mutex_unlock(&ch_mutex);
597 598 599 600 601 602 603 604 605 606 607
	return 0;
}

static int
ch_checkrange(scsi_changer *ch, unsigned int type, unsigned int unit)
{
	if (type >= CH_TYPES  ||  unit >= ch->counts[type])
		return -1;
	return 0;
}

608
static long ch_ioctl(struct file *file,
609 610 611 612
		    unsigned int cmd, unsigned long arg)
{
	scsi_changer *ch = file->private_data;
	int retval;
613
	void __user *argp = (void __user *)arg;
614

615 616 617 618
	switch (cmd) {
	case CHIOGPARAMS:
	{
		struct changer_params params;
619

620 621 622 623 624
		params.cp_curpicker = 0;
		params.cp_npickers  = ch->counts[CHET_MT];
		params.cp_nslots    = ch->counts[CHET_ST];
		params.cp_nportals  = ch->counts[CHET_IE];
		params.cp_ndrives   = ch->counts[CHET_DT];
625

626
		if (copy_to_user(argp, &params, sizeof(params)))
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650
			return -EFAULT;
		return 0;
	}
	case CHIOGVPARAMS:
	{
		struct changer_vendor_params vparams;

		memset(&vparams,0,sizeof(vparams));
		if (ch->counts[CHET_V1]) {
			vparams.cvp_n1  = ch->counts[CHET_V1];
			strncpy(vparams.cvp_label1,vendor_labels[0],16);
		}
		if (ch->counts[CHET_V2]) {
			vparams.cvp_n2  = ch->counts[CHET_V2];
			strncpy(vparams.cvp_label2,vendor_labels[1],16);
		}
		if (ch->counts[CHET_V3]) {
			vparams.cvp_n3  = ch->counts[CHET_V3];
			strncpy(vparams.cvp_label3,vendor_labels[2],16);
		}
		if (ch->counts[CHET_V4]) {
			vparams.cvp_n4  = ch->counts[CHET_V4];
			strncpy(vparams.cvp_label4,vendor_labels[3],16);
		}
651
		if (copy_to_user(argp, &vparams, sizeof(vparams)))
652 653 654
			return -EFAULT;
		return 0;
	}
655

656 657 658
	case CHIOPOSITION:
	{
		struct changer_position pos;
659

660
		if (copy_from_user(&pos, argp, sizeof (pos)))
661 662 663
			return -EFAULT;

		if (0 != ch_checkrange(ch, pos.cp_type, pos.cp_unit)) {
664
			DPRINTK("CHIOPOSITION: invalid parameter\n");
665 666
			return -EBADSLT;
		}
667
		mutex_lock(&ch->lock);
668 669 670
		retval = ch_position(ch,0,
				     ch->firsts[pos.cp_type] + pos.cp_unit,
				     pos.cp_flags & CP_INVERT);
671
		mutex_unlock(&ch->lock);
672 673
		return retval;
	}
674

675 676 677 678
	case CHIOMOVE:
	{
		struct changer_move mv;

679
		if (copy_from_user(&mv, argp, sizeof (mv)))
680 681 682 683
			return -EFAULT;

		if (0 != ch_checkrange(ch, mv.cm_fromtype, mv.cm_fromunit) ||
		    0 != ch_checkrange(ch, mv.cm_totype,   mv.cm_tounit  )) {
684
			DPRINTK("CHIOMOVE: invalid parameter\n");
685 686
			return -EBADSLT;
		}
687

688
		mutex_lock(&ch->lock);
689 690 691 692
		retval = ch_move(ch,0,
				 ch->firsts[mv.cm_fromtype] + mv.cm_fromunit,
				 ch->firsts[mv.cm_totype]   + mv.cm_tounit,
				 mv.cm_flags & CM_INVERT);
693
		mutex_unlock(&ch->lock);
694 695 696 697 698 699
		return retval;
	}

	case CHIOEXCHANGE:
	{
		struct changer_exchange mv;
700

701
		if (copy_from_user(&mv, argp, sizeof (mv)))
702 703 704 705 706
			return -EFAULT;

		if (0 != ch_checkrange(ch, mv.ce_srctype,  mv.ce_srcunit ) ||
		    0 != ch_checkrange(ch, mv.ce_fdsttype, mv.ce_fdstunit) ||
		    0 != ch_checkrange(ch, mv.ce_sdsttype, mv.ce_sdstunit)) {
707
			DPRINTK("CHIOEXCHANGE: invalid parameter\n");
708 709
			return -EBADSLT;
		}
710

711
		mutex_lock(&ch->lock);
712 713 714 715 716 717
		retval = ch_exchange
			(ch,0,
			 ch->firsts[mv.ce_srctype]  + mv.ce_srcunit,
			 ch->firsts[mv.ce_fdsttype] + mv.ce_fdstunit,
			 ch->firsts[mv.ce_sdsttype] + mv.ce_sdstunit,
			 mv.ce_flags & CE_INVERT1, mv.ce_flags & CE_INVERT2);
718
		mutex_unlock(&ch->lock);
719 720 721 722 723 724
		return retval;
	}

	case CHIOGSTATUS:
	{
		struct changer_element_status ces;
725

726
		if (copy_from_user(&ces, argp, sizeof (ces)))
727 728 729 730 731 732 733 734 735 736
			return -EFAULT;
		if (ces.ces_type < 0 || ces.ces_type >= CH_TYPES)
			return -EINVAL;

		return ch_gstatus(ch, ces.ces_type, ces.ces_data);
	}

	case CHIOGELEM:
	{
		struct changer_get_element cge;
737 738
		u_char ch_cmd[12];
		u_char *buffer;
739 740
		unsigned int elem;
		int     result,i;
741

742
		if (copy_from_user(&cge, argp, sizeof (cge)))
743 744 745 746 747
			return -EFAULT;

		if (0 != ch_checkrange(ch, cge.cge_type, cge.cge_unit))
			return -EINVAL;
		elem = ch->firsts[cge.cge_type] + cge.cge_unit;
748

749 750 751
		buffer = kmalloc(512, GFP_KERNEL | GFP_DMA);
		if (!buffer)
			return -ENOMEM;
752
		mutex_lock(&ch->lock);
753

754
	voltag_retry:
755 756 757
		memset(ch_cmd, 0, sizeof(ch_cmd));
		ch_cmd[0] = READ_ELEMENT_STATUS;
		ch_cmd[1] = (ch->device->lun << 5) |
758 759
			(ch->voltags ? 0x10 : 0) |
			ch_elem_to_typecode(ch,elem);
760 761 762 763
		ch_cmd[2] = (elem >> 8) & 0xff;
		ch_cmd[3] = elem        & 0xff;
		ch_cmd[5] = 1;
		ch_cmd[9] = 255;
764

765 766
		result = ch_do_scsi(ch, ch_cmd, buffer, 256, DMA_FROM_DEVICE);
		if (!result) {
767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799
			cge.cge_status = buffer[18];
			cge.cge_flags = 0;
			if (buffer[18] & CESTATUS_EXCEPT) {
				cge.cge_errno = EIO;
			}
			if (buffer[25] & 0x80) {
				cge.cge_flags |= CGE_SRC;
				if (buffer[25] & 0x40)
					cge.cge_flags |= CGE_INVERT;
				elem = (buffer[26]<<8) | buffer[27];
				for (i = 0; i < 4; i++) {
					if (elem >= ch->firsts[i] &&
					    elem <  ch->firsts[i] + ch->counts[i]) {
						cge.cge_srctype = i;
						cge.cge_srcunit = elem-ch->firsts[i];
					}
				}
			}
			if ((buffer[22] & 0x30) == 0x30) {
				cge.cge_flags |= CGE_IDLUN;
				cge.cge_id  = buffer[23];
				cge.cge_lun = buffer[22] & 7;
			}
			if (buffer[9] & 0x80) {
				cge.cge_flags |= CGE_PVOLTAG;
				memcpy(cge.cge_pvoltag,buffer+28,36);
			}
			if (buffer[9] & 0x40) {
				cge.cge_flags |= CGE_AVOLTAG;
				memcpy(cge.cge_avoltag,buffer+64,36);
			}
		} else if (ch->voltags) {
			ch->voltags = 0;
800
			VPRINTK(KERN_INFO, "device has no volume tag support\n");
801 802 803
			goto voltag_retry;
		}
		kfree(buffer);
804
		mutex_unlock(&ch->lock);
805

806
		if (copy_to_user(argp, &cge, sizeof (cge)))
807 808 809 810 811 812
			return -EFAULT;
		return result;
	}

	case CHIOINITELEM:
	{
813
		mutex_lock(&ch->lock);
814
		retval = ch_init_elem(ch);
815
		mutex_unlock(&ch->lock);
816 817
		return retval;
	}
818

819 820 821 822 823
	case CHIOSVOLTAG:
	{
		struct changer_set_voltag csv;
		int elem;

824
		if (copy_from_user(&csv, argp, sizeof(csv)))
825 826 827
			return -EFAULT;

		if (0 != ch_checkrange(ch, csv.csv_type, csv.csv_unit)) {
828
			DPRINTK("CHIOSVOLTAG: invalid parameter\n");
829 830 831
			return -EBADSLT;
		}
		elem = ch->firsts[csv.csv_type] + csv.csv_unit;
832
		mutex_lock(&ch->lock);
833 834 835 836
		retval = ch_set_voltag(ch, elem,
				       csv.csv_flags & CSV_AVOLTAG,
				       csv.csv_flags & CSV_CLEARTAG,
				       csv.csv_voltag);
837
		mutex_unlock(&ch->lock);
838 839 840 841
		return retval;
	}

	default:
842
		return scsi_ioctl(ch->device, cmd, argp);
843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858

	}
}

#ifdef CONFIG_COMPAT

struct changer_element_status32 {
	int		ces_type;
	compat_uptr_t	ces_data;
};
#define CHIOGSTATUS32  _IOW('c', 8,struct changer_element_status32)

static long ch_ioctl_compat(struct file * file,
			    unsigned int cmd, unsigned long arg)
{
	scsi_changer *ch = file->private_data;
859

860 861 862 863 864 865 866 867 868 869
	switch (cmd) {
	case CHIOGPARAMS:
	case CHIOGVPARAMS:
	case CHIOPOSITION:
	case CHIOMOVE:
	case CHIOEXCHANGE:
	case CHIOGELEM:
	case CHIOINITELEM:
	case CHIOSVOLTAG:
		/* compatible */
870
		return ch_ioctl(file, cmd, arg);
871 872 873
	case CHIOGSTATUS32:
	{
		struct changer_element_status32 ces32;
874
		unsigned char __user *data;
875

876
		if (copy_from_user(&ces32, (void __user *)arg, sizeof (ces32)))
877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896
			return -EFAULT;
		if (ces32.ces_type < 0 || ces32.ces_type >= CH_TYPES)
			return -EINVAL;

		data = compat_ptr(ces32.ces_data);
		return ch_gstatus(ch, ces32.ces_type, data);
	}
	default:
		// return scsi_ioctl_compat(ch->device, cmd, (void*)arg);
		return -ENOIOCTLCMD;

	}
}
#endif

/* ------------------------------------------------------------------------ */

static int ch_probe(struct device *dev)
{
	struct scsi_device *sd = to_scsi_device(dev);
897
	struct device *class_dev;
Tejun Heo's avatar
Tejun Heo committed
898
	int ret;
899
	scsi_changer *ch;
900

901 902
	if (sd->type != TYPE_MEDIUM_CHANGER)
		return -ENODEV;
903

904
	ch = kzalloc(sizeof(*ch), GFP_KERNEL);
905 906 907
	if (NULL == ch)
		return -ENOMEM;

Tejun Heo's avatar
Tejun Heo committed
908
	idr_preload(GFP_KERNEL);
909
	spin_lock(&ch_index_lock);
Tejun Heo's avatar
Tejun Heo committed
910
	ret = idr_alloc(&ch_index_idr, ch, 0, CH_MAX_DEVS + 1, GFP_NOWAIT);
911
	spin_unlock(&ch_index_lock);
Tejun Heo's avatar
Tejun Heo committed
912
	idr_preload_end();
913

Tejun Heo's avatar
Tejun Heo committed
914 915 916
	if (ret < 0) {
		if (ret == -ENOSPC)
			ret = -ENODEV;
917 918 919
		goto free_ch;
	}

Tejun Heo's avatar
Tejun Heo committed
920
	ch->minor = ret;
921
	sprintf(ch->name,"ch%d",ch->minor);
922

923 924 925
	class_dev = device_create(ch_sysfs_class, dev,
				  MKDEV(SCSI_CHANGER_MAJOR, ch->minor), ch,
				  "s%s", ch->name);
926
	if (IS_ERR(class_dev)) {
927
		printk(KERN_WARNING "ch%d: device_create failed\n",
928
		       ch->minor);
929 930
		ret = PTR_ERR(class_dev);
		goto remove_idr;
931 932
	}

933
	mutex_init(&ch->lock);
934 935 936 937 938
	ch->device = sd;
	ch_readconfig(ch);
	if (init)
		ch_init_elem(ch);

939
	dev_set_drvdata(dev, ch);
940
	sdev_printk(KERN_INFO, sd, "Attached scsi changer %s\n", ch->name);
941

942
	return 0;
943
remove_idr:
Tejun Heo's avatar
Tejun Heo committed
944
	idr_remove(&ch_index_idr, ch->minor);
945 946 947
free_ch:
	kfree(ch);
	return ret;
948 949 950 951
}

static int ch_remove(struct device *dev)
{
952
	scsi_changer *ch = dev_get_drvdata(dev);
953

954 955 956
	spin_lock(&ch_index_lock);
	idr_remove(&ch_index_idr, ch->minor);
	spin_unlock(&ch_index_lock);
957

958
	device_destroy(ch_sysfs_class, MKDEV(SCSI_CHANGER_MAJOR,ch->minor));
959 960 961 962 963
	kfree(ch->dt);
	kfree(ch);
	return 0;
}

964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980
static struct scsi_driver ch_template = {
	.owner     	= THIS_MODULE,
	.gendrv     	= {
		.name	= "ch",
		.probe  = ch_probe,
		.remove = ch_remove,
	},
};

static const struct file_operations changer_fops = {
	.owner		= THIS_MODULE,
	.open		= ch_open,
	.release	= ch_release,
	.unlocked_ioctl	= ch_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= ch_ioctl_compat,
#endif
981
	.llseek		= noop_llseek,
982 983
};

984 985 986
static int __init init_ch_module(void)
{
	int rc;
987

988
	printk(KERN_INFO "SCSI Media Changer driver v" VERSION " \n");
989
        ch_sysfs_class = class_create(THIS_MODULE, "scsi_changer");
990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
        if (IS_ERR(ch_sysfs_class)) {
		rc = PTR_ERR(ch_sysfs_class);
		return rc;
        }
	rc = register_chrdev(SCSI_CHANGER_MAJOR,"ch",&changer_fops);
	if (rc < 0) {
		printk("Unable to get major %d for SCSI-Changer\n",
		       SCSI_CHANGER_MAJOR);
		goto fail1;
	}
	rc = scsi_register_driver(&ch_template.gendrv);
	if (rc < 0)
		goto fail2;
	return 0;

 fail2:
	unregister_chrdev(SCSI_CHANGER_MAJOR, "ch");
 fail1:
1008
	class_destroy(ch_sysfs_class);
1009 1010 1011
	return rc;
}

1012
static void __exit exit_ch_module(void)
1013 1014 1015
{
	scsi_unregister_driver(&ch_template.gendrv);
	unregister_chrdev(SCSI_CHANGER_MAJOR, "ch");
1016
	class_destroy(ch_sysfs_class);
1017
	idr_destroy(&ch_index_idr);
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
}

module_init(init_ch_module);
module_exit(exit_ch_module);

/*
 * Local variables:
 * c-basic-offset: 8
 * End:
 */