Subversion Repositories f9daq

Rev

Rev 44 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
9 f9daq 1
//****************************************************************************
2
// Copyright (C) 2000-2006  ARW Elektronik Germany
3
//
4
//
5
// This program is free software; you can redistribute it and/or modify
6
// it under the terms of the GNU General Public License as published by
7
// the Free Software Foundation; either version 2 of the License, or
8
// (at your option) any later version.
9
//
10
// This program is distributed in the hope that it will be useful,
11
// but WITHOUT ANY WARRANTY; without even the implied warranty of
12
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
// GNU General Public License for more details.
14
//
15
// You should have received a copy of the GNU General Public License
16
// along with this program; if not, write to the Free Software
17
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18
//
19
// This product is not authorized for use as critical component in 
20
// life support systems without the express written approval of 
21
// ARW Elektronik Germany.
22
//  
23
// Please announce changes and hints to ARW Elektronik
24
//
25
// Maintainer(s): Klaus Hitschler (klaus.hitschler@gmx.de)
26
//
27
//****************************************************************************
28
 
29
//****************************************************************************
30
//
31
// main.c -- the main driver module for the PCIVME PCI to VME Interface
32
//           Thanks to A.Rubini's Book and Dirk Muelhlenberg and H.J.Mathes 
33
//           for their arwvme driver
34
//
35
// $Log: main.c,v $
36
// Revision 1.10  2006/06/04 12:20:46  klaus
37
// release_20060604; Version 3.2; pci_{en|dis}able_device() added
38
//
39
// Revision 1.9  2004/08/13 19:23:26  klaus
40
// conversion to kernel-version 2.6, released version 3.0
41
//
42
// Revision 1.8  2003/06/27 17:25:52  klaus
43
// incomplete try to get mmap() with nopage() running for automatic page switch
44
//
45
// Revision 1.7  2002/10/18 21:56:28  klaus
46
// completed functional features, untested
47
//
48
// Revision 1.6  2002/10/18 21:56:28  klaus
49
// completed functional features, untested
50
//
51
// Revision 1.5  2002/10/17 19:05:03  klaus
52
// VME access is working through test to lib to driver
53
//
54
//****************************************************************************
55
#define NOPAGE_SIGBUS   (NULL)
56
 
57
#define VERSION_HI 3
58
#define VERSION_LO 2
59
 
60
/*--- INCLUDES ---------------------------------------------------------------------------*/
61
#include "common.h"  /* must be the first include */
62
#include <linux/module.h>
63
 
64
#include <linux/sched.h>
65
#include <linux/proc_fs.h>
66
#include <linux/pci.h>
67
#include <asm/types.h>
68
#include <linux/mm.h>
69
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
70
#include <linux/interrupt.h>
71
#endif
72
 
73
#include "askpci.h"
74
#include "plxbug.h"
75
#include "plx9050.h"
76
#include "fops.h"
77
#include "pcivme.h"
78
#include "pciif.h"
79
#include "vic.h"
80
#include "main.h"
81
 
82
/*--- DEFINES -----------------------------------------------------------------------------*/
83
MODULE_AUTHOR("klaus.hitschler@gmx.de");
84
MODULE_DESCRIPTION("Driver for ARW Elektronik PCI VME interface.");
85
MODULE_SUPPORTED_DEVICE("PCIVME");
86
MODULE_LICENSE("GPL");
87
 
88
#define MAJOR_NO               0                         /* use dynamic assignment */
89
 
90
#define PCIVME_VENDOR_ID  0x10B5
91
#define PCIVME_DEVICE_ID  0x9050
92
#define PCIVME_SUBSYS_ID  0x1167
93
#define PCIVME_SUBVEN_ID  0x9050
94
 
95
/*--- TYPEDEFS ----------------------------------------------------------------------------*/
96
 
97
/*--- GLOBALS -----------------------------------------------------------------------------*/
98
DRIVER_OBJ drv;
99
 
100
/*--- LOCALS ------------------------------------------------------------------------------*/
101
 
102
/*--- FUNCTIONS ---------------------------------------------------------------------------*/
44 f9daq 103
 
104
struct proc_dir_entry *proc;
105
 
9 f9daq 106
static int my_interrupt(u16 intCSR)
107
{
108
    int result = NOT_MY_INTERRUPT;
109
 
110
    if (intCSR & 0x0040)  // it is global enabled
111
    {
112
        if ((intCSR & 0x0028) == 0x0028) // it is a enabled PCIADA interrupt
113
            result = PCIADA_INTERRUPT;
114
        else
115
            if ((intCSR & 0x0005) == 0x0005) // it is a enabled VMEMM interrupt
116
            result = VMEMM_INTERRUPT;
117
    }
118
 
119
    return result;
120
}
121
 
43 f9daq 122
static irqreturn_t pcivme_irqhandler(int irq, void *dev_id )
9 f9daq 123
{
124
    DEVICE_OBJ *pd = (DEVICE_OBJ *)dev_id;
125
 
126
    if (pd)
127
    {
128
        // evaluate the reason of the interrupt - if it is mine
129
        u16 intCSR          = readw((const volatile void *) (pd->pPCIADAIntCSR));
130
        int which_interrupt = my_interrupt(intCSR);
131
 
132
        if (which_interrupt)
133
        {
134
            writew(intCSR & ~0x40, (volatile void *) pd->pPCIADAIntCSR); /* disable global interrupts */
135
            pd->wIrqStatus = (u16)which_interrupt;
136
            pd->dwInterruptCount++;
137
            wake_up_interruptible(&pd->event_queue);   /* stop blocking if any */
138
 
139
                        return IRQ_RETVAL(1);
140
        }
141
    }
142
 
143
        return IRQ_RETVAL(0);
144
}
145
 
146
static int request_io_memory(PCIConfig *pPch)
147
{
362 f9daq 148
    if (!request_mem_region(pci_resource_start(pPch->pciDev, 0),  LCR_SPACE, DEVICE_NAME) ) {
149
                        PRINTK(KERN_WARNING "%s: LCR memory region %llx-%llx already in use\n", DEVICE_NAME,
150
                                 pci_resource_start(pPch->pciDev, 0), pci_resource_start(pPch->pciDev, 0) + LCR_SPACE );
151
                        kfree(pPch);
152
                        return EBUSY;
9 f9daq 153
 
362 f9daq 154
    };
155
    if (!request_mem_region(pci_resource_start(pPch->pciDev, 2),  CTL_SPACE, DEVICE_NAME) ){
156
                        PRINTK(KERN_WARNING "%s: CTL memory region %llx-%llx already in use\n", DEVICE_NAME,
157
                                 pci_resource_start(pPch->pciDev, 0),  pci_resource_start(pPch->pciDev, 2) + CTL_SPACE );
158
                        kfree(pPch);
159
                        return EBUSY;
9 f9daq 160
 
161
    }
362 f9daq 162
    if (!request_mem_region(pci_resource_start(pPch->pciDev, 2) + CTL_SPACE, VME_SPACE, DEVICE_NAME) ){
163
                        PRINTK(KERN_WARNING "%s: VME memory region %llx-%llx already in use\n", DEVICE_NAME,
164
                                 pci_resource_start(pPch->pciDev, 0)+CTL_SPACE,  pci_resource_start(pPch->pciDev, 0) + LCR_SPACE+VME_SPACE );
165
                        kfree(pPch);
166
                        return EBUSY;
9 f9daq 167
 
362 f9daq 168
    };
9 f9daq 169
    return 0;
170
}
171
 
172
static void release_io_memory(PCIConfig *pPch)
173
{
174
    release_mem_region(pci_resource_start(pPch->pciDev, 0),  LCR_SPACE);
175
    release_mem_region(pci_resource_start(pPch->pciDev, 2),  CTL_SPACE);
176
    release_mem_region(pci_resource_start(pPch->pciDev, 2) + CTL_SPACE, VME_SPACE);
177
}
178
 
179
static int translate_addresses(DEVICE_OBJ *pd, PCIConfig *pPch)    /* differs from PCICC32 */
180
{
181
    if (pci_resource_start(pPch->pciDev, 0) < LOW_MEMORY)  /* LCR ISA base addresses */
182
        pd->pLCR = (u32)bus_to_virt(pci_resource_start(pPch->pciDev, 0));
183
    else
184
        pd->pLCR = (u32)ioremap(pci_resource_start(pPch->pciDev, 0), LCR_SPACE);
185
 
186
    if (pci_resource_start(pPch->pciDev, 2) < LOW_MEMORY)  /* User ISA base addresses */
187
    {
188
        pd->pCtl = (u32)bus_to_virt(pci_resource_start(pPch->pciDev, 2)            );
189
        pd->pVME = (u32)bus_to_virt(pci_resource_start(pPch->pciDev, 2) + CTL_SPACE);
190
    }
191
    else
192
    {
193
        pd->pPhysVME = pci_resource_start(pPch->pciDev, 2) + CTL_SPACE;
194
 
195
        pd->pCtl = (u32)ioremap(pci_resource_start(pPch->pciDev, 2)            , CTL_SPACE);
196
        pd->pVME = (u32)ioremap(pci_resource_start(pPch->pciDev, 2) + CTL_SPACE, VME_SPACE);
197
    }
198
 
199
    return 0;
200
}
201
 
202
static void un_translate_addresses(DEVICE_OBJ *pd, PCIConfig *pPch)
203
{
204
    if (pci_resource_start(pPch->pciDev, 0) >= LOW_MEMORY)  /* no LCR ISA base addresses */
205
        iounmap((void *)pd->pLCR);
206
 
207
    if (pci_resource_start(pPch->pciDev, 2) >= LOW_MEMORY)
208
    {
209
        pd->pPhysVME = 0;
210
 
211
        iounmap((void *)pd->pCtl);
212
        iounmap((void *)pd->pVME);
213
    }
214
}
215
 
216
static void soft_init(DEVICE_OBJ *pd)
217
{
218
    if (pd)
219
    {
220
        init_waitqueue_head(&pd->event_queue);
221
 
222
        pd->pLCR = pd->pCtl = pd->pVME = 0;
223
        pd->pPch = (PCIConfig *)NULL;
224
        pd->bConnected = 0;
225
        pd->wInitStep = 0;    
226
        pd->wIrq = 0xFFFF;          
227
        pd->dwInterruptCount = 0;
228
        pd->wIrqStatus = 0;
229
        pd->nOpenCounter = 0;
230
 
231
        pd->cModuleNumber = 255;
232
        pd->cFPGAVersion = 255;
233
        pd->cSystemController = 0;
234
        pd->cWordMode         = 0;
235
 
236
        pd->pAdrMod = 0;
237
        pd->pAdrReg = 0;
238
        pd->pCSR    = 0;
239
 
240
        pd->pPCIADACntrl  = 0;
241
        pd->pPCIADAIntCSR = 0;      
242
 
243
        pd->bCurrentModifier     = 0;
244
        pd->dwCurrentPageAddress = -1;
245
                                pd->currentMap.pageptr = NOPAGE_SIGBUS;
246
                                pd->currentMap.addr = 0;
247
    }
248
}
249
 
250
int test_connection(DEVICE_OBJ *pd)
251
{
252
    u16 intCSR_store;
253
    u16 cntrl_store;
254
    int i;      
255
    int error   = 0;
256
    u32 dwADRH  = pd->pCtl + ADRH;
257
    u32 dwADRL  = pd->pCtl + ADRL;
258
    u32 dwADRHL = pd->pCtl + ADRHL;
259
    u32 dwStore;
260
    u16 wRet;
261
 
262
    cntrl_store  = readw((const volatile void *) pd->pPCIADACntrl);         /* read CONTROL register */
263
    intCSR_store = readw((const volatile void *) pd->pPCIADAIntCSR);        /* read interrupt + CSR register */
264
 
265
    writew(0, (volatile void *) pd->pPCIADAIntCSR);                   /* disable interrupts */
266
    writew(cntrl_store | 0x0180, (volatile void *) pd->pPCIADACntrl); /* enable access */
267
 
268
    // save adr register
269
    dwStore = readl((const volatile void *) dwADRHL);
270
    for (i = 1000; i; i--)
271
    {
272
        writew(0x5555, (volatile void *) dwADRH);
273
        writew(0xAAAA, (volatile void *) dwADRL);
274
        wRet   = readw((const volatile void *) dwADRH);
275
        if (wRet != 0x5555)
276
        {
277
            error = 1;
278
            break;
279
        }
280
 
281
        writew(0xAAAA, (volatile void *) dwADRH);
282
        writew(0x5555, (volatile void *) dwADRL);
283
        wRet   = readw((const volatile void *) dwADRH);
284
        if (wRet != 0xAAAA)
285
        {
286
            error = 1;
287
            break;
288
        }
289
 
290
        writew(0x0000, (volatile void *) dwADRH);
291
        writew(0xFFFF, (volatile void *) dwADRL);
292
        wRet   = readw((const volatile void *) dwADRH);
293
        if (wRet != 0x0000)
294
        {
295
            error = 1;
296
            break;
297
        }
298
 
299
        writew(0xFFFF, (volatile void *) dwADRH);
300
        writew(0x0000, (volatile void *) dwADRL);
301
        wRet   = readw((const volatile void *) dwADRH);
302
        if (wRet != 0xFFFF)
303
        {
304
            error = 1;
305
            break;
306
        }
307
    }
308
 
309
    // restore register
310
    writel(dwStore, (volatile void *) dwADRHL);
311
 
312
    //clear possible interrupts
313
    writew(cntrl_store & ~0x0100, (volatile void *) pd->pPCIADACntrl); /* clear potential interrupt */
314
 
315
    // restore LCR registers
316
    writew(cntrl_store,  (volatile void *) pd->pPCIADACntrl);
317
    writew(intCSR_store, (volatile void *) pd->pPCIADAIntCSR);
318
 
319
    return error;  
320
}
321
 
322
int get_module_info(DEVICE_OBJ *pd)
323
{
324
    u16 intCSR_store;
325
    u16 cntrl_store;
326
    int found = 0;
327
    u16 data;
328
 
329
    cntrl_store  = readw((const volatile void *) pd->pPCIADACntrl);  /* read CONTROL register */
330
    intCSR_store = readw((const volatile void *) pd->pPCIADAIntCSR); /* read interrupt + CSR register */
331
 
332
    PRINTK(KERN_DEBUG "%s : cntrl=0x%04x, intCSR=0x%04x\n", DEVICE_NAME, cntrl_store, intCSR_store);
333
 
334
    if (cntrl_store & 0x0800) /* a VMEMM is connected */
335
    {
336
        u16 bla = cntrl_store | 0x0180;
337
 
338
        writew(0,   (volatile void *) pd->pPCIADAIntCSR); /* disable interrupts */
339
        writew(bla, (volatile void *) pd->pPCIADACntrl);  /* enable access */
340
 
341
        // read main status register
342
        data = readw((const volatile void *) pd->pCSR);
343
 
344
        if ((data & 0xF000) != VMEMM_MODULE_TYPE)
345
        {
346
            pd->cModuleNumber = pd->cFPGAVersion = 255;
347
            printk(KERN_ERR "%s : Wrong module type connected @ index %d!\n", DEVICE_NAME, pd->wIndex);
348
        }
349
        else
350
        {
351
            found = 1;
352
            pd->cModuleNumber     = (data >> 4) & 0xF;
353
            pd->cFPGAVersion      = (data >> 8) & 0xF;
354
            pd->cSystemController = (data & 0x0008);
355
            pd->cWordMode         = (data & 0x0004);
356
        }
357
 
358
        // clear possible interrupts
359
        writew(cntrl_store & ~0x0100, (volatile void *) pd->pPCIADACntrl); /* clear potential interrupt */
360
 
361
        /* restore all contents */
362
        writew(cntrl_store,  (volatile void *) pd->pPCIADACntrl);
363
        writew(intCSR_store, (volatile void *) pd->pPCIADAIntCSR);
364
    }
365
 
366
    return found;  
367
}
368
 
43 f9daq 369
//static int pcivme_read_proc(char *buf, char **start, off_t offset, int len, int *eof, void *data)
362 f9daq 370
static ssize_t pcivme_read_proc(struct file *filp,char *buf,size_t count,loff_t *offp )
9 f9daq 371
    {
372
    int              pos = 0;
373
    DEVICE_OBJ       *pd;
374
    PCIConfig        *ch;
375
    u16                cntrl;
376
    char             *cause = "none";
377
    struct list_head *ptr;
44 f9daq 378
    PRINTK(KERN_DEBUG "%s : pcivme_read_proc()\n",DEVICE_NAME);
379
 
380
    if (*offp != 0) return 0;
362 f9daq 381
    pos += sprintf(buf + pos, "\nPCIVME information. Version %d.%d from Klaus Hitschler.\n", VERSION_HI, VERSION_LO);
9 f9daq 382
 
383
    pos += sprintf(buf + pos, " ---------------------\n");
384
    pos += sprintf(buf + pos, " Interfaces found : %d\n", drv.count);
385
    pos += sprintf(buf + pos, " Major Number     : %d\n", drv.nMajor);
386
 
387
    for (ptr = drv.devList.next; ptr != &drv.devList; ptr = ptr->next)
388
    {
389
        pd = list_entry(ptr, DEVICE_OBJ, list);
390
        ch = pd->pPch;
391
        cntrl = readw((const volatile void *)(pd->pLCR + PLX9050_CNTRL));
392
        pos += sprintf(buf + pos, " --- %d ---------------\n", pd->wIndex + 1);
393
        pos += sprintf(buf + pos, " LCR     phys/virt/size : 0x%08lx/0x%08x/%d\n",(long unsigned int) pci_resource_start(ch->pciDev, 0),             pd->pLCR, LCR_SPACE);
394
        pos += sprintf(buf + pos, " Control phys/virt/size : 0x%08lx/0x%08x/%d\n",(long unsigned int)  pci_resource_start(ch->pciDev, 2),             pd->pCtl, CTL_SPACE);
395
        pos += sprintf(buf + pos, " VME     phys/virt/size : 0x%08lx/0x%08x/%d\n",(long unsigned int)  pci_resource_start(ch->pciDev, 2) + CTL_SPACE, pd->pVME, VME_SPACE);
396
        pos += sprintf(buf + pos, " Irq                    : %d\n", pd->wIrq);
397
 
398
        if (pd->bConnected)
399
        {
400
            pos += sprintf(buf + pos, " VMEMM is or was        : (software) connected.\n");
401
            pos += sprintf(buf + pos, " Module-Number          : %d\n", pd->cModuleNumber);
402
            pos += sprintf(buf + pos, " FPGA-Version           : %d\n", pd->cFPGAVersion);
403
            pos += sprintf(buf + pos, " Systemcontroller       : %s\n", (pd->cSystemController) ? "yes" : "no");
404
            pos += sprintf(buf + pos, " Word Mode              : %s\n", (pd->cWordMode) ? "yes" : "no");
405
        }
406
        else
407
            pos += sprintf(buf + pos, " VMEMM is or was        : not (software) connected.\n");      
408
 
409
        if (!((cntrl & 0x0800) && (!(cntrl & 0x0600))))
410
            pos += sprintf(buf + pos, " VMEMM is               : powered off or cable disconnected.\n");
411
 
412
        pos += sprintf(buf + pos, " IrqCount               : %d\n", pd->dwInterruptCount);
413
        if (pd->wIrqStatus & PCIADA_INTERRUPT)
414
            cause = "Timeout";
415
        else
416
            if (pd->wIrqStatus & VMEMM_INTERRUPT)
417
                cause = "VME";
418
        pos += sprintf(buf + pos, " Pending IrqStatus      : %s\n", cause);
419
    }
420
 
421
    pos += sprintf(buf + pos, "\n");
44 f9daq 422
    if (pos>count) {
423
      buf[count-1]=0;
424
      pos=count;
425
    }    
426
    PRINTK(KERN_DEBUG "%s : pcivme_read_proc() end count=%d\n",DEVICE_NAME, pos);
43 f9daq 427
    //*eof = 1;
44 f9daq 428
    *offp = pos;
9 f9daq 429
    return pos;
430
}
431
 
362 f9daq 432
static const struct proc_ops  pcivme_read_proc_fops = {    
433
proc_read: pcivme_read_proc
9 f9daq 434
};
435
 
436
static void deleteMyLists(void)
437
{
438
    DEVICE_OBJ      *pd;
439
 
440
    /* delete my lists */
441
    while (!list_empty(&drv.devList))                 // cycle through the list of pci devices and remove them
442
    {
443
        pd = (DEVICE_OBJ *)drv.devList.prev;            // empty in reverse order
444
        list_del(&pd->list);
445
        kfree(pd);
446
    }
447
 
448
    DeletePCIConfig(&drv);
449
}
450
 
44 f9daq 451
int pcivme_module_init(void)
9 f9daq 452
{
453
    PCIConfig        *ch;
454
    DEVICE_OBJ       *pd;
455
    int              result = 0;
456
    struct list_head *ptr;
457
 
458
    PRINTK(KERN_DEBUG "%s : init_module\n", DEVICE_NAME);
459
 
460
    /* create list of PCIADAs and work devices */
461
    INIT_LIST_HEAD(&drv.devList);
462
    INIT_LIST_HEAD(&drv.pciList);
463
 
464
    drv.count = 0;
465
 
466
    /* search for all PCIADA modules */
467
    if ((result = GetPCIConfig(&drv, PCIVME_DEVICE_ID, PCIVME_VENDOR_ID, PCIVME_SUBSYS_ID, PCIVME_SUBVEN_ID)))
468
    {
469
        deleteMyLists();
470
        return result;
471
    }
472
 
473
    /* fix the PLX bug in all PCIADAs */
474
    for (ptr = drv.pciList.next; ptr != &drv.pciList; ptr = ptr->next)
475
    {
476
        ch = list_entry(ptr, PCIConfig, list);
477
        PLX9050BugFix(ch);
478
    }
479
 
480
    /* create work_devices and translate the access addresses */
481
    for (ptr = drv.pciList.next; ptr != &drv.pciList; ptr = ptr->next)
482
    {
483
        ch = list_entry(ptr, PCIConfig, list);
484
 
485
        pd = (DEVICE_OBJ *)kmalloc(sizeof(DEVICE_OBJ), GFP_ATOMIC);
486
        soft_init(pd);
487
        pd->pPch = ch;
488
        pd->wIndex = drv.count;
489
 
490
        if (!request_io_memory(ch))
491
        {
492
            pd->wInitStep = 1;
493
 
494
            if (translate_addresses(pd, ch))
495
            {
496
                printk(KERN_ERR "%s : translation of addresses failed!\n", DEVICE_NAME);
497
                kfree_s(pd, sizeof(*pd));       // FREE(pd);
498
            }
499
            else
500
            {
501
                // successful translate_addresses
502
                pd->wInitStep = 2;
503
 
504
                // create some 'fast access' addresses
505
                pd->pAdrMod = pd->pCtl + VICBASE + AMSR;
506
                pd->pAdrReg = pd->pCtl + ADRHL;
507
                pd->pCSR    = pd->pCtl + CSR;
508
 
509
                pd->pPCIADACntrl  = pd->pLCR + PLX9050_CNTRL;
510
                pd->pPCIADAIntCSR = pd->pLCR + PLX9050_INTCSR;
511
 
362 f9daq 512
                //if (request_irq(pd->pPch->pciDev->irq, pcivme_irqhandler, IRQF_DISABLED| IRQF_SHARED, DEVICE_NAME, pd))
513
                if (request_irq(pd->pPch->pciDev->irq, pcivme_irqhandler, IRQF_SHARED, DEVICE_NAME, pd))
9 f9daq 514
                {
515
                    printk(KERN_ERR "%s : can't get irq @ %d\n", DEVICE_NAME, pd->pPch->pciDev->irq);
516
                    kfree_s(pd, sizeof(*pd));       // FREE(pd);
517
                }
518
                else
519
                {
520
                    // successful request_irq
521
                    pd->wInitStep = 3;
522
                    pd->wIrq = pd->pPch->pciDev->irq;
523
 
524
                    list_add_tail(&pd->list, &drv.devList);  /* add this device to list of working devices*/
525
                    drv.count++;
526
 
527
                    pd->bConnected =  get_module_info(pd);
528
                    if (pd->bConnected && test_connection(pd))
529
                    {
530
                        printk(KERN_ERR "%s : connection test @ driver install failed!\n", DEVICE_NAME);
531
                        pd->bConnected = 0;
532
                    }
533
                }
534
            }
535
        }
536
        else
537
            printk(KERN_ERR "%s : requested io-memory still claimed!\n", DEVICE_NAME);
538
    }
539
 
540
    drv.nMajor = MAJOR_NO;
541
    result = register_chrdev(drv.nMajor, DEVICE_NAME, &pcivme_fops);
542
    if (result < 0)
543
    {
544
        printk(KERN_ERR "%s: Can't install driver (%d)\n", DEVICE_NAME, result);
545
 
546
        /* untranslate translated addresses */
547
        for (ptr = drv.devList.next; ptr != &drv.devList; ptr = ptr->next)
548
        {
549
            pd = list_entry(ptr, DEVICE_OBJ, list);
550
            ch = pd->pPch;
551
            un_translate_addresses(pd, ch);
552
        }
553
 
554
        /* delete my lists */
555
        deleteMyLists();
556
 
557
        return result;
558
    }
559
    else
560
    {
561
        if (drv.nMajor == 0)
562
            drv.nMajor = result;
563
 
564
        printk(KERN_DEBUG "%s : major #%d assigned.\n", DEVICE_NAME, drv.nMajor);
565
    }
566
 
567
    /* register the proc device */
568
 
43 f9daq 569
    // create_proc_read_entry is depricated since kernel 3.10
44 f9daq 570
    //return create_proc_read_entry(DEVICE_NAME, 0, NULL, pcivme_read_proc, NULL) ? 0 : -ENODEV;
571
    proc = proc_create_data(DEVICE_NAME, 0, NULL, &pcivme_read_proc_fops, NULL);
572
    return (proc) ? 0 : -ENODEV;
573
 
9 f9daq 574
}
575
 
44 f9daq 576
void pcivme_module_exit(void)
9 f9daq 577
{
578
    PCIConfig        *ch;
579
    DEVICE_OBJ       *pd;
580
    struct list_head *ptr;
581
 
582
    PRINTK(KERN_DEBUG "%s : cleanup_module.\n", DEVICE_NAME);
583
 
584
    unregister_chrdev(drv.nMajor, DEVICE_NAME);
585
 
586
    /* unregister the proc device */
587
    remove_proc_entry(DEVICE_NAME, NULL);
588
 
589
    /* redo all */
590
    for (ptr = drv.devList.next; ptr != &drv.devList; ptr = ptr->next)
591
    {
592
        pd = list_entry(ptr, DEVICE_OBJ, list);
593
        ch = pd->pPch;
594
        switch (pd->wInitStep)
595
        {
596
            case 3:  writew(readw((const volatile void *)(pd->pLCR + PLX9050_INTCSR)) & ~0x40, (volatile void *) (pd->pLCR + PLX9050_INTCSR));  // disable global interrupts
597
                     free_irq(pd->wIrq, pd);  
598
            case 2:  un_translate_addresses(pd, ch);
599
            case 1:  release_io_memory(ch);
600
            default: pd->wInitStep = 0;
601
        }
602
 
603
        drv.count--;
604
    }
605
 
606
    deleteMyLists();
607
 
608
    return;
609
}
610
 
44 f9daq 611
module_init(pcivme_module_init);
612
module_exit(pcivme_module_exit);
613