Changeset 9767


Ignore:
Timestamp:
2007-12-15T17:54:18+01:00 (9 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

    r9766 r9767  
    108108static inline unsigned int 
    109109ifx_ssc_get_kernel_clk (struct ifx_ssc_port *info) 
    110 {                               // ATTENTION: This function assumes that the CLC register is set with the  
    111         // appropriate value for RMC. 
     110{ 
    112111        unsigned int rmc; 
    113112 
    114         rmc = (READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_CLC) & 
    115                IFX_CLC_RUN_DIVIDER_MASK) >> IFX_CLC_RUN_DIVIDER_OFFSET; 
    116         if (rmc == 0) { 
     113        rmc = (READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_CLC) & IFX_CLC_RUN_DIVIDER_MASK) >> IFX_CLC_RUN_DIVIDER_OFFSET; 
     114        if (rmc == 0) 
     115        { 
    117116                printk ("ifx_ssc_get_kernel_clk rmc==0 \n"); 
    118                 return (0); 
    119         } 
    120         return (danube_get_fpi_hz () / rmc); 
     117                return 0; 
     118        } 
     119        return danube_get_fpi_hz () / rmc; 
    121120} 
    122121 
     
    142141        struct ifx_ssc_port *info = (struct ifx_ssc_port *) private_; 
    143142 
    144         if (test_and_clear_bit (Cy_EVENT_HANGUP, &info->event)) { 
     143        if (test_and_clear_bit (Cy_EVENT_HANGUP, &info->event)) 
     144        { 
    145145                wake_up_interruptible (&info->open_wait); 
    146146                info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CALLOUT_ACTIVE); 
    147147        } 
    148         if (test_and_clear_bit (Cy_EVENT_OPEN_WAKEUP, &info->event)) { 
     148 
     149        if (test_and_clear_bit (Cy_EVENT_OPEN_WAKEUP, &info->event)) 
    149150                wake_up_interruptible (&info->open_wait); 
    150         } 
    151         if (test_and_clear_bit (Cy_EVENT_DELTA_WAKEUP, &info->event)) { 
     151 
     152        if (test_and_clear_bit (Cy_EVENT_DELTA_WAKEUP, &info->event)) 
    152153                wake_up_interruptible (&info->delta_msr_wait); 
    153         } 
    154         if (test_and_clear_bit (Cy_EVENT_WRITE_WAKEUP, &info->event)) { 
     154 
     155        if (test_and_clear_bit (Cy_EVENT_WRITE_WAKEUP, &info->event)) 
    155156                wake_up_interruptible (&tty->write_wait); 
    156         } 
    157157#ifdef Z_WAKE 
    158         if (test_and_clear_bit (Cy_EVENT_SHUTDOWN_WAKEUP, &info->event)) { 
     158        if (test_and_clear_bit (Cy_EVENT_SHUTDOWN_WAKEUP, &info->event)) 
    159159                wake_up_interruptible (&info->shutdown_wait); 
    160         } 
    161160#endif 
    162 }                               /* do_softint */ 
    163 #endif /* IFX_SSC_INT_USE_BH */ 
    164 #endif // not_yet 
     161} 
     162#endif 
     163#endif 
    165164 
    166165inline static void 
     
    172171        unsigned int rx_valid_cnt; 
    173172        /* number of words waiting in the RX FIFO */ 
    174         fifo_fill_lev = (READ_PERIPHERAL_REGISTER (info->mapbase + 
    175                                                    IFX_SSC_FSTAT) & 
    176                          IFX_SSC_FSTAT_RECEIVED_WORDS_MASK) >> 
    177                 IFX_SSC_FSTAT_RECEIVED_WORDS_OFFSET; 
     173        fifo_fill_lev = (READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_FSTAT) & IFX_SSC_FSTAT_RECEIVED_WORDS_MASK) >> IFX_SSC_FSTAT_RECEIVED_WORDS_OFFSET; 
    178174        // Note: There are always 32 bits in a fifo-entry except for the last  
    179175        // word of a contigous transfer block and except for not in rx-only  
     
    192188        while ((bytes_in_buf >= 4) && (fifo_fill_lev > 0)) { 
    193189                tmp_ptr = (unsigned long *) info->rxbuf_ptr; 
    194                 *tmp_ptr = 
    195                         READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_RB); 
     190                *tmp_ptr = READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_RB); 
    196191                info->rxbuf_ptr += 4; 
    197192                info->stats.rxBytes += 4; 
    198193                fifo_fill_lev--; 
    199194                bytes_in_buf -= 4; 
    200         }                       // while ((bytes_in_buf >= 4) && (fifo_fill_lev > 0)) 
     195        } 
     196 
    201197        // now do the rest as mentioned in STATE.RXBV 
    202198        while ((bytes_in_buf > 0) && (fifo_fill_lev > 0)) { 
    203                 rx_valid_cnt = 
    204                         (READ_PERIPHERAL_REGISTER 
    205                          (info->mapbase + 
    206                           IFX_SSC_STATE) & IFX_SSC_STATE_RX_BYTE_VALID_MASK) 
    207                         >> IFX_SSC_STATE_RX_BYTE_VALID_OFFSET; 
     199                rx_valid_cnt = (READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_STATE) & IFX_SSC_STATE_RX_BYTE_VALID_MASK) >> IFX_SSC_STATE_RX_BYTE_VALID_OFFSET; 
    208200                if (rx_valid_cnt == 0) 
    209201                        break; 
    210                 if (rx_valid_cnt > bytes_in_buf) { 
    211                         // ### TO DO: warning message: not block aligned data, other data  
    212                         //                             in this entry will be lost 
     202 
     203                if (rx_valid_cnt > bytes_in_buf) 
    213204                        rx_valid_cnt = bytes_in_buf; 
    214                 } 
    215                 tmp_val = 
    216                         READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_RB); 
    217  
    218                 for (i = 0; i < rx_valid_cnt; i++) { 
    219                         *info->rxbuf_ptr = 
    220                                 (tmp_val >> (8 * (rx_valid_cnt - i - 1))) & 
    221                                 0xff; 
    222 /*                       
    223                         *info->rxbuf_ptr = tmp_val & 0xff; 
    224                         tmp_val >>= 8; 
    225 */ 
     205 
     206                tmp_val = READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_RB); 
     207 
     208                for (i = 0; i < rx_valid_cnt; i++) 
     209                { 
     210                        *info->rxbuf_ptr = (tmp_val >> (8 * (rx_valid_cnt - i - 1))) & 0xff; 
    226211                        bytes_in_buf--; 
    227  
    228212                        info->rxbuf_ptr++; 
    229213                } 
    230214                info->stats.rxBytes += rx_valid_cnt; 
    231         }                       // while ((bytes_in_buf > 0) && (fifo_fill_lev > 0)) 
     215        } 
    232216 
    233217        // check if transfer is complete 
    234         if (info->rxbuf_ptr >= info->rxbuf_end) { 
     218        if (info->rxbuf_ptr >= info->rxbuf_end) 
     219        { 
    235220                disable_irq(info->rxirq); 
    236                 /* wakeup any processes waiting in read() */ 
    237221                wake_up_interruptible (&info->rwait); 
    238                 /* and in poll() */ 
    239                 //wake_up_interruptible(&info->pwait); 
    240         } 
    241         else if ((info->opts.modeRxTx == IFX_SSC_MODE_RX) && 
    242                  (READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_RXCNT) == 
    243                   0)) { 
    244                 // if buffer not filled completely and rx request done initiate new transfer 
    245 /* 
    246                 if  (info->rxbuf_end - info->rxbuf_ptr < 65536) 
    247 */ 
    248                 if (info->rxbuf_end - info->rxbuf_ptr < 
    249                     IFX_SSC_RXREQ_BLOCK_SIZE) 
    250                         WRITE_PERIPHERAL_REGISTER ((info->rxbuf_end - 
    251                                                     info-> 
    252                                                     rxbuf_ptr) << 
    253                                                    IFX_SSC_RXREQ_RXCOUNT_OFFSET, 
    254                                                    info->mapbase + 
    255                                                    IFX_SSC_RXREQ); 
     222        } else if ((info->opts.modeRxTx == IFX_SSC_MODE_RX) && (READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_RXCNT) == 0)) 
     223        { 
     224                if (info->rxbuf_end - info->rxbuf_ptr < IFX_SSC_RXREQ_BLOCK_SIZE) 
     225                        WRITE_PERIPHERAL_REGISTER ((info->rxbuf_end - info->rxbuf_ptr) << IFX_SSC_RXREQ_RXCOUNT_OFFSET, info->mapbase + IFX_SSC_RXREQ); 
    256226                else 
    257                         WRITE_PERIPHERAL_REGISTER (IFX_SSC_RXREQ_BLOCK_SIZE << 
    258                                                    IFX_SSC_RXREQ_RXCOUNT_OFFSET, 
    259                                                    info->mapbase + 
    260                                                    IFX_SSC_RXREQ); 
     227                        WRITE_PERIPHERAL_REGISTER (IFX_SSC_RXREQ_BLOCK_SIZE << IFX_SSC_RXREQ_RXCOUNT_OFFSET,  info->mapbase + IFX_SSC_RXREQ); 
    261228        } 
    262229} 
     
    267234 
    268235        int fifo_space, fill, i; 
    269         fifo_space = ((READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_ID) & 
    270                        IFX_SSC_PERID_TXFS_MASK) >> IFX_SSC_PERID_TXFS_OFFSET) 
    271                 - 
    272                 ((READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_FSTAT) & 
    273                   IFX_SSC_FSTAT_TRANSMIT_WORDS_MASK) >> 
    274                  IFX_SSC_FSTAT_TRANSMIT_WORDS_OFFSET); 
     236        fifo_space = ((READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_ID) & IFX_SSC_PERID_TXFS_MASK) >> IFX_SSC_PERID_TXFS_OFFSET) 
     237                - ((READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_FSTAT) & IFX_SSC_FSTAT_TRANSMIT_WORDS_MASK) >> IFX_SSC_FSTAT_TRANSMIT_WORDS_OFFSET); 
    275238 
    276239        if (fifo_space == 0) 
     
    282245                fill = fifo_space * 4; 
    283246 
    284         for (i = 0; i < fill / 4; i++) { 
     247        for (i = 0; i < fill / 4; i++) 
     248        { 
    285249                // at first 32 bit access 
    286                 WRITE_PERIPHERAL_REGISTER (*(UINT32 *) info->txbuf_ptr, 
    287                                            info->mapbase + IFX_SSC_TB); 
     250                WRITE_PERIPHERAL_REGISTER (*(UINT32 *) info->txbuf_ptr, info->mapbase + IFX_SSC_TB); 
    288251                info->txbuf_ptr += 4; 
    289252        } 
     
    292255        info->stats.txBytes += fill & ~0x3; 
    293256        fill &= 0x3; 
    294         if ((fifo_space > 0) & (fill > 1)) { 
     257        if ((fifo_space > 0) & (fill > 1)) 
     258        { 
    295259                // trailing 16 bit access 
    296                 WRITE_PERIPHERAL_REGISTER_16 (*(UINT16 *) info->txbuf_ptr, 
    297                                               info->mapbase + IFX_SSC_TB); 
     260                WRITE_PERIPHERAL_REGISTER_16 (*(UINT16 *) info->txbuf_ptr, info->mapbase + IFX_SSC_TB); 
    298261                info->txbuf_ptr += 2; 
    299262                info->stats.txBytes += 2; 
    300263                fifo_space--; 
    301 /* added by bingtao */ 
    302264                fill -= 2; 
    303265        } 
    304         if ((fifo_space > 0) & (fill > 0)) { 
     266 
     267        if ((fifo_space > 0) & (fill > 0)) 
     268        { 
    305269                // trailing 8 bit access 
    306                 WRITE_PERIPHERAL_REGISTER_8 (*(UINT8 *) info->txbuf_ptr, 
    307                                              info->mapbase + IFX_SSC_TB); 
     270                WRITE_PERIPHERAL_REGISTER_8 (*(UINT8 *) info->txbuf_ptr, info->mapbase + IFX_SSC_TB); 
    308271                info->txbuf_ptr++; 
    309272                info->stats.txBytes++; 
    310 /* 
    311                 fifo_space --; 
    312 */ 
    313273        } 
    314274 
    315275        // check if transmission complete 
    316         if (info->txbuf_ptr >= info->txbuf_end) { 
     276        if (info->txbuf_ptr >= info->txbuf_end) 
     277        { 
    317278                disable_irq(info->txirq); 
    318279                kfree (info->txbuf); 
    319280                info->txbuf = NULL; 
    320                 /* wake up any process waiting in poll() */ 
    321                 //wake_up_interruptible(&info->pwait); 
    322281        } 
    323282 
     
    357316                write_back |= IFX_SSC_WHBSTATE_CLR_RX_UFL_ERROR; 
    358317        } 
     318 
    359319        if ((state & IFX_SSC_STATE_RX_OFL) != 0) { 
    360320                info->stats.rxOvErr++; 
    361321                write_back |= IFX_SSC_WHBSTATE_CLR_RX_OFL_ERROR; 
    362322        } 
     323 
    363324        if ((state & IFX_SSC_STATE_TX_OFL) != 0) { 
    364325                info->stats.txOvErr++; 
    365326                write_back |= IFX_SSC_WHBSTATE_CLR_TX_OFL_ERROR; 
    366327        } 
     328 
    367329        if ((state & IFX_SSC_STATE_TX_UFL) != 0) { 
    368330                info->stats.txUnErr++; 
    369331                write_back |= IFX_SSC_WHBSTATE_CLR_TX_UFL_ERROR; 
    370332        } 
    371 //      if ((state & IFX_SSC_STATE_ABORT_ERR) != 0) { 
    372 //              info->stats.abortErr++; 
    373 //              write_back |= IFX_SSC_WHBSTATE_CLR_ABORT_ERROR; 
    374 //      } 
     333 
    375334        if ((state & IFX_SSC_STATE_MODE_ERR) != 0) { 
    376335                info->stats.modeErr++; 
     
    379338 
    380339        if (write_back) 
    381                 WRITE_PERIPHERAL_REGISTER (write_back, 
    382                                            info->mapbase + IFX_SSC_WHBSTATE); 
     340                WRITE_PERIPHERAL_REGISTER (write_back, info->mapbase + IFX_SSC_WHBSTATE); 
    383341 
    384342        local_irq_restore (flags); 
     
    406364        // releases the chip selects. This could result in unpredictable  
    407365        // behavior of connected external devices! 
    408         enabled = (READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_STATE) 
    409                    & IFX_SSC_STATE_IS_ENABLED) != 0; 
    410         WRITE_PERIPHERAL_REGISTER (IFX_SSC_WHBSTATE_CLR_ENABLE, 
    411                                    info->mapbase + IFX_SSC_WHBSTATE); 
     366        enabled = (READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_STATE) & IFX_SSC_STATE_IS_ENABLED) != 0; 
     367        WRITE_PERIPHERAL_REGISTER (IFX_SSC_WHBSTATE_CLR_ENABLE, info->mapbase + IFX_SSC_WHBSTATE); 
    412368 
    413369        // flush fifos 
    414         WRITE_PERIPHERAL_REGISTER (IFX_SSC_XFCON_FIFO_FLUSH, 
    415                                    info->mapbase + IFX_SSC_TXFCON); 
    416         WRITE_PERIPHERAL_REGISTER (IFX_SSC_XFCON_FIFO_FLUSH, 
    417                                    info->mapbase + IFX_SSC_RXFCON); 
     370        WRITE_PERIPHERAL_REGISTER (IFX_SSC_XFCON_FIFO_FLUSH, info->mapbase + IFX_SSC_TXFCON); 
     371        WRITE_PERIPHERAL_REGISTER (IFX_SSC_XFCON_FIFO_FLUSH, info->mapbase + IFX_SSC_RXFCON); 
    418372 
    419373        // free txbuf 
    420         if (info->txbuf != NULL) { 
     374        if (info->txbuf != NULL) 
     375        { 
    421376                kfree (info->txbuf); 
    422377                info->txbuf = NULL; 
     
    433388 
    434389        // clear error flags 
    435         WRITE_PERIPHERAL_REGISTER (IFX_SSC_WHBSTATE_CLR_ALL_ERROR, 
    436                                    info->mapbase + IFX_SSC_WHBSTATE); 
     390        WRITE_PERIPHERAL_REGISTER (IFX_SSC_WHBSTATE_CLR_ALL_ERROR, info->mapbase + IFX_SSC_WHBSTATE); 
    437391 
    438392        if (enabled) 
    439                 WRITE_PERIPHERAL_REGISTER (IFX_SSC_WHBSTATE_SET_ENABLE, 
    440                                            info->mapbase + IFX_SSC_WHBSTATE); 
     393                WRITE_PERIPHERAL_REGISTER (IFX_SSC_WHBSTATE_SET_ENABLE, info->mapbase + IFX_SSC_WHBSTATE); 
    441394 
    442395} 
     
    456409                from_kernel = 1; 
    457410                line = (int) inode; 
    458         } 
    459         else { 
     411        } else { 
    460412                line = MINOR (filp->f_dentry->d_inode->i_rdev); 
    461413                filp->f_op = &ifx_ssc_fops; 
     
    478430 
    479431        /* Flush and enable TX/RX FIFO */ 
    480         WRITE_PERIPHERAL_REGISTER ((IFX_SSC_DEF_TXFIFO_FL << 
    481                                     IFX_SSC_XFCON_ITL_OFFSET) | 
    482                                    IFX_SSC_XFCON_FIFO_FLUSH | 
    483                                    IFX_SSC_XFCON_FIFO_ENABLE, 
    484                                    info->mapbase + IFX_SSC_TXFCON); 
    485         WRITE_PERIPHERAL_REGISTER ((IFX_SSC_DEF_RXFIFO_FL << 
    486                                     IFX_SSC_XFCON_ITL_OFFSET) | 
    487                                    IFX_SSC_XFCON_FIFO_FLUSH | 
    488                                    IFX_SSC_XFCON_FIFO_ENABLE, 
    489                                    info->mapbase + IFX_SSC_RXFCON); 
     432        WRITE_PERIPHERAL_REGISTER ((IFX_SSC_DEF_TXFIFO_FL << IFX_SSC_XFCON_ITL_OFFSET) | IFX_SSC_XFCON_FIFO_FLUSH | IFX_SSC_XFCON_FIFO_ENABLE, info->mapbase + IFX_SSC_TXFCON); 
     433        WRITE_PERIPHERAL_REGISTER ((IFX_SSC_DEF_RXFIFO_FL << IFX_SSC_XFCON_ITL_OFFSET) | IFX_SSC_XFCON_FIFO_FLUSH | IFX_SSC_XFCON_FIFO_ENABLE, info->mapbase + IFX_SSC_RXFCON); 
    490434 
    491435        /* logically flush the software FIFOs */ 
     
    494438 
    495439        /* clear all error bits */ 
    496         WRITE_PERIPHERAL_REGISTER (IFX_SSC_WHBSTATE_CLR_ALL_ERROR, 
    497                                    info->mapbase + IFX_SSC_WHBSTATE); 
     440        WRITE_PERIPHERAL_REGISTER (IFX_SSC_WHBSTATE_CLR_ALL_ERROR, info->mapbase + IFX_SSC_WHBSTATE); 
    498441 
    499442        // clear pending interrupts 
     
    502445        mask_and_ack_danube_irq(info->errirq); 
    503446 
    504         WRITE_PERIPHERAL_REGISTER (IFX_SSC_WHBSTATE_SET_ENABLE, 
    505                                    info->mapbase + IFX_SSC_WHBSTATE); 
     447        WRITE_PERIPHERAL_REGISTER (IFX_SSC_WHBSTATE_SET_ENABLE, info->mapbase + IFX_SSC_WHBSTATE); 
    506448 
    507449        return 0; 
    508450} 
    509 EXPORT_SYMBOL (ifx_ssc_open); 
    510  
    511 /* 
    512  * This routine is called when a particular device is closed. 
    513  */ 
     451EXPORT_SYMBOL(ifx_ssc_open); 
     452 
    514453int 
    515454ifx_ssc_close (struct inode *inode, struct file *filp) 
     
    530469                return -ENXIO; 
    531470 
    532         // disable SSC 
    533         WRITE_PERIPHERAL_REGISTER (IFX_SSC_WHBSTATE_CLR_ENABLE, 
    534                                    info->mapbase + IFX_SSC_WHBSTATE); 
    535  
    536         // call abort function to disable int's, flush fifos... 
    537         ifx_ssc_abort (info); 
     471        WRITE_PERIPHERAL_REGISTER (IFX_SSC_WHBSTATE_CLR_ENABLE, info->mapbase + IFX_SSC_WHBSTATE); 
     472 
     473        ifx_ssc_abort(info); 
    538474 
    539475        info->port_is_open--; 
     
    541477        return 0; 
    542478} 
    543 EXPORT_SYMBOL (ifx_ssc_close); 
    544  
    545 /* added by bingtao */ 
    546 /* helper routine to handle reads from the kernel or user-space */ 
    547 /* info->rxbuf : never kfree and contains valid data */ 
    548 /* should be points to NULL after copying data !!! */ 
     479EXPORT_SYMBOL(ifx_ssc_close); 
     480 
    549481static ssize_t 
    550 ifx_ssc_read_helper_poll (struct ifx_ssc_port *info, char *buf, size_t len, 
    551                           int from_kernel) 
     482ifx_ssc_read_helper_poll (struct ifx_ssc_port *info, char *buf, size_t len, int from_kernel) 
    552483{ 
    553484        ssize_t ret_val; 
     
    562493        /* Vinetic driver always works in IFX_SSC_MODE_RXTX */ 
    563494        /* TXRX in poll mode */ 
    564         while (info->rxbuf_ptr < info->rxbuf_end) { 
    565                 /* This is the key point, if you don't check this condition  
    566                    kfree (NULL) will happen  
    567                    because tx only need write into FIFO, it's much fast than rx 
    568                    So when rx still waiting , tx already finish and release buf      
    569                  */ 
    570                 if (info->txbuf_ptr < info->txbuf_end) { 
     495        while (info->rxbuf_ptr < info->rxbuf_end) 
     496        { 
     497                if (info->txbuf_ptr < info->txbuf_end) 
    571498                        tx_int (info); 
    572                 } 
    573499 
    574500                rx_int (info); 
     
    576502 
    577503        ret_val = info->rxbuf_ptr - info->rxbuf; 
    578         return (ret_val); 
    579 } 
    580  
    581 /* helper routine to handle reads from the kernel or user-space */ 
    582 /* info->rx_buf : never kfree and contains valid data */ 
    583 /* should be points to NULL after copying data !!! */ 
     504 
     505        return ret_val; 
     506} 
     507 
    584508static ssize_t 
    585 ifx_ssc_read_helper (struct ifx_ssc_port *info, char *buf, size_t len, 
    586                      int from_kernel) 
     509ifx_ssc_read_helper (struct ifx_ssc_port *info, char *buf, size_t len, int from_kernel) 
    587510{ 
    588511        ssize_t ret_val; 
     
    592515        if (info->opts.modeRxTx == IFX_SSC_MODE_TX) 
    593516                return -EFAULT; 
     517 
    594518        local_irq_save (flags); 
    595519        info->rxbuf_ptr = info->rxbuf; 
    596520        info->rxbuf_end = info->rxbuf + len; 
    597         if (info->opts.modeRxTx == IFX_SSC_MODE_RXTX) { 
    598                 if ((info->txbuf == NULL) || 
    599                     (info->txbuf != info->txbuf_ptr) || 
    600                     (info->txbuf_end != len + info->txbuf)) { 
     521 
     522        if (info->opts.modeRxTx == IFX_SSC_MODE_RXTX) 
     523        { 
     524                if ((info->txbuf == NULL) || (info->txbuf != info->txbuf_ptr) || (info->txbuf_end != len + info->txbuf)) 
     525                { 
    601526                        local_irq_restore (flags); 
    602527                        printk ("IFX SSC - %s: write must be called before calling " "read in combined RX/TX!\n", __func__); 
    603528                        return -EFAULT; 
    604529                } 
    605                 local_irq_restore (flags); 
    606                 /* should enable tx, right? */ 
     530 
     531                local_irq_restore(flags); 
    607532                tx_int (info); 
     533 
    608534                if (info->txbuf_ptr < info->txbuf_end) 
    609535                        enable_irq(info->txirq); 
    610536 
    611537                enable_irq(info->rxirq); 
    612         } 
    613         else {                  // rx mode 
    614                 local_irq_restore (flags); 
    615                 if (READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_RXCNT) & 
    616                     IFX_SSC_RXCNT_TODO_MASK) 
     538        } else { 
     539                local_irq_restore(flags); 
     540                if (READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_RXCNT) & IFX_SSC_RXCNT_TODO_MASK) 
    617541                        return -EBUSY; 
    618542                enable_irq(info->rxirq); 
    619                 // rx request limited to ' bytes 
    620 /* 
    621                 if (len < 65536) 
    622 */ 
    623543                if (len < IFX_SSC_RXREQ_BLOCK_SIZE) 
    624                         WRITE_PERIPHERAL_REGISTER (len << 
    625                                                    IFX_SSC_RXREQ_RXCOUNT_OFFSET, 
    626                                                    info->mapbase + 
    627                                                    IFX_SSC_RXREQ); 
     544                        WRITE_PERIPHERAL_REGISTER (len << IFX_SSC_RXREQ_RXCOUNT_OFFSET, info->mapbase + IFX_SSC_RXREQ); 
    628545                else 
    629                         WRITE_PERIPHERAL_REGISTER (IFX_SSC_RXREQ_BLOCK_SIZE << 
    630                                                    IFX_SSC_RXREQ_RXCOUNT_OFFSET, 
    631                                                    info->mapbase + 
    632                                                    IFX_SSC_RXREQ); 
     546                        WRITE_PERIPHERAL_REGISTER (IFX_SSC_RXREQ_BLOCK_SIZE << IFX_SSC_RXREQ_RXCOUNT_OFFSET, info->mapbase + IFX_SSC_RXREQ); 
    633547        } 
    634548 
    635549        __add_wait_queue (&info->rwait, &wait); 
    636550        set_current_state (TASK_INTERRUPTIBLE); 
    637         // wakeup done in rx_int 
    638551 
    639552        do { 
     
    641554                if (info->rxbuf_ptr >= info->rxbuf_end) 
    642555                        break; 
     556 
    643557                local_irq_restore (flags); 
    644558 
    645                 if (signal_pending (current)) { 
     559                if (signal_pending (current)) 
     560                { 
    646561                        ret_val = -ERESTARTSYS; 
    647562                        goto out; 
    648563                } 
    649                 schedule (); 
     564                schedule(); 
    650565        } while (1); 
    651566 
     
    653568        local_irq_restore (flags); 
    654569 
    655       out: 
     570out: 
    656571        current->state = TASK_RUNNING; 
    657572        __remove_wait_queue (&info->rwait, &wait); 
     573 
    658574        return (ret_val); 
    659575} 
    660576 
    661  
    662 /* helper routine to handle writes to the kernel or user-space */ 
    663 /* info->txbuf has two cases: 
    664  *      1) return value < 0 (-EFAULT), not touched at all 
    665  *      2) kfree and points to NULL in interrupt routine (but maybe later ) 
    666  */ 
    667577static ssize_t 
    668578ifx_ssc_write_helper (struct ifx_ssc_port *info, const char *buf, 
    669579                      size_t len, int from_kernel) 
    670580{ 
    671         // check if in tx or tx/rx mode 
    672581        if (info->opts.modeRxTx == IFX_SSC_MODE_RX) 
    673582                return -EFAULT; 
     
    675584        info->txbuf_ptr = info->txbuf; 
    676585        info->txbuf_end = len + info->txbuf; 
    677         /* start the transmission (not in rx/tx, see read helper) */ 
    678         if (info->opts.modeRxTx == IFX_SSC_MODE_TX) { 
     586        if (info->opts.modeRxTx == IFX_SSC_MODE_TX) 
     587        { 
    679588                tx_int (info); 
    680                 if (info->txbuf_ptr < info->txbuf_end) { 
     589                if (info->txbuf_ptr < info->txbuf_end) 
     590                { 
    681591                        enable_irq(info->txirq); 
    682592                } 
    683593        } 
    684         //local_irq_restore(flags); 
     594 
    685595        return len; 
    686596} 
    687597 
    688 /* 
    689  * kernel interfaces for read and write. 
    690  * The caller must set port to: n for SSC<m> with n=m-1 (e.g. n=0 for SSC1) 
    691  */ 
    692598ssize_t 
    693599ifx_ssc_kread (int port, char *kbuf, size_t len) 
     
    704610        info = &isp[port]; 
    705611 
    706         // check if reception in progress 
    707         if (info->rxbuf != NULL) { 
     612        if (info->rxbuf != NULL) 
     613        { 
    708614                printk ("SSC device busy\n"); 
    709615                return -EBUSY; 
     
    711617 
    712618        info->rxbuf = kbuf; 
    713         if (info->rxbuf == NULL) { 
     619        if (info->rxbuf == NULL) 
     620        { 
    714621                printk ("SSC device error\n"); 
    715622                return -EINVAL; 
    716623        } 
    717624 
    718 /* changed by bingtao */ 
    719         /* change by TaiCheng */ 
    720         //if (!in_irq()){ 
    721         if (0) { 
    722                 ret_val = ifx_ssc_read_helper (info, kbuf, len, 1); 
    723         } 
    724         else { 
    725                 ret_val = ifx_ssc_read_helper_poll (info, kbuf, len, 1); 
    726         }; 
     625        ret_val = ifx_ssc_read_helper_poll (info, kbuf, len, 1); 
    727626        info->rxbuf = NULL; 
    728627 
    729         // ### TO DO: perhaps warn if ret_val != len 
    730628        disable_irq(info->rxirq); 
    731629 
    732         return (ret_val); 
    733 }                               // ifx_ssc_kread 
    734  
    735 EXPORT_SYMBOL (ifx_ssc_kread); 
     630        return ret_val; 
     631} 
     632EXPORT_SYMBOL(ifx_ssc_kread); 
    736633 
    737634ssize_t 
     
    752649        if (info->txbuf != NULL) 
    753650                return -EBUSY; 
     651 
    754652        info->txbuf = (char *) kbuf; 
    755653 
    756654        ret_val = ifx_ssc_write_helper (info, info->txbuf, len, 1); 
    757         if (ret_val < 0) { 
     655 
     656        if (ret_val < 0) 
    758657                info->txbuf = NULL; 
    759         } 
     658 
    760659        return ret_val; 
    761660} 
    762  
    763 EXPORT_SYMBOL (ifx_ssc_kwrite); 
    764  
    765 /*  
    766  * user interfaces to read and write 
    767  */ 
     661EXPORT_SYMBOL(ifx_ssc_kwrite); 
     662 
    768663static ssize_t 
    769664ifx_ssc_read (struct file *filp, char *ubuf, size_t len, loff_t * off) 
     
    776671        info = &isp[idx]; 
    777672 
    778         // check if reception in progress 
    779673        if (info->rxbuf != NULL) 
    780674                return -EBUSY; 
     
    785679 
    786680        ret_val = ifx_ssc_read_helper (info, info->rxbuf, len, 0); 
    787         // ### TO DO: perhaps warn if ret_val != len 
    788681        if (copy_to_user ((void *) ubuf, info->rxbuf, ret_val) != 0) 
    789682                ret_val = -EFAULT; 
     
    793686        kfree (info->rxbuf); 
    794687        info->rxbuf = NULL; 
     688 
    795689        return (ret_val); 
    796690} 
    797691 
    798 /* 
    799  * As many bytes as we have free space for are copied from the user 
    800  * into txbuf and the actual byte count is returned. The transmission is 
    801  * always kicked off by calling the appropriate TX routine. 
    802  */ 
    803692static ssize_t 
    804693ifx_ssc_write (struct file *filp, const char *ubuf, size_t len, loff_t * off) 
     
    814703        info = &isp[idx]; 
    815704 
    816         // check if transmission in progress 
    817705        if (info->txbuf != NULL) 
    818706                return -EBUSY; 
     
    827715        else 
    828716                ret_val = -EFAULT; 
    829         if (ret_val < 0) { 
    830                 kfree (info->txbuf);    // otherwise will be done in ISR 
     717 
     718        if (ret_val < 0) 
     719        { 
     720                kfree (info->txbuf); 
    831721                info->txbuf = NULL; 
    832722        } 
     723 
    833724        return (ret_val); 
    834725} 
     
    842733        info->frm_status.DataBusy = (tmp & IFX_SSC_SFSTAT_IN_DATA) > 0; 
    843734        info->frm_status.PauseBusy = (tmp & IFX_SSC_SFSTAT_IN_PAUSE) > 0; 
    844         info->frm_status.DataCount = (tmp & IFX_SSC_SFSTAT_DATA_COUNT_MASK) 
    845                 >> IFX_SSC_SFSTAT_DATA_COUNT_OFFSET; 
    846         info->frm_status.PauseCount = (tmp & IFX_SSC_SFSTAT_PAUSE_COUNT_MASK) 
    847                 >> IFX_SSC_SFSTAT_PAUSE_COUNT_OFFSET; 
     735        info->frm_status.DataCount = (tmp & IFX_SSC_SFSTAT_DATA_COUNT_MASK) >> IFX_SSC_SFSTAT_DATA_COUNT_OFFSET; 
     736        info->frm_status.PauseCount = (tmp & IFX_SSC_SFSTAT_PAUSE_COUNT_MASK) >> IFX_SSC_SFSTAT_PAUSE_COUNT_OFFSET; 
    848737        tmp = READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_SFCON); 
    849         info->frm_status.EnIntAfterData = 
    850                 (tmp & IFX_SSC_SFCON_FIR_ENABLE_BEFORE_PAUSE) > 0; 
    851         info->frm_status.EnIntAfterPause = 
    852                 (tmp & IFX_SSC_SFCON_FIR_ENABLE_AFTER_PAUSE) > 0; 
    853         return (&info->frm_status); 
     738        info->frm_status.EnIntAfterData = (tmp & IFX_SSC_SFCON_FIR_ENABLE_BEFORE_PAUSE) > 0; 
     739        info->frm_status.EnIntAfterPause = (tmp & IFX_SSC_SFCON_FIR_ENABLE_AFTER_PAUSE) > 0; 
     740 
     741        return &info->frm_status; 
    854742} 
    855743 
     
    862750        tmp = READ_PERIPHERAL_REGISTER (info->mapbase + IFX_SSC_SFCON); 
    863751        info->frm_opts.FrameEnable = (tmp & IFX_SSC_SFCON_SF_ENABLE) > 0; 
    864         info->frm_opts.DataLength = (tmp & IFX_SSC_SFCON_DATA_LENGTH_MASK) 
    865                 >> IFX_SSC_SFCON_DATA_LENGTH_OFFSET; 
    866         info->frm_opts.PauseLength = (tmp & IFX_SSC_SFCON_PAUSE_LENGTH_MASK) 
    867                 >> IFX_SSC_SFCON_PAUSE_LENGTH_OFFSET; 
    868         info->frm_opts.IdleData = (tmp & IFX_SSC_SFCON_PAUSE_DATA_MASK) 
    869                 >> IFX_SSC_SFCON_PAUSE_DATA_OFFSET; 
    870         info->frm_opts.IdleClock = (tmp & IFX_SSC_SFCON_PAUSE_CLOCK_MASK) 
    871                 >> IFX_SSC_SFCON_PAUSE_CLOCK_OFFSET; 
    872         info->frm_opts.StopAfterPause = 
    873                 (tmp & IFX_SSC_SFCON_STOP_AFTER_PAUSE) > 0; 
    874         return (&info->frm_opts); 
     752        info->frm_opts.DataLength = (tmp & IFX_SSC_SFCON_DATA_LENGTH_MASK) >> IFX_SSC_SFCON_DATA_LENGTH_OFFSET; 
     753        info->frm_opts.PauseLength = (tmp & IFX_SSC_SFCON_PAUSE_LENGTH_MASK) >> IFX_SSC_SFCON_PAUSE_LENGTH_OFFSET; 
     754        info->frm_opts.IdleData = (tmp & IFX_SSC_SFCON_PAUSE_DATA_MASK) >> IFX_SSC_SFCON_PAUSE_DATA_OFFSET; 
     755        info->frm_opts.IdleClock = (tmp & IFX_SSC_SFCON_PAUSE_CLOCK_MASK) >> IFX_SSC_SFCON_PAUSE_CLOCK_OFFSET; 
     756        info->frm_opts.StopAfterPause = (tmp & IFX_SSC_SFCON_STOP_AFTER_PAUSE) > 0; 
     757 
     758        return &info->frm_opts; 
    875759} 
    876760 
     
    12981182        return ret_val; 
    12991183} 
    1300  
    1301 EXPORT_SYMBOL (ifx_ssc_ioctl); 
     1184EXPORT_SYMBOL(ifx_ssc_ioctl); 
    13021185 
    13031186static int 
    1304 ifx_ssc1_read_proc (char *page, char **start, off_t offset, int count, 
    1305                     int *eof, void *data) 
     1187ifx_ssc1_read_proc (char *page, char **start, off_t offset, int count, int *eof, void *data) 
    13061188{ 
    13071189        int off = 0; 
    13081190        unsigned long flags; 
    13091191 
    1310         /* don't want any interrupts here */ 
    13111192        local_save_flags(flags); 
    13121193        local_irq_disable(); 
    13131194 
    1314         /* print statistics */ 
    1315         off += sprintf (page + off, 
    1316                         "Statistics for Infineon Synchronous Serial Controller SSC1\n"); 
    1317         off += sprintf (page + off, "RX overflow errors %d\n", 
    1318                         isp[0].stats.rxOvErr); 
    1319         off += sprintf (page + off, "RX underflow errors %d\n", 
    1320                         isp[0].stats.rxUnErr); 
    1321         off += sprintf (page + off, "TX overflow errors %d\n", 
    1322                         isp[0].stats.txOvErr); 
    1323         off += sprintf (page + off, "TX underflow errors %d\n", 
    1324                         isp[0].stats.txUnErr); 
    1325         off += sprintf (page + off, "Abort errors %d\n", 
    1326                         isp[0].stats.abortErr); 
     1195        off += sprintf (page + off, "Statistics for Infineon Synchronous Serial Controller SSC1\n"); 
     1196        off += sprintf (page + off, "RX overflow errors %d\n", isp[0].stats.rxOvErr); 
     1197        off += sprintf (page + off, "RX underflow errors %d\n", isp[0].stats.rxUnErr); 
     1198        off += sprintf (page + off, "TX overflow errors %d\n", isp[0].stats.txOvErr); 
     1199        off += sprintf (page + off, "TX underflow errors %d\n", isp[0].stats.txUnErr); 
     1200        off += sprintf (page + off, "Abort errors %d\n", isp[0].stats.abortErr); 
    13271201        off += sprintf (page + off, "Mode errors %d\n", isp[0].stats.modeErr); 
    13281202        off += sprintf (page + off, "RX Bytes %d\n", isp[0].stats.rxBytes); 
     
    13311205        local_irq_restore(flags); 
    13321206        *eof = 1; 
    1333         return (off); 
    1334 } 
    1335  
    1336 /* 
    1337  * Due to the fact that a port can be dynamically switched between slave 
    1338  * and master mode using an IOCTL the hardware is not initialized here, 
    1339  * but in ifx_ssc_hwinit() as a result of an IOCTL. 
    1340  */ 
     1207 
     1208        return off; 
     1209} 
     1210 
    13411211int __init 
    13421212ifx_ssc_init (void) 
     
    13471217        int ret_val; 
    13481218 
    1349         // ### TO DO: dynamic port count evaluation due to pin multiplexing 
    1350  
    13511219        ret_val = -ENOMEM; 
    1352         nbytes = PORT_CNT * sizeof (struct ifx_ssc_port); 
    1353         isp = (struct ifx_ssc_port *) kmalloc (nbytes, GFP_KERNEL); 
    1354         if (isp == NULL) { 
    1355                 printk ("%s: no memory for isp\n", __func__); 
     1220        nbytes = PORT_CNT * sizeof(struct ifx_ssc_port); 
     1221        isp = (struct ifx_ssc_port*)kmalloc(nbytes, GFP_KERNEL); 
     1222 
     1223        if (isp == NULL) 
     1224        { 
     1225                printk("%s: no memory for isp\n", __func__); 
    13561226                return (ret_val); 
    13571227        } 
    1358         memset (isp, 0, nbytes); 
    1359  
    1360         /* register the device */ 
     1228        memset(isp, 0, nbytes); 
     1229 
    13611230        ret_val = -ENXIO; 
    1362 /* 
    1363         i = maj; 
    1364 */ 
    1365         if ((i = register_chrdev (maj, "ssc", &ifx_ssc_fops)) < 0) { 
    1366                 printk ("Unable to register major %d for the Infineon SSC\n", 
    1367                         maj); 
    1368                 if (maj == 0) { 
     1231        if ((i = register_chrdev (maj, "ssc", &ifx_ssc_fops)) < 0) 
     1232        { 
     1233                printk ("Unable to register major %d for the Infineon SSC\n", maj); 
     1234                if (maj == 0) 
     1235                { 
    13691236                        goto errout; 
    1370                 } 
    1371                 else { 
     1237                } else { 
    13721238                        maj = 0; 
    1373                         if ((i = 
    1374                              register_chrdev (maj, "ssc", 
    1375                                               &ifx_ssc_fops)) < 0) { 
     1239                        if ((i = register_chrdev (maj, "ssc", &ifx_ssc_fops)) < 0) 
     1240                        { 
    13761241                                printk ("Unable to register major %d for the Infineon SSC\n", maj); 
    13771242                                goto errout; 
     
    13791244                } 
    13801245        } 
     1246 
    13811247        if (maj == 0) 
    13821248                maj = i; 
    1383         //printk("registered major %d for Infineon SSC\n", maj); 
    13841249 
    13851250        /* set default values in ifx_ssc_port */ 
     
    14101275                if (i == 0) { 
    14111276                        info->mapbase = DANUBE_SSC1_BASE_ADDR; 
    1412                         // ### TO DO: power management 
    1413  
    1414                         // setting interrupt vectors 
    14151277                        info->txirq = DANUBE_SSC_TIR; 
    14161278                        info->rxirq = DANUBE_SSC_RIR; 
    14171279                        info->errirq = DANUBE_SSC_EIR; 
    1418 /* 
    1419                         info->frmirq = IFX_SSC_FIR; 
    1420 */ 
    1421                 } 
    1422                 /* activate SSC */ 
    1423                 /* CLC.DISS = 0 */ 
    1424                 WRITE_PERIPHERAL_REGISTER (IFX_SSC_DEF_RMC << 
    1425                                            IFX_CLC_RUN_DIVIDER_OFFSET, 
    1426                                            info->mapbase + IFX_SSC_CLC); 
    1427  
    1428 // ### TO DO: multiple instances 
     1280                } 
     1281 
     1282                WRITE_PERIPHERAL_REGISTER (IFX_SSC_DEF_RMC << IFX_CLC_RUN_DIVIDER_OFFSET, info->mapbase + IFX_SSC_CLC); 
    14291283 
    14301284                init_waitqueue_head (&info->rwait); 
    1431                 //init_waitqueue_head(&info->pwait); 
    14321285 
    14331286                local_irq_save (flags); 
    14341287 
    14351288                // init serial framing register 
    1436                 WRITE_PERIPHERAL_REGISTER (IFX_SSC_DEF_SFCON, 
    1437                                            info->mapbase + IFX_SSC_SFCON); 
    1438  
    1439                 /* try to get the interrupts */ 
    1440                 // ### TO DO: interrupt handling with multiple instances 
    1441                 ret_val = 
    1442                         request_irq(info->txirq, ifx_ssc_tx_int, SA_INTERRUPT, "ifx_ssc_tx", info); 
    1443                 if (ret_val) { 
    1444                         printk ("%s: unable to get irq %d\n", __func__, 
    1445                                 info->txirq); 
    1446                         local_irq_restore (flags); 
     1289                WRITE_PERIPHERAL_REGISTER (IFX_SSC_DEF_SFCON, info->mapbase + IFX_SSC_SFCON); 
     1290 
     1291                ret_val = request_irq(info->txirq, ifx_ssc_tx_int, SA_INTERRUPT, "ifx_ssc_tx", info); 
     1292                if (ret_val) 
     1293                { 
     1294                        printk("%s: unable to get irq %d\n", __func__, info->txirq); 
     1295                        local_irq_restore(flags); 
    14471296                        goto errout; 
    14481297                } 
    1449                 ret_val = 
    1450                         request_irq(info->rxirq, ifx_ssc_rx_int, SA_INTERRUPT, "ifx_ssc_rx", info); 
    1451                 if (ret_val) { 
    1452                         printk ("%s: unable to get irq %d\n", __func__, 
    1453                                 info->rxirq); 
     1298 
     1299                ret_val = request_irq(info->rxirq, ifx_ssc_rx_int, SA_INTERRUPT, "ifx_ssc_rx", info); 
     1300                if (ret_val) 
     1301                { 
     1302                        printk ("%s: unable to get irq %d\n", __func__, info->rxirq); 
    14541303                        local_irq_restore (flags); 
    14551304                        goto irqerr; 
    14561305                } 
    1457                 ret_val = 
    1458                         request_irq(info->errirq, ifx_ssc_err_int, SA_INTERRUPT,"ifx_ssc_err", info); 
    1459                 if (ret_val) { 
    1460                         printk ("%s: unable to get irq %d\n", __func__, 
    1461                                 info->errirq); 
     1306 
     1307                ret_val = request_irq(info->errirq, ifx_ssc_err_int, SA_INTERRUPT,"ifx_ssc_err", info); 
     1308                if (ret_val) 
     1309                { 
     1310                        printk ("%s: unable to get irq %d\n", __func__, info->errirq); 
    14621311                        local_irq_restore (flags); 
    14631312                        goto irqerr; 
    14641313                } 
    1465                 WRITE_PERIPHERAL_REGISTER (IFX_SSC_DEF_IRNEN, 
    1466                                            info->mapbase + IFX_SSC_IRN_EN); 
     1314                WRITE_PERIPHERAL_REGISTER (IFX_SSC_DEF_IRNEN, info->mapbase + IFX_SSC_IRN_EN); 
     1315 
    14671316                enable_irq(info->txirq); 
    14681317                enable_irq(info->rxirq); 
     
    14721321        } 
    14731322 
    1474         /* init the SSCs with default values */ 
    14751323        for (i = 0; i < PORT_CNT; i++) { 
    14761324                info = &isp[i]; 
    1477                 if (ifx_ssc_hwinit (info) < 0) { 
    1478                         printk ("%s: hardware init failed for port %d\n", 
    1479                                 __func__, i); 
     1325                if (ifx_ssc_hwinit (info) < 0) 
     1326                { 
     1327                        printk ("%s: hardware init failed for port %d\n", __func__, i); 
    14801328                        goto irqerr; 
    14811329                } 
    14821330        } 
    14831331 
    1484         /* register /proc read handler */ 
    1485         // ### TO DO: multiple instances 
    1486         /* for SSC1, which is always present */ 
    1487         create_proc_read_entry ("driver/ssc1", 0, NULL, ifx_ssc1_read_proc, 
    1488                                 NULL); 
     1332        create_proc_read_entry ("driver/ssc1", 0, NULL, ifx_ssc1_read_proc, NULL); 
     1333 
    14891334        return 0; 
    14901335 
    14911336irqerr: 
    1492         // ### TO DO: multiple instances 
    14931337        free_irq(isp[0].txirq, &isp[0]); 
    14941338        free_irq(isp[0].rxirq, &isp[0]); 
    14951339        free_irq(isp[0].errirq, &isp[0]); 
    14961340errout: 
    1497         /* free up any allocated memory in the error case */ 
    14981341        kfree (isp); 
    14991342        return (ret_val); 
    1500 }                               /* ifx_ssc_init */ 
     1343} 
    15011344 
    15021345void 
     
    15051348        int i; 
    15061349 
    1507         /* free up any allocated memory */ 
    15081350        for (i = 0; i < PORT_CNT; i++) { 
    1509                 /* disable the SSC */ 
    1510                 WRITE_PERIPHERAL_REGISTER (IFX_SSC_WHBSTATE_CLR_ENABLE, 
    1511                                            isp[i].mapbase + IFX_SSC_WHBSTATE); 
    1512                 /* free the interrupts */ 
     1351                WRITE_PERIPHERAL_REGISTER (IFX_SSC_WHBSTATE_CLR_ENABLE, isp[i].mapbase + IFX_SSC_WHBSTATE); 
    15131352                free_irq(isp[i].txirq, &isp[i]); 
    15141353                free_irq(isp[i].rxirq, &isp[i]); 
     
    15161355        } 
    15171356        kfree (isp); 
    1518         /* delete /proc read handler */ 
    15191357        remove_proc_entry ("driver/ssc1", NULL); 
    1520         remove_proc_entry ("driver/ssc2", NULL); 
    15211358} 
    15221359 
Note: See TracChangeset for help on using the changeset viewer.