]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* -*- linux-c -*- |
2 | * drivers/char/viotape.c | |
3 | * | |
4 | * iSeries Virtual Tape | |
5 | * | |
6 | * Authors: Dave Boutcher <boutcher@us.ibm.com> | |
7 | * Ryan Arnold <ryanarn@us.ibm.com> | |
8 | * Colin Devilbiss <devilbis@us.ibm.com> | |
8962cadb | 9 | * Stephen Rothwell |
1da177e4 LT |
10 | * |
11 | * (C) Copyright 2000-2004 IBM Corporation | |
12 | * | |
13 | * This program is free software; you can redistribute it and/or | |
14 | * modify it under the terms of the GNU General Public License as | |
15 | * published by the Free Software Foundation; either version 2 of the | |
16 | * License, or (at your option) anyu later version. | |
17 | * | |
18 | * This program is distributed in the hope that it will be useful, but | |
19 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
21 | * General Public License for more details. | |
22 | * | |
23 | * You should have received a copy of the GNU General Public License | |
24 | * along with this program; if not, write to the Free Software Foundation, | |
25 | * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
26 | * | |
27 | * This routine provides access to tape drives owned and managed by an OS/400 | |
28 | * partition running on the same box as this Linux partition. | |
29 | * | |
30 | * All tape operations are performed by sending messages back and forth to | |
31 | * the OS/400 partition. The format of the messages is defined in | |
b4206778 | 32 | * iseries/vio.h |
1da177e4 | 33 | */ |
1da177e4 LT |
34 | #include <linux/module.h> |
35 | #include <linux/kernel.h> | |
36 | #include <linux/errno.h> | |
37 | #include <linux/init.h> | |
38 | #include <linux/wait.h> | |
39 | #include <linux/spinlock.h> | |
40 | #include <linux/mtio.h> | |
41 | #include <linux/device.h> | |
42 | #include <linux/dma-mapping.h> | |
43 | #include <linux/fs.h> | |
44 | #include <linux/cdev.h> | |
1da177e4 LT |
45 | #include <linux/major.h> |
46 | #include <linux/completion.h> | |
47 | #include <linux/proc_fs.h> | |
48 | #include <linux/seq_file.h> | |
613655fa | 49 | #include <linux/mutex.h> |
5a0e3ad6 | 50 | #include <linux/slab.h> |
1da177e4 LT |
51 | |
52 | #include <asm/uaccess.h> | |
53 | #include <asm/ioctls.h> | |
fd38451f | 54 | #include <asm/firmware.h> |
1da177e4 | 55 | #include <asm/vio.h> |
b4206778 | 56 | #include <asm/iseries/vio.h> |
e45423ea | 57 | #include <asm/iseries/hv_lp_event.h> |
c0a8d05c | 58 | #include <asm/iseries/hv_call_event.h> |
15b17189 | 59 | #include <asm/iseries/hv_lp_config.h> |
1da177e4 LT |
60 | |
61 | #define VIOTAPE_VERSION "1.2" | |
62 | #define VIOTAPE_MAXREQ 1 | |
63 | ||
64 | #define VIOTAPE_KERN_WARN KERN_WARNING "viotape: " | |
65 | #define VIOTAPE_KERN_INFO KERN_INFO "viotape: " | |
66 | ||
613655fa | 67 | static DEFINE_MUTEX(proc_viotape_mutex); |
1da177e4 LT |
68 | static int viotape_numdev; |
69 | ||
70 | /* | |
71 | * The minor number follows the conventions of the SCSI tape drives. The | |
72 | * rewind and mode are encoded in the minor #. We use this struct to break | |
73 | * them out | |
74 | */ | |
75 | struct viot_devinfo_struct { | |
76 | int devno; | |
77 | int mode; | |
78 | int rewind; | |
79 | }; | |
80 | ||
81 | #define VIOTAPOP_RESET 0 | |
82 | #define VIOTAPOP_FSF 1 | |
83 | #define VIOTAPOP_BSF 2 | |
84 | #define VIOTAPOP_FSR 3 | |
85 | #define VIOTAPOP_BSR 4 | |
86 | #define VIOTAPOP_WEOF 5 | |
87 | #define VIOTAPOP_REW 6 | |
88 | #define VIOTAPOP_NOP 7 | |
89 | #define VIOTAPOP_EOM 8 | |
90 | #define VIOTAPOP_ERASE 9 | |
91 | #define VIOTAPOP_SETBLK 10 | |
92 | #define VIOTAPOP_SETDENSITY 11 | |
93 | #define VIOTAPOP_SETPOS 12 | |
94 | #define VIOTAPOP_GETPOS 13 | |
95 | #define VIOTAPOP_SETPART 14 | |
96 | #define VIOTAPOP_UNLOAD 15 | |
97 | ||
1da177e4 LT |
98 | enum viotaperc { |
99 | viotape_InvalidRange = 0x0601, | |
100 | viotape_InvalidToken = 0x0602, | |
101 | viotape_DMAError = 0x0603, | |
102 | viotape_UseError = 0x0604, | |
103 | viotape_ReleaseError = 0x0605, | |
104 | viotape_InvalidTape = 0x0606, | |
105 | viotape_InvalidOp = 0x0607, | |
106 | viotape_TapeErr = 0x0608, | |
107 | ||
108 | viotape_AllocTimedOut = 0x0640, | |
109 | viotape_BOTEnc = 0x0641, | |
110 | viotape_BlankTape = 0x0642, | |
111 | viotape_BufferEmpty = 0x0643, | |
112 | viotape_CleanCartFound = 0x0644, | |
113 | viotape_CmdNotAllowed = 0x0645, | |
114 | viotape_CmdNotSupported = 0x0646, | |
115 | viotape_DataCheck = 0x0647, | |
116 | viotape_DecompressErr = 0x0648, | |
117 | viotape_DeviceTimeout = 0x0649, | |
118 | viotape_DeviceUnavail = 0x064a, | |
119 | viotape_DeviceBusy = 0x064b, | |
120 | viotape_EndOfMedia = 0x064c, | |
121 | viotape_EndOfTape = 0x064d, | |
122 | viotape_EquipCheck = 0x064e, | |
123 | viotape_InsufficientRs = 0x064f, | |
124 | viotape_InvalidLogBlk = 0x0650, | |
125 | viotape_LengthError = 0x0651, | |
126 | viotape_LibDoorOpen = 0x0652, | |
127 | viotape_LoadFailure = 0x0653, | |
128 | viotape_NotCapable = 0x0654, | |
129 | viotape_NotOperational = 0x0655, | |
130 | viotape_NotReady = 0x0656, | |
131 | viotape_OpCancelled = 0x0657, | |
132 | viotape_PhyLinkErr = 0x0658, | |
133 | viotape_RdyNotBOT = 0x0659, | |
134 | viotape_TapeMark = 0x065a, | |
135 | viotape_WriteProt = 0x065b | |
136 | }; | |
137 | ||
138 | static const struct vio_error_entry viotape_err_table[] = { | |
139 | { viotape_InvalidRange, EIO, "Internal error" }, | |
140 | { viotape_InvalidToken, EIO, "Internal error" }, | |
141 | { viotape_DMAError, EIO, "DMA error" }, | |
142 | { viotape_UseError, EIO, "Internal error" }, | |
143 | { viotape_ReleaseError, EIO, "Internal error" }, | |
144 | { viotape_InvalidTape, EIO, "Invalid tape device" }, | |
145 | { viotape_InvalidOp, EIO, "Invalid operation" }, | |
146 | { viotape_TapeErr, EIO, "Tape error" }, | |
147 | { viotape_AllocTimedOut, EBUSY, "Allocate timed out" }, | |
148 | { viotape_BOTEnc, EIO, "Beginning of tape encountered" }, | |
149 | { viotape_BlankTape, EIO, "Blank tape" }, | |
150 | { viotape_BufferEmpty, EIO, "Buffer empty" }, | |
151 | { viotape_CleanCartFound, ENOMEDIUM, "Cleaning cartridge found" }, | |
152 | { viotape_CmdNotAllowed, EIO, "Command not allowed" }, | |
153 | { viotape_CmdNotSupported, EIO, "Command not supported" }, | |
154 | { viotape_DataCheck, EIO, "Data check" }, | |
155 | { viotape_DecompressErr, EIO, "Decompression error" }, | |
156 | { viotape_DeviceTimeout, EBUSY, "Device timeout" }, | |
157 | { viotape_DeviceUnavail, EIO, "Device unavailable" }, | |
158 | { viotape_DeviceBusy, EBUSY, "Device busy" }, | |
159 | { viotape_EndOfMedia, ENOSPC, "End of media" }, | |
160 | { viotape_EndOfTape, ENOSPC, "End of tape" }, | |
161 | { viotape_EquipCheck, EIO, "Equipment check" }, | |
162 | { viotape_InsufficientRs, EOVERFLOW, "Insufficient tape resources" }, | |
163 | { viotape_InvalidLogBlk, EIO, "Invalid logical block location" }, | |
164 | { viotape_LengthError, EOVERFLOW, "Length error" }, | |
165 | { viotape_LibDoorOpen, EBUSY, "Door open" }, | |
166 | { viotape_LoadFailure, ENOMEDIUM, "Load failure" }, | |
167 | { viotape_NotCapable, EIO, "Not capable" }, | |
168 | { viotape_NotOperational, EIO, "Not operational" }, | |
169 | { viotape_NotReady, EIO, "Not ready" }, | |
170 | { viotape_OpCancelled, EIO, "Operation cancelled" }, | |
171 | { viotape_PhyLinkErr, EIO, "Physical link error" }, | |
172 | { viotape_RdyNotBOT, EIO, "Ready but not beginning of tape" }, | |
173 | { viotape_TapeMark, EIO, "Tape mark" }, | |
174 | { viotape_WriteProt, EROFS, "Write protection error" }, | |
175 | { 0, 0, NULL }, | |
176 | }; | |
177 | ||
178 | /* Maximum number of tapes we support */ | |
179 | #define VIOTAPE_MAX_TAPE HVMAXARCHITECTEDVIRTUALTAPES | |
180 | #define MAX_PARTITIONS 4 | |
181 | ||
182 | /* defines for current tape state */ | |
183 | #define VIOT_IDLE 0 | |
184 | #define VIOT_READING 1 | |
185 | #define VIOT_WRITING 2 | |
186 | ||
187 | /* Our info on the tapes */ | |
7465ce0d SR |
188 | static struct { |
189 | const char *rsrcname; | |
190 | const char *type; | |
191 | const char *model; | |
192 | } viotape_unitinfo[VIOTAPE_MAX_TAPE]; | |
1da177e4 LT |
193 | |
194 | static struct mtget viomtget[VIOTAPE_MAX_TAPE]; | |
195 | ||
ca8eca68 | 196 | static struct class *tape_class; |
1da177e4 LT |
197 | |
198 | static struct device *tape_device[VIOTAPE_MAX_TAPE]; | |
199 | ||
200 | /* | |
201 | * maintain the current state of each tape (and partition) | |
202 | * so that we know when to write EOF marks. | |
203 | */ | |
204 | static struct { | |
205 | unsigned char cur_part; | |
1da177e4 LT |
206 | unsigned char part_stat_rwi[MAX_PARTITIONS]; |
207 | } state[VIOTAPE_MAX_TAPE]; | |
208 | ||
209 | /* We single-thread */ | |
210 | static struct semaphore reqSem; | |
211 | ||
212 | /* | |
213 | * When we send a request, we use this struct to get the response back | |
214 | * from the interrupt handler | |
215 | */ | |
216 | struct op_struct { | |
217 | void *buffer; | |
218 | dma_addr_t dmaaddr; | |
219 | size_t count; | |
220 | int rc; | |
221 | int non_blocking; | |
222 | struct completion com; | |
223 | struct device *dev; | |
224 | struct op_struct *next; | |
225 | }; | |
226 | ||
227 | static spinlock_t op_struct_list_lock; | |
228 | static struct op_struct *op_struct_list; | |
229 | ||
230 | /* forward declaration to resolve interdependence */ | |
231 | static int chg_state(int index, unsigned char new_state, struct file *file); | |
232 | ||
233 | /* procfs support */ | |
234 | static int proc_viotape_show(struct seq_file *m, void *v) | |
235 | { | |
236 | int i; | |
237 | ||
238 | seq_printf(m, "viotape driver version " VIOTAPE_VERSION "\n"); | |
239 | for (i = 0; i < viotape_numdev; i++) { | |
240 | seq_printf(m, "viotape device %d is iSeries resource %10.10s" | |
241 | "type %4.4s, model %3.3s\n", | |
242 | i, viotape_unitinfo[i].rsrcname, | |
243 | viotape_unitinfo[i].type, | |
244 | viotape_unitinfo[i].model); | |
245 | } | |
246 | return 0; | |
247 | } | |
248 | ||
249 | static int proc_viotape_open(struct inode *inode, struct file *file) | |
250 | { | |
251 | return single_open(file, proc_viotape_show, NULL); | |
252 | } | |
253 | ||
62322d25 | 254 | static const struct file_operations proc_viotape_operations = { |
1b502217 | 255 | .owner = THIS_MODULE, |
1da177e4 LT |
256 | .open = proc_viotape_open, |
257 | .read = seq_read, | |
258 | .llseek = seq_lseek, | |
259 | .release = single_release, | |
260 | }; | |
261 | ||
262 | /* Decode the device minor number into its parts */ | |
263 | void get_dev_info(struct inode *ino, struct viot_devinfo_struct *devi) | |
264 | { | |
265 | devi->devno = iminor(ino) & 0x1F; | |
266 | devi->mode = (iminor(ino) & 0x60) >> 5; | |
267 | /* if bit is set in the minor, do _not_ rewind automatically */ | |
268 | devi->rewind = (iminor(ino) & 0x80) == 0; | |
269 | } | |
270 | ||
271 | /* This is called only from the exit and init paths, so no need for locking */ | |
272 | static void clear_op_struct_pool(void) | |
273 | { | |
274 | while (op_struct_list) { | |
275 | struct op_struct *toFree = op_struct_list; | |
276 | op_struct_list = op_struct_list->next; | |
277 | kfree(toFree); | |
278 | } | |
279 | } | |
280 | ||
281 | /* Likewise, this is only called from the init path */ | |
282 | static int add_op_structs(int structs) | |
283 | { | |
284 | int i; | |
285 | ||
286 | for (i = 0; i < structs; ++i) { | |
287 | struct op_struct *new_struct = | |
288 | kmalloc(sizeof(*new_struct), GFP_KERNEL); | |
289 | if (!new_struct) { | |
290 | clear_op_struct_pool(); | |
291 | return -ENOMEM; | |
292 | } | |
293 | new_struct->next = op_struct_list; | |
294 | op_struct_list = new_struct; | |
295 | } | |
296 | return 0; | |
297 | } | |
298 | ||
299 | /* Allocate an op structure from our pool */ | |
300 | static struct op_struct *get_op_struct(void) | |
301 | { | |
302 | struct op_struct *retval; | |
303 | unsigned long flags; | |
304 | ||
305 | spin_lock_irqsave(&op_struct_list_lock, flags); | |
306 | retval = op_struct_list; | |
307 | if (retval) | |
308 | op_struct_list = retval->next; | |
309 | spin_unlock_irqrestore(&op_struct_list_lock, flags); | |
310 | if (retval) { | |
311 | memset(retval, 0, sizeof(*retval)); | |
312 | init_completion(&retval->com); | |
313 | } | |
314 | ||
315 | return retval; | |
316 | } | |
317 | ||
318 | /* Return an op structure to our pool */ | |
319 | static void free_op_struct(struct op_struct *op_struct) | |
320 | { | |
321 | unsigned long flags; | |
322 | ||
323 | spin_lock_irqsave(&op_struct_list_lock, flags); | |
324 | op_struct->next = op_struct_list; | |
325 | op_struct_list = op_struct; | |
326 | spin_unlock_irqrestore(&op_struct_list_lock, flags); | |
327 | } | |
328 | ||
329 | /* Map our tape return codes to errno values */ | |
330 | int tape_rc_to_errno(int tape_rc, char *operation, int tapeno) | |
331 | { | |
332 | const struct vio_error_entry *err; | |
333 | ||
334 | if (tape_rc == 0) | |
335 | return 0; | |
336 | ||
337 | err = vio_lookup_rc(viotape_err_table, tape_rc); | |
338 | printk(VIOTAPE_KERN_WARN "error(%s) 0x%04x on Device %d (%-10s): %s\n", | |
339 | operation, tape_rc, tapeno, | |
340 | viotape_unitinfo[tapeno].rsrcname, err->msg); | |
341 | return -err->errno; | |
342 | } | |
343 | ||
1da177e4 LT |
344 | /* Write */ |
345 | static ssize_t viotap_write(struct file *file, const char *buf, | |
346 | size_t count, loff_t * ppos) | |
347 | { | |
348 | HvLpEvent_Rc hvrc; | |
349 | unsigned short flags = file->f_flags; | |
350 | int noblock = ((flags & O_NONBLOCK) != 0); | |
351 | ssize_t ret; | |
352 | struct viot_devinfo_struct devi; | |
353 | struct op_struct *op = get_op_struct(); | |
354 | ||
355 | if (op == NULL) | |
356 | return -ENOMEM; | |
357 | ||
a7113a96 | 358 | get_dev_info(file->f_path.dentry->d_inode, &devi); |
1da177e4 LT |
359 | |
360 | /* | |
361 | * We need to make sure we can send a request. We use | |
362 | * a semaphore to keep track of # requests in use. If | |
363 | * we are non-blocking, make sure we don't block on the | |
364 | * semaphore | |
365 | */ | |
366 | if (noblock) { | |
367 | if (down_trylock(&reqSem)) { | |
368 | ret = -EWOULDBLOCK; | |
369 | goto free_op; | |
370 | } | |
371 | } else | |
372 | down(&reqSem); | |
373 | ||
374 | /* Allocate a DMA buffer */ | |
375 | op->dev = tape_device[devi.devno]; | |
376 | op->buffer = dma_alloc_coherent(op->dev, count, &op->dmaaddr, | |
377 | GFP_ATOMIC); | |
378 | ||
379 | if (op->buffer == NULL) { | |
380 | printk(VIOTAPE_KERN_WARN | |
381 | "error allocating dma buffer for len %ld\n", | |
382 | count); | |
383 | ret = -EFAULT; | |
384 | goto up_sem; | |
385 | } | |
386 | ||
387 | /* Copy the data into the buffer */ | |
388 | if (copy_from_user(op->buffer, buf, count)) { | |
389 | printk(VIOTAPE_KERN_WARN "tape: error on copy from user\n"); | |
390 | ret = -EFAULT; | |
391 | goto free_dma; | |
392 | } | |
393 | ||
394 | op->non_blocking = noblock; | |
395 | init_completion(&op->com); | |
396 | op->count = count; | |
397 | ||
398 | hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp, | |
399 | HvLpEvent_Type_VirtualIo, | |
400 | viomajorsubtype_tape | viotapewrite, | |
401 | HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck, | |
402 | viopath_sourceinst(viopath_hostLp), | |
403 | viopath_targetinst(viopath_hostLp), | |
404 | (u64)(unsigned long)op, VIOVERSION << 16, | |
405 | ((u64)devi.devno << 48) | op->dmaaddr, count, 0, 0); | |
406 | if (hvrc != HvLpEvent_Rc_Good) { | |
407 | printk(VIOTAPE_KERN_WARN "hv error on op %d\n", | |
408 | (int)hvrc); | |
409 | ret = -EIO; | |
410 | goto free_dma; | |
411 | } | |
412 | ||
413 | if (noblock) | |
414 | return count; | |
415 | ||
416 | wait_for_completion(&op->com); | |
417 | ||
418 | if (op->rc) | |
419 | ret = tape_rc_to_errno(op->rc, "write", devi.devno); | |
420 | else { | |
421 | chg_state(devi.devno, VIOT_WRITING, file); | |
422 | ret = op->count; | |
423 | } | |
424 | ||
425 | free_dma: | |
426 | dma_free_coherent(op->dev, count, op->buffer, op->dmaaddr); | |
427 | up_sem: | |
428 | up(&reqSem); | |
429 | free_op: | |
430 | free_op_struct(op); | |
431 | return ret; | |
432 | } | |
433 | ||
434 | /* read */ | |
435 | static ssize_t viotap_read(struct file *file, char *buf, size_t count, | |
436 | loff_t *ptr) | |
437 | { | |
438 | HvLpEvent_Rc hvrc; | |
439 | unsigned short flags = file->f_flags; | |
440 | struct op_struct *op = get_op_struct(); | |
441 | int noblock = ((flags & O_NONBLOCK) != 0); | |
442 | ssize_t ret; | |
443 | struct viot_devinfo_struct devi; | |
444 | ||
445 | if (op == NULL) | |
446 | return -ENOMEM; | |
447 | ||
a7113a96 | 448 | get_dev_info(file->f_path.dentry->d_inode, &devi); |
1da177e4 LT |
449 | |
450 | /* | |
451 | * We need to make sure we can send a request. We use | |
452 | * a semaphore to keep track of # requests in use. If | |
453 | * we are non-blocking, make sure we don't block on the | |
454 | * semaphore | |
455 | */ | |
456 | if (noblock) { | |
457 | if (down_trylock(&reqSem)) { | |
458 | ret = -EWOULDBLOCK; | |
459 | goto free_op; | |
460 | } | |
461 | } else | |
462 | down(&reqSem); | |
463 | ||
464 | chg_state(devi.devno, VIOT_READING, file); | |
465 | ||
466 | /* Allocate a DMA buffer */ | |
467 | op->dev = tape_device[devi.devno]; | |
468 | op->buffer = dma_alloc_coherent(op->dev, count, &op->dmaaddr, | |
469 | GFP_ATOMIC); | |
470 | if (op->buffer == NULL) { | |
471 | ret = -EFAULT; | |
472 | goto up_sem; | |
473 | } | |
474 | ||
475 | op->count = count; | |
476 | init_completion(&op->com); | |
477 | ||
478 | hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp, | |
479 | HvLpEvent_Type_VirtualIo, | |
480 | viomajorsubtype_tape | viotaperead, | |
481 | HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck, | |
482 | viopath_sourceinst(viopath_hostLp), | |
483 | viopath_targetinst(viopath_hostLp), | |
484 | (u64)(unsigned long)op, VIOVERSION << 16, | |
485 | ((u64)devi.devno << 48) | op->dmaaddr, count, 0, 0); | |
486 | if (hvrc != HvLpEvent_Rc_Good) { | |
487 | printk(VIOTAPE_KERN_WARN "tape hv error on op %d\n", | |
488 | (int)hvrc); | |
489 | ret = -EIO; | |
490 | goto free_dma; | |
491 | } | |
492 | ||
493 | wait_for_completion(&op->com); | |
494 | ||
495 | if (op->rc) | |
496 | ret = tape_rc_to_errno(op->rc, "read", devi.devno); | |
497 | else { | |
498 | ret = op->count; | |
499 | if (ret && copy_to_user(buf, op->buffer, ret)) { | |
500 | printk(VIOTAPE_KERN_WARN "error on copy_to_user\n"); | |
501 | ret = -EFAULT; | |
502 | } | |
503 | } | |
504 | ||
505 | free_dma: | |
506 | dma_free_coherent(op->dev, count, op->buffer, op->dmaaddr); | |
507 | up_sem: | |
508 | up(&reqSem); | |
509 | free_op: | |
510 | free_op_struct(op); | |
511 | return ret; | |
512 | } | |
513 | ||
514 | /* ioctl */ | |
515 | static int viotap_ioctl(struct inode *inode, struct file *file, | |
516 | unsigned int cmd, unsigned long arg) | |
517 | { | |
518 | HvLpEvent_Rc hvrc; | |
519 | int ret; | |
520 | struct viot_devinfo_struct devi; | |
521 | struct mtop mtc; | |
522 | u32 myOp; | |
523 | struct op_struct *op = get_op_struct(); | |
524 | ||
525 | if (op == NULL) | |
526 | return -ENOMEM; | |
527 | ||
a7113a96 | 528 | get_dev_info(file->f_path.dentry->d_inode, &devi); |
1da177e4 LT |
529 | |
530 | down(&reqSem); | |
531 | ||
532 | ret = -EINVAL; | |
533 | ||
534 | switch (cmd) { | |
535 | case MTIOCTOP: | |
536 | ret = -EFAULT; | |
537 | /* | |
538 | * inode is null if and only if we (the kernel) | |
539 | * made the request | |
540 | */ | |
541 | if (inode == NULL) | |
542 | memcpy(&mtc, (void *) arg, sizeof(struct mtop)); | |
543 | else if (copy_from_user((char *)&mtc, (char *)arg, | |
544 | sizeof(struct mtop))) | |
545 | goto free_op; | |
546 | ||
547 | ret = -EIO; | |
548 | switch (mtc.mt_op) { | |
549 | case MTRESET: | |
550 | myOp = VIOTAPOP_RESET; | |
551 | break; | |
552 | case MTFSF: | |
553 | myOp = VIOTAPOP_FSF; | |
554 | break; | |
555 | case MTBSF: | |
556 | myOp = VIOTAPOP_BSF; | |
557 | break; | |
558 | case MTFSR: | |
559 | myOp = VIOTAPOP_FSR; | |
560 | break; | |
561 | case MTBSR: | |
562 | myOp = VIOTAPOP_BSR; | |
563 | break; | |
564 | case MTWEOF: | |
565 | myOp = VIOTAPOP_WEOF; | |
566 | break; | |
567 | case MTREW: | |
568 | myOp = VIOTAPOP_REW; | |
569 | break; | |
570 | case MTNOP: | |
571 | myOp = VIOTAPOP_NOP; | |
572 | break; | |
573 | case MTEOM: | |
574 | myOp = VIOTAPOP_EOM; | |
575 | break; | |
576 | case MTERASE: | |
577 | myOp = VIOTAPOP_ERASE; | |
578 | break; | |
579 | case MTSETBLK: | |
580 | myOp = VIOTAPOP_SETBLK; | |
581 | break; | |
582 | case MTSETDENSITY: | |
583 | myOp = VIOTAPOP_SETDENSITY; | |
584 | break; | |
585 | case MTTELL: | |
586 | myOp = VIOTAPOP_GETPOS; | |
587 | break; | |
588 | case MTSEEK: | |
589 | myOp = VIOTAPOP_SETPOS; | |
590 | break; | |
591 | case MTSETPART: | |
592 | myOp = VIOTAPOP_SETPART; | |
593 | break; | |
594 | case MTOFFL: | |
595 | myOp = VIOTAPOP_UNLOAD; | |
596 | break; | |
597 | default: | |
598 | printk(VIOTAPE_KERN_WARN "MTIOCTOP called " | |
599 | "with invalid op 0x%x\n", mtc.mt_op); | |
600 | goto free_op; | |
601 | } | |
602 | ||
603 | /* | |
604 | * if we moved the head, we are no longer | |
605 | * reading or writing | |
606 | */ | |
607 | switch (mtc.mt_op) { | |
608 | case MTFSF: | |
609 | case MTBSF: | |
610 | case MTFSR: | |
611 | case MTBSR: | |
612 | case MTTELL: | |
613 | case MTSEEK: | |
614 | case MTREW: | |
615 | chg_state(devi.devno, VIOT_IDLE, file); | |
616 | } | |
617 | ||
618 | init_completion(&op->com); | |
619 | hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp, | |
620 | HvLpEvent_Type_VirtualIo, | |
621 | viomajorsubtype_tape | viotapeop, | |
622 | HvLpEvent_AckInd_DoAck, | |
623 | HvLpEvent_AckType_ImmediateAck, | |
624 | viopath_sourceinst(viopath_hostLp), | |
625 | viopath_targetinst(viopath_hostLp), | |
626 | (u64)(unsigned long)op, | |
627 | VIOVERSION << 16, | |
628 | ((u64)devi.devno << 48), 0, | |
629 | (((u64)myOp) << 32) | mtc.mt_count, 0); | |
630 | if (hvrc != HvLpEvent_Rc_Good) { | |
631 | printk(VIOTAPE_KERN_WARN "hv error on op %d\n", | |
632 | (int)hvrc); | |
633 | goto free_op; | |
634 | } | |
635 | wait_for_completion(&op->com); | |
636 | ret = tape_rc_to_errno(op->rc, "tape operation", devi.devno); | |
637 | goto free_op; | |
638 | ||
639 | case MTIOCGET: | |
640 | ret = -EIO; | |
641 | init_completion(&op->com); | |
642 | hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp, | |
643 | HvLpEvent_Type_VirtualIo, | |
644 | viomajorsubtype_tape | viotapegetstatus, | |
645 | HvLpEvent_AckInd_DoAck, | |
646 | HvLpEvent_AckType_ImmediateAck, | |
647 | viopath_sourceinst(viopath_hostLp), | |
648 | viopath_targetinst(viopath_hostLp), | |
649 | (u64)(unsigned long)op, VIOVERSION << 16, | |
650 | ((u64)devi.devno << 48), 0, 0, 0); | |
651 | if (hvrc != HvLpEvent_Rc_Good) { | |
652 | printk(VIOTAPE_KERN_WARN "hv error on op %d\n", | |
653 | (int)hvrc); | |
654 | goto free_op; | |
655 | } | |
656 | wait_for_completion(&op->com); | |
657 | ||
658 | /* Operation is complete - grab the error code */ | |
659 | ret = tape_rc_to_errno(op->rc, "get status", devi.devno); | |
660 | free_op_struct(op); | |
661 | up(&reqSem); | |
662 | ||
663 | if ((ret == 0) && copy_to_user((void *)arg, | |
664 | &viomtget[devi.devno], | |
665 | sizeof(viomtget[0]))) | |
666 | ret = -EFAULT; | |
667 | return ret; | |
668 | case MTIOCPOS: | |
669 | printk(VIOTAPE_KERN_WARN "Got an (unsupported) MTIOCPOS\n"); | |
670 | break; | |
671 | default: | |
672 | printk(VIOTAPE_KERN_WARN "got an unsupported ioctl 0x%0x\n", | |
673 | cmd); | |
674 | break; | |
675 | } | |
676 | ||
677 | free_op: | |
678 | free_op_struct(op); | |
679 | up(&reqSem); | |
680 | return ret; | |
681 | } | |
682 | ||
10c0ad4d SR |
683 | static long viotap_unlocked_ioctl(struct file *file, |
684 | unsigned int cmd, unsigned long arg) | |
685 | { | |
686 | long rc; | |
687 | ||
613655fa | 688 | mutex_lock(&proc_viotape_mutex); |
10c0ad4d | 689 | rc = viotap_ioctl(file->f_path.dentry->d_inode, file, cmd, arg); |
613655fa | 690 | mutex_unlock(&proc_viotape_mutex); |
10c0ad4d SR |
691 | return rc; |
692 | } | |
693 | ||
1da177e4 LT |
694 | static int viotap_open(struct inode *inode, struct file *file) |
695 | { | |
696 | HvLpEvent_Rc hvrc; | |
697 | struct viot_devinfo_struct devi; | |
698 | int ret; | |
699 | struct op_struct *op = get_op_struct(); | |
700 | ||
701 | if (op == NULL) | |
702 | return -ENOMEM; | |
703 | ||
613655fa | 704 | mutex_lock(&proc_viotape_mutex); |
a7113a96 | 705 | get_dev_info(file->f_path.dentry->d_inode, &devi); |
1da177e4 LT |
706 | |
707 | /* Note: We currently only support one mode! */ | |
708 | if ((devi.devno >= viotape_numdev) || (devi.mode)) { | |
709 | ret = -ENODEV; | |
710 | goto free_op; | |
711 | } | |
712 | ||
713 | init_completion(&op->com); | |
714 | ||
715 | hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp, | |
716 | HvLpEvent_Type_VirtualIo, | |
717 | viomajorsubtype_tape | viotapeopen, | |
718 | HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck, | |
719 | viopath_sourceinst(viopath_hostLp), | |
720 | viopath_targetinst(viopath_hostLp), | |
721 | (u64)(unsigned long)op, VIOVERSION << 16, | |
722 | ((u64)devi.devno << 48), 0, 0, 0); | |
723 | if (hvrc != 0) { | |
724 | printk(VIOTAPE_KERN_WARN "bad rc on signalLpEvent %d\n", | |
725 | (int) hvrc); | |
726 | ret = -EIO; | |
727 | goto free_op; | |
728 | } | |
729 | ||
730 | wait_for_completion(&op->com); | |
731 | ret = tape_rc_to_errno(op->rc, "open", devi.devno); | |
732 | ||
733 | free_op: | |
734 | free_op_struct(op); | |
613655fa | 735 | mutex_unlock(&proc_viotape_mutex); |
1da177e4 LT |
736 | return ret; |
737 | } | |
738 | ||
739 | ||
740 | static int viotap_release(struct inode *inode, struct file *file) | |
741 | { | |
742 | HvLpEvent_Rc hvrc; | |
743 | struct viot_devinfo_struct devi; | |
744 | int ret = 0; | |
745 | struct op_struct *op = get_op_struct(); | |
746 | ||
747 | if (op == NULL) | |
748 | return -ENOMEM; | |
749 | init_completion(&op->com); | |
750 | ||
a7113a96 | 751 | get_dev_info(file->f_path.dentry->d_inode, &devi); |
1da177e4 LT |
752 | |
753 | if (devi.devno >= viotape_numdev) { | |
754 | ret = -ENODEV; | |
755 | goto free_op; | |
756 | } | |
757 | ||
758 | chg_state(devi.devno, VIOT_IDLE, file); | |
759 | ||
760 | if (devi.rewind) { | |
761 | hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp, | |
762 | HvLpEvent_Type_VirtualIo, | |
763 | viomajorsubtype_tape | viotapeop, | |
764 | HvLpEvent_AckInd_DoAck, | |
765 | HvLpEvent_AckType_ImmediateAck, | |
766 | viopath_sourceinst(viopath_hostLp), | |
767 | viopath_targetinst(viopath_hostLp), | |
768 | (u64)(unsigned long)op, VIOVERSION << 16, | |
769 | ((u64)devi.devno << 48), 0, | |
770 | ((u64)VIOTAPOP_REW) << 32, 0); | |
771 | wait_for_completion(&op->com); | |
772 | ||
773 | tape_rc_to_errno(op->rc, "rewind", devi.devno); | |
774 | } | |
775 | ||
776 | hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp, | |
777 | HvLpEvent_Type_VirtualIo, | |
778 | viomajorsubtype_tape | viotapeclose, | |
779 | HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck, | |
780 | viopath_sourceinst(viopath_hostLp), | |
781 | viopath_targetinst(viopath_hostLp), | |
782 | (u64)(unsigned long)op, VIOVERSION << 16, | |
783 | ((u64)devi.devno << 48), 0, 0, 0); | |
784 | if (hvrc != 0) { | |
785 | printk(VIOTAPE_KERN_WARN "bad rc on signalLpEvent %d\n", | |
786 | (int) hvrc); | |
787 | ret = -EIO; | |
788 | goto free_op; | |
789 | } | |
790 | ||
791 | wait_for_completion(&op->com); | |
792 | ||
793 | if (op->rc) | |
794 | printk(VIOTAPE_KERN_WARN "close failed\n"); | |
795 | ||
796 | free_op: | |
797 | free_op_struct(op); | |
798 | return ret; | |
799 | } | |
800 | ||
2b8693c0 | 801 | const struct file_operations viotap_fops = { |
10c0ad4d SR |
802 | .owner = THIS_MODULE, |
803 | .read = viotap_read, | |
804 | .write = viotap_write, | |
805 | .unlocked_ioctl = viotap_unlocked_ioctl, | |
806 | .open = viotap_open, | |
807 | .release = viotap_release, | |
aadbd436 | 808 | .llseek = noop_llseek, |
1da177e4 LT |
809 | }; |
810 | ||
811 | /* Handle interrupt events for tape */ | |
812 | static void vioHandleTapeEvent(struct HvLpEvent *event) | |
813 | { | |
814 | int tapeminor; | |
815 | struct op_struct *op; | |
816 | struct viotapelpevent *tevent = (struct viotapelpevent *)event; | |
817 | ||
818 | if (event == NULL) { | |
819 | /* Notification that a partition went away! */ | |
820 | if (!viopath_isactive(viopath_hostLp)) { | |
821 | /* TODO! Clean up */ | |
822 | } | |
823 | return; | |
824 | } | |
825 | ||
826 | tapeminor = event->xSubtype & VIOMINOR_SUBTYPE_MASK; | |
827 | op = (struct op_struct *)event->xCorrelationToken; | |
828 | switch (tapeminor) { | |
1da177e4 LT |
829 | case viotapeopen: |
830 | case viotapeclose: | |
831 | op->rc = tevent->sub_type_result; | |
832 | complete(&op->com); | |
833 | break; | |
834 | case viotaperead: | |
835 | op->rc = tevent->sub_type_result; | |
836 | op->count = tevent->len; | |
837 | complete(&op->com); | |
838 | break; | |
839 | case viotapewrite: | |
840 | if (op->non_blocking) { | |
841 | dma_free_coherent(op->dev, op->count, | |
842 | op->buffer, op->dmaaddr); | |
843 | free_op_struct(op); | |
844 | up(&reqSem); | |
845 | } else { | |
846 | op->rc = tevent->sub_type_result; | |
847 | op->count = tevent->len; | |
848 | complete(&op->com); | |
849 | } | |
850 | break; | |
851 | case viotapeop: | |
852 | case viotapegetpos: | |
853 | case viotapesetpos: | |
854 | case viotapegetstatus: | |
855 | if (op) { | |
856 | op->count = tevent->u.op.count; | |
857 | op->rc = tevent->sub_type_result; | |
858 | if (!op->non_blocking) | |
859 | complete(&op->com); | |
860 | } | |
861 | break; | |
862 | default: | |
863 | printk(VIOTAPE_KERN_WARN "weird ack\n"); | |
864 | } | |
865 | } | |
866 | ||
867 | static int viotape_probe(struct vio_dev *vdev, const struct vio_device_id *id) | |
868 | { | |
1da177e4 LT |
869 | int i = vdev->unit_address; |
870 | int j; | |
61c7a080 | 871 | struct device_node *node = vdev->dev.of_node; |
1da177e4 | 872 | |
a85c8e17 | 873 | if (i >= VIOTAPE_MAX_TAPE) |
7465ce0d SR |
874 | return -ENODEV; |
875 | if (!node) | |
1da177e4 LT |
876 | return -ENODEV; |
877 | ||
7465ce0d SR |
878 | if (i >= viotape_numdev) |
879 | viotape_numdev = i + 1; | |
880 | ||
1da177e4 | 881 | tape_device[i] = &vdev->dev; |
7465ce0d SR |
882 | viotape_unitinfo[i].rsrcname = of_get_property(node, |
883 | "linux,vio_rsrcname", NULL); | |
884 | viotape_unitinfo[i].type = of_get_property(node, "linux,vio_type", | |
885 | NULL); | |
886 | viotape_unitinfo[i].model = of_get_property(node, "linux,vio_model", | |
887 | NULL); | |
1da177e4 LT |
888 | |
889 | state[i].cur_part = 0; | |
890 | for (j = 0; j < MAX_PARTITIONS; ++j) | |
891 | state[i].part_stat_rwi[j] = VIOT_IDLE; | |
03457cd4 GKH |
892 | device_create(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i), NULL, |
893 | "iseries!vt%d", i); | |
894 | device_create(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i | 0x80), NULL, | |
895 | "iseries!nvt%d", i); | |
380ed24b | 896 | printk(VIOTAPE_KERN_INFO "tape iseries/vt%d is iSeries " |
1da177e4 | 897 | "resource %10.10s type %4.4s, model %3.3s\n", |
380ed24b | 898 | i, viotape_unitinfo[i].rsrcname, |
1da177e4 LT |
899 | viotape_unitinfo[i].type, viotape_unitinfo[i].model); |
900 | return 0; | |
901 | } | |
902 | ||
903 | static int viotape_remove(struct vio_dev *vdev) | |
904 | { | |
905 | int i = vdev->unit_address; | |
906 | ||
07c015e7 | 907 | device_destroy(tape_class, MKDEV(VIOTAPE_MAJOR, i | 0x80)); |
908 | device_destroy(tape_class, MKDEV(VIOTAPE_MAJOR, i)); | |
1da177e4 LT |
909 | return 0; |
910 | } | |
911 | ||
912 | /** | |
913 | * viotape_device_table: Used by vio.c to match devices that we | |
914 | * support. | |
915 | */ | |
916 | static struct vio_device_id viotape_device_table[] __devinitdata = { | |
de0fe3b8 | 917 | { "byte", "IBM,iSeries-viotape" }, |
fb120da6 | 918 | { "", "" } |
1da177e4 | 919 | }; |
1da177e4 | 920 | MODULE_DEVICE_TABLE(vio, viotape_device_table); |
915124d8 | 921 | |
1da177e4 | 922 | static struct vio_driver viotape_driver = { |
1da177e4 LT |
923 | .id_table = viotape_device_table, |
924 | .probe = viotape_probe, | |
6fdf5392 SR |
925 | .remove = viotape_remove, |
926 | .driver = { | |
927 | .name = "viotape", | |
915124d8 | 928 | .owner = THIS_MODULE, |
6fdf5392 | 929 | } |
1da177e4 LT |
930 | }; |
931 | ||
932 | ||
933 | int __init viotap_init(void) | |
934 | { | |
935 | int ret; | |
1da177e4 | 936 | |
fd38451f SR |
937 | if (!firmware_has_feature(FW_FEATURE_ISERIES)) |
938 | return -ENODEV; | |
939 | ||
1da177e4 LT |
940 | op_struct_list = NULL; |
941 | if ((ret = add_op_structs(VIOTAPE_MAXREQ)) < 0) { | |
942 | printk(VIOTAPE_KERN_WARN "couldn't allocate op structs\n"); | |
943 | return ret; | |
944 | } | |
945 | spin_lock_init(&op_struct_list_lock); | |
946 | ||
947 | sema_init(&reqSem, VIOTAPE_MAXREQ); | |
948 | ||
949 | if (viopath_hostLp == HvLpIndexInvalid) { | |
950 | vio_set_hostlp(); | |
951 | if (viopath_hostLp == HvLpIndexInvalid) { | |
952 | ret = -ENODEV; | |
953 | goto clear_op; | |
954 | } | |
955 | } | |
956 | ||
957 | ret = viopath_open(viopath_hostLp, viomajorsubtype_tape, | |
958 | VIOTAPE_MAXREQ + 2); | |
959 | if (ret) { | |
960 | printk(VIOTAPE_KERN_WARN | |
961 | "error on viopath_open to hostlp %d\n", ret); | |
962 | ret = -EIO; | |
963 | goto clear_op; | |
964 | } | |
965 | ||
966 | printk(VIOTAPE_KERN_INFO "vers " VIOTAPE_VERSION | |
967 | ", hosting partition %d\n", viopath_hostLp); | |
968 | ||
969 | vio_setHandler(viomajorsubtype_tape, vioHandleTapeEvent); | |
970 | ||
971 | ret = register_chrdev(VIOTAPE_MAJOR, "viotape", &viotap_fops); | |
972 | if (ret < 0) { | |
973 | printk(VIOTAPE_KERN_WARN "Error registering viotape device\n"); | |
974 | goto clear_handler; | |
975 | } | |
976 | ||
ca8eca68 | 977 | tape_class = class_create(THIS_MODULE, "tape"); |
1da177e4 LT |
978 | if (IS_ERR(tape_class)) { |
979 | printk(VIOTAPE_KERN_WARN "Unable to allocat class\n"); | |
980 | ret = PTR_ERR(tape_class); | |
981 | goto unreg_chrdev; | |
982 | } | |
983 | ||
1da177e4 LT |
984 | ret = vio_register_driver(&viotape_driver); |
985 | if (ret) | |
986 | goto unreg_class; | |
987 | ||
1b502217 DL |
988 | proc_create("iSeries/viotape", S_IFREG|S_IRUGO, NULL, |
989 | &proc_viotape_operations); | |
1da177e4 LT |
990 | |
991 | return 0; | |
992 | ||
993 | unreg_class: | |
ca8eca68 | 994 | class_destroy(tape_class); |
1da177e4 LT |
995 | unreg_chrdev: |
996 | unregister_chrdev(VIOTAPE_MAJOR, "viotape"); | |
997 | clear_handler: | |
998 | vio_clearHandler(viomajorsubtype_tape); | |
999 | viopath_close(viopath_hostLp, viomajorsubtype_tape, VIOTAPE_MAXREQ + 2); | |
1000 | clear_op: | |
1001 | clear_op_struct_pool(); | |
1002 | return ret; | |
1003 | } | |
1004 | ||
1005 | /* Give a new state to the tape object */ | |
1006 | static int chg_state(int index, unsigned char new_state, struct file *file) | |
1007 | { | |
1008 | unsigned char *cur_state = | |
1009 | &state[index].part_stat_rwi[state[index].cur_part]; | |
1010 | int rc = 0; | |
1011 | ||
1012 | /* if the same state, don't bother */ | |
1013 | if (*cur_state == new_state) | |
1014 | return 0; | |
1015 | ||
1016 | /* write an EOF if changing from writing to some other state */ | |
1017 | if (*cur_state == VIOT_WRITING) { | |
1018 | struct mtop write_eof = { MTWEOF, 1 }; | |
1019 | ||
1020 | rc = viotap_ioctl(NULL, file, MTIOCTOP, | |
1021 | (unsigned long)&write_eof); | |
1022 | } | |
1023 | *cur_state = new_state; | |
1024 | return rc; | |
1025 | } | |
1026 | ||
1027 | /* Cleanup */ | |
1028 | static void __exit viotap_exit(void) | |
1029 | { | |
1da177e4 LT |
1030 | remove_proc_entry("iSeries/viotape", NULL); |
1031 | vio_unregister_driver(&viotape_driver); | |
ca8eca68 | 1032 | class_destroy(tape_class); |
68fc4fab | 1033 | unregister_chrdev(VIOTAPE_MAJOR, "viotape"); |
1da177e4 LT |
1034 | viopath_close(viopath_hostLp, viomajorsubtype_tape, VIOTAPE_MAXREQ + 2); |
1035 | vio_clearHandler(viomajorsubtype_tape); | |
1036 | clear_op_struct_pool(); | |
1037 | } | |
1038 | ||
1039 | MODULE_LICENSE("GPL"); | |
1040 | module_init(viotap_init); | |
1041 | module_exit(viotap_exit); |