Changeset 9765


Ignore:
Timestamp:
2007-12-15T16:53:56+01:00 (8 years ago)
Author:
blogic
Message:

danube ssc cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/danube/files/drivers/char/danube_ssc.c

    r9764 r9765  
    9191/* other forward declarations */ 
    9292static unsigned int ifx_ssc_get_kernel_clk (struct ifx_ssc_port *info); 
    93 #ifdef SSC_FRAME_INT_ENABLE 
    94 static void ifx_ssc_frm_int (int, void *, struct pt_regs *); 
    95 #endif 
    9693static void tx_int (struct ifx_ssc_port *); 
    9794static int ifx_ssc1_read_proc (char *, char **, off_t, int, int *, void *); 
    9895static void ifx_gpio_init (void); 
    99 /************************************************************************ 
    100  *  Function declaration 
    101  ************************************************************************/ 
    102 //interrupt.c 
     96 
    10397extern unsigned int danube_get_fpi_hz (void); 
    104 extern void disable_danube_irq (unsigned int irq_nr); 
    105 extern void enable_danube_irq (unsigned int irq_nr); 
    10698extern void mask_and_ack_danube_irq (unsigned int irq_nr); 
    10799 
    108 /*****************************************************************/ 
    109 typedef struct { 
    110         int (*request) (unsigned int, irq_handler_t handler, 
    111                 unsigned long, const char *, void *); 
    112         void (*free) (unsigned int irq, void *dev_id); 
    113         void (*enable) (unsigned int irq); 
    114         void (*disable) (unsigned int irq); 
    115         void (*clear) (unsigned int irq); 
    116 } ifx_int_wrapper_t; 
    117  
    118 static ifx_int_wrapper_t ifx_int_wrapper = { 
    119       request:request_irq,      // IM action: enable int 
    120       free:free_irq,            // IM action: disable int 
    121       enable:enable_danube_irq, 
    122       disable:disable_danube_irq, 
    123       clear:mask_and_ack_danube_irq, 
    124         //end:           
    125 }; 
    126  
    127 /* Fops-struct */ 
    128100static struct file_operations ifx_ssc_fops = { 
    129       owner:THIS_MODULE, 
    130       read:ifx_ssc_read,        /* read */ 
    131       write:ifx_ssc_write,      /* write */ 
    132 //        poll:         ifx_ssc_poll,    /* poll */ 
    133       ioctl:ifx_ssc_ioctl,      /* ioctl */ 
    134       open:ifx_ssc_open,        /* open */ 
    135       release:ifx_ssc_close,    /* release */ 
     101      .owner = THIS_MODULE, 
     102      .read = ifx_ssc_read, 
     103      .write = ifx_ssc_write, 
     104      .ioctl = ifx_ssc_ioctl, 
     105      .open = ifx_ssc_open, 
     106      .release = ifx_ssc_close, 
    136107}; 
    137108 
     
    165136        queue_task (&info->tqueue, &tq_cyclades);       /* it belongs to */ 
    166137        mark_bh (CYCLADES_BH);  /* then trigger event */ 
    167 }                               /* ifx_ssc_sched_event */ 
    168  
    169 /* 
    170  * This routine is used to handle the "bottom half" processing for the 
    171  * serial driver, known also the "software interrupt" processing. 
    172  * This processing is done at the kernel interrupt level, after the 
    173  * cy#/_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON.  This 
    174  * is where time-consuming activities which can not be done in the 
    175  * interrupt driver proper are done; the interrupt driver schedules 
    176  * them using ifx_ssc_sched_event(), and they get done here. 
    177  * 
    178  * This is done through one level of indirection--the task queue. 
    179  * When a hardware interrupt service routine wants service by the 
    180  * driver's bottom half, it enqueues the appropriate tq_struct (one 
    181  * per port) to the tq_cyclades work queue and sets a request flag 
    182  * via mark_bh for processing that queue.  When the time is right, 
    183  * do_ifx_ssc_bh is called (because of the mark_bh) and it requests 
    184  * that the work queue be processed. 
    185  * 
    186  * Although this may seem unwieldy, it gives the system a way to 
    187  * pass an argument (in this case the pointer to the ifx_ssc_port 
    188  * structure) to the bottom half of the driver.  Previous kernels 
    189  * had to poll every port to see if that port needed servicing. 
    190  */ 
    191 static void 
    192 do_ifx_ssc_bh (void) 
    193 { 
    194         run_task_queue (&tq_cyclades); 
    195 }                               /* do_ifx_ssc_bh */ 
     138} 
    196139 
    197140static void 
     
    291234        // check if transfer is complete 
    292235        if (info->rxbuf_ptr >= info->rxbuf_end) { 
    293                 ifx_int_wrapper.disable (info->rxirq); 
     236                disable_irq(info->rxirq); 
    294237                /* wakeup any processes waiting in read() */ 
    295238                wake_up_interruptible (&info->rwait); 
     
    318261                                                   IFX_SSC_RXREQ); 
    319262        } 
    320 }                               // rx_int 
     263} 
    321264 
    322265inline static void 
     
    373316        // check if transmission complete 
    374317        if (info->txbuf_ptr >= info->txbuf_end) { 
    375                 ifx_int_wrapper.disable (info->txirq); 
     318                disable_irq(info->txirq); 
    376319                kfree (info->txbuf); 
    377320                info->txbuf = NULL; 
     
    380323        } 
    381324 
    382 }                               // tx_int 
     325} 
    383326 
    384327irqreturn_t 
     
    445388} 
    446389 
    447 #ifdef SSC_FRAME_INT_ENABLE 
    448 static void 
    449 ifx_ssc_frm_int (int irq, void *dev_id, struct pt_regs *regs) 
    450 { 
    451         // ### TO DO: wake up framing wait-queue in conjunction with batch execution 
    452 } 
    453 #endif 
    454  
    455390static void 
    456391ifx_ssc_abort (struct ifx_ssc_port *info) 
     
    461396        local_irq_save (flags); 
    462397 
    463         // disable all int's 
    464         ifx_int_wrapper.disable (info->rxirq); 
    465         ifx_int_wrapper.disable (info->txirq); 
    466         ifx_int_wrapper.disable (info->errirq); 
    467 /* 
    468         ifx_int_wrapper.disable(info->frmirq); 
    469 */ 
     398        disable_irq(info->rxirq); 
     399        disable_irq(info->txirq); 
     400        disable_irq(info->errirq); 
     401 
    470402        local_irq_restore (flags); 
    471403 
     
    497429 
    498430        // clear pending int's  
    499         ifx_int_wrapper.clear (info->rxirq); 
    500         ifx_int_wrapper.clear (info->txirq); 
    501         ifx_int_wrapper.clear (info->errirq); 
    502 /* 
    503         ifx_int_wrapper.clear(info->frmirq); 
    504 */ 
     431        mask_and_ack_danube_irq(info->rxirq); 
     432        mask_and_ack_danube_irq(info->txirq); 
     433        mask_and_ack_danube_irq(info->errirq); 
    505434 
    506435        // clear error flags 
     
    508437                                   info->mapbase + IFX_SSC_WHBSTATE); 
    509438 
    510         //printk("IFX SSC%d: Transmission aborted\n", info->port_nr); 
    511         // enable SSC 
    512439        if (enabled) 
    513440                WRITE_PERIPHERAL_REGISTER (IFX_SSC_WHBSTATE_SET_ENABLE, 
    514441                                           info->mapbase + IFX_SSC_WHBSTATE); 
    515442 
    516 }                               // ifx_ssc_abort 
     443} 
    517444 
    518445/* 
     
    547474        info->port_is_open++; 
    548475 
    549         ifx_int_wrapper.disable (info->rxirq); 
    550         ifx_int_wrapper.disable (info->txirq); 
    551         ifx_int_wrapper.disable (info->errirq); 
    552 /* 
    553         ifx_int_wrapper.disable(info->frmirq); 
    554 */ 
     476        disable_irq(info->rxirq); 
     477        disable_irq(info->txirq); 
     478        disable_irq(info->errirq); 
    555479 
    556480        /* Flush and enable TX/RX FIFO */ 
     
    575499 
    576500        // clear pending interrupts 
    577         ifx_int_wrapper.clear (info->rxirq); 
    578         ifx_int_wrapper.clear (info->txirq); 
    579         ifx_int_wrapper.clear (info->errirq); 
    580 /* 
    581         ifx_int_wrapper.clear(info->frmirq); 
    582 */ 
    583  
    584         // enable SSC 
     501        mask_and_ack_danube_irq(info->rxirq); 
     502        mask_and_ack_danube_irq(info->txirq); 
     503        mask_and_ack_danube_irq(info->errirq); 
     504 
    585505        WRITE_PERIPHERAL_REGISTER (IFX_SSC_WHBSTATE_SET_ENABLE, 
    586506                                   info->mapbase + IFX_SSC_WHBSTATE); 
    587507 
    588508        return 0; 
    589 }                               /* ifx_ssc_open */ 
    590  
     509} 
    591510EXPORT_SYMBOL (ifx_ssc_open); 
    592511 
     
    622541 
    623542        return 0; 
    624 }                               /* ifx_ssc_close */ 
    625  
     543} 
    626544EXPORT_SYMBOL (ifx_ssc_close); 
    627545 
     
    660578        ret_val = info->rxbuf_ptr - info->rxbuf; 
    661579        return (ret_val); 
    662 }                               // ifx_ssc_read_helper_poll 
     580} 
    663581 
    664582/* helper routine to handle reads from the kernel or user-space */ 
     
    689607                /* should enable tx, right? */ 
    690608                tx_int (info); 
    691                 if (info->txbuf_ptr < info->txbuf_end) { 
    692                         ifx_int_wrapper.enable (info->txirq); 
    693                 } 
    694  
    695                 ifx_int_wrapper.enable (info->rxirq); 
     609                if (info->txbuf_ptr < info->txbuf_end) 
     610                        enable_irq(info->txirq); 
     611 
     612                enable_irq(info->rxirq); 
    696613        } 
    697614        else {                  // rx mode 
     
    700617                    IFX_SSC_RXCNT_TODO_MASK) 
    701618                        return -EBUSY; 
    702                 ifx_int_wrapper.enable (info->rxirq); 
     619                enable_irq(info->rxirq); 
    703620                // rx request limited to ' bytes 
    704621/* 
     
    727644                local_irq_restore (flags); 
    728645 
    729 //                if (filp->f_flags & O_NONBLOCK) 
    730 //                { 
    731 //                        N = -EAGAIN; 
    732 //                        goto out; 
    733 //                } 
    734646                if (signal_pending (current)) { 
    735647                        ret_val = -ERESTARTSYS; 
     
    739651        } while (1); 
    740652 
    741         ret_val = info->rxbuf_ptr - info->rxbuf;        // should be equal to len 
     653        ret_val = info->rxbuf_ptr - info->rxbuf; 
    742654        local_irq_restore (flags); 
    743655 
     
    746658        __remove_wait_queue (&info->rwait, &wait); 
    747659        return (ret_val); 
    748 }                               // ifx_ssc_read_helper 
     660} 
    749661 
    750662 
     
    768680                tx_int (info); 
    769681                if (info->txbuf_ptr < info->txbuf_end) { 
    770                         ifx_int_wrapper.enable (info->txirq); 
     682                        enable_irq(info->txirq); 
    771683                } 
    772684        } 
     
    817729 
    818730        // ### TO DO: perhaps warn if ret_val != len 
    819         ifx_int_wrapper.disable (info->rxirq); 
     731        disable_irq(info->rxirq); 
    820732 
    821733        return (ret_val); 
     
    882794                ret_val = -EFAULT; 
    883795 
    884         ifx_int_wrapper.disable (info->rxirq); 
     796        disable_irq(info->rxirq); 
    885797 
    886798        kfree (info->rxbuf); 
    887799        info->rxbuf = NULL; 
    888800        return (ret_val); 
    889 }                               // ifx_ssc_read 
     801} 
    890802 
    891803/* 
     
    925837        } 
    926838        return (ret_val); 
    927 }                               /* ifx_ssc_write */ 
    928  
    929 /* 
    930  * ------------------------------------------------------------ 
    931  * ifx_ssc_ioctl() and friends 
    932  * ------------------------------------------------------------ 
    933  */ 
    934  
    935 /*----------------------------------------------------------------------------- 
    936  FUNC-NAME  : ifx_ssc_frm_status_get 
    937  LONG-NAME  : framing status get 
    938  PURPOSE    : Get the actual status of the framing. 
    939  
    940  PARAMETER  : *info     pointer to the port-specific structure ifx_ssc_port. 
    941  
    942  RESULT     : pointer to a structure ifx_ssc_frm_status which holds busy and  
    943               count values. 
    944  
    945  REMARKS    : Returns a register value independent of framing is enabled or  
    946               not! Changes structure inside of info, so the return value isn't  
    947               needed at all, but could be used for simple access. 
    948 -----------------------------------------------------------------------------*/ 
     839} 
     840 
    949841static struct ifx_ssc_frm_status * 
    950842ifx_ssc_frm_status_get (struct ifx_ssc_port *info) 
     
    965857                (tmp & IFX_SSC_SFCON_FIR_ENABLE_AFTER_PAUSE) > 0; 
    966858        return (&info->frm_status); 
    967 }                               // ifx_ssc_frm_status_get 
    968  
    969 /*----------------------------------------------------------------------------- 
    970  FUNC-NAME  : ifx_ssc_frm_control_get 
    971  LONG-NAME  : framing control get 
    972  PURPOSE    : Get the actual control values of the framing. 
    973  
    974  PARAMETER  : *info     pointer to the port-specific structure ifx_ssc_port. 
    975  
    976  RESULT     : pointer to a structure ifx_ssc_frm_opts which holds control bits   
    977               and count reload values. 
    978  
    979  REMARKS    : Changes structure inside of info, so the return value isn't  
    980               needed at all, but could be used for simple access. 
    981 -----------------------------------------------------------------------------*/ 
     859} 
     860 
     861 
    982862static struct ifx_ssc_frm_opts * 
    983863ifx_ssc_frm_control_get (struct ifx_ssc_port *info) 
     
    998878                (tmp & IFX_SSC_SFCON_STOP_AFTER_PAUSE) > 0; 
    999879        return (&info->frm_opts); 
    1000 }                               // ifx_ssc_frm_control_get 
    1001  
    1002 /*----------------------------------------------------------------------------- 
    1003  FUNC-NAME  : ifx_ssc_frm_control_set 
    1004  LONG-NAME  : framing control set 
    1005  PURPOSE    : Set the actual control values of the framing. 
    1006  
    1007  PARAMETER  : *info     pointer to the port-specific structure ifx_ssc_port. 
    1008  
    1009  RESULT     : pointer to a structure ifx_ssc_frm_opts which holds control bits   
    1010               and count reload values. 
    1011  
    1012  REMARKS    :  
    1013 -----------------------------------------------------------------------------*/ 
     880} 
     881 
    1014882static int 
    1015883ifx_ssc_frm_control_set (struct ifx_ssc_port *info) 
     
    1050918 
    1051919        return 0; 
    1052 }                               // ifx_ssc_frm_control_set 
    1053  
    1054 /*----------------------------------------------------------------------------- 
    1055  FUNC-NAME  : ifx_ssc_rxtx_mode_set 
    1056  LONG-NAME  : rxtx mode set 
    1057  PURPOSE    : Set the transmission mode. 
    1058  
    1059  PARAMETER  : *info     pointer to the port-specific structure ifx_ssc_port. 
    1060  
    1061  RESULT     : Returns error code 
    1062  
    1063  REMARKS    : Assumes that SSC not used (SSC disabled, device not opened yet  
    1064               or just closed)  
    1065 -----------------------------------------------------------------------------*/ 
     920} 
     921 
    1066922static int 
    1067923ifx_ssc_rxtx_mode_set (struct ifx_ssc_port *info, unsigned int val) 
     
    1084940        WRITE_PERIPHERAL_REGISTER (tmp, info->mapbase + IFX_SSC_CON); 
    1085941        info->opts.modeRxTx = val; 
    1086 /*       
    1087         printk(KERN_DEBUG "IFX SSC%d: Setting mode to %s%s\n",  
    1088                info->port_nr, 
    1089                ((val & IFX_SSC_CON_RX_OFF) == 0) ? "rx ":"",  
    1090                ((val & IFX_SSC_CON_TX_OFF) == 0) ? "tx":""); 
    1091 */ 
    1092942        return 0; 
    1093 }                               // ifx_ssc_rxtx_mode_set 
     943} 
    1094944 
    1095945void 
     
    1118968} 
    1119969 
    1120 /* 
    1121  * This routine intializes the SSC appropriately depending 
    1122  * on slave/master and full-/half-duplex mode. 
    1123  * It assumes that the SSC is disabled and the fifo's and buffers  
    1124  * are flushes later on. 
    1125  */ 
    1126970static int 
    1127971ifx_ssc_sethwopts (struct ifx_ssc_port *info) 
     
    11951039 
    11961040        return 0; 
    1197 }                               // ifx_ssc_sethwopts 
     1041} 
    11981042 
    11991043static int 
     
    12171061        // compute divider 
    12181062        br = (((ifx_ssc_clock >> 1) + baud / 2) / baud) - 1; 
    1219         asm ("SYNC"); 
     1063        wmb(); 
    12201064        if (br > 0xffff || 
    12211065            ((br == 0) && 
     
    12331077        local_irq_restore (flags); 
    12341078        return 0; 
    1235 }                               // ifx_ssc_set_baud 
     1079} 
    12361080 
    12371081static int 
     
    12731117                                           info->mapbase + IFX_SSC_WHBSTATE); 
    12741118        return 0; 
    1275 }                               // ifx_ssc_hwinit 
    1276  
    1277 /*----------------------------------------------------------------------------- 
    1278  FUNC-NAME  : ifx_ssc_batch_exec 
    1279  LONG-NAME  :  
    1280  PURPOSE    :  
    1281  
    1282  PARAMETER  : *info     pointer to the port-specific structure ifx_ssc_port. 
    1283  
    1284  RESULT     : Returns error code 
    1285  
    1286  REMARKS    :  
    1287 -----------------------------------------------------------------------------*/ 
    1288 static int 
    1289 ifx_ssc_batch_exec (struct ifx_ssc_port *info, 
    1290                     struct ifx_ssc_batch_list *batch_anchor) 
    1291 { 
    1292         // ### TO DO: implement user space batch execution 
    1293         // first, copy the whole linked list from user to kernel space 
    1294         // save some hardware options 
    1295         // execute list 
    1296         // restore hardware options if selected 
    1297         return -EFAULT; 
    1298 }                               // ifx_ssc_batch_exec 
    1299  
    1300 /* 
    1301  * This routine allows the driver to implement device- 
    1302  * specific ioctl's.  If the ioctl number passed in cmd is 
    1303  * not recognized by the driver, it should return ENOIOCTLCMD. 
    1304  */ 
     1119} 
     1120 
    13051121int 
    13061122ifx_ssc_ioctl (struct inode *inode, struct file *filp, unsigned int cmd, 
     
    15111327 
    15121328        return ret_val; 
    1513 }                               /* ifx_ssc_ioctl */ 
     1329} 
    15141330 
    15151331EXPORT_SYMBOL (ifx_ssc_ioctl); 
    1516  
    1517 ///* the poll routine */ 
    1518 //static unsigned int 
    1519 //ifx_ssc_poll(struct file *filp, struct poll_table_struct *pts) 
    1520 //{ 
    1521 //        int unit = MINOR(filp->f_dentry->d_inode->i_rdev); 
    1522 //      struct ifx_ssc_port *info; 
    1523 //        unsigned int mask = 0;  
    1524 //      int spc; 
    1525 // 
    1526 //      info = &isp[unit]; 
    1527 // 
    1528 //        /* add event to the wait queues */ 
    1529 //        /* DO NOT FORGET TO DO A WAKEUP ON THESE !!!! */ 
    1530 //        poll_wait(filp, &info->pwait, pts); 
    1531 // 
    1532 //      /* are there bytes in the RX SW-FIFO? */ 
    1533 //        if (info->rxrp != info->rxwp) 
    1534 //                mask |= POLLIN | POLLRDNORM; 
    1535 // 
    1536 //      /* free space in the TX SW-FIFO */ 
    1537 //      spc = info->txrp - info->txwp - 1; 
    1538 //      if (spc < 0) 
    1539 //              spc += TX_BUFSIZE; 
    1540 //#ifdef IFX_SSC_USEDMA 
    1541 //      /* writing always works, except in the DMA case when all descriptors */ 
    1542 //      /* are used up */ 
    1543 //      if (unit == 1 && info->dma_freecnt == 0) 
    1544 //              spc = 0; 
    1545 //#endif 
    1546 //      if (spc > 0) 
    1547 //              mask |= POLLOUT | POLLWRNORM; 
    1548 // 
    1549 //        return (mask); 
    1550 //} 
    15511332 
    15521333static int 
     
    15781359        off += sprintf (page + off, "TX Bytes %d\n", isp[0].stats.txBytes); 
    15791360 
    1580         local_irq_restore(flags);       /* XXXXX */ 
     1361        local_irq_restore(flags); 
    15811362        *eof = 1; 
    15821363        return (off); 
    15831364} 
    1584  
    1585 /* 
    1586  * This routine prints out the appropriate serial driver version number 
    1587  */ 
    1588 static inline void 
    1589 show_version (void) 
    1590 { 
    1591 #if 0 
    1592         printk ("Infineon Technologies Synchronous Serial Controller (SSC) driver\n" "  version %s - built %s %s\n", IFX_SSC_DRV_VERSION, __DATE__, __TIME__); 
    1593 #endif 
    1594 }                               /* show_version */ 
    15951365 
    15961366/* 
     
    16171387        } 
    16181388        memset (isp, 0, nbytes); 
    1619  
    1620         show_version (); 
    16211389 
    16221390        /* register the device */ 
     
    17021470                // ### TO DO: interrupt handling with multiple instances 
    17031471                ret_val = 
    1704                         ifx_int_wrapper.request (info->txirq, ifx_ssc_tx_int, SA_INTERRUPT, "ifx_ssc_tx", info); 
     1472                        request_irq(info->txirq, ifx_ssc_tx_int, SA_INTERRUPT, "ifx_ssc_tx", info); 
    17051473                if (ret_val) { 
    17061474                        printk ("%s: unable to get irq %d\n", __FUNCTION__, 
     
    17101478                } 
    17111479                ret_val = 
    1712                         ifx_int_wrapper.request (info->rxirq, ifx_ssc_rx_int, SA_INTERRUPT, "ifx_ssc_rx", info); 
     1480                        request_irq(info->rxirq, ifx_ssc_rx_int, SA_INTERRUPT, "ifx_ssc_rx", info); 
    17131481                if (ret_val) { 
    17141482                        printk ("%s: unable to get irq %d\n", __FUNCTION__, 
     
    17181486                } 
    17191487                ret_val = 
    1720                         ifx_int_wrapper.request (info->errirq, ifx_ssc_err_int, SA_INTERRUPT,"ifx_ssc_err", info); 
     1488                        request_irq(info->errirq, ifx_ssc_err_int, SA_INTERRUPT,"ifx_ssc_err", info); 
    17211489                if (ret_val) { 
    17221490                        printk ("%s: unable to get irq %d\n", __FUNCTION__, 
     
    17251493                        goto irqerr; 
    17261494                } 
    1727 /* 
    1728                 ret_val = ifx_int_wrapper.request(info->frmirq, ifx_ssc_frm_int,  
    1729                                                   0, "ifx_ssc_frm", info); 
    1730                 if (ret_val){ 
    1731                         printk("%s: unable to get irq %d\n", __FUNCTION__, 
    1732                                         info->frmirq); 
    1733                         local_irq_restore(flags); 
    1734                         goto irqerr; 
    1735                 } 
    1736  
    1737 */ 
    17381495                WRITE_PERIPHERAL_REGISTER (IFX_SSC_DEF_IRNEN, 
    17391496                                           info->mapbase + IFX_SSC_IRN_EN); 
    1740                 ifx_int_wrapper.enable (info->txirq); 
    1741                 ifx_int_wrapper.enable (info->rxirq); 
    1742                 ifx_int_wrapper.enable (info->errirq); 
     1497                enable_irq(info->txirq); 
     1498                enable_irq(info->rxirq); 
     1499                enable_irq(info->errirq); 
    17431500 
    17441501                local_irq_restore (flags); 
    1745         }                       // for (i = 0; i < PORT_CNT; i++) 
     1502        } 
    17461503 
    17471504        /* init the SSCs with default values */ 
     
    17621519        return 0; 
    17631520 
    1764       irqerr: 
     1521irqerr: 
    17651522        // ### TO DO: multiple instances 
    1766         ifx_int_wrapper.free (isp[0].txirq, &isp[0]); 
    1767         ifx_int_wrapper.free (isp[0].rxirq, &isp[0]); 
    1768         ifx_int_wrapper.free (isp[0].errirq, &isp[0]); 
    1769 /* 
    1770         ifx_int_wrapper.free(isp[0].frmirq, &isp[0]); 
    1771 */ 
    1772       errout: 
     1523        free_irq(isp[0].txirq, &isp[0]); 
     1524        free_irq(isp[0].rxirq, &isp[0]); 
     1525        free_irq(isp[0].errirq, &isp[0]); 
     1526errout: 
    17731527        /* free up any allocated memory in the error case */ 
    17741528        kfree (isp); 
     
    17871541                                           isp[i].mapbase + IFX_SSC_WHBSTATE); 
    17881542                /* free the interrupts */ 
    1789                 ifx_int_wrapper.free (isp[i].txirq, &isp[i]); 
    1790                 ifx_int_wrapper.free (isp[i].rxirq, &isp[i]); 
    1791                 ifx_int_wrapper.free (isp[i].errirq, &isp[i]); 
    1792 /* 
    1793                 ifx_int_wrapper.free(isp[i].frmirq, &isp[i]); 
    1794  
    1795                 if (isp[i].rxbuf != NULL) 
    1796                         kfree(isp[i].rxbuf); 
    1797                 if (isp[i].txbuf != NULL) 
    1798                         kfree(isp[i].txbuf); 
    1799 */ 
     1543                free_irq(isp[i].txirq, &isp[i]); 
     1544                free_irq(isp[i].rxirq, &isp[i]); 
     1545                free_irq(isp[i].errirq, &isp[i]); 
    18001546        } 
    18011547        kfree (isp); 
    1802         /* unregister the device */ 
    1803 //      if (unregister_chrdev (maj, "ssc")) { 
    1804 //              printk ("Unable to unregister major %d for the SSC\n", maj); 
    1805 //      } 
    18061548        /* delete /proc read handler */ 
    18071549        remove_proc_entry ("driver/ssc1", NULL); 
    18081550        remove_proc_entry ("driver/ssc2", NULL); 
    1809 }                               /* ifx_ssc_cleanup_module */ 
     1551} 
    18101552 
    18111553module_exit (ifx_ssc_cleanup_module); 
Note: See TracChangeset for help on using the changeset viewer.