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