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