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