v2.4.8 -> v2.4.8.1
[opensuse:kernel.git] / drivers / i2o / i2o_config.c
1 /*
2  * I2O Configuration Interface Driver
3  *
4  * (C) Copyright 1999   Red Hat Software
5  *      
6  * Written by Alan Cox, Building Number Three Ltd
7  *
8  * Modified 04/20/1999 by Deepak Saxena
9  *   - Added basic ioctl() support
10  * Modified 06/07/1999 by Deepak Saxena
11  *   - Added software download ioctl (still testing)
12  * Modified 09/10/1999 by Auvo Häkkinen
13  *   - Changes to i2o_cfg_reply(), ioctl_parms()
14  *   - Added ioct_validate()
15  * Modified 09/30/1999 by Taneli Vähäkangas
16  *   - Fixed ioctl_swdl()
17  * Modified 10/04/1999 by Taneli Vähäkangas
18  *   - Changed ioctl_swdl(), implemented ioctl_swul() and ioctl_swdel()
19  * Modified 11/18/199 by Deepak Saxena
20  *   - Added event managmenet support
21  *
22  * This program is free software; you can redistribute it and/or
23  * modify it under the terms of the GNU General Public License
24  * as published by the Free Software Foundation; either version
25  * 2 of the License, or (at your option) any later version.
26  */
27
28 #include <linux/module.h>
29 #include <linux/kernel.h>
30 #include <linux/pci.h>
31 #include <linux/i2o.h>
32 #include <linux/errno.h>
33 #include <linux/init.h>
34 #include <linux/slab.h>
35 #include <linux/miscdevice.h>
36 #include <linux/mm.h>
37 #include <linux/spinlock.h>
38 #include <linux/smp_lock.h>
39
40 #include <asm/uaccess.h>
41 #include <asm/io.h>
42
43 static int i2o_cfg_context = -1;
44 static void *page_buf;
45 static spinlock_t i2o_config_lock = SPIN_LOCK_UNLOCKED;
46 struct wait_queue *i2o_wait_queue;
47
48 #define MODINC(x,y) (x = x++ % y)
49
50 struct i2o_cfg_info
51 {
52         struct file* fp;
53         struct fasync_struct *fasync;
54         struct i2o_evt_info event_q[I2O_EVT_Q_LEN];
55         u16             q_in;           // Queue head index
56         u16             q_out;          // Queue tail index
57         u16             q_len;          // Queue length
58         u16             q_lost;         // Number of lost events
59         u32             q_id;           // Event queue ID...used as tx_context
60         struct  i2o_cfg_info *next;
61 };
62 static struct i2o_cfg_info *open_files = NULL;
63 static int i2o_cfg_info_id = 0;
64
65 static int ioctl_getiops(unsigned long);
66 static int ioctl_gethrt(unsigned long);
67 static int ioctl_getlct(unsigned long);
68 static int ioctl_parms(unsigned long, unsigned int);
69 static int ioctl_html(unsigned long);
70 static int ioctl_swdl(unsigned long);
71 static int ioctl_swul(unsigned long);
72 static int ioctl_swdel(unsigned long);
73 static int ioctl_validate(unsigned long); 
74 static int ioctl_evt_reg(unsigned long, struct file *);
75 static int ioctl_evt_get(unsigned long, struct file *);
76 static int cfg_fasync(int, struct file*, int);
77
78 /*
79  *      This is the callback for any message we have posted. The message itself
80  *      will be returned to the message pool when we return from the IRQ
81  *
82  *      This runs in irq context so be short and sweet.
83  */
84 static void i2o_cfg_reply(struct i2o_handler *h, struct i2o_controller *c, struct i2o_message *m)
85 {
86         u32 *msg = (u32 *)m;
87
88         if (msg[0] & MSG_FAIL) {
89                 u32 *preserved_msg = (u32*)(c->mem_offset + msg[7]);
90
91                 printk(KERN_ERR "i2o_config: IOP failed to process the msg.\n");
92
93                 /* Release the preserved msg frame by resubmitting it as a NOP */
94
95                 preserved_msg[0] = THREE_WORD_MSG_SIZE | SGL_OFFSET_0;
96                 preserved_msg[1] = I2O_CMD_UTIL_NOP << 24 | HOST_TID << 12 | 0;
97                 preserved_msg[2] = 0;
98                 i2o_post_message(c, msg[7]);
99         }
100
101         if (msg[4] >> 24)  // ReqStatus != SUCCESS
102                 i2o_report_status(KERN_INFO,"i2o_config", msg);
103
104         if(m->function == I2O_CMD_UTIL_EVT_REGISTER)
105         {
106                 struct i2o_cfg_info *inf;
107
108                 for(inf = open_files; inf; inf = inf->next)
109                         if(inf->q_id == msg[3])
110                                 break;
111
112                 //
113                 // If this is the case, it means that we're getting
114                 // events for a file descriptor that's been close()'d
115                 // w/o the user unregistering for events first.
116                 // The code currently assumes that the user will 
117                 // take care of unregistering for events before closing
118                 // a file.
119                 // 
120                 // TODO: 
121                 // Should we track event registartion and deregister
122                 // for events when a file is close()'d so this doesn't
123                 // happen? That would get rid of the search through
124                 // the linked list since file->private_data could point
125                 // directly to the i2o_config_info data structure...but
126                 // it would mean having all sorts of tables to track
127                 // what each file is registered for...I think the
128                 // current method is simpler. - DS
129                 //                      
130                 if(!inf)
131                         return;
132
133                 inf->event_q[inf->q_in].id.iop = c->unit;
134                 inf->event_q[inf->q_in].id.tid = m->target_tid;
135                 inf->event_q[inf->q_in].id.evt_mask = msg[4];
136
137                 //
138                 // Data size = msg size - reply header
139                 //
140                 inf->event_q[inf->q_in].data_size = (m->size - 5) * 4;
141                 if(inf->event_q[inf->q_in].data_size)
142                         memcpy(inf->event_q[inf->q_in].evt_data, 
143                                 (unsigned char *)(msg + 5),
144                                 inf->event_q[inf->q_in].data_size);
145
146                 spin_lock(&i2o_config_lock);
147                 MODINC(inf->q_in, I2O_EVT_Q_LEN);
148                 if(inf->q_len == I2O_EVT_Q_LEN)
149                 {
150                         MODINC(inf->q_out, I2O_EVT_Q_LEN);
151                         inf->q_lost++;
152                 }
153                 else
154                 {
155                         // Keep I2OEVTGET on another CPU from touching this
156                         inf->q_len++;
157                 }
158                 spin_unlock(&i2o_config_lock);
159                 
160
161 //              printk(KERN_INFO "File %p w/id %d has %d events\n",
162 //                      inf->fp, inf->q_id, inf->q_len);        
163
164                 kill_fasync(&inf->fasync, SIGIO, POLL_IN);
165         }
166
167         return;
168 }
169
170 /*
171  *      Each of these describes an i2o message handler. They are
172  *      multiplexed by the i2o_core code
173  */
174  
175 struct i2o_handler cfg_handler=
176 {
177         i2o_cfg_reply,
178         NULL,
179         NULL,
180         NULL,
181         "Configuration",
182         0,
183         0xffffffff      // All classes
184 };
185
186 static ssize_t cfg_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
187 {
188         printk(KERN_INFO "i2o_config write not yet supported\n");
189
190         return 0;
191 }
192
193
194 static ssize_t cfg_read(struct file *file, char *buf, size_t count, loff_t *ptr)
195 {
196         return 0;
197 }
198
199 /*
200  * IOCTL Handler
201  */
202 static int cfg_ioctl(struct inode *inode, struct file *fp, unsigned int cmd,
203         unsigned long arg)
204 {
205         int ret;
206
207         switch(cmd)
208         {       
209                 case I2OGETIOPS:
210                         ret = ioctl_getiops(arg);
211                         break;
212
213                 case I2OHRTGET:
214                         ret = ioctl_gethrt(arg);
215                         break;
216
217                 case I2OLCTGET:
218                         ret = ioctl_getlct(arg);
219                         break;
220
221                 case I2OPARMSET:
222                         ret = ioctl_parms(arg, I2OPARMSET);
223                         break;
224
225                 case I2OPARMGET:
226                         ret = ioctl_parms(arg, I2OPARMGET);
227                         break;
228
229                 case I2OSWDL:
230                         ret = ioctl_swdl(arg);
231                         break;
232
233                 case I2OSWUL:
234                         ret = ioctl_swul(arg);
235                         break;
236
237                 case I2OSWDEL:
238                         ret = ioctl_swdel(arg);
239                         break;
240
241                 case I2OVALIDATE:
242                         ret = ioctl_validate(arg);
243                         break;
244                         
245                 case I2OHTML:
246                         ret = ioctl_html(arg);
247                         break;
248
249                 case I2OEVTREG:
250                         ret = ioctl_evt_reg(arg, fp);
251                         break;
252
253                 case I2OEVTGET:
254                         ret = ioctl_evt_get(arg, fp);
255                         break;
256
257                 default:
258                         ret = -EINVAL;
259         }
260
261         return ret;
262 }
263
264 int ioctl_getiops(unsigned long arg)
265 {
266         u8 *user_iop_table = (u8*)arg;
267         struct i2o_controller *c = NULL;
268         int i;
269         u8 foo[MAX_I2O_CONTROLLERS];
270
271         if(!access_ok(VERIFY_WRITE, user_iop_table,  MAX_I2O_CONTROLLERS))
272                 return -EFAULT;
273
274         for(i = 0; i < MAX_I2O_CONTROLLERS; i++)
275         {
276                 c = i2o_find_controller(i);
277                 if(c)
278                 {
279                         foo[i] = 1;
280                         i2o_unlock_controller(c);
281                 }
282                 else
283                 {
284                         foo[i] = 0;
285                 }
286         }
287
288         __copy_to_user(user_iop_table, foo, MAX_I2O_CONTROLLERS);
289         return 0;
290 }
291
292 int ioctl_gethrt(unsigned long arg)
293 {
294         struct i2o_controller *c;
295         struct i2o_cmd_hrtlct *cmd = (struct i2o_cmd_hrtlct*)arg;
296         struct i2o_cmd_hrtlct kcmd;
297         i2o_hrt *hrt;
298         int len;
299         u32 reslen;
300         int ret = 0;
301
302         if(copy_from_user(&kcmd, cmd, sizeof(struct i2o_cmd_hrtlct)))
303                 return -EFAULT;
304
305         if(get_user(reslen, kcmd.reslen) < 0)
306                 return -EFAULT;
307
308         if(kcmd.resbuf == NULL)
309                 return -EFAULT;
310
311         c = i2o_find_controller(kcmd.iop);
312         if(!c)
313                 return -ENXIO;
314                 
315         hrt = (i2o_hrt *)c->hrt;
316
317         i2o_unlock_controller(c);
318
319         len = 8 + ((hrt->entry_len * hrt->num_entries) << 2);
320         
321         /* We did a get user...so assuming mem is ok...is this bad? */
322         put_user(len, kcmd.reslen);
323         if(len > reslen)
324                 ret = -ENOBUFS; 
325         if(copy_to_user(kcmd.resbuf, (void*)hrt, len))
326                 ret = -EFAULT;
327
328         return ret;
329 }
330
331 int ioctl_getlct(unsigned long arg)
332 {
333         struct i2o_controller *c;
334         struct i2o_cmd_hrtlct *cmd = (struct i2o_cmd_hrtlct*)arg;
335         struct i2o_cmd_hrtlct kcmd;
336         i2o_lct *lct;
337         int len;
338         int ret = 0;
339         u32 reslen;
340
341         if(copy_from_user(&kcmd, cmd, sizeof(struct i2o_cmd_hrtlct)))
342                 return -EFAULT;
343
344         if(get_user(reslen, kcmd.reslen) < 0)
345                 return -EFAULT;
346
347         if(kcmd.resbuf == NULL)
348                 return -EFAULT;
349
350         c = i2o_find_controller(kcmd.iop);
351         if(!c)
352                 return -ENXIO;
353
354         lct = (i2o_lct *)c->lct;
355         i2o_unlock_controller(c);
356
357         len = (unsigned int)lct->table_size << 2;
358         put_user(len, kcmd.reslen);
359         if(len > reslen)
360                 ret = -ENOBUFS; 
361         else if(copy_to_user(kcmd.resbuf, (void*)lct, len))
362                 ret = -EFAULT;
363
364         return ret;
365 }
366
367 static int ioctl_parms(unsigned long arg, unsigned int type)
368 {
369         int ret = 0;
370         struct i2o_controller *c;
371         struct i2o_cmd_psetget *cmd = (struct i2o_cmd_psetget*)arg;
372         struct i2o_cmd_psetget kcmd;
373         u32 reslen;
374         u8 *ops;
375         u8 *res;
376         int len;
377
378         u32 i2o_cmd = (type == I2OPARMGET ? 
379                                 I2O_CMD_UTIL_PARAMS_GET :
380                                 I2O_CMD_UTIL_PARAMS_SET);
381
382         if(copy_from_user(&kcmd, cmd, sizeof(struct i2o_cmd_psetget)))
383                 return -EFAULT;
384
385         if(get_user(reslen, kcmd.reslen))
386                 return -EFAULT;
387
388         c = i2o_find_controller(kcmd.iop);
389         if(!c)
390                 return -ENXIO;
391
392         ops = (u8*)kmalloc(kcmd.oplen, GFP_KERNEL);
393         if(!ops)
394         {
395                 i2o_unlock_controller(c);
396                 return -ENOMEM;
397         }
398
399         if(copy_from_user(ops, kcmd.opbuf, kcmd.oplen))
400         {
401                 i2o_unlock_controller(c);
402                 kfree(ops);
403                 return -EFAULT;
404         }
405
406         /*
407          * It's possible to have a _very_ large table
408          * and that the user asks for all of it at once...
409          */
410         res = (u8*)kmalloc(65536, GFP_KERNEL);
411         if(!res)
412         {
413                 i2o_unlock_controller(c);
414                 kfree(ops);
415                 return -ENOMEM;
416         }
417
418         len = i2o_issue_params(i2o_cmd, c, kcmd.tid, 
419                                 ops, kcmd.oplen, res, 65536);
420         i2o_unlock_controller(c);
421         kfree(ops);
422         
423         if (len < 0) {
424                 kfree(res);
425                 return -EAGAIN;
426         }
427
428         put_user(len, kcmd.reslen);
429         if(len > reslen)
430                 ret = -ENOBUFS;
431         else if(copy_to_user(cmd->resbuf, res, len))
432                 ret = -EFAULT;
433
434         kfree(res);
435
436         return ret;
437 }
438
439 int ioctl_html(unsigned long arg)
440 {
441         struct i2o_html *cmd = (struct i2o_html*)arg;
442         struct i2o_html kcmd;
443         struct i2o_controller *c;
444         u8 *res = NULL;
445         void *query = NULL;
446         int ret = 0;
447         int token;
448         u32 len;
449         u32 reslen;
450         u32 msg[MSG_FRAME_SIZE/4];
451
452         if(copy_from_user(&kcmd, cmd, sizeof(struct i2o_html)))
453         {
454                 printk(KERN_INFO "i2o_config: can't copy html cmd\n");
455                 return -EFAULT;
456         }
457
458         if(get_user(reslen, kcmd.reslen) < 0)
459         {
460                 printk(KERN_INFO "i2o_config: can't copy html reslen\n");
461                 return -EFAULT;
462         }
463
464         if(!kcmd.resbuf)                
465         {
466                 printk(KERN_INFO "i2o_config: NULL html buffer\n");
467                 return -EFAULT;
468         }
469
470         c = i2o_find_controller(kcmd.iop);
471         if(!c)
472                 return -ENXIO;
473
474         if(kcmd.qlen) /* Check for post data */
475         {
476                 query = kmalloc(kcmd.qlen, GFP_KERNEL);
477                 if(!query)
478                 {
479                         i2o_unlock_controller(c);
480                         return -ENOMEM;
481                 }
482                 if(copy_from_user(query, kcmd.qbuf, kcmd.qlen))
483                 {
484                         i2o_unlock_controller(c);
485                         printk(KERN_INFO "i2o_config: could not get query\n");
486                         kfree(query);
487                         return -EFAULT;
488                 }
489         }
490
491         res = kmalloc(65536, GFP_KERNEL);
492         if(!res)
493         {
494                 i2o_unlock_controller(c);
495                 kfree(query);
496                 return -ENOMEM;
497         }
498
499         msg[1] = (I2O_CMD_UTIL_CONFIG_DIALOG << 24)|HOST_TID<<12|kcmd.tid;
500         msg[2] = i2o_cfg_context;
501         msg[3] = 0;
502         msg[4] = kcmd.page;
503         msg[5] = 0xD0000000|65536;
504         msg[6] = virt_to_bus(res);
505         if(!kcmd.qlen) /* Check for post data */
506                 msg[0] = SEVEN_WORD_MSG_SIZE|SGL_OFFSET_5;
507         else
508         {
509                 msg[0] = NINE_WORD_MSG_SIZE|SGL_OFFSET_5;
510                 msg[5] = 0x50000000|65536;
511                 msg[7] = 0xD4000000|(kcmd.qlen);
512                 msg[8] = virt_to_bus(query);
513         }
514         /*
515         Wait for a considerable time till the Controller 
516         does its job before timing out. The controller might
517         take more time to process this request if there are
518         many devices connected to it.
519         */
520         token = i2o_post_wait_mem(c, msg, 9*4, 400, query, res);
521         if(token < 0)
522         {
523                 printk(KERN_DEBUG "token = %#10x\n", token);
524                 i2o_unlock_controller(c);
525                 
526                 if(token != -ETIMEDOUT)
527                 {
528                         kfree(res);
529                         if(kcmd.qlen) kfree(query);
530                 }
531
532                 return token;
533         }
534         i2o_unlock_controller(c);
535
536         len = strnlen(res, 65536);
537         put_user(len, kcmd.reslen);
538         if(len > reslen)
539                 ret = -ENOMEM;
540         if(copy_to_user(kcmd.resbuf, res, len))
541                 ret = -EFAULT;
542
543         kfree(res);
544         if(kcmd.qlen) 
545                 kfree(query);
546
547         return ret;
548 }
549  
550 int ioctl_swdl(unsigned long arg)
551 {
552         struct i2o_sw_xfer kxfer;
553         struct i2o_sw_xfer *pxfer = (struct i2o_sw_xfer *)arg;
554         unsigned char maxfrag = 0, curfrag = 1;
555         unsigned char *buffer;
556         u32 msg[9];
557         unsigned int status = 0, swlen = 0, fragsize = 8192;
558         struct i2o_controller *c;
559
560         if(copy_from_user(&kxfer, pxfer, sizeof(struct i2o_sw_xfer)))
561                 return -EFAULT;
562
563         if(get_user(swlen, kxfer.swlen) < 0)
564                 return -EFAULT;
565
566         if(get_user(maxfrag, kxfer.maxfrag) < 0)
567                 return -EFAULT;
568
569         if(get_user(curfrag, kxfer.curfrag) < 0)
570                 return -EFAULT;
571
572         if(curfrag==maxfrag) fragsize = swlen-(maxfrag-1)*8192;
573
574         if(!kxfer.buf || !access_ok(VERIFY_READ, kxfer.buf, fragsize))
575                 return -EFAULT;
576         
577         c = i2o_find_controller(kxfer.iop);
578         if(!c)
579                 return -ENXIO;
580
581         buffer=kmalloc(fragsize, GFP_KERNEL);
582         if (buffer==NULL)
583         {
584                 i2o_unlock_controller(c);
585                 return -ENOMEM;
586         }
587         __copy_from_user(buffer, kxfer.buf, fragsize);
588
589         msg[0]= NINE_WORD_MSG_SIZE | SGL_OFFSET_7;
590         msg[1]= I2O_CMD_SW_DOWNLOAD<<24 | HOST_TID<<12 | ADAPTER_TID;
591         msg[2]= (u32)cfg_handler.context;
592         msg[3]= 0;
593         msg[4]= (((u32)kxfer.flags)<<24) | (((u32)kxfer.sw_type)<<16) |
594                 (((u32)maxfrag)<<8) | (((u32)curfrag));
595         msg[5]= swlen;
596         msg[6]= kxfer.sw_id;
597         msg[7]= (0xD0000000 | fragsize);
598         msg[8]= virt_to_bus(buffer);
599
600 //      printk("i2o_config: swdl frag %d/%d (size %d)\n", curfrag, maxfrag, fragsize);
601         status = i2o_post_wait_mem(c, msg, sizeof(msg), 60, buffer, NULL);
602
603         i2o_unlock_controller(c);
604         if(status != -ETIMEDOUT)
605                 kfree(buffer);
606         
607         if (status != I2O_POST_WAIT_OK)
608         {
609                 // it fails if you try and send frags out of order
610                 // and for some yet unknown reasons too
611                 printk(KERN_INFO "i2o_config: swdl failed, DetailedStatus = %d\n", status);
612                 return status;
613         }
614
615         return 0;
616 }
617
618 int ioctl_swul(unsigned long arg)
619 {
620         struct i2o_sw_xfer kxfer;
621         struct i2o_sw_xfer *pxfer = (struct i2o_sw_xfer *)arg;
622         unsigned char maxfrag = 0, curfrag = 1;
623         unsigned char *buffer;
624         u32 msg[9];
625         unsigned int status = 0, swlen = 0, fragsize = 8192;
626         struct i2o_controller *c;
627         
628         if(copy_from_user(&kxfer, pxfer, sizeof(struct i2o_sw_xfer)))
629                 return -EFAULT;
630                 
631         if(get_user(swlen, kxfer.swlen) < 0)
632                 return -EFAULT;
633                 
634         if(get_user(maxfrag, kxfer.maxfrag) < 0)
635                 return -EFAULT;
636                 
637         if(get_user(curfrag, kxfer.curfrag) < 0)
638                 return -EFAULT;
639         
640         if(curfrag==maxfrag) fragsize = swlen-(maxfrag-1)*8192;
641         
642         if(!kxfer.buf || !access_ok(VERIFY_WRITE, kxfer.buf, fragsize))
643                 return -EFAULT;
644                 
645         c = i2o_find_controller(kxfer.iop);
646         if(!c)
647                 return -ENXIO;
648                 
649         buffer=kmalloc(fragsize, GFP_KERNEL);
650         if (buffer==NULL)
651         {
652                 i2o_unlock_controller(c);
653                 return -ENOMEM;
654         }
655         
656         msg[0]= NINE_WORD_MSG_SIZE | SGL_OFFSET_7;
657         msg[1]= I2O_CMD_SW_UPLOAD<<24 | HOST_TID<<12 | ADAPTER_TID;
658         msg[2]= (u32)cfg_handler.context;
659         msg[3]= 0;
660         msg[4]= (u32)kxfer.flags<<24|(u32)kxfer.sw_type<<16|(u32)maxfrag<<8|(u32)curfrag;
661         msg[5]= swlen;
662         msg[6]= kxfer.sw_id;
663         msg[7]= (0xD0000000 | fragsize);
664         msg[8]= virt_to_bus(buffer);
665         
666 //      printk("i2o_config: swul frag %d/%d (size %d)\n", curfrag, maxfrag, fragsize);
667         status = i2o_post_wait_mem(c, msg, sizeof(msg), 60, buffer, NULL);
668         i2o_unlock_controller(c);
669         
670         if (status != I2O_POST_WAIT_OK)
671         {
672                 if(status != -ETIMEDOUT)
673                         kfree(buffer);
674                 printk(KERN_INFO "i2o_config: swul failed, DetailedStatus = %d\n", status);
675                 return status;
676         }
677         
678         __copy_to_user(kxfer.buf, buffer, fragsize);
679         kfree(buffer);
680         
681         return 0;
682 }
683
684 int ioctl_swdel(unsigned long arg)
685 {
686         struct i2o_controller *c;
687         struct i2o_sw_xfer kxfer, *pxfer = (struct i2o_sw_xfer *)arg;
688         u32 msg[7];
689         unsigned int swlen;
690         int token;
691         
692         if (copy_from_user(&kxfer, pxfer, sizeof(struct i2o_sw_xfer)))
693                 return -EFAULT;
694                 
695         if (get_user(swlen, kxfer.swlen) < 0)
696                 return -EFAULT;
697                 
698         c = i2o_find_controller(kxfer.iop);
699         if (!c)
700                 return -ENXIO;
701
702         msg[0] = SEVEN_WORD_MSG_SIZE | SGL_OFFSET_0;
703         msg[1] = I2O_CMD_SW_REMOVE<<24 | HOST_TID<<12 | ADAPTER_TID;
704         msg[2] = (u32)i2o_cfg_context;
705         msg[3] = 0;
706         msg[4] = (u32)kxfer.flags<<24 | (u32)kxfer.sw_type<<16;
707         msg[5] = swlen;
708         msg[6] = kxfer.sw_id;
709
710         token = i2o_post_wait(c, msg, sizeof(msg), 10);
711         i2o_unlock_controller(c);
712         
713         if (token != I2O_POST_WAIT_OK)
714         {
715                 printk(KERN_INFO "i2o_config: swdel failed, DetailedStatus = %d\n", token);
716                 return -ETIMEDOUT;
717         }
718         
719         return 0;
720 }
721
722 int ioctl_validate(unsigned long arg)
723 {
724         int token;
725         int iop = (int)arg;
726         u32 msg[4];
727         struct i2o_controller *c;
728
729         c=i2o_find_controller(iop);
730         if (!c)
731                 return -ENXIO;
732
733         msg[0] = FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
734         msg[1] = I2O_CMD_CONFIG_VALIDATE<<24 | HOST_TID<<12 | iop;
735         msg[2] = (u32)i2o_cfg_context;
736         msg[3] = 0;
737
738         token = i2o_post_wait(c, msg, sizeof(msg), 10);
739         i2o_unlock_controller(c);
740
741         if (token != I2O_POST_WAIT_OK)
742         {
743                 printk(KERN_INFO "Can't validate configuration, ErrorStatus = %d\n",
744                         token);
745                 return -ETIMEDOUT;
746         }
747
748         return 0;
749 }   
750
751 static int ioctl_evt_reg(unsigned long arg, struct file *fp)
752 {
753         u32 msg[5];
754         struct i2o_evt_id *pdesc = (struct i2o_evt_id *)arg;
755         struct i2o_evt_id kdesc;
756         struct i2o_controller *iop;
757         struct i2o_device *d;
758
759         if (copy_from_user(&kdesc, pdesc, sizeof(struct i2o_evt_id)))
760                 return -EFAULT;
761
762         /* IOP exists? */
763         iop = i2o_find_controller(kdesc.iop);
764         if(!iop)
765                 return -ENXIO;
766         i2o_unlock_controller(iop);
767
768         /* Device exists? */
769         for(d = iop->devices; d; d = d->next)
770                 if(d->lct_data.tid == kdesc.tid)
771                         break;
772
773         if(!d)
774                 return -ENODEV;
775
776         msg[0] = FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
777         msg[1] = I2O_CMD_UTIL_EVT_REGISTER<<24 | HOST_TID<<12 | kdesc.tid;
778         msg[2] = (u32)i2o_cfg_context;
779         msg[3] = (u32)fp->private_data;
780         msg[4] = kdesc.evt_mask;
781
782         i2o_post_this(iop, msg, 20);
783
784         return 0;
785 }       
786
787 static int ioctl_evt_get(unsigned long arg, struct file *fp)
788 {
789         u32 id = (u32)fp->private_data;
790         struct i2o_cfg_info *p = NULL;
791         struct i2o_evt_get *uget = (struct i2o_evt_get*)arg;
792         struct i2o_evt_get kget;
793         unsigned int flags;
794
795         for(p = open_files; p; p = p->next)
796                 if(p->q_id == id)
797                         break;
798
799         if(!p->q_len)
800         {
801                 return -ENOENT;
802                 return 0;
803         }
804
805         memcpy(&kget.info, &p->event_q[p->q_out], sizeof(struct i2o_evt_info));
806         MODINC(p->q_out, I2O_EVT_Q_LEN);
807         spin_lock_irqsave(&i2o_config_lock, flags);
808         p->q_len--;
809         kget.pending = p->q_len;
810         kget.lost = p->q_lost;
811         spin_unlock_irqrestore(&i2o_config_lock, flags);
812
813         if(copy_to_user(uget, &kget, sizeof(struct i2o_evt_get)))
814                 return -EFAULT;
815         return 0;
816 }
817
818 static int cfg_open(struct inode *inode, struct file *file)
819 {
820         struct i2o_cfg_info *tmp = 
821                 (struct i2o_cfg_info *)kmalloc(sizeof(struct i2o_cfg_info), GFP_KERNEL);
822         unsigned int flags;
823
824         if(!tmp)
825                 return -ENOMEM;
826
827         file->private_data = (void*)(i2o_cfg_info_id++);
828         tmp->fp = file;
829         tmp->fasync = NULL;
830         tmp->q_id = (u32)file->private_data;
831         tmp->q_len = 0;
832         tmp->q_in = 0;
833         tmp->q_out = 0;
834         tmp->q_lost = 0;
835         tmp->next = open_files;
836
837         spin_lock_irqsave(&i2o_config_lock, flags);
838         open_files = tmp;
839         spin_unlock_irqrestore(&i2o_config_lock, flags);
840         
841         return 0;
842 }
843
844 static int cfg_release(struct inode *inode, struct file *file)
845 {
846         u32 id = (u32)file->private_data;
847         struct i2o_cfg_info *p1, *p2;
848         unsigned int flags;
849
850         lock_kernel();
851         p1 = p2 = NULL;
852
853         spin_lock_irqsave(&i2o_config_lock, flags);
854         for(p1 = open_files; p1; )
855         {
856                 if(p1->q_id == id)
857                 {
858
859                         if(p1->fasync)
860                                 cfg_fasync(-1, file, 0);
861                         if(p2)
862                                 p2->next = p1->next;
863                         else
864                                 open_files = p1->next;
865
866                         kfree(p1);
867                         break;
868                 }
869                 p2 = p1;
870                 p1 = p1->next;
871         }
872         spin_unlock_irqrestore(&i2o_config_lock, flags);
873         unlock_kernel();
874
875         return 0;
876 }
877
878 static int cfg_fasync(int fd, struct file *fp, int on)
879 {
880         u32 id = (u32)fp->private_data;
881         struct i2o_cfg_info *p;
882
883         for(p = open_files; p; p = p->next)
884                 if(p->q_id == id)
885                         break;
886
887         if(!p)
888                 return -EBADF;
889
890         return fasync_helper(fd, fp, on, &p->fasync);
891 }
892
893 static struct file_operations config_fops =
894 {
895         owner:          THIS_MODULE,
896         llseek:         no_llseek,
897         read:           cfg_read,
898         write:          cfg_write,
899         ioctl:          cfg_ioctl,
900         open:           cfg_open,
901         release:        cfg_release,
902         fasync:         cfg_fasync,
903 };
904
905 static struct miscdevice i2o_miscdev = {
906         I2O_MINOR,
907         "i2octl",
908         &config_fops
909 };      
910
911 #ifdef MODULE
912 int init_module(void)
913 #else
914 int __init i2o_config_init(void)
915 #endif
916 {
917         printk(KERN_INFO "I2O configuration manager v 0.04.\n");
918         printk(KERN_INFO "  (C) Copyright 1999 Red Hat Software\n");
919         
920         if((page_buf = kmalloc(4096, GFP_KERNEL))==NULL)
921         {
922                 printk(KERN_ERR "i2o_config: no memory for page buffer.\n");
923                 return -ENOBUFS;
924         }
925         if(misc_register(&i2o_miscdev)==-1)
926         {
927                 printk(KERN_ERR "i2o_config: can't register device.\n");
928                 kfree(page_buf);
929                 return -EBUSY;
930         }
931         /*
932          *      Install our handler
933          */
934         if(i2o_install_handler(&cfg_handler)<0)
935         {
936                 kfree(page_buf);
937                 printk(KERN_ERR "i2o_config: handler register failed.\n");
938                 misc_deregister(&i2o_miscdev);
939                 return -EBUSY;
940         }
941         /*
942          *      The low 16bits of the transaction context must match this
943          *      for everything we post. Otherwise someone else gets our mail
944          */
945         i2o_cfg_context = cfg_handler.context;
946         return 0;
947 }
948
949 #ifdef MODULE
950
951 void cleanup_module(void)
952 {
953         misc_deregister(&i2o_miscdev);
954         
955         if(page_buf)
956                 kfree(page_buf);
957         if(i2o_cfg_context != -1)
958                 i2o_remove_handler(&cfg_handler);
959 }
960  
961 EXPORT_NO_SYMBOLS;
962 MODULE_AUTHOR("Red Hat Software");
963 MODULE_DESCRIPTION("I2O Configuration");
964
965 #endif