target/linux/amazon-2.6/files/drivers/char/ifx_ssc.c

   1 /**************************************************
   2  *
   3  * drivers/ifx/serial/ifx_ssc.c
   4  *
   5  * Driver for IFX_SSC serial ports
   6  *
   7  * Copyright (C) 2004 Infineon Technologies AG
   8  * Author Michael Schoenenborn (IFX COM TI BT)
   9  *
  10  */
  11 #define IFX_SSC_DRV_VERSION "0.2.1"
  12 /*
  13  **************************************************
  14  *
  15  * This driver was originally based on the INCA-IP driver, but due to
  16  * fundamental conceptual drawbacks there has been changed a lot.
  17  *
  18  * Based on INCA-IP driver Copyright (c) 2003 Gary Jennejohn <gj@denx.de>
  19  * Based on the VxWorks drivers Copyright (c) 2002, Infineon Technologies.
  20  *
  21  * This program is free software; you can redistribute it and/or modify
  22  * it under the terms of the GNU General Public License as published by
  23  * the Free Software Foundation; either version 2 of the License, or
  24  * (at your option) any later version.
  25  *
  26  * This program is distributed in the hope that it will be useful,
  27  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  28  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  29  * GNU General Public License for more details.
  30  *
  31  * You should have received a copy of the GNU General Public License
  32  * along with this program; if not, write to the Free Software
  33  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  34  *
  35  */
  36
  37 // ### TO DO: general issues:
  38 //            - power management
  39 //            - interrupt handling (direct/indirect)
  40 //            - pin/mux-handling (just overall concept due to project dependency)
  41 //            - multiple instances capability
  42 //            - slave functionality
  43
  44 /*
  45  * Include section
  46  */
  47 #ifndef EXPORT_SYMTAB
  48 #define EXPORT_SYMTAB
  49 #endif
  50
  51 #include <linux/config.h>
  52 #include <linux/module.h>
  53 #include <linux/errno.h>
  54 #include <linux/signal.h>
  55 #include <linux/sched.h>
  56 #include <linux/timer.h>
  57 #include <linux/interrupt.h>
  58 #include <linux/major.h>
  59 #include <linux/string.h>
  60 #include <linux/fs.h>
  61 #include <linux/proc_fs.h>
  62 #include <linux/fcntl.h>
  63 #include <linux/ptrace.h>
  64 #include <linux/mm.h>
  65 #include <linux/ioport.h>
  66 #include <linux/init.h>
  67 #include <linux/delay.h>
  68 #include <linux/spinlock.h>
  69 #include <linux/slab.h>
  70 //#include <linux/poll.h>
  71
  72 #include <asm/system.h>
  73 #include <asm/io.h>
  74 #include <asm/irq.h>
  75 #include <asm/uaccess.h>
  76 #include <asm/bitops.h>
  77
  78 #include <linux/types.h>
  79 #include <linux/kernel.h>
  80 #include <linux/version.h>
  81
  82 #include <asm/amazon/amazon.h>
  83 #include <asm/amazon/irq.h>
  84 #include <asm/amazon/ifx_ssc_defines.h>
  85 #include <asm/amazon/ifx_ssc.h>
  86
  87 #ifdef SSC_FRAME_INT_ENABLE
  88 #undef SSC_FRAME_INT_ENABLE
  89 #endif
  90
  91 #define not_yet
  92
  93 #define SPI_VINETIC
  94
  95 /*
  96  * Deal with CONFIG_MODVERSIONS
  97  */
  98 #if CONFIG_MODVERSIONS==1
  99 # include <linux/modversions.h>
 100 #endif
 101
 102 MODULE_LICENSE("GPL");
 103 MODULE_AUTHOR("Michael Schoenenborn");
 104 MODULE_DESCRIPTION("IFX SSC driver");
 105 MODULE_SUPPORTED_DEVICE("ifx_ssc");
 106 MODULE_PARM(maj, "i");
 107 MODULE_PARM_DESC(maj, "Major device number");
 108
 109 /* allow the user to set the major device number */
 110 static int maj = 0;
 111
 112
 113 /*
 114  * This is the per-channel data structure containing pointers, flags
 115  * and variables for the port. This driver supports a maximum of PORT_CNT.
 116  * isp is allocated in ifx_ssc_init() based on the chip version.
 117  */
 118 static struct ifx_ssc_port *isp;
 119
 120 /* prototypes for fops */
 121 static ssize_t ifx_ssc_read(struct file *, char *, size_t, loff_t *);
 122 static ssize_t ifx_ssc_write(struct file *, const char *, size_t, loff_t *);
 123 //static unsigned int ifx_ssc_poll(struct file *, struct poll_table_struct *);
 124 int ifx_ssc_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
 125 int ifx_ssc_open(struct inode *, struct file *);
 126 int ifx_ssc_close(struct inode *, struct file *);
 127
 128 /* other forward declarations */
 129 static unsigned int ifx_ssc_get_kernel_clk(struct ifx_ssc_port *info);
 130 static void ifx_ssc_rx_int(int, void *, struct pt_regs *);
 131 static void ifx_ssc_tx_int(int, void *, struct pt_regs *);
 132 static void ifx_ssc_err_int(int, void *, struct pt_regs *);
 133 #ifdef SSC_FRAME_INT_ENABLE
 134 static void ifx_ssc_frm_int(int, void *, struct pt_regs *);
 135 #endif
 136 static void tx_int(struct ifx_ssc_port *);
 137 static int ifx_ssc1_read_proc(char *, char **, off_t, int, int *, void *);
 138 static void ifx_gpio_init(void);
 139 /************************************************************************
 140  *  Function declaration
 141  ************************************************************************/
 142 //interrupt.c
 143 extern unsigned int amazon_get_fpi_hz(void);
 144 extern void disable_amazon_irq(unsigned int irq_nr);
 145 extern void enable_amazon_irq(unsigned int irq_nr);
 146 extern void mask_and_ack_amazon_irq(unsigned int irq_nr);
 147
 148
 149 /*****************************************************************/
 150 typedef struct {
 151         int (*request)(unsigned int irq,
 152                        void (*handler)(int, void *, struct pt_regs *),
 153                        unsigned long irqflags,
 154                        const char * devname,
 155                        void *dev_id);
 156         void (*free)(unsigned int irq, void *dev_id);
 157         void (*enable)(unsigned int irq);
 158         void (*disable)(unsigned int irq);
 159         void (*clear)(unsigned int irq);
 160 } ifx_int_wrapper_t;
 161
 162 static ifx_int_wrapper_t ifx_int_wrapper = {
 163         request:        request_irq,    // IM action: enable int
 164         free:           free_irq,       // IM action: disable int
 165         enable:         enable_amazon_irq,
 166         disable:        disable_amazon_irq,
 167         clear:          mask_and_ack_amazon_irq,
 168         //end:
 169 };
 170
 171 /* Fops-struct */
 172 static struct file_operations ifx_ssc_fops = {
 173         owner:          THIS_MODULE,
 174         read:           ifx_ssc_read,    /* read */
 175         write:          ifx_ssc_write,   /* write */
 176 //        poll:         ifx_ssc_poll,    /* poll */
 177         ioctl:          ifx_ssc_ioctl,   /* ioctl */
 178         open:           ifx_ssc_open,    /* open */
 179         release:        ifx_ssc_close,   /* release */
 180 };
 181
 182
 183 static inline unsigned int ifx_ssc_get_kernel_clk(struct ifx_ssc_port *info)
 184 { // ATTENTION: This function assumes that the CLC register is set with the
 185   // appropriate value for RMC.
 186         unsigned int rmc;
 187
 188         rmc = (READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_CLC) &
 189                IFX_CLC_RUN_DIVIDER_MASK) >> IFX_CLC_RUN_DIVIDER_OFFSET;
 190         if (rmc == 0){
 191                 printk("ifx_ssc_get_kernel_clk rmc==0 \n");
 192                 return (0);
 193         }
 194         return (amazon_get_fpi_hz() / rmc);
 195 }
 196
 197 #ifndef not_yet
 198 #ifdef IFX_SSC_INT_USE_BH
 199 /*
 200  * This routine is used by the interrupt handler to schedule
 201  * processing in the software interrupt portion of the driver
 202  * (also known as the "bottom half").  This can be called any
 203  * number of times for any channel without harm.
 204  */
 205 static inline void
 206 ifx_ssc_sched_event(struct ifx_ssc_port *info, int event)
 207 {
 208     info->event |= 1 << event; /* remember what kind of event and who */
 209     queue_task(&info->tqueue, &tq_cyclades); /* it belongs to */
 210     mark_bh(CYCLADES_BH);                       /* then trigger event */
 211 } /* ifx_ssc_sched_event */
 212
 213
 214 /*
 215  * This routine is used to handle the "bottom half" processing for the
 216  * serial driver, known also the "software interrupt" processing.
 217  * This processing is done at the kernel interrupt level, after the
 218  * cy#/_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON.  This
 219  * is where time-consuming activities which can not be done in the
 220  * interrupt driver proper are done; the interrupt driver schedules
 221  * them using ifx_ssc_sched_event(), and they get done here.
 222  *
 223  * This is done through one level of indirection--the task queue.
 224  * When a hardware interrupt service routine wants service by the
 225  * driver's bottom half, it enqueues the appropriate tq_struct (one
 226  * per port) to the tq_cyclades work queue and sets a request flag
 227  * via mark_bh for processing that queue.  When the time is right,
 228  * do_ifx_ssc_bh is called (because of the mark_bh) and it requests
 229  * that the work queue be processed.
 230  *
 231  * Although this may seem unwieldy, it gives the system a way to
 232  * pass an argument (in this case the pointer to the ifx_ssc_port
 233  * structure) to the bottom half of the driver.  Previous kernels
 234  * had to poll every port to see if that port needed servicing.
 235  */
 236 static void
 237 do_ifx_ssc_bh(void)
 238 {
 239     run_task_queue(&tq_cyclades);
 240 } /* do_ifx_ssc_bh */
 241
 242 static void
 243 do_softint(void *private_)
 244 {
 245   struct ifx_ssc_port *info = (struct ifx_ssc_port *) private_;
 246
 247     if (test_and_clear_bit(Cy_EVENT_HANGUP, &info->event)) {
 248         wake_up_interruptible(&info->open_wait);
 249         info->flags &= ~(ASYNC_NORMAL_ACTIVE|
 250                              ASYNC_CALLOUT_ACTIVE);
 251     }
 252     if (test_and_clear_bit(Cy_EVENT_OPEN_WAKEUP, &info->event)) {
 253         wake_up_interruptible(&info->open_wait);
 254     }
 255     if (test_and_clear_bit(Cy_EVENT_DELTA_WAKEUP, &info->event)) {
 256         wake_up_interruptible(&info->delta_msr_wait);
 257     }
 258     if (test_and_clear_bit(Cy_EVENT_WRITE_WAKEUP, &info->event)) {
 259         wake_up_interruptible(&tty->write_wait);
 260     }
 261 #ifdef Z_WAKE
 262     if (test_and_clear_bit(Cy_EVENT_SHUTDOWN_WAKEUP, &info->event)) {
 263         wake_up_interruptible(&info->shutdown_wait);
 264     }
 265 #endif
 266 } /* do_softint */
 267 #endif /* IFX_SSC_INT_USE_BH */
 268 #endif // not_yet
 269
 270 inline static void
 271 rx_int(struct ifx_ssc_port *info)
 272 {
 273         int             fifo_fill_lev, bytes_in_buf, i;
 274         unsigned long   tmp_val;
 275         unsigned long   *tmp_ptr;
 276         unsigned int    rx_valid_cnt;
 277         /* number of words waiting in the RX FIFO */
 278         fifo_fill_lev = (READ_PERIPHERAL_REGISTER(info->mapbase +
 279                                                   IFX_SSC_FSTAT) &
 280                          IFX_SSC_FSTAT_RECEIVED_WORDS_MASK) >>
 281                          IFX_SSC_FSTAT_RECEIVED_WORDS_OFFSET;
 282         // Note: There are always 32 bits in a fifo-entry except for the last
 283         // word of a contigous transfer block and except for not in rx-only
 284         // mode and CON.ENBV set. But for this case it should be a convention
 285         // in software which helps:
 286         // In tx or rx/tx mode all transfers from the buffer to the FIFO are
 287         // 32-bit wide, except for the last three bytes, which could be a
 288         // combination of 16- and 8-bit access.
 289         // => The whole block is received as 32-bit words as a contigous stream,
 290         // even if there was a gap in tx which has the fifo run out of data!
 291         // Just the last fifo entry *may* be partially filled (0, 1, 2 or 3 bytes)!
 292
 293         /* free space in the RX buffer */
 294         bytes_in_buf = info->rxbuf_end - info->rxbuf_ptr;
 295         // transfer with 32 bits per entry
 296         while ((bytes_in_buf >= 4) && (fifo_fill_lev > 0)) {
 297                 tmp_ptr = (unsigned long *)info->rxbuf_ptr;
 298                 *tmp_ptr = READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_RB);
 299                 info->rxbuf_ptr += 4;
 300                 info->stats.rxBytes += 4;
 301                 fifo_fill_lev --;
 302                 bytes_in_buf -= 4;
 303         } // while ((bytes_in_buf >= 4) && (fifo_fill_lev > 0))
 304         // now do the rest as mentioned in STATE.RXBV
 305         while ((bytes_in_buf > 0) && (fifo_fill_lev > 0)) {
 306                 rx_valid_cnt = (READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_STATE) &
 307                                 IFX_SSC_STATE_RX_BYTE_VALID_MASK) >>
 308                         IFX_SSC_STATE_RX_BYTE_VALID_OFFSET;
 309                 if (rx_valid_cnt == 0) break;
 310                 if (rx_valid_cnt > bytes_in_buf) {
 311                         // ### TO DO: warning message: not block aligned data, other data
 312                         //                             in this entry will be lost
 313                         rx_valid_cnt = bytes_in_buf;
 314                 }
 315                 tmp_val = READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_RB);
 316
 317                 for (i=0; i<rx_valid_cnt; i++) {
 318                         *info->rxbuf_ptr = (tmp_val >> ( 8 * (rx_valid_cnt - i-1))) & 0xff;
 319 /*
 320                         *info->rxbuf_ptr = tmp_val & 0xff;
 321                         tmp_val >>= 8;
 322 */
 323                         bytes_in_buf--;
 324
 325
 326                         info->rxbuf_ptr++;
 327                 }
 328                 info->stats.rxBytes += rx_valid_cnt;
 329         }  // while ((bytes_in_buf > 0) && (fifo_fill_lev > 0))
 330
 331         // check if transfer is complete
 332         if (info->rxbuf_ptr >= info->rxbuf_end) {
 333                 ifx_int_wrapper.disable(info->rxirq);
 334                 /* wakeup any processes waiting in read() */
 335                 wake_up_interruptible(&info->rwait);
 336                 /* and in poll() */
 337                 //wake_up_interruptible(&info->pwait);
 338         } else if ((info->opts.modeRxTx == IFX_SSC_MODE_RX) &&
 339                    (READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_RXCNT) == 0)) {
 340                 // if buffer not filled completely and rx request done initiate new transfer
 341 /*
 342                 if  (info->rxbuf_end - info->rxbuf_ptr < 65536)
 343 */
 344                 if  (info->rxbuf_end - info->rxbuf_ptr < IFX_SSC_RXREQ_BLOCK_SIZE)
 345                         WRITE_PERIPHERAL_REGISTER((info->rxbuf_end - info->rxbuf_ptr) <<
 346                                                   IFX_SSC_RXREQ_RXCOUNT_OFFSET,
 347                                                   info->mapbase + IFX_SSC_RXREQ);
 348                 else
 349                         WRITE_PERIPHERAL_REGISTER(IFX_SSC_RXREQ_BLOCK_SIZE << IFX_SSC_RXREQ_RXCOUNT_OFFSET,
 350                                                   info->mapbase + IFX_SSC_RXREQ);
 351         }
 352 } // rx_int
 353
 354 inline static void
 355 tx_int(struct ifx_ssc_port *info)
 356 {
 357
 358         int fifo_space, fill, i;
 359         fifo_space = ((READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_ID) &
 360                        IFX_SSC_PERID_TXFS_MASK) >> IFX_SSC_PERID_TXFS_OFFSET) -
 361                 ((READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_FSTAT) &
 362                   IFX_SSC_FSTAT_TRANSMIT_WORDS_MASK) >>
 363                  IFX_SSC_FSTAT_TRANSMIT_WORDS_OFFSET);
 364
 365         if (fifo_space == 0)
 366                 return;
 367
 368         fill = info->txbuf_end - info->txbuf_ptr;
 369
 370         if (fill > fifo_space * 4)
 371                 fill = fifo_space * 4;
 372
 373         for (i = 0; i < fill / 4; i++) {
 374                 // at first 32 bit access
 375                 WRITE_PERIPHERAL_REGISTER(*(UINT32 *)info->txbuf_ptr, info->mapbase + IFX_SSC_TB);
 376                 info->txbuf_ptr += 4;
 377         }
 378
 379         fifo_space -= fill / 4;
 380         info->stats.txBytes += fill & ~0x3;
 381         fill &= 0x3;
 382         if ((fifo_space > 0) & (fill > 1)) {
 383                 // trailing 16 bit access
 384                 WRITE_PERIPHERAL_REGISTER_16(*(UINT16 *)info->txbuf_ptr, info->mapbase + IFX_SSC_TB);
 385                 info->txbuf_ptr += 2;
 386                 info->stats.txBytes += 2;
 387                 fifo_space --;
 388 /* added by bingtao */
 389                 fill -=2;
 390         }
 391         if ((fifo_space > 0) & (fill > 0)) {
 392                 // trailing 8 bit access
 393                 WRITE_PERIPHERAL_REGISTER_8(*(UINT8 *)info->txbuf_ptr, info->mapbase + IFX_SSC_TB);
 394                 info->txbuf_ptr ++;
 395                 info->stats.txBytes ++;
 396 /*
 397                 fifo_space --;
 398 */
 399         }
 400
 401         // check if transmission complete
 402         if (info->txbuf_ptr >= info->txbuf_end) {
 403                 ifx_int_wrapper.disable(info->txirq);
 404                 kfree(info->txbuf);
 405                 info->txbuf = NULL;
 406                 /* wake up any process waiting in poll() */
 407                 //wake_up_interruptible(&info->pwait);
 408         }
 409
 410 } // tx_int
 411
 412 static void
 413 ifx_ssc_rx_int(int irq, void *dev_id, struct pt_regs *regs)
 414 {
 415         struct ifx_ssc_port *info = (struct ifx_ssc_port *)dev_id;
 416         //WRITE_PERIPHERAL_REGISTER(IFX_SSC_R_BIT, info->mapbase + IFX_SSC_IRN_CR);
 417         rx_int(info);
 418 }
 419
 420 static void
 421 ifx_ssc_tx_int(int irq, void *dev_id, struct pt_regs *regs)
 422 {
 423         struct ifx_ssc_port *info = (struct ifx_ssc_port *)dev_id;
 424         //WRITE_PERIPHERAL_REGISTER(IFX_SSC_T_BIT, info->mapbase + IFX_SSC_IRN_CR);
 425         tx_int(info);
 426 }
 427
 428 static void
 429 ifx_ssc_err_int(int irq, void *dev_id, struct pt_regs *regs)
 430 {
 431         struct ifx_ssc_port *info = (struct ifx_ssc_port *)dev_id;
 432         unsigned int state;
 433         unsigned int write_back = 0;
 434         unsigned long flags;
 435
 436
 437         local_irq_save(flags);
 438         state = READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_STATE);
 439
 440         if ((state & IFX_SSC_STATE_RX_UFL) != 0) {
 441                 info->stats.rxUnErr++;
 442                 write_back |= IFX_SSC_WHBSTATE_CLR_RX_UFL_ERROR;
 443         }
 444         if ((state & IFX_SSC_STATE_RX_OFL) != 0) {
 445                 info->stats.rxOvErr++;
 446                 write_back |= IFX_SSC_WHBSTATE_CLR_RX_OFL_ERROR;
 447         }
 448         if ((state & IFX_SSC_STATE_TX_OFL) != 0) {
 449                 info->stats.txOvErr++;
 450                 write_back |= IFX_SSC_WHBSTATE_CLR_TX_OFL_ERROR;
 451         }
 452         if ((state & IFX_SSC_STATE_TX_UFL) != 0) {
 453                 info->stats.txUnErr++;
 454                 write_back |= IFX_SSC_WHBSTATE_CLR_TX_UFL_ERROR;
 455         }
 456 //      if ((state & IFX_SSC_STATE_ABORT_ERR) != 0) {
 457 //              info->stats.abortErr++;
 458 //              write_back |= IFX_SSC_WHBSTATE_CLR_ABORT_ERROR;
 459 //      }
 460         if ((state & IFX_SSC_STATE_MODE_ERR) != 0) {
 461                 info->stats.modeErr++;
 462                 write_back |= IFX_SSC_WHBSTATE_CLR_MODE_ERROR;
 463         }
 464
 465         if (write_back)
 466                 WRITE_PERIPHERAL_REGISTER(write_back,
 467                                           info->mapbase + IFX_SSC_WHBSTATE);
 468
 469         local_irq_restore(flags);
 470 }
 471
 472 #ifdef SSC_FRAME_INT_ENABLE
 473 static void
 474 ifx_ssc_frm_int(int irq, void *dev_id, struct pt_regs *regs)
 475 {
 476         // ### TO DO: wake up framing wait-queue in conjunction with batch execution
 477 }
 478 #endif
 479
 480 static void
 481 ifx_ssc_abort(struct ifx_ssc_port *info)
 482 {
 483         unsigned long flags;
 484         bool enabled;
 485
 486         local_irq_save(flags);
 487
 488         // disable all int's
 489         ifx_int_wrapper.disable(info->rxirq);
 490         ifx_int_wrapper.disable(info->txirq);
 491         ifx_int_wrapper.disable(info->errirq);
 492 /*
 493         ifx_int_wrapper.disable(info->frmirq);
 494 */
 495         local_irq_restore(flags);
 496
 497         // disable SSC (also aborts a receive request!)
 498         // ### TO DO: Perhaps it's better to abort after the receiption of a
 499         // complete word. The disable cuts the transmission immediatly and
 500         // releases the chip selects. This could result in unpredictable
 501         // behavior of connected external devices!
 502         enabled = (READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_STATE)
 503                    & IFX_SSC_STATE_IS_ENABLED) != 0;
 504         WRITE_PERIPHERAL_REGISTER(IFX_SSC_WHBSTATE_CLR_ENABLE,
 505                                   info->mapbase + IFX_SSC_WHBSTATE);
 506
 507
 508         // flush fifos
 509         WRITE_PERIPHERAL_REGISTER(IFX_SSC_XFCON_FIFO_FLUSH,
 510                                   info->mapbase + IFX_SSC_TXFCON);
 511         WRITE_PERIPHERAL_REGISTER(IFX_SSC_XFCON_FIFO_FLUSH,
 512                                   info->mapbase + IFX_SSC_RXFCON);
 513
 514         // free txbuf
 515         if (info->txbuf != NULL) {
 516                 kfree(info->txbuf);
 517                 info->txbuf = NULL;
 518         }
 519
 520         // wakeup read process
 521         if (info->rxbuf != NULL)
 522                 wake_up_interruptible(&info->rwait);
 523
 524         // clear pending int's
 525         ifx_int_wrapper.clear(info->rxirq);
 526         ifx_int_wrapper.clear(info->txirq);
 527         ifx_int_wrapper.clear(info->errirq);
 528 /*
 529         ifx_int_wrapper.clear(info->frmirq);
 530 */
 531
 532         // clear error flags
 533         WRITE_PERIPHERAL_REGISTER(IFX_SSC_WHBSTATE_CLR_ALL_ERROR,
 534                                   info->mapbase + IFX_SSC_WHBSTATE);
 535
 536         //printk("IFX SSC%d: Transmission aborted\n", info->port_nr);
 537         // enable SSC
 538         if (enabled)
 539                 WRITE_PERIPHERAL_REGISTER(IFX_SSC_WHBSTATE_SET_ENABLE,
 540                                           info->mapbase + IFX_SSC_WHBSTATE);
 541
 542 } // ifx_ssc_abort
 543
 544
 545 /*
 546  * This routine is called whenever a port is opened.  It enforces
 547  * exclusive opening of a port and enables interrupts, etc.
 548  */
 549 int
 550 ifx_ssc_open(struct inode *inode, struct file * filp)
 551 {
 552         struct ifx_ssc_port  *info;
 553         int line;
 554         int from_kernel = 0;
 555
 556         if ((inode == (struct inode *)0) || (inode == (struct inode *)1)) {
 557                 from_kernel = 1;
 558                 line = (int)inode;
 559         }
 560         else {
 561                 line = MINOR(filp->f_dentry->d_inode->i_rdev);
 562                 filp->f_op = &ifx_ssc_fops;
 563         }
 564
 565         /* don't open more minor devices than we can support */
 566         if (line < 0 || line >= PORT_CNT)
 567                 return -ENXIO;
 568
 569         info = &isp[line];
 570
 571         /* exclusive open */
 572         if (info->port_is_open != 0)
 573                 return -EBUSY;
 574         info->port_is_open++;
 575
 576         ifx_int_wrapper.disable(info->rxirq);
 577         ifx_int_wrapper.disable(info->txirq);
 578         ifx_int_wrapper.disable(info->errirq);
 579 /*
 580         ifx_int_wrapper.disable(info->frmirq);
 581 */
 582
 583         /* Flush and enable TX/RX FIFO */
 584         WRITE_PERIPHERAL_REGISTER((IFX_SSC_DEF_TXFIFO_FL <<
 585                                    IFX_SSC_XFCON_ITL_OFFSET) |
 586                                   IFX_SSC_XFCON_FIFO_FLUSH   |
 587                                   IFX_SSC_XFCON_FIFO_ENABLE,
 588                                   info->mapbase + IFX_SSC_TXFCON);
 589         WRITE_PERIPHERAL_REGISTER((IFX_SSC_DEF_RXFIFO_FL <<
 590                                    IFX_SSC_XFCON_ITL_OFFSET) |
 591                                   IFX_SSC_XFCON_FIFO_FLUSH   |
 592                                   IFX_SSC_XFCON_FIFO_ENABLE,
 593                                   info->mapbase + IFX_SSC_RXFCON);
 594
 595
 596         /* logically flush the software FIFOs */
 597         info->rxbuf_ptr = 0;
 598         info->txbuf_ptr = 0;
 599
 600         /* clear all error bits */
 601         WRITE_PERIPHERAL_REGISTER(IFX_SSC_WHBSTATE_CLR_ALL_ERROR,
 602                                   info->mapbase + IFX_SSC_WHBSTATE);
 603
 604         // clear pending interrupts
 605         ifx_int_wrapper.clear(info->rxirq);
 606         ifx_int_wrapper.clear(info->txirq);
 607         ifx_int_wrapper.clear(info->errirq);
 608 /*
 609         ifx_int_wrapper.clear(info->frmirq);
 610 */
 611
 612         // enable SSC
 613         WRITE_PERIPHERAL_REGISTER(IFX_SSC_WHBSTATE_SET_ENABLE,
 614                                   info->mapbase + IFX_SSC_WHBSTATE);
 615
 616         MOD_INC_USE_COUNT;
 617
 618         return 0;
 619 } /* ifx_ssc_open */
 620 EXPORT_SYMBOL(ifx_ssc_open);
 621
 622 /*
 623  * This routine is called when a particular device is closed.
 624  */
 625 int
 626 ifx_ssc_close(struct inode *inode, struct file *filp)
 627 {
 628         struct ifx_ssc_port *info;
 629         int idx;
 630
 631         if ((inode == (struct inode *)0) || (inode == (struct inode *)1))
 632                 idx = (int)inode;
 633         else
 634                 idx = MINOR(filp->f_dentry->d_inode->i_rdev);
 635
 636         if (idx < 0 || idx >= PORT_CNT)
 637                 return -ENXIO;
 638
 639         info = &isp[idx];
 640         if (!info)
 641                 return -ENXIO;
 642
 643         // disable SSC
 644         WRITE_PERIPHERAL_REGISTER(IFX_SSC_WHBSTATE_CLR_ENABLE,
 645                                   info->mapbase + IFX_SSC_WHBSTATE);
 646
 647         // call abort function to disable int's, flush fifos...
 648         ifx_ssc_abort(info);
 649
 650         info->port_is_open --;
 651         MOD_DEC_USE_COUNT;
 652
 653         return 0;
 654 } /* ifx_ssc_close */
 655 EXPORT_SYMBOL(ifx_ssc_close);
 656
 657 /* added by bingtao */
 658 /* helper routine to handle reads from the kernel or user-space */
 659 /* info->rxbuf : never kfree and contains valid data */
 660 /* should be points to NULL after copying data !!! */
 661 static ssize_t
 662 ifx_ssc_read_helper_poll(struct ifx_ssc_port *info, char *buf, size_t len,
 663                     int from_kernel)
 664 {
 665         ssize_t         ret_val;
 666         unsigned long   flags;
 667
 668         if (info->opts.modeRxTx == IFX_SSC_MODE_TX)
 669                 return -EFAULT;
 670         local_irq_save(flags);
 671         info->rxbuf_ptr = info->rxbuf;
 672         info->rxbuf_end = info->rxbuf + len;
 673         local_irq_restore(flags);
 674 /* Vinetic driver always works in IFX_SSC_MODE_RXTX */
 675 /* TXRX in poll mode */
 676         while (info->rxbuf_ptr < info->rxbuf_end){
 677 /* This is the key point, if you don't check this condition
 678    kfree (NULL) will happen
 679    because tx only need write into FIFO, it's much fast than rx
 680    So when rx still waiting , tx already finish and release buf
 681 */
 682                 if (info->txbuf_ptr < info->txbuf_end) {
 683                         tx_int(info);
 684                 }
 685
 686                 rx_int(info);
 687         };
 688
 689         ret_val = info->rxbuf_ptr - info->rxbuf;
 690         return (ret_val);
 691 } // ifx_ssc_read_helper_poll
 692
 693 /* helper routine to handle reads from the kernel or user-space */
 694 /* info->rx_buf : never kfree and contains valid data */
 695 /* should be points to NULL after copying data !!! */
 696 static ssize_t
 697 ifx_ssc_read_helper(struct ifx_ssc_port *info, char *buf, size_t len,
 698                     int from_kernel)
 699 {
 700         ssize_t         ret_val;
 701         unsigned long   flags;
 702         DECLARE_WAITQUEUE(wait, current);
 703
 704         if (info->opts.modeRxTx == IFX_SSC_MODE_TX)
 705                 return -EFAULT;
 706         local_irq_save(flags);
 707         info->rxbuf_ptr = info->rxbuf;
 708         info->rxbuf_end = info->rxbuf + len;
 709         if (info->opts.modeRxTx == IFX_SSC_MODE_RXTX) {
 710                 if ((info->txbuf == NULL) ||
 711                     (info->txbuf != info->txbuf_ptr) ||
 712                     (info->txbuf_end != len + info->txbuf)) {
 713                         local_irq_restore(flags);
 714                         printk("IFX SSC - %s: write must be called before calling "
 715                                "read in combined RX/TX!\n", __FUNCTION__);
 716                         return -EFAULT;
 717                 }
 718                 local_irq_restore(flags);
 719                 /* should enable tx, right?*/
 720                 tx_int(info);
 721                 if (info->txbuf_ptr < info->txbuf_end){
 722                         ifx_int_wrapper.enable(info->txirq);
 723                 }
 724
 725                 ifx_int_wrapper.enable(info->rxirq);
 726         } else { // rx mode
 727                 local_irq_restore(flags);
 728                 if (READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_RXCNT) &
 729                     IFX_SSC_RXCNT_TODO_MASK)
 730                         return -EBUSY;
 731                 ifx_int_wrapper.enable(info->rxirq);
 732                 // rx request limited to ' bytes
 733 /*
 734                 if (len < 65536)
 735 */
 736                 if (len < IFX_SSC_RXREQ_BLOCK_SIZE)
 737                         WRITE_PERIPHERAL_REGISTER(len << IFX_SSC_RXREQ_RXCOUNT_OFFSET,
 738                                                   info->mapbase + IFX_SSC_RXREQ);
 739                 else
 740                         WRITE_PERIPHERAL_REGISTER(IFX_SSC_RXREQ_BLOCK_SIZE << IFX_SSC_RXREQ_RXCOUNT_OFFSET,
 741                                                   info->mapbase + IFX_SSC_RXREQ);
 742         }
 743
 744         __add_wait_queue(&info->rwait, &wait);
 745         set_current_state(TASK_INTERRUPTIBLE);
 746         // wakeup done in rx_int
 747
 748         do {
 749                 local_irq_save(flags);
 750                 if (info->rxbuf_ptr >= info->rxbuf_end)
 751                         break;
 752                 local_irq_restore(flags);
 753
 754 //                if (filp->f_flags & O_NONBLOCK)
 755 //                {
 756 //                        N = -EAGAIN;
 757 //                        goto out;
 758 //                }
 759                 if (signal_pending(current)) {
 760                         ret_val = -ERESTARTSYS;
 761                         goto out;
 762                 }
 763                 schedule();
 764         } while (1);
 765
 766         ret_val = info->rxbuf_ptr - info->rxbuf; // should be equal to len
 767         local_irq_restore(flags);
 768
 769   out:
 770         current->state = TASK_RUNNING;
 771         __remove_wait_queue(&info->rwait, &wait);
 772         return (ret_val);
 773 } // ifx_ssc_read_helper
 774
 775
 776 #if 0
 777 /* helper routine to handle reads from the kernel or user-space */
 778 /* appropriate in interrupt context */
 779 static ssize_t
 780 ifx_ssc_read_helper(struct ifx_ssc_port *info, char *buf, size_t len,
 781                     int from_kernel)
 782 {
 783         ssize_t         ret_val;
 784         unsigned long   flags;
 785         DECLARE_WAITQUEUE(wait, current);
 786
 787         if (info->opts.modeRxTx == IFX_SSC_MODE_TX)
 788                 return -EFAULT;
 789         local_irq_save(flags);
 790         info->rxbuf_ptr = info->rxbuf;
 791         info->rxbuf_end = info->rxbuf + len;
 792         if (info->opts.modeRxTx == IFX_SSC_MODE_RXTX) {
 793                 if ((info->txbuf == NULL) ||
 794                     (info->txbuf != info->txbuf_ptr) ||
 795                     (info->txbuf_end != len + info->txbuf)) {
 796                         local_irq_restore(flags);
 797                         printk("IFX SSC - %s: write must be called before calling "
 798                                "read in combined RX/TX!\n", __FUNCTION__);
 799                         return -EFAULT;
 800                 }
 801                 local_irq_restore(flags);
 802                 /* should enable tx, right?*/
 803                 tx_int(info);
 804                 if (!in_irq()){
 805                         if (info->txbuf_ptr < info->txbuf_end){
 806                                 ifx_int_wrapper.enable(info->txirq);
 807                         }
 808                         ifx_int_wrapper.enable(info->rxirq);
 809                 }
 810         } else { // rx mode
 811                 local_irq_restore(flags);
 812                 if (READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_RXCNT) &
 813                     IFX_SSC_RXCNT_TODO_MASK)
 814                         return -EBUSY;
 815                 if (!in_irq()){
 816                         ifx_int_wrapper.enable(info->rxirq);
 817                 }
 818
 819                 if (len < IFX_SSC_RXREQ_BLOCK_SIZE)
 820                         WRITE_PERIPHERAL_REGISTER(len << IFX_SSC_RXREQ_RXCOUNT_OFFSET,
 821                                                   info->mapbase + IFX_SSC_RXREQ);
 822                 else
 823                         WRITE_PERIPHERAL_REGISTER(IFX_SSC_RXREQ_BLOCK_SIZE << IFX_SSC_RXREQ_RXCOUNT_OFFSET,
 824                                                   info->mapbase + IFX_SSC_RXREQ);
 825         }
 826         if (in_irq()){
 827                 do {
 828                         rx_int(info);
 829                         if (info->opts.modeRxTx == IFX_SSC_MODE_RXTX) {
 830                                 tx_int(info);
 831                         }
 832
 833                         if (info->rxbuf_ptr >= info->rxbuf_end)
 834                                 break;
 835                 } while (1);
 836                 ret_val = info->rxbuf_ptr - info->rxbuf;
 837         }else{
 838                 __add_wait_queue(&info->rwait, &wait);
 839                 set_current_state(TASK_INTERRUPTIBLE);
 840                 // wakeup done in rx_int
 841
 842                 do {
 843                         local_irq_save(flags);
 844                         if (info->rxbuf_ptr >= info->rxbuf_end)
 845                                 break;
 846                         local_irq_restore(flags);
 847
 848                         if (signal_pending(current)) {
 849                                 ret_val = -ERESTARTSYS;
 850                                 goto out;
 851                         }
 852                         schedule();
 853                 } while (1);
 854
 855                 ret_val = info->rxbuf_ptr - info->rxbuf; // should be equal to len
 856                 local_irq_restore(flags);
 857
 858   out:
 859                 current->state = TASK_RUNNING;
 860                 __remove_wait_queue(&info->rwait, &wait);
 861         }
 862         return (ret_val);
 863 } // ifx_ssc_read_helper
 864 #endif
 865
 866 /* helper routine to handle writes to the kernel or user-space */
 867 /* info->txbuf has two cases:
 868  *      1) return value < 0 (-EFAULT), not touched at all
 869  *      2) kfree and points to NULL in interrupt routine (but maybe later )
 870  */
 871 static ssize_t
 872 ifx_ssc_write_helper(struct ifx_ssc_port *info, const char *buf,
 873                 size_t len, int from_kernel)
 874 {
 875         // check if in tx or tx/rx mode
 876         if (info->opts.modeRxTx == IFX_SSC_MODE_RX)
 877                 return -EFAULT;
 878
 879         info->txbuf_ptr = info->txbuf;
 880         info->txbuf_end = len + info->txbuf;
 881         /* start the transmission (not in rx/tx, see read helper) */
 882         if (info->opts.modeRxTx == IFX_SSC_MODE_TX) {
 883                 tx_int(info);
 884                 if (info->txbuf_ptr < info->txbuf_end){
 885                         ifx_int_wrapper.enable(info->txirq);
 886                 }
 887         }
 888         //local_irq_restore(flags);
 889         return len;
 890 }
 891
 892 /*
 893  * kernel interfaces for read and write.
 894  * The caller must set port to: n for SSC<m> with n=m-1 (e.g. n=0 for SSC1)
 895  */
 896 ssize_t
 897 ifx_ssc_kread(int port, char *kbuf, size_t len)
 898 {
 899         struct ifx_ssc_port *info;
 900         ssize_t ret_val;
 901
 902         if (port < 0 || port >= PORT_CNT)
 903                 return -ENXIO;
 904
 905         if (len == 0)
 906                 return 0;
 907
 908         info = &isp[port];
 909
 910         // check if reception in progress
 911         if (info->rxbuf != NULL){
 912                 printk("SSC device busy\n");
 913                 return -EBUSY;
 914         }
 915
 916         info->rxbuf = kbuf;
 917         if (info->rxbuf == NULL){
 918                 printk("SSC device error\n");
 919                 return -EINVAL;
 920         }
 921
 922 /* changed by bingtao */
 923         /* change by TaiCheng */
 924         //if (!in_irq()){
 925         if (0){
 926                 ret_val = ifx_ssc_read_helper(info, kbuf, len, 1);
 927         }else{
 928                 ret_val = ifx_ssc_read_helper_poll(info, kbuf, len, 1);
 929         };
 930         info->rxbuf = NULL;
 931
 932         // ### TO DO: perhaps warn if ret_val != len
 933         ifx_int_wrapper.disable(info->rxirq);
 934
 935         return (ret_val);
 936 } // ifx_ssc_kread
 937 EXPORT_SYMBOL(ifx_ssc_kread);
 938
 939 ssize_t
 940 ifx_ssc_kwrite(int port, const char *kbuf, size_t len)
 941 {
 942         struct ifx_ssc_port *info;
 943         ssize_t ret_val;
 944
 945         if (port < 0 || port >= PORT_CNT)
 946                 return -ENXIO;
 947
 948         if (len == 0)
 949                 return 0;
 950
 951         info = &isp[port];
 952
 953         // check if transmission in progress
 954         if (info->txbuf != NULL)
 955                 return -EBUSY;
 956         info->txbuf = (char *)kbuf;
 957
 958         ret_val = ifx_ssc_write_helper(info, info->txbuf, len, 1);
 959         if (ret_val < 0){
 960                 info->txbuf = NULL;
 961         }
 962         return ret_val;
 963 }
 964 EXPORT_SYMBOL(ifx_ssc_kwrite);
 965
 966
 967 /*
 968  * user interfaces to read and write
 969  */
 970 static ssize_t
 971 ifx_ssc_read(struct file *filp, char *ubuf, size_t len, loff_t *off)
 972 {
 973         ssize_t ret_val;
 974         int idx;
 975         struct ifx_ssc_port *info;
 976
 977 /*
 978         if (len == 0)
 979                 return (0);
 980 */
 981         idx = MINOR(filp->f_dentry->d_inode->i_rdev);
 982         info = &isp[idx];
 983
 984         // check if reception in progress
 985         if (info->rxbuf != NULL)
 986                 return -EBUSY;
 987
 988         info->rxbuf = kmalloc(len+ 3, GFP_KERNEL);
 989         if (info->rxbuf == NULL)
 990                 return -ENOMEM;
 991
 992         ret_val = ifx_ssc_read_helper(info, info->rxbuf, len, 0);
 993         // ### TO DO: perhaps warn if ret_val != len
 994         if (copy_to_user((void*)ubuf, info->rxbuf, ret_val) != 0)
 995                 ret_val = -EFAULT;
 996
 997         ifx_int_wrapper.disable(info->rxirq);
 998
 999         kfree(info->rxbuf);
1000         info->rxbuf = NULL;
1001         return (ret_val);
1002 } // ifx_ssc_read
1003
1004 /*
1005  * As many bytes as we have free space for are copied from the user
1006  * into txbuf and the actual byte count is returned. The transmission is
1007  * always kicked off by calling the appropriate TX routine.
1008  */
1009 static ssize_t
1010 ifx_ssc_write(struct file *filp, const char *ubuf, size_t len, loff_t *off)
1011 {
1012         int idx;
1013         struct ifx_ssc_port *info;
1014         int ret_val;
1015
1016         if (len == 0)
1017                 return (0);
1018
1019         idx = MINOR(filp->f_dentry->d_inode->i_rdev);
1020         info = &isp[idx];
1021
1022         // check if transmission in progress
1023         if (info->txbuf != NULL)
1024                 return -EBUSY;
1025
1026         info->txbuf = kmalloc(len+ 3, GFP_KERNEL);
1027         if (info->txbuf == NULL)
1028                 return -ENOMEM;
1029
1030         ret_val = copy_from_user(info->txbuf, ubuf, len);
1031         if (ret_val == 0)
1032                 ret_val = ifx_ssc_write_helper(info, info->txbuf, len, 0);
1033         else
1034                 ret_val = -EFAULT;
1035         if (ret_val < 0) {
1036                 kfree(info->txbuf); // otherwise will be done in ISR
1037                 info->txbuf = NULL;
1038         }
1039         return (ret_val);
1040 } /* ifx_ssc_write */
1041
1042
1043 /*
1044  * ------------------------------------------------------------
1045  * ifx_ssc_ioctl() and friends
1046  * ------------------------------------------------------------
1047  */
1048
1049 /*-----------------------------------------------------------------------------
1050  FUNC-NAME  : ifx_ssc_frm_status_get
1051  LONG-NAME  : framing status get
1052  PURPOSE    : Get the actual status of the framing.
1053
1054  PARAMETER  : *info     pointer to the port-specific structure ifx_ssc_port.
1055
1056  RESULT     : pointer to a structure ifx_ssc_frm_status which holds busy and
1057               count values.
1058
1059  REMARKS    : Returns a register value independent of framing is enabled or
1060               not! Changes structure inside of info, so the return value isn't
1061               needed at all, but could be used for simple access.
1062 -----------------------------------------------------------------------------*/
1063 static struct ifx_ssc_frm_status *
1064 ifx_ssc_frm_status_get(struct ifx_ssc_port *info)
1065 {
1066         unsigned long tmp;
1067
1068         tmp = READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_SFSTAT);
1069         info->frm_status.DataBusy = (tmp & IFX_SSC_SFSTAT_IN_DATA) > 0;
1070         info->frm_status.PauseBusy = (tmp & IFX_SSC_SFSTAT_IN_PAUSE) > 0;
1071         info->frm_status.DataCount = (tmp & IFX_SSC_SFSTAT_DATA_COUNT_MASK)
1072                 >> IFX_SSC_SFSTAT_DATA_COUNT_OFFSET;
1073         info->frm_status.PauseCount = (tmp & IFX_SSC_SFSTAT_PAUSE_COUNT_MASK)
1074                 >> IFX_SSC_SFSTAT_PAUSE_COUNT_OFFSET;
1075         tmp = READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_SFCON);
1076         info->frm_status.EnIntAfterData =
1077                 (tmp & IFX_SSC_SFCON_FIR_ENABLE_BEFORE_PAUSE) > 0;
1078         info->frm_status.EnIntAfterPause =
1079                 (tmp & IFX_SSC_SFCON_FIR_ENABLE_AFTER_PAUSE) > 0;
1080         return (&info->frm_status);
1081 } // ifx_ssc_frm_status_get
1082
1083
1084 /*-----------------------------------------------------------------------------
1085  FUNC-NAME  : ifx_ssc_frm_control_get
1086  LONG-NAME  : framing control get
1087  PURPOSE    : Get the actual control values of the framing.
1088
1089  PARAMETER  : *info     pointer to the port-specific structure ifx_ssc_port.
1090
1091  RESULT     : pointer to a structure ifx_ssc_frm_opts which holds control bits
1092               and count reload values.
1093
1094  REMARKS    : Changes structure inside of info, so the return value isn't
1095               needed at all, but could be used for simple access.
1096 -----------------------------------------------------------------------------*/
1097 static struct ifx_ssc_frm_opts *
1098 ifx_ssc_frm_control_get(struct ifx_ssc_port *info)
1099 {
1100         unsigned long tmp;
1101
1102         tmp = READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_SFCON);
1103         info->frm_opts.FrameEnable = (tmp & IFX_SSC_SFCON_SF_ENABLE) > 0;
1104         info->frm_opts.DataLength = (tmp & IFX_SSC_SFCON_DATA_LENGTH_MASK)
1105                 >> IFX_SSC_SFCON_DATA_LENGTH_OFFSET;
1106         info->frm_opts.PauseLength = (tmp & IFX_SSC_SFCON_PAUSE_LENGTH_MASK)
1107                 >> IFX_SSC_SFCON_PAUSE_LENGTH_OFFSET;
1108         info->frm_opts.IdleData = (tmp & IFX_SSC_SFCON_PAUSE_DATA_MASK)
1109                 >> IFX_SSC_SFCON_PAUSE_DATA_OFFSET;
1110         info->frm_opts.IdleClock = (tmp & IFX_SSC_SFCON_PAUSE_CLOCK_MASK)
1111                 >> IFX_SSC_SFCON_PAUSE_CLOCK_OFFSET;
1112         info->frm_opts.StopAfterPause =
1113                 (tmp & IFX_SSC_SFCON_STOP_AFTER_PAUSE) > 0;
1114         return (&info->frm_opts);
1115 } // ifx_ssc_frm_control_get
1116
1117
1118 /*-----------------------------------------------------------------------------
1119  FUNC-NAME  : ifx_ssc_frm_control_set
1120  LONG-NAME  : framing control set
1121  PURPOSE    : Set the actual control values of the framing.
1122
1123  PARAMETER  : *info     pointer to the port-specific structure ifx_ssc_port.
1124
1125  RESULT     : pointer to a structure ifx_ssc_frm_opts which holds control bits
1126               and count reload values.
1127
1128  REMARKS    :
1129 -----------------------------------------------------------------------------*/
1130 static int
1131 ifx_ssc_frm_control_set(struct ifx_ssc_port *info)
1132 {
1133         unsigned long tmp;
1134
1135         // check parameters
1136         if ((info->frm_opts.DataLength > IFX_SSC_SFCON_DATA_LENGTH_MAX) ||
1137             (info->frm_opts.DataLength < 1) ||
1138             (info->frm_opts.PauseLength > IFX_SSC_SFCON_PAUSE_LENGTH_MAX) ||
1139             (info->frm_opts.PauseLength < 1) ||
1140             ((info->frm_opts.IdleData & ~(IFX_SSC_SFCON_PAUSE_DATA_MASK >>
1141                                           IFX_SSC_SFCON_PAUSE_DATA_OFFSET)) != 0 ) ||
1142             ((info->frm_opts.IdleClock & ~(IFX_SSC_SFCON_PAUSE_CLOCK_MASK >>
1143                                            IFX_SSC_SFCON_PAUSE_CLOCK_OFFSET)) != 0 ))
1144                 return -EINVAL;
1145
1146         // read interrupt bits (they're not changed here)
1147         tmp = READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_SFCON) &
1148                 (IFX_SSC_SFCON_FIR_ENABLE_BEFORE_PAUSE |
1149                  IFX_SSC_SFCON_FIR_ENABLE_AFTER_PAUSE);
1150
1151         // set all values with respect to it's bit position (for data and pause
1152         // length set N-1)
1153         tmp = (info->frm_opts.DataLength - 1) << IFX_SSC_SFCON_DATA_LENGTH_OFFSET;
1154         tmp |= (info->frm_opts.PauseLength - 1) << IFX_SSC_SFCON_PAUSE_LENGTH_OFFSET;
1155         tmp |= info->frm_opts.IdleData << IFX_SSC_SFCON_PAUSE_DATA_OFFSET;
1156         tmp |= info->frm_opts.IdleClock << IFX_SSC_SFCON_PAUSE_CLOCK_OFFSET;
1157         tmp |= info->frm_opts.FrameEnable * IFX_SSC_SFCON_SF_ENABLE;
1158         tmp |= info->frm_opts.StopAfterPause * IFX_SSC_SFCON_STOP_AFTER_PAUSE;
1159
1160         WRITE_PERIPHERAL_REGISTER(tmp, info->mapbase + IFX_SSC_SFCON);
1161
1162         return 0;
1163 } // ifx_ssc_frm_control_set
1164
1165
1166 /*-----------------------------------------------------------------------------
1167  FUNC-NAME  : ifx_ssc_rxtx_mode_set
1168  LONG-NAME  : rxtx mode set
1169  PURPOSE    : Set the transmission mode.
1170
1171  PARAMETER  : *info     pointer to the port-specific structure ifx_ssc_port.
1172
1173  RESULT     : Returns error code
1174
1175  REMARKS    : Assumes that SSC not used (SSC disabled, device not opened yet
1176               or just closed)
1177 -----------------------------------------------------------------------------*/
1178 static int
1179 ifx_ssc_rxtx_mode_set(struct ifx_ssc_port *info, unsigned int val)
1180 {
1181         unsigned long tmp;
1182
1183         // check parameters
1184         if (!(info) || (val & ~(IFX_SSC_MODE_MASK)))
1185                 return -EINVAL;
1186         /*check BUSY and RXCNT*/
1187         if (  READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_STATE) & IFX_SSC_STATE_BUSY
1188             ||READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_RXCNT) & IFX_SSC_RXCNT_TODO_MASK)
1189                 return -EBUSY;
1190         // modify
1191         tmp = (READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_CON) &
1192                 ~(IFX_SSC_CON_RX_OFF | IFX_SSC_CON_TX_OFF)) | (val);
1193         WRITE_PERIPHERAL_REGISTER(tmp, info->mapbase + IFX_SSC_CON);
1194         info->opts.modeRxTx = val;
1195 /*
1196         printk(KERN_DEBUG "IFX SSC%d: Setting mode to %s%s\n",
1197                info->port_nr,
1198                ((val & IFX_SSC_CON_RX_OFF) == 0) ? "rx ":"",
1199                ((val & IFX_SSC_CON_TX_OFF) == 0) ? "tx":"");
1200 */
1201         return 0;
1202 } // ifx_ssc_rxtx_mode_set
1203
1204 void ifx_gpio_init(void)
1205 {
1206         u32     temp;
1207 /* set gpio pin p0.10(SPI_DIN) p0.11(SPI_DOUT) p0.12(SPI_CLK) p0.13(SPI_CS2) direction */
1208         temp = *(AMAZON_GPIO_P0_DIR) ;
1209         temp &= 0xFFFFFBFF;
1210         temp |= 0x3800;
1211         *(AMAZON_GPIO_P0_DIR) = temp;
1212 /* set port 0 alternate select register 0 */
1213         temp = *(AMAZON_GPIO_P0_ALTSEL0) ;
1214         temp &= 0xFFFFC3FF;
1215         temp |= 0x00001c00;
1216         *(AMAZON_GPIO_P0_ALTSEL0) = temp;
1217
1218 /* set port 0 alternate select register 1 */
1219         temp = *(AMAZON_GPIO_P0_ALTSEL1) ;
1220         temp &= 0xFFFFC3FF;
1221         temp |= 0x00002000;
1222         *(AMAZON_GPIO_P0_ALTSEL1) = temp;
1223
1224 /* set port 0 open drain mode register */
1225         temp = *(AMAZON_GPIO_P0_OD);
1226         temp |= 0x00003800;     /* set output pin normal mode */
1227         *(AMAZON_GPIO_P0_OD)= temp;
1228 }
1229
1230 /*
1231  * This routine intializes the SSC appropriately depending
1232  * on slave/master and full-/half-duplex mode.
1233  * It assumes that the SSC is disabled and the fifo's and buffers
1234  * are flushes later on.
1235  */
1236 static int
1237 ifx_ssc_sethwopts(struct ifx_ssc_port *info)
1238 {
1239         unsigned long flags, bits;
1240         struct ifx_ssc_hwopts *opts = &info->opts;
1241
1242         /* sanity checks */
1243         if ((opts->dataWidth < IFX_SSC_MIN_DATA_WIDTH) ||
1244             (opts->dataWidth > IFX_SSC_MAX_DATA_WIDTH)) {
1245                 printk("%s: sanity check failed\n", __FUNCTION__);
1246                 return -EINVAL;
1247         }
1248         bits = (opts->dataWidth - 1) << IFX_SSC_CON_DATA_WIDTH_OFFSET;
1249         bits |= IFX_SSC_CON_ENABLE_BYTE_VALID;
1250 //      if (opts->abortErrDetect)
1251 //              bits |= IFX_SSC_CON_ABORT_ERR_CHECK;
1252         if (opts->rxOvErrDetect)
1253                 bits |= IFX_SSC_CON_RX_OFL_CHECK;
1254         if (opts->rxUndErrDetect)
1255                 bits |= IFX_SSC_CON_RX_UFL_CHECK;
1256         if (opts->txOvErrDetect)
1257                 bits |= IFX_SSC_CON_TX_OFL_CHECK;
1258         if (opts->txUndErrDetect)
1259                 bits |= IFX_SSC_CON_TX_UFL_CHECK;
1260         if (opts->loopBack)
1261                 bits |= IFX_SSC_CON_LOOPBACK_MODE;
1262         if (opts->echoMode)
1263                 bits |= IFX_SSC_CON_ECHO_MODE_ON;
1264         if (opts->headingControl)
1265                 bits |= IFX_SSC_CON_MSB_FIRST;
1266         if (opts->clockPhase)
1267                 bits |= IFX_SSC_CON_LATCH_THEN_SHIFT;
1268         if (opts->clockPolarity)
1269                 bits |= IFX_SSC_CON_CLOCK_FALL;
1270         switch (opts->modeRxTx) {
1271         case IFX_SSC_MODE_TX:
1272                 bits |= IFX_SSC_CON_RX_OFF;
1273                 break;
1274         case IFX_SSC_MODE_RX:
1275                 bits |= IFX_SSC_CON_TX_OFF;
1276                 break;
1277         } // switch (opts->modeRxT)
1278         local_irq_save(flags);
1279         WRITE_PERIPHERAL_REGISTER(bits, info->mapbase + IFX_SSC_CON);
1280         WRITE_PERIPHERAL_REGISTER((info->opts.gpoCs << IFX_SSC_GPOCON_ISCSB0_POS) |
1281                                   (info->opts.gpoInv << IFX_SSC_GPOCON_INVOUT0_POS),
1282                                   info->mapbase + IFX_SSC_GPOCON);
1283         //master mode
1284         if (opts->masterSelect){
1285                 WRITE_PERIPHERAL_REGISTER(IFX_SSC_WHBSTATE_SET_MASTER_SELECT,info->mapbase + IFX_SSC_WHBSTATE);
1286         }else{
1287                 WRITE_PERIPHERAL_REGISTER(IFX_SSC_WHBSTATE_CLR_MASTER_SELECT,info->mapbase + IFX_SSC_WHBSTATE);
1288         }
1289         // init serial framing
1290         WRITE_PERIPHERAL_REGISTER(0, info->mapbase + IFX_SSC_SFCON);
1291         /* set up the port pins */
1292         //check for general requirements to switch (external) pad/pin characteristics
1293         ifx_gpio_init();
1294         local_irq_restore(flags);
1295
1296         return 0;
1297 } // ifx_ssc_sethwopts
1298
1299 static int
1300 ifx_ssc_set_baud(struct ifx_ssc_port *info, unsigned int baud)
1301 {
1302         unsigned int ifx_ssc_clock;
1303         unsigned int br;
1304         unsigned long flags;
1305         bool enabled;
1306
1307         ifx_ssc_clock = ifx_ssc_get_kernel_clk(info);
1308         if (ifx_ssc_clock ==0)
1309                 return -EINVAL;
1310
1311         local_irq_save(flags);
1312         /* have to disable the SSC to set the baudrate */
1313         enabled = (READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_STATE)
1314                    & IFX_SSC_STATE_IS_ENABLED) != 0;
1315         WRITE_PERIPHERAL_REGISTER(IFX_SSC_WHBSTATE_CLR_ENABLE,
1316                                   info->mapbase + IFX_SSC_WHBSTATE);
1317
1318         // compute divider
1319         br = ((ifx_ssc_clock >> 1)/baud) - 1;
1320         asm("SYNC");
1321         if (br > 0xffff ||
1322             ((br == 0) &&
1323              ((READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_STATE) &
1324                IFX_SSC_STATE_IS_MASTER) == 0))){
1325                 local_irq_restore(flags);
1326                 printk("%s: illegal baudrate %u\n", __FUNCTION__, baud);
1327                 return -EINVAL;
1328         }
1329         WRITE_PERIPHERAL_REGISTER(br, info->mapbase + IFX_SSC_BR);
1330         if (enabled)
1331                 WRITE_PERIPHERAL_REGISTER(IFX_SSC_WHBSTATE_SET_ENABLE,
1332                                           info->mapbase + IFX_SSC_WHBSTATE);
1333
1334         local_irq_restore(flags);
1335         return 0;
1336 } // ifx_ssc_set_baud
1337
1338 static int
1339 ifx_ssc_hwinit(struct ifx_ssc_port *info)
1340 {
1341         unsigned long flags;
1342         bool enabled;
1343
1344         /* have to disable the SSC */
1345         enabled = (READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_STATE)
1346                    & IFX_SSC_STATE_IS_ENABLED) != 0;
1347         WRITE_PERIPHERAL_REGISTER(IFX_SSC_WHBSTATE_CLR_ENABLE,
1348                                   info->mapbase + IFX_SSC_WHBSTATE);
1349
1350         if (ifx_ssc_sethwopts(info) < 0)
1351         {
1352                 printk("%s: setting the hardware options failed\n",
1353                        __FUNCTION__);
1354                 return -EINVAL;
1355         }
1356
1357         if (ifx_ssc_set_baud(info, info->baud) < 0) {
1358                 printk("%s: setting the baud rate failed\n", __FUNCTION__);
1359                 return -EINVAL;
1360         }
1361         local_irq_save(flags);
1362         /* TX FIFO */
1363         WRITE_PERIPHERAL_REGISTER((IFX_SSC_DEF_TXFIFO_FL <<
1364                                    IFX_SSC_XFCON_ITL_OFFSET) |
1365                                   IFX_SSC_XFCON_FIFO_ENABLE,
1366                                   info->mapbase + IFX_SSC_TXFCON);
1367         /* RX FIFO */
1368         WRITE_PERIPHERAL_REGISTER((IFX_SSC_DEF_RXFIFO_FL <<
1369                                    IFX_SSC_XFCON_ITL_OFFSET) |
1370                                   IFX_SSC_XFCON_FIFO_ENABLE,
1371                                   info->mapbase + IFX_SSC_RXFCON);
1372         local_irq_restore(flags);
1373         if (enabled)
1374                 WRITE_PERIPHERAL_REGISTER(IFX_SSC_WHBSTATE_SET_ENABLE,
1375                                           info->mapbase + IFX_SSC_WHBSTATE);
1376         return 0;
1377 } // ifx_ssc_hwinit
1378
1379 /*-----------------------------------------------------------------------------
1380  FUNC-NAME  : ifx_ssc_batch_exec
1381  LONG-NAME  :
1382  PURPOSE    :
1383
1384  PARAMETER  : *info     pointer to the port-specific structure ifx_ssc_port.
1385
1386  RESULT     : Returns error code
1387
1388  REMARKS    :
1389 -----------------------------------------------------------------------------*/
1390 static int
1391 ifx_ssc_batch_exec(struct ifx_ssc_port *info, struct ifx_ssc_batch_list *batch_anchor)
1392 {
1393         // ### TO DO: implement user space batch execution
1394         // first, copy the whole linked list from user to kernel space
1395         // save some hardware options
1396         // execute list
1397         // restore hardware options if selected
1398         return -EFAULT;
1399 } // ifx_ssc_batch_exec
1400
1401
1402 /*
1403  * This routine allows the driver to implement device-
1404  * specific ioctl's.  If the ioctl number passed in cmd is
1405  * not recognized by the driver, it should return ENOIOCTLCMD.
1406  */
1407 int
1408 ifx_ssc_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
1409               unsigned long data)
1410 {
1411         struct ifx_ssc_port *info;
1412         int line, ret_val = 0;
1413         unsigned long flags;
1414         unsigned long tmp;
1415         int from_kernel = 0;
1416
1417         if ((inode == (struct inode *)0) || (inode == (struct inode *)1))
1418         {
1419                 from_kernel = 1;
1420                 line = (int)inode;
1421         }
1422         else
1423                 line = MINOR(filp->f_dentry->d_inode->i_rdev);
1424
1425         /* don't use more minor devices than we can support */
1426         if (line < 0 || line >= PORT_CNT)
1427                 return -ENXIO;
1428
1429         info = &isp[line];
1430
1431         switch (cmd) {
1432         case IFX_SSC_STATS_READ:
1433                 /* data must be a pointer to a struct ifx_ssc_statistics */
1434                 if (from_kernel)
1435                         memcpy((void *)data, (void *)&info->stats,
1436                                sizeof(struct ifx_ssc_statistics));
1437                 else
1438                         if (copy_to_user((void *)data,
1439                                          (void *)&info->stats,
1440                                          sizeof(struct ifx_ssc_statistics)))
1441                                 ret_val = -EFAULT;
1442                 break;
1443         case IFX_SSC_STATS_RESET:
1444                 /* just resets the statistics counters */
1445                 memset((void *)&info->stats, 0, sizeof(struct ifx_ssc_statistics));
1446                 break;
1447         case IFX_SSC_BAUD_SET:
1448                 /* if the buffers are not empty then the port is */
1449                 /* busy and we shouldn't change things on-the-fly! */
1450                 if (!info->txbuf || !info->rxbuf ||
1451                     (READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_STATE)
1452                      & IFX_SSC_STATE_BUSY)) {
1453                         ret_val = -EBUSY;
1454                         break;
1455                 }
1456                 /* misuse flags */
1457                 if (from_kernel)
1458                         flags = *((unsigned long *)data);
1459                 else
1460                         if (copy_from_user((void *)&flags,
1461                                            (void *)data, sizeof(flags)))
1462                         {
1463                                 ret_val = -EFAULT;
1464                                 break;
1465                         }
1466                 if (flags == 0)
1467                 {
1468                         ret_val = -EINVAL;
1469                         break;
1470                 }
1471                 if (ifx_ssc_set_baud(info, flags) < 0)
1472                 {
1473                         ret_val = -EINVAL;
1474                         break;
1475                 }
1476                 info->baud = flags;
1477                 break;
1478         case IFX_SSC_BAUD_GET:
1479                 if (from_kernel)
1480                         *((unsigned int *)data) = info->baud;
1481                 else
1482                         if (copy_to_user((void *)data,
1483                                          (void *)&info->baud,
1484                                          sizeof(unsigned long)))
1485                                 ret_val = -EFAULT;
1486                 break;
1487         case IFX_SSC_RXTX_MODE_SET:
1488                 if (from_kernel)
1489                         tmp = *((unsigned long *)data);
1490                 else
1491                         if (copy_from_user((void *)&tmp,
1492                                            (void *)data, sizeof(tmp))) {
1493                                 ret_val = -EFAULT;
1494                                 break;
1495                         }
1496                 ret_val = ifx_ssc_rxtx_mode_set(info, tmp);
1497                 break;
1498         case IFX_SSC_RXTX_MODE_GET:
1499                 tmp = READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_CON) &
1500                         (~(IFX_SSC_CON_RX_OFF | IFX_SSC_CON_TX_OFF));
1501                 if (from_kernel)
1502                         *((unsigned int *)data) = tmp;
1503                 else
1504                         if (copy_to_user((void *)data,
1505                                          (void *)&tmp,
1506                                          sizeof(tmp)))
1507                                 ret_val = -EFAULT;
1508                 break;
1509
1510         case IFX_SSC_ABORT:
1511                 ifx_ssc_abort(info);
1512                 break;
1513
1514         case IFX_SSC_GPO_OUT_SET:
1515                 if (from_kernel)
1516                         tmp = *((unsigned long *)data);
1517                 else
1518                         if (copy_from_user((void *)&tmp,
1519                                            (void *)data, sizeof(tmp))) {
1520                                 ret_val = -EFAULT;
1521                                 break;
1522                         }
1523                 if (tmp > IFX_SSC_MAX_GPO_OUT)
1524                         ret_val = -EINVAL;
1525                 else
1526                         WRITE_PERIPHERAL_REGISTER
1527                                 (1<<(tmp + IFX_SSC_WHBGPOSTAT_SETOUT0_POS),
1528                                  info->mapbase + IFX_SSC_WHBGPOSTAT);
1529                 break;
1530         case IFX_SSC_GPO_OUT_CLR:
1531                 if (from_kernel)
1532                         tmp = *((unsigned long *)data);
1533                 else
1534                         if (copy_from_user((void *)&tmp,
1535                                            (void *)data, sizeof(tmp))) {
1536                                 ret_val = -EFAULT;
1537                                 break;
1538                         }
1539                 if (tmp > IFX_SSC_MAX_GPO_OUT)
1540                         ret_val = -EINVAL;
1541                 else {
1542                         WRITE_PERIPHERAL_REGISTER
1543                                 (1<<(tmp + IFX_SSC_WHBGPOSTAT_CLROUT0_POS),
1544                                  info->mapbase + IFX_SSC_WHBGPOSTAT);
1545                 }
1546                 break;
1547         case IFX_SSC_GPO_OUT_GET:
1548                 tmp = READ_PERIPHERAL_REGISTER
1549                         (info->mapbase + IFX_SSC_GPOSTAT);
1550                 if (from_kernel)
1551                         *((unsigned int *)data) = tmp;
1552                 else
1553                         if (copy_to_user((void *)data,
1554                                          (void *)&tmp,
1555                                          sizeof(tmp)))
1556                                 ret_val = -EFAULT;
1557                 break;
1558         case IFX_SSC_FRM_STATUS_GET:
1559                 ifx_ssc_frm_status_get(info);
1560                 if (from_kernel)
1561                         memcpy((void *)data, (void *)&info->frm_status,
1562                                sizeof(struct ifx_ssc_frm_status));
1563                 else
1564                         if (copy_to_user((void *)data,
1565                                          (void *)&info->frm_status,
1566                                          sizeof(struct ifx_ssc_frm_status)))
1567                                 ret_val = -EFAULT;
1568                 break;
1569         case IFX_SSC_FRM_CONTROL_GET:
1570                 ifx_ssc_frm_control_get(info);
1571                 if (from_kernel)
1572                         memcpy((void *)data, (void *)&info->frm_opts,
1573                                sizeof(struct ifx_ssc_frm_opts));
1574                 else
1575                         if (copy_to_user((void *)data,
1576                                          (void *)&info->frm_opts,
1577                                          sizeof(struct ifx_ssc_frm_opts)))
1578                                 ret_val = -EFAULT;
1579                 break;
1580         case IFX_SSC_FRM_CONTROL_SET:
1581                 if (from_kernel)
1582                         memcpy((void *)&info->frm_opts, (void *)data,
1583                                sizeof(struct ifx_ssc_frm_opts));
1584                 else
1585                         if (copy_to_user((void *)&info->frm_opts,
1586                                          (void *)data,
1587                                          sizeof(struct ifx_ssc_frm_opts))){
1588                                 ret_val = -EFAULT;
1589                                 break;
1590                         }
1591                 ret_val = ifx_ssc_frm_control_set(info);
1592                 break;
1593         case IFX_SSC_HWOPTS_SET:
1594                 /* data must be a pointer to a struct ifx_ssc_hwopts */
1595                 /* if the buffers are not empty then the port is */
1596                 /* busy and we shouldn't change things on-the-fly! */
1597                 if (!info->txbuf || !info->rxbuf ||
1598                     (READ_PERIPHERAL_REGISTER(info->mapbase + IFX_SSC_STATE)
1599                      & IFX_SSC_STATE_BUSY)) {
1600                         ret_val = -EBUSY;
1601                         break;
1602                 }
1603                 if (from_kernel)
1604                         memcpy((void *)&info->opts, (void *)data,
1605                                sizeof(struct ifx_ssc_hwopts));
1606                 else
1607                         if (copy_from_user((void *)&info->opts,
1608                                            (void *)data,
1609                                            sizeof(struct ifx_ssc_hwopts)))
1610                         {
1611                                 ret_val = -EFAULT;
1612                                 break;
1613                         }
1614                 if (ifx_ssc_hwinit(info) < 0)
1615                 {
1616                         ret_val = -EIO;
1617                 }
1618                 break;
1619         case IFX_SSC_HWOPTS_GET:
1620                 /* data must be a pointer to a struct ifx_ssc_hwopts */
1621                 if (from_kernel)
1622                         memcpy((void *)data, (void *)&info->opts,
1623                                sizeof(struct ifx_ssc_hwopts));
1624                 else
1625                         if (copy_to_user((void *)data,
1626                                          (void *)&info->opts,
1627                                          sizeof(struct ifx_ssc_hwopts)))
1628                                 ret_val = -EFAULT;
1629                 break;
1630         default:
1631                 ret_val = -ENOIOCTLCMD;
1632         }
1633
1634         return ret_val;
1635 } /* ifx_ssc_ioctl */
1636 EXPORT_SYMBOL(ifx_ssc_ioctl);
1637
1638 ///* the poll routine */
1639 //static unsigned int
1640 //ifx_ssc_poll(struct file *filp, struct poll_table_struct *pts)
1641 //{
1642 //        int unit = MINOR(filp->f_dentry->d_inode->i_rdev);
1643 //      struct ifx_ssc_port *info;
1644 //        unsigned int mask = 0;
1645 //      int spc;
1646 //
1647 //      info = &isp[unit];
1648 //
1649 //        /* add event to the wait queues */
1650 //        /* DO NOT FORGET TO DO A WAKEUP ON THESE !!!! */
1651 //        poll_wait(filp, &info->pwait, pts);
1652 //
1653 //      /* are there bytes in the RX SW-FIFO? */
1654 //        if (info->rxrp != info->rxwp)
1655 //                mask |= POLLIN | POLLRDNORM;
1656 //
1657 //      /* free space in the TX SW-FIFO */
1658 //      spc = info->txrp - info->txwp - 1;
1659 //      if (spc < 0)
1660 //              spc += TX_BUFSIZE;
1661 //#ifdef IFX_SSC_USEDMA
1662 //      /* writing always works, except in the DMA case when all descriptors */
1663 //      /* are used up */
1664 //      if (unit == 1 && info->dma_freecnt == 0)
1665 //              spc = 0;
1666 //#endif
1667 //      if (spc > 0)
1668 //              mask |= POLLOUT | POLLWRNORM;
1669 //
1670 //        return (mask);
1671 //}
1672
1673 static int
1674 ifx_ssc1_read_proc(char *page, char **start, off_t offset, int count, int *eof, void *data)
1675 {
1676         int off = 0;
1677         unsigned long flags;
1678
1679         /* don't want any interrupts here */
1680         save_flags(flags);
1681         cli();
1682
1683
1684         /* print statistics */
1685         off += sprintf(page+off, "Statistics for Infineon Synchronous Serial Controller SSC1\n");
1686         off += sprintf(page+off, "RX overflow errors %d\n", isp[0].stats.rxOvErr);
1687         off += sprintf(page+off, "RX underflow errors %d\n", isp[0].stats.rxUnErr);
1688         off += sprintf(page+off, "TX overflow errors %d\n", isp[0].stats.txOvErr);
1689         off += sprintf(page+off, "TX underflow errors %d\n", isp[0].stats.txUnErr);
1690         off += sprintf(page+off, "Abort errors %d\n", isp[0].stats.abortErr);
1691         off += sprintf(page+off, "Mode errors %d\n", isp[0].stats.modeErr);
1692         off += sprintf(page+off, "RX Bytes %d\n", isp[0].stats.rxBytes);
1693         off += sprintf(page+off, "TX Bytes %d\n", isp[0].stats.txBytes);
1694
1695         restore_flags (flags); /* XXXXX */
1696         *eof = 1;
1697         return (off);
1698 }
1699
1700
1701 /*
1702  * This routine prints out the appropriate serial driver version number
1703  */
1704 static inline void
1705 show_version(void)
1706 {
1707 #if 0
1708     printk("Infineon Technologies Synchronous Serial Controller (SSC) driver\n"
1709            "  version %s - built %s %s\n", IFX_SSC_DRV_VERSION, __DATE__, __TIME__);
1710 #endif
1711 } /* show_version */
1712
1713
1714 /*
1715  * Due to the fact that a port can be dynamically switched between slave
1716  * and master mode using an IOCTL the hardware is not initialized here,
1717  * but in ifx_ssc_hwinit() as a result of an IOCTL.
1718  */
1719 int __init
1720 ifx_ssc_init(void)
1721 {
1722         struct ifx_ssc_port  *info;
1723         int i, nbytes;
1724         unsigned long flags;
1725         int ret_val;
1726
1727         // ### TO DO: dynamic port count evaluation due to pin multiplexing
1728
1729         ret_val = -ENOMEM;
1730         nbytes = PORT_CNT * sizeof(struct ifx_ssc_port);
1731         isp = (struct ifx_ssc_port *)kmalloc(nbytes, GFP_KERNEL);
1732         if (isp == NULL)
1733         {
1734                 printk("%s: no memory for isp\n", __FUNCTION__);
1735                 return (ret_val);
1736         }
1737         memset(isp, 0, nbytes);
1738
1739         show_version();
1740
1741         /* register the device */
1742         ret_val = -ENXIO;
1743 /*
1744         i = maj;
1745 */
1746         if ((i = register_chrdev(maj, "ssc", &ifx_ssc_fops)) < 0)
1747         {
1748                 printk("Unable to register major %d for the Infineon SSC\n", maj);
1749                 if (maj == 0){
1750                         goto errout;
1751                 }
1752                 else{
1753                         maj = 0;
1754                         if ((i = register_chrdev(maj, "ssc", &ifx_ssc_fops)) < 0)
1755                         {
1756                                 printk("Unable to register major %d for the Infineon SSC\n", maj);
1757                                 goto errout;
1758                         }
1759                 }
1760         }
1761         if (maj == 0) maj = i;
1762         //printk("registered major %d for Infineon SSC\n", maj);
1763
1764         /* set default values in ifx_ssc_port */
1765         for (i = 0; i < PORT_CNT; i++) {
1766                 info = &isp[i];
1767                 info->port_nr = i;
1768                 /* default values for the HwOpts */
1769                 info->opts.AbortErrDetect = IFX_SSC_DEF_ABRT_ERR_DETECT;
1770                 info->opts.rxOvErrDetect = IFX_SSC_DEF_RO_ERR_DETECT;
1771                 info->opts.rxUndErrDetect = IFX_SSC_DEF_RU_ERR_DETECT;
1772                 info->opts.txOvErrDetect = IFX_SSC_DEF_TO_ERR_DETECT;
1773                 info->opts.txUndErrDetect = IFX_SSC_DEF_TU_ERR_DETECT;
1774                 info->opts.loopBack = IFX_SSC_DEF_LOOP_BACK;
1775                 info->opts.echoMode = IFX_SSC_DEF_ECHO_MODE;
1776                 info->opts.idleValue = IFX_SSC_DEF_IDLE_DATA;
1777                 info->opts.clockPolarity = IFX_SSC_DEF_CLOCK_POLARITY;
1778                 info->opts.clockPhase = IFX_SSC_DEF_CLOCK_PHASE;
1779                 info->opts.headingControl = IFX_SSC_DEF_HEADING_CONTROL;
1780                 info->opts.dataWidth = IFX_SSC_DEF_DATA_WIDTH;
1781                 info->opts.modeRxTx = IFX_SSC_DEF_MODE_RXTX;
1782                 info->opts.gpoCs = IFX_SSC_DEF_GPO_CS;
1783                 info->opts.gpoInv = IFX_SSC_DEF_GPO_INV;
1784                 info->opts.masterSelect = IFX_SSC_DEF_MASTERSLAVE;
1785                 info->baud = IFX_SSC_DEF_BAUDRATE;
1786                 info->rxbuf = NULL;
1787                 info->txbuf = NULL;
1788                 /* values specific to SSC1 */
1789                 if (i == 0) {
1790                         info->mapbase = AMAZON_SSC_BASE_ADD_0;
1791                         // ### TO DO: power management
1792
1793                         // setting interrupt vectors
1794                         info->txirq = IFX_SSC_TIR;
1795                         info->rxirq = IFX_SSC_RIR;
1796                         info->errirq = IFX_SSC_EIR;
1797 /*
1798                         info->frmirq = IFX_SSC_FIR;
1799 */
1800                 }
1801                 /* activate SSC */
1802                 /* CLC.DISS = 0 */
1803                 WRITE_PERIPHERAL_REGISTER(IFX_SSC_DEF_RMC << IFX_CLC_RUN_DIVIDER_OFFSET, info->mapbase + IFX_SSC_CLC);
1804
1805 // ### TO DO: multiple instances
1806
1807                 init_waitqueue_head(&info->rwait);
1808                 //init_waitqueue_head(&info->pwait);
1809
1810                 local_irq_save(flags);
1811
1812                 // init serial framing register
1813                 WRITE_PERIPHERAL_REGISTER(IFX_SSC_DEF_SFCON, info->mapbase + IFX_SSC_SFCON);
1814
1815                 /* try to get the interrupts */
1816                 // ### TO DO: interrupt handling with multiple instances
1817                 ret_val = ifx_int_wrapper.request(info->txirq, ifx_ssc_tx_int,
1818                                                   0, "ifx_ssc_tx", info);
1819                 if (ret_val){
1820                         printk("%s: unable to get irq %d\n", __FUNCTION__,
1821                                         info->txirq);
1822                         local_irq_restore(flags);
1823                         goto errout;
1824                 }
1825                 ret_val = ifx_int_wrapper.request(info->rxirq, ifx_ssc_rx_int,
1826                                                   0, "ifx_ssc_rx", info);
1827                 if (ret_val){
1828                         printk("%s: unable to get irq %d\n", __FUNCTION__,
1829                                         info->rxirq);
1830                         local_irq_restore(flags);
1831                         goto irqerr;
1832                 }
1833                 ret_val = ifx_int_wrapper.request(info->errirq, ifx_ssc_err_int,
1834                                                   0, "ifx_ssc_err", info);
1835                 if (ret_val){
1836                         printk("%s: unable to get irq %d\n", __FUNCTION__,
1837                                         info->errirq);
1838                         local_irq_restore(flags);
1839                         goto irqerr;
1840                 }
1841 /*
1842                 ret_val = ifx_int_wrapper.request(info->frmirq, ifx_ssc_frm_int,
1843                                                   0, "ifx_ssc_frm", info);
1844                 if (ret_val){
1845                         printk("%s: unable to get irq %d\n", __FUNCTION__,
1846                                         info->frmirq);
1847                         local_irq_restore(flags);
1848                         goto irqerr;
1849                 }
1850
1851 */
1852                 WRITE_PERIPHERAL_REGISTER(IFX_SSC_DEF_IRNEN, info->mapbase + IFX_SSC_IRN_EN);
1853
1854                 local_irq_restore(flags);
1855         } // for (i = 0; i < PORT_CNT; i++)
1856
1857         /* init the SSCs with default values */
1858         for (i = 0; i < PORT_CNT; i++)
1859         {
1860                 info = &isp[i];
1861                 if (ifx_ssc_hwinit(info) < 0)
1862                 {
1863                         printk("%s: hardware init failed for port %d\n",
1864                                 __FUNCTION__, i);
1865                         goto irqerr;
1866                 }
1867         }
1868
1869         /* register /proc read handler */
1870         // ### TO DO: multiple instances
1871         /* for SSC1, which is always present */
1872         create_proc_read_entry("driver/ssc1", 0, NULL, ifx_ssc1_read_proc, NULL);
1873         return 0;
1874
1875 irqerr:
1876         // ### TO DO: multiple instances
1877         ifx_int_wrapper.free(isp[0].txirq,&isp[0]);
1878         ifx_int_wrapper.free(isp[0].rxirq,&isp[0]);
1879         ifx_int_wrapper.free(isp[0].errirq,&isp[0]);
1880 /*
1881         ifx_int_wrapper.free(isp[0].frmirq, &isp[0]);
1882 */
1883 errout:
1884         /* free up any allocated memory in the error case */
1885         kfree(isp);
1886         return (ret_val);
1887 } /* ifx_ssc_init */
1888
1889
1890 void
1891 ifx_ssc_cleanup_module(void)
1892 {
1893         int i;
1894
1895         /* free up any allocated memory */
1896         for (i = 0; i < PORT_CNT; i++)
1897         {
1898                 /* disable the SSC */
1899                 WRITE_PERIPHERAL_REGISTER(IFX_SSC_WHBSTATE_CLR_ENABLE,isp[i].mapbase + IFX_SSC_WHBSTATE);
1900                 /* free the interrupts */
1901                 ifx_int_wrapper.free(isp[i].txirq, &isp[i]);
1902                 ifx_int_wrapper.free(isp[i].rxirq, &isp[i]);
1903                 ifx_int_wrapper.free(isp[i].errirq, &isp[i]);
1904 /*
1905                 ifx_int_wrapper.free(isp[i].frmirq, &isp[i]);
1906
1907                 if (isp[i].rxbuf != NULL)
1908                         kfree(isp[i].rxbuf);
1909                 if (isp[i].txbuf != NULL)
1910                         kfree(isp[i].txbuf);
1911 */
1912         }
1913         kfree(isp);
1914         /* unregister the device */
1915         if (unregister_chrdev(maj, "ssc"))
1916         {
1917                 printk("Unable to unregister major %d for the SSC\n", maj);
1918         }
1919         /* delete /proc read handler */
1920         remove_proc_entry("driver/ssc1", NULL);
1921         remove_proc_entry("driver/ssc2", NULL);
1922 } /* ifx_ssc_cleanup_module */
1923
1924 module_exit(ifx_ssc_cleanup_module);
1925
1926 /* Module entry-points */
1927 module_init(ifx_ssc_init);
1928
1929 #ifndef MODULE
1930 static int __init
1931 ifx_ssc_set_maj(char *str)
1932 {
1933         maj = simple_strtol(str, NULL, 0);
1934         return 1;
1935 }
1936 __setup("ssc_maj=", ifx_ssc_set_maj);
1937 #endif /* !MODULE */
1938
1939 #define AMAZON_SSC_EMSG(fmt,arg...) printk("%s: "fmt,__FUNCTION__, ##arg)
1940 /* Brief:       chip select enable
1941  */
1942 inline int amazon_ssc_cs_low(u32 pin)
1943 {
1944         int ret=0;
1945         if ((ret=ifx_ssc_ioctl((struct inode *)0, NULL,IFX_SSC_GPO_OUT_CLR, (unsigned long)&pin))){
1946                 AMAZON_SSC_EMSG("clear CS %d fails\n",pin);
1947         }
1948         wmb();
1949         return ret;
1950 }
1951 EXPORT_SYMBOL(amazon_ssc_cs_low);
1952 /* Brief:       chip select disable
1953  */
1954 inline int amazon_ssc_cs_high(u32 pin)
1955 {
1956         int ret=0;
1957         if ((ret=ifx_ssc_ioctl((struct inode *)0, NULL,IFX_SSC_GPO_OUT_SET, (unsigned long)&pin))){
1958                 AMAZON_SSC_EMSG("set CS %d fails\n", pin);
1959         }
1960         wmb();
1961         return ret;
1962 }
1963 EXPORT_SYMBOL(amazon_ssc_cs_high);
1964 /* Brief:       one SSC session
1965  * Parameter:
1966  *      tx_buf
1967  *      tx_len
1968  *      rx_buf
1969  *      rx_len
1970  *      session_mode: IFX_SSC_MODE_RXTX or IFX_SSC_MODE_TX
1971  * Return:      >=0 number of bytes received (if rx_buf != 0) or transmitted
1972  *              <0 error code
1973  * Description:
1974  *      0. copy data to internal buffer
1975  *      1. Write command
1976  *      2a. If SSC_SESSION_MODE_TXONLY, read tx_len data
1977  *      2b. If not Read back (tx_len + rx_len) data
1978  *      3. copy internal buffer to rx buf if necessary
1979  */
1980 static int ssc_session(char * tx_buf, u32 tx_len, char * rx_buf, u32 rx_len)
1981 {
1982         int ret=0;
1983
1984         char * ssc_tx_buf=NULL;
1985         char * ssc_rx_buf=NULL;
1986
1987 //      volatile char ssc_tx_buf[128]={0};
1988 //      volatile char ssc_rx_buf[128]={0};
1989
1990         int eff_size=0;
1991         u8 mode=0;
1992
1993         if (tx_buf == NULL && tx_len ==0 && rx_buf == NULL && rx_len == 0){
1994                 AMAZON_SSC_EMSG("invalid parameters\n");
1995                 ret=-EINVAL;
1996                 goto ssc_session_exit;
1997         }else if (tx_buf == NULL || tx_len == 0){
1998                 if (rx_buf != NULL && rx_len != 0){
1999                         mode = IFX_SSC_MODE_RX;
2000                 }else{
2001                         AMAZON_SSC_EMSG("invalid parameters\n");
2002                         ret=-EINVAL;
2003                         goto ssc_session_exit;
2004                 }
2005         }else if (rx_buf == NULL || rx_len ==0){
2006                 if (tx_buf != NULL && tx_len != 0){
2007                         mode = IFX_SSC_MODE_TX;
2008                 }else{
2009                         AMAZON_SSC_EMSG("invalid parameters\n");
2010                         ret=-EINVAL;
2011                         goto ssc_session_exit;
2012                 }
2013         }else{
2014                 mode = IFX_SSC_MODE_RXTX;
2015         }
2016
2017         if (mode == IFX_SSC_MODE_RXTX){
2018                 eff_size = tx_len + rx_len;
2019         }else if (mode == IFX_SSC_MODE_RX){
2020                 eff_size = rx_len;
2021         }else{
2022                 eff_size = tx_len;
2023         }
2024
2025         //4 bytes alignment,  required by driver
2026         /* change by TaiCheng */
2027         //if (in_irq()){
2028         if (1){
2029                 ssc_tx_buf = (char*) kmalloc(sizeof(char) *  ((eff_size + 3) & (~3)), GFP_ATOMIC);
2030                 ssc_rx_buf = (char*) kmalloc(sizeof(char) *  ((eff_size + 3) & (~3)), GFP_ATOMIC);
2031         }else{
2032                 ssc_tx_buf = (char*) kmalloc(sizeof(char) *  ((eff_size + 3) & (~3)), GFP_KERNEL);
2033                 ssc_rx_buf = (char*) kmalloc(sizeof(char) *  ((eff_size + 3) & (~3)), GFP_KERNEL);
2034         }
2035         if (ssc_tx_buf == NULL || ssc_rx_buf == NULL){
2036                 AMAZON_SSC_EMSG("no memory for size of %d\n", eff_size);
2037                 ret = -ENOMEM;
2038                 goto ssc_session_exit;
2039         }
2040         memset((void*)ssc_tx_buf, 0, eff_size);
2041         memset((void*)ssc_rx_buf, 0, eff_size);
2042
2043         if (tx_len>0){
2044                 memcpy(ssc_tx_buf, tx_buf, tx_len);
2045         }
2046
2047         ret=ifx_ssc_kwrite(0, ssc_tx_buf, eff_size);
2048
2049         if (ret > 0) {
2050                 ssc_tx_buf = NULL; //should be freed by ifx_ssc_kwrite
2051         }
2052
2053         if (  ret != eff_size ){
2054                 AMAZON_SSC_EMSG("ifx_ssc_write return %d\n",ret);
2055                 goto ssc_session_exit;
2056         }
2057         ret=ifx_ssc_kread(0, ssc_rx_buf,eff_size);
2058         if (  ret != eff_size ){
2059                 AMAZON_SSC_EMSG("ifx_ssc_read return %d\n",ret);
2060                 goto ssc_session_exit;
2061         }
2062
2063         memcpy(rx_buf, ssc_rx_buf+tx_len, rx_len);
2064
2065         if (mode == IFX_SSC_MODE_TX) {
2066                 ret = tx_len;
2067         }else{
2068                 ret = rx_len;
2069         }
2070 ssc_session_exit:
2071
2072         if (ssc_tx_buf != NULL) kfree(ssc_tx_buf);
2073         if (ssc_rx_buf != NULL) kfree(ssc_rx_buf);
2074
2075         if (ret<0) {
2076                 printk("ssc session fails\n");
2077         }
2078         return ret;
2079 }
2080 /* Brief:       TX-RX session
2081  * Parameter:
2082  *      tx_buf
2083  *      tx_len
2084  *      rx_buf
2085  *      rx_len
2086  * Return:      >=0 number of bytes received
2087  *              <0 error code
2088  * Description:
2089  *      1. TX session
2090  *      2. RX session
2091  */
2092 int amazon_ssc_txrx(char * tx_buf, u32 tx_len, char * rx_buf, u32 rx_len)
2093 {
2094         return ssc_session(tx_buf,tx_len,rx_buf,rx_len);
2095 }
2096 EXPORT_SYMBOL(amazon_ssc_txrx);
2097 /* Brief:       TX only session
2098  * Parameter:
2099  *      tx_buf
2100  *      tx_len
2101  * Return:      >=0 number of bytes transmitted
2102  *              <0 error code
2103  */
2104 int amazon_ssc_tx(char * tx_buf, u32 tx_len)
2105 {
2106         return ssc_session(tx_buf,tx_len,NULL,0);
2107 }
2108 EXPORT_SYMBOL(amazon_ssc_tx);
2109 /* Brief:       RX only session
2110  * Parameter:
2111  *      rx_buf
2112  *      rx_len
2113  * Return:      >=0 number of bytes received
2114  *              <0 error code
2115  */
2116 int amazon_ssc_rx(char * rx_buf, u32 rx_len)
2117 {
2118         return ssc_session(NULL,0,rx_buf,rx_len);
2119 }
2120 EXPORT_SYMBOL(amazon_ssc_rx);
2121