开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
sync_serial.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：30k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

sync_serial.c：源码内容
  1. /*  
  2.  * Simple synchronous serial port driver for ETRAX 100LX.
  3.  *
  4.  * Synchronous serial ports are used for continous streamed data like audio.
  5.  * The default setting for this driver is compatible with the STA 013 MP3
  6.  * decoder. The driver can easily be tuned to fit other audio encoder/decoders
  7.  * and SPI
  8.  *
  9.  * Copyright (c) 2001 Axis Communications AB
  10.  * 
  11.  * Author: Mikael Starvik 
  12.  *
  13.  */
  14. #include <linux/module.h>
  15. #include <linux/kernel.h>
  16. #include <linux/config.h>
  17. #include <linux/types.h>
  18. #include <linux/errno.h>
  19. #include <linux/major.h>
  20. #include <linux/sched.h>
  21. #include <linux/slab.h>
  22. #include <linux/interrupt.h>
  23. #include <linux/init.h>
  24. #include <linux/timer.h>
  25. #include <asm/irq.h>
  26. #include <asm/io.h>
  27. #include <asm/svinto.h>
  28. #include <asm/uaccess.h>
  29. #include <asm/system.h>
  30. #include <asm/sync_serial.h>
  32. /* The receiver is a bit tricky beacuse of the continous stream of data. */
  33. /*                                                                       */
  34. /* Two DMA descriptors are linked together. Each DMA descriptor is       */
  35. /* responsible for one half of a common buffer.                          */
  36. /*                                                                       */
  37. /* ------------------------------                                        */
  38. /* |   ----------   ---------- |                                        */
  39. /* --> | Descr1 |-->| Descr2 |---                                        */
  40. /*     ----------   ----------                                           */
  41. /*         |            |                                                */
  42. /*         v            v                                                */
  43. /*   -----------------------------                                       */
  44. /*   |        BUFFER             |                                       */
  45. /*   -----------------------------                                       */
  46. /*      |             |                                                  */
  47. /*    readp          writep                                              */
  48. /*                                                                       */
  49. /* If the application keeps up the pace readp will be right after writep.*/
  50. /* If the application can't keep the pace we have to throw away data.    */ 
  51. /* The idea is that readp should be ready with the data pointed out by  */
  52. /* Descr1 when the DMA has filled in Descr2. Otherwise we will discard  */
  53. /* the rest of the data pointed out by Descr1 and set readp to the start */
  54. /* of Descr2                                                             */
  56. #define SYNC_SERIAL_MAJOR 125
  58. /* IN_BUFFER_SIZE should be a multiple of 6 to make sure that 24 bit */
  59. /* words can be handled */
  61. #define IN_BUFFER_SIZE 12288
  62. #define OUT_BUFFER_SIZE 4096
  64. #define DEFAULT_FRAME_RATE 0
  65. #define DEFAULT_WORD_RATE 7
  67. #define DEBUG(x) 
  69. /* Define some macros to access ETRAX 100 registers */
  70. #define SETF(var, reg, field, val) var = (var & ~IO_MASK(##reg##, field)) | 
  71.   IO_FIELD(##reg##, field, val)
  72. #define SETS(var, reg, field, val) var = (var & ~IO_MASK(##reg##, field)) | 
  73.   IO_STATE(##reg##, field, val)
  75. typedef struct sync_port
  76. {
  77. /* Etrax registers and bits*/
  78. volatile unsigned * const status;
  79. volatile unsigned * const ctrl_data;
  80. volatile unsigned * const output_dma_first;
  81. volatile unsigned char * const output_dma_cmd;
  82. volatile unsigned char * const output_dma_clr_irq;
  83. volatile unsigned * const input_dma_first;
  84. volatile unsigned char * const input_dma_cmd;
  85. volatile unsigned char * const input_dma_clr_irq;
  86. volatile unsigned * const data_out;
  87. volatile unsigned * const data_in;
  88. char data_avail_bit; /* In R_IRQ_MASK1_RD */
  89. char transmitter_ready_bit; /* In R_IRQ_MASK1_RD */
  90. char ready_irq_bit; /* In R_IRQ_MASK1_SET and R_IRQ_MASK1_CLR */
  91. char input_dma_descr_bit; /* In R_IRQ_MASK2_RD */
  92. char output_dma_bit; /* In R_IRQ_MASK2_RD */
  94. int enabled;  /* 1 if port is enabled */
  95. int use_dma;  /* 1 if port uses dma */
  96. int port_nbr; /* Port 0 or 1 */
  97. unsigned ctrl_data_shadow; /* Register shadow */
  98. char busy; /* 1 if port is busy */
  99. wait_queue_head_t out_wait_q;
  100. wait_queue_head_t in_wait_q;
  101. struct etrax_dma_descr out_descr;
  102. struct etrax_dma_descr in_descr1;
  103. struct etrax_dma_descr in_descr2;
  104. char out_buffer[OUT_BUFFER_SIZE];
  105. int out_count; /* Remaining bytes for current transfer */
  106. char* outp; /* Current position in out_buffer */
  107. char in_buffer[IN_BUFFER_SIZE];
  108. volatile char* readp;  /* Next byte to be read by application */
  109. volatile char* writep; /* Next byte to be written by etrax */
  110. int odd_output; /* 1 if writing odd nible in 12 bit mode */
  111. int odd_input;  /* 1 if reading odd nible in 12 bit mode */
  112. } sync_port;
  115. static int etrax_sync_serial_init(void);
  116. static void initialize_port(int portnbr);
  117. static int sync_serial_open(struct inode *, struct file*);
  118. static int sync_serial_release(struct inode*, struct file*);
  119. static int sync_serial_ioctl(struct inode*, struct file*,
  120.      unsigned int cmd, unsigned long arg);
  121. static ssize_t sync_serial_write(struct file * file, const char * buf, 
  122.  size_t count, loff_t *ppos);
  123. static ssize_t sync_serial_manual_write(struct file * file, const char * buf, 
  124. size_t count, loff_t *ppos);
  125. static ssize_t sync_serial_read(struct file *file, char *buf, 
  126. size_t count, loff_t *ppos);
  127. static void send_word(sync_port* port);
  128. static void start_dma(struct sync_port *port, const char* data, int count);
  129. static void start_dma_in(sync_port* port);
  130. static void tr_interrupt(int irq, void *dev_id, struct pt_regs * regs);
  131. static void rx_interrupt(int irq, void *dev_id, struct pt_regs * regs);
  132. static void manual_interrupt(int irq, void *dev_id, struct pt_regs * regs);
  134. /* The ports */
  135. static struct sync_port ports[]=
  136. {
  137. {
  138. R_SYNC_SERIAL1_STATUS,  /* status */
  139. R_SYNC_SERIAL1_CTRL,    /* ctrl_data */
  140. R_DMA_CH8_FIRST,        /* output_dma_first */
  141. R_DMA_CH8_CMD,          /* output_dma_cmd */
  142. R_DMA_CH8_CLR_INTR,     /* output_dma_clr_irq */
  143. R_DMA_CH9_FIRST,        /* input_dma_first */
  144. R_DMA_CH9_CMD,          /* input_dma_cmd */
  145. R_DMA_CH9_CLR_INTR,     /* input_dma_clr_irq */
  146. R_SYNC_SERIAL1_TR_DATA, /* data_out */
  147. R_SYNC_SERIAL1_REC_DATA,/* data in */
  148. IO_BITNR(R_IRQ_MASK1_RD, ser1_data),   /* data_avail_bit */
  149. IO_BITNR(R_IRQ_MASK1_RD, ser1_ready),  /* transmitter_ready_bit */
  150. IO_BITNR(R_IRQ_MASK1_SET, ser1_ready), /* ready_irq_bit */
  151. IO_BITNR(R_IRQ_MASK2_RD, dma9_descr),  /* input_dma_descr_bit */
  152. IO_BITNR(R_IRQ_MASK2_RD, dma8_eop),    /* output_dma_bit */
  153. },
  154. {
  155. R_SYNC_SERIAL3_STATUS,  /* status */
  156. R_SYNC_SERIAL3_CTRL,    /* ctrl_data */
  157. R_DMA_CH4_FIRST,        /* output_dma_first */
  158. R_DMA_CH4_CMD,          /* output_dma_cmd */
  159. R_DMA_CH4_CLR_INTR,     /* output_dma_clr_irq */
  160. R_DMA_CH5_FIRST,        /* input_dma_first */
  161. R_DMA_CH5_CMD,          /* input_dma_cmd */
  162. R_DMA_CH5_CLR_INTR,     /* input_dma_clr_irq */
  163. R_SYNC_SERIAL3_TR_DATA, /* data_out */
  164. R_SYNC_SERIAL3_REC_DATA,/* data in */
  165. IO_BITNR(R_IRQ_MASK1_RD, ser3_data),   /* data_avail_bit */
  166. IO_BITNR(R_IRQ_MASK1_RD, ser3_ready),  /* transmitter_ready_bit */
  167. IO_BITNR(R_IRQ_MASK1_SET, ser3_ready), /* ready_irq_bit */
  168. IO_BITNR(R_IRQ_MASK2_RD, dma5_descr),  /* input_dma_descr_bit */
  169. IO_BITNR(R_IRQ_MASK2_RD, dma4_eop),    /* output_dma_bit */
  170. }
  171. };
  173. /* Register shadows */
  174. static unsigned sync_serial_prescale_shadow = 0;
  175. static unsigned gen_config_ii_shadow = 0;
  177. #define NUMBER_OF_PORTS (sizeof(ports)/sizeof(sync_port))
  179. static struct file_operations sync_serial_fops = {
  180.        owner: THIS_MODULE,
  181.        write: sync_serial_write,
  182.        read: sync_serial_read,
  183.        ioctl: sync_serial_ioctl,
  184.        open: sync_serial_open,
  185.        release: sync_serial_release
  186. };
  188. static int __init etrax_sync_serial_init(void)
  189. {
  190. ports[0].enabled = 0;
  191. ports[1].enabled = 0;
  193. if (register_chrdev(SYNC_SERIAL_MAJOR,"sync serial", &sync_serial_fops) <0 ) 
  194. {
  195. printk("unable to get major for synchronous serial portn");
  196. return -EBUSY;
  197. }
  199. /* Deselect synchronous serial ports */
  200. SETS(gen_config_ii_shadow, R_GEN_CONFIG_II, sermode1, async);
  201. SETS(gen_config_ii_shadow, R_GEN_CONFIG_II, sermode3, async);
  202. *R_GEN_CONFIG_II = gen_config_ii_shadow;
  203.   
  204. /* Initialize Ports */
  205. #if defined(CONFIG_ETRAX_SYNCHRONOUS_SERIAL_PORT0)
  206. ports[0].enabled = 1;
  207. SETS(port_pb_i2c_shadow, R_PORT_PB_I2C, syncser1, ss1extra); 
  208. SETS(gen_config_ii_shadow, R_GEN_CONFIG_II, sermode1, sync);
  209. #if defined(CONFIG_ETRAX_SYNCHRONOUS_SERIAL0_DMA)
  210. ports[0].use_dma = 1;
  211. initialize_port(0);
  212. if(request_irq(24, tr_interrupt, 0, "synchronous serial 1 dma tr", &ports[0]))
  213.  panic("Can't allocate sync serial port 1 IRQ");
  214. if(request_irq(25, rx_interrupt, 0, "synchronous serial 1 dma rx", &ports[0]))
  215. panic("Can't allocate sync serial port 1 IRQ");
  216. RESET_DMA(8); WAIT_DMA(8);
  217. RESET_DMA(9); WAIT_DMA(9);
  218. *R_DMA_CH8_CLR_INTR = IO_STATE(R_DMA_CH8_CLR_INTR, clr_eop, do) |
  219.   IO_STATE(R_DMA_CH8_CLR_INTR, clr_descr, do); 
  220. *R_DMA_CH9_CLR_INTR = IO_STATE(R_DMA_CH9_CLR_INTR, clr_eop, do) |
  221.   IO_STATE(R_DMA_CH9_CLR_INTR, clr_descr, do); 
  222. *R_IRQ_MASK2_SET =
  223.   IO_STATE(R_IRQ_MASK2_SET, dma8_eop, set) |
  224.   IO_STATE(R_IRQ_MASK2_SET, dma8_descr, set) |
  225.           IO_STATE(R_IRQ_MASK2_SET, dma9_descr, set);
  226. start_dma_in(&ports[0]);
  227. #else
  228. ports[0].use_dma = 0;
  229. initialize_port(0);
  230. if (request_irq(8, manual_interrupt, SA_SHIRQ | SA_INTERRUPT, "synchronous serial manual irq", &ports[0]))
  231. panic("Can't allocate sync serial manual irq");
  232. *R_IRQ_MASK1_SET = IO_STATE(R_IRQ_MASK1_SET, ser1_data, set);  
  233. #endif
  234. #endif
  236. #if defined(CONFIG_ETRAX_SYNCHRONOUS_SERIAL_PORT1)
  237. ports[1].enabled = 1;
  238. SETS(port_pb_i2c_shadow, R_PORT_PB_I2C, syncser3, ss3extra);
  239. SETS(gen_config_ii_shadow, R_GEN_CONFIG_II, sermode3, sync);
  240. #if defined(CONFIG_ETRAX_SYNCHRONOUS_SERIAL1_DMA)
  241. ports[1].use_dma = 1;
  242. initialize_port(1);
  243. if(request_irq(20, tr_interrupt, 0, "synchronous serial 3 dma tr", &ports[1]))
  244. panic("Can't allocate sync serial port 1 IRQ");
  245. if(request_irq(21, rx_interrupt, 0, "synchronous serial 3 dma rx", &ports[1]))
  246. panic("Can't allocate sync serial port 1 IRQ");
  247. RESET_DMA(4); WAIT_DMA(4);
  248. RESET_DMA(5); WAIT_DMA(5);
  249. *R_DMA_CH4_CLR_INTR = IO_STATE(R_DMA_CH4_CLR_INTR, clr_eop, do) |
  250.   IO_STATE(R_DMA_CH4_CLR_INTR, clr_descr, do); 
  251. *R_DMA_CH5_CLR_INTR = IO_STATE(R_DMA_CH5_CLR_INTR, clr_eop, do) |
  252.   IO_STATE(R_DMA_CH5_CLR_INTR, clr_descr, do); 
  253. *R_IRQ_MASK2_SET =
  254.   IO_STATE(R_IRQ_MASK2_SET, dma4_eop, set) |
  255.   IO_STATE(R_IRQ_MASK2_SET, dma4_descr, set) |
  256.   IO_STATE(R_IRQ_MASK2_SET, dma5_descr, set);
  257. start_dma_in(&ports[1]);
  258. #else
  259. ports[1].use_dma = 0;
  260. initialize_port(1);
  261. if (ports[0].use_dma) /* Port 0 uses dma, we must manual allocate IRQ */
  262. {
  263. if (request_irq(8, manual_interrupt, SA_SHIRQ |燬A_INTERRUPT, "synchronous serial manual irq", &ports[1]))
  264. panic("Can't allocate sync serial manual irq");
  265. }
  266. *R_IRQ_MASK1_SET = IO_STATE(R_IRQ_MASK1_SET, ser3_data, set);  
  267. #endif
  268. #endif
  270. *R_PORT_PB_I2C = port_pb_i2c_shadow; /* Use PB4/PB7 */
  272. /* Set up timing */
  273. *R_SYNC_SERIAL_PRESCALE = sync_serial_prescale_shadow = (
  274.   IO_STATE(R_SYNC_SERIAL_PRESCALE, clk_sel_u1, codec) | 
  275.   IO_STATE(R_SYNC_SERIAL_PRESCALE, word_stb_sel_u1, external) | 
  276.   IO_STATE(R_SYNC_SERIAL_PRESCALE, clk_sel_u3, codec) | 
  277.   IO_STATE(R_SYNC_SERIAL_PRESCALE, word_stb_sel_u3, external) | 
  278.   IO_STATE(R_SYNC_SERIAL_PRESCALE, prescaler, div4) | 
  279.   IO_FIELD(R_SYNC_SERIAL_PRESCALE, frame_rate, DEFAULT_FRAME_RATE) | 
  280.   IO_FIELD(R_SYNC_SERIAL_PRESCALE, word_rate, DEFAULT_WORD_RATE) | 
  281.   IO_STATE(R_SYNC_SERIAL_PRESCALE, warp_mode, normal));
  283. /* Select synchronous ports */
  284. *R_GEN_CONFIG_II = gen_config_ii_shadow;
  286. printk("ETRAX 100LX synchronous serial port drivern");
  287. return 0;
  288. }
  290. static void initialize_port(int portnbr)
  291. {
  292. struct sync_port* port = &ports[portnbr];
  294. DEBUG(printk("Init sync serial port %dn", portnbr));
  295.     
  296. port->port_nbr = portnbr;
  297. port->busy = 0;
  298. port->readp = port->in_buffer;
  299. port->writep = port->in_buffer + IN_BUFFER_SIZE/2;
  300. port->odd_input = 0;
  302. init_waitqueue_head(&port->out_wait_q);
  303. init_waitqueue_head(&port->in_wait_q);
  305. port->ctrl_data_shadow =
  306.   IO_STATE(R_SYNC_SERIAL1_CTRL, tr_baud, c115k2Hz)   | 
  307.   IO_STATE(R_SYNC_SERIAL1_CTRL, mode, master_output) | 
  308.   IO_STATE(R_SYNC_SERIAL1_CTRL, error, ignore)       |
  309.   IO_STATE(R_SYNC_SERIAL1_CTRL, rec_enable, disable) |
  310.   IO_STATE(R_SYNC_SERIAL1_CTRL, f_synctype, normal)  |
  311.   IO_STATE(R_SYNC_SERIAL1_CTRL, f_syncsize, word)    |
  312.   IO_STATE(R_SYNC_SERIAL1_CTRL, f_sync, on)      |
  313.   IO_STATE(R_SYNC_SERIAL1_CTRL, clk_mode, normal)    |
  314.   IO_STATE(R_SYNC_SERIAL1_CTRL, clk_halt, stopped)   |
  315.   IO_STATE(R_SYNC_SERIAL1_CTRL, bitorder, msb)      |
  316.   IO_STATE(R_SYNC_SERIAL1_CTRL, tr_enable, disable)  |
  317.   IO_STATE(R_SYNC_SERIAL1_CTRL, wordsize, size8bit)  |
  318.   IO_STATE(R_SYNC_SERIAL1_CTRL, buf_empty, lmt_8)    |
  319.   IO_STATE(R_SYNC_SERIAL1_CTRL, buf_full, lmt_8)     |
  320.   IO_STATE(R_SYNC_SERIAL1_CTRL, flow_ctrl, enabled)  |
  321.   IO_STATE(R_SYNC_SERIAL1_CTRL, clk_polarity, neg)   |
  322.   IO_STATE(R_SYNC_SERIAL1_CTRL, frame_polarity, normal)|
  323.   IO_STATE(R_SYNC_SERIAL1_CTRL, status_polarity, inverted)|
  324.   IO_STATE(R_SYNC_SERIAL1_CTRL, clk_driver, normal)   |
  325.   IO_STATE(R_SYNC_SERIAL1_CTRL, frame_driver, normal) |
  326.   IO_STATE(R_SYNC_SERIAL1_CTRL, status_driver, normal)|
  327.   IO_STATE(R_SYNC_SERIAL1_CTRL, def_out0, high);
  328.   
  329. if (port->use_dma)
  330. port->ctrl_data_shadow |= IO_STATE(R_SYNC_SERIAL1_CTRL, dma_enable, on);
  331. else
  332. port->ctrl_data_shadow |= IO_STATE(R_SYNC_SERIAL1_CTRL, dma_enable, off);
  333.   
  334. *port->ctrl_data = port->ctrl_data_shadow;
  335. }
  337. static int sync_serial_open(struct inode *inode, struct file *file)
  338. {
  339. int dev = MINOR(inode->i_rdev);
  340. DEBUG(printk("Open sync serial port %dn", dev)); 
  341.   
  342. if (dev < 0 || dev >= NUMBER_OF_PORTS || !ports[dev].enabled)
  343. {
  344. DEBUG(printk("Invalid minor %dn", dev));
  345. return -ENODEV;
  346. }
  347. if (ports[dev].busy)
  348. {
  349. DEBUG(printk("Device is busy.. n"));
  350. return -EBUSY;
  351. }
  352. ports[dev].busy = 1;
  353. return 0;
  354. }
  356. static int sync_serial_release(struct inode *inode, struct file *file)
  357. {
  358. int dev = MINOR(inode->i_rdev);
  359. if (dev < 0 || dev >= NUMBER_OF_PORTS || !ports[dev].enabled)
  360. {
  361. DEBUG(printk("Invalid minor %dn", dev));
  362. return -ENODEV;
  363. }
  364. ports[dev].busy = 0;
  365. return 0;
  366. }
  368. static int sync_serial_ioctl(struct inode *inode, struct file *file,
  369.   unsigned int cmd, unsigned long arg)
  370. {
  371. int return_val = 0;
  372. int dev = MINOR(file->f_dentry->d_inode->i_rdev);
  373.   sync_port* port;
  374.         
  375. if (dev < 0 || dev >= NUMBER_OF_PORTS || !ports[dev].enabled)
  376. {
  377. DEBUG(printk("Invalid minor %dn", dev));
  378. return -1;
  379. }
  380.         port = &ports[dev];
  382. /* Disable port while changing config */
  383. if (dev)
  384. {
  385. RESET_DMA(4); WAIT_DMA(4);
  386. *R_DMA_CH4_CLR_INTR = IO_STATE(R_DMA_CH4_CLR_INTR, clr_eop, do) |
  387.                   IO_STATE(R_DMA_CH4_CLR_INTR, clr_descr, do); 
  388. SETS(gen_config_ii_shadow, R_GEN_CONFIG_II, sermode3, async);
  389. }
  390. else
  391. {
  392. RESET_DMA(8); WAIT_DMA(8);
  393. *R_DMA_CH8_CLR_INTR = IO_STATE(R_DMA_CH8_CLR_INTR, clr_eop, do) |
  394.                   IO_STATE(R_DMA_CH8_CLR_INTR, clr_descr, do);  
  395. SETS(gen_config_ii_shadow, R_GEN_CONFIG_II, sermode1, async);
  396. }
  397. *R_GEN_CONFIG_II = gen_config_ii_shadow;
  399. switch(cmd)
  400. {
  401. case SSP_SPEED:
  402. if (GET_SPEED(arg) == CODEC)
  403. {
  404. if (dev)
  405. SETS(sync_serial_prescale_shadow, R_SYNC_SERIAL_PRESCALE, clk_sel_u3, codec);
  406. else
  407. SETS(sync_serial_prescale_shadow, R_SYNC_SERIAL_PRESCALE, clk_sel_u1, codec);
  409. SETF(sync_serial_prescale_shadow, R_SYNC_SERIAL_PRESCALE, prescaler, GET_FREQ(arg));
  410. SETF(sync_serial_prescale_shadow, R_SYNC_SERIAL_PRESCALE, frame_rate, GET_FRAME_RATE(arg));
  411. SETF(sync_serial_prescale_shadow, R_SYNC_SERIAL_PRESCALE, word_rate, GET_WORD_RATE(arg));
  412. }
  413. else
  414. {
  415. SETF(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, tr_baud, GET_SPEED(arg));
  416. if (dev)
  417. SETS(sync_serial_prescale_shadow, R_SYNC_SERIAL_PRESCALE, clk_sel_u3, baudrate);
  418. else
  419. SETS(sync_serial_prescale_shadow, R_SYNC_SERIAL_PRESCALE, clk_sel_u1, baudrate);
  420. }
  421. break;
  422. case SSP_MODE:
  423. if (arg > 5)
  424. return -EINVAL;
  425. SETF(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, mode, arg);
  426. break;
  427. case SSP_FRAME_SYNC:
  428. if (arg & NORMAL_SYNC)
  429. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, f_synctype, normal);
  430. else if (arg & EARLY_SYNC)
  431. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, f_synctype, early);
  432.     
  433. if (arg & BIT_SYNC)
  434. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, f_syncsize, bit);
  435. else if (arg & WORD_SYNC)
  436. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, f_syncsize, word);
  437. else if (arg & EXTENDED_SYNC)
  438. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, f_syncsize, extended);
  439.     
  440. if (arg & SYNC_ON)
  441. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, f_sync, on);
  442. else if (arg & SYNC_OFF)
  443. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, f_sync, off);
  444.     
  445. if (arg & WORD_SIZE_8)
  446. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, wordsize, size8bit);
  447. else if (arg & WORD_SIZE_12)
  448. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, wordsize, size12bit);
  449. else if (arg & WORD_SIZE_16)
  450. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, wordsize, size16bit);
  451. else if (arg & WORD_SIZE_24)
  452. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, wordsize, size24bit);
  453. else if (arg & WORD_SIZE_32)
  454. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, wordsize, size32bit);
  455.     
  456. if (arg & BIT_ORDER_MSB)
  457. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, bitorder, msb);
  458. else if (arg & BIT_ORDER_LSB)
  459. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, bitorder, lsb);
  461. if (arg & FLOW_CONTROL_ENABLE)
  462. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, flow_ctrl, enabled);
  463. else if (arg & FLOW_CONTROL_DISABLE)
  464. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, flow_ctrl, disabled);
  466. if (arg & CLOCK_NOT_GATED)
  467. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, clk_mode, normal);
  468. else if (arg & CLOCK_GATED)
  469. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, clk_mode, gated);
  470.     
  471. break;
  472. case SSP_IPOLARITY:
  473. if (arg & CLOCK_NORMAL)
  474. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, clk_polarity, neg);
  475. else if (arg & CLOCK_INVERT)
  476. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, clk_polarity, pos);
  478. if (arg & FRAME_NORMAL)
  479. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, frame_polarity, normal);
  480. else if (arg & FRAME_INVERT)
  481. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, frame_polarity, inverted);
  483. if (arg & STATUS_NORMAL)
  484. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, status_polarity, normal);
  485. else if (arg & STATUS_INVERT)
  486. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, status_polarity, inverted);
  487. break;
  488. case SSP_OPOLARITY:
  489. if (arg & CLOCK_NORMAL)
  490. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, clk_driver, normal);
  491. else if (arg & CLOCK_INVERT)
  492. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, clk_driver, inverted);
  493.     
  494. if (arg & FRAME_NORMAL)
  495. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, frame_driver, normal);
  496. else if (arg & FRAME_INVERT)
  497. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, frame_driver, inverted);
  499. if (arg & STATUS_NORMAL)
  500. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, status_driver, normal);
  501. else if (arg & STATUS_INVERT)
  502. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, status_driver, inverted);
  503. break;
  504. case SSP_SPI:
  505. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, flow_ctrl, disabled);
  506. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, bitorder, msb);
  507. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, wordsize, size8bit);
  508. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, f_sync, on);
  509. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, f_syncsize, word);
  510. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, f_synctype, normal);
  511. if (arg & SPI_SLAVE)
  512. {
  513. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, frame_polarity, inverted);
  514. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, clk_polarity, neg);
  515. SETF(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, mode, SLAVE_INPUT);
  516. }
  517. else
  518. {
  519. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, frame_driver, inverted);
  520. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, clk_driver, inverted);
  521. SETF(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, mode, MASTER_OUTPUT);
  522. }
  523. break;
  524. default:
  525. return_val = -1;
  526. }
  527. /* Set config and enable port */
  528. *port->ctrl_data = port->ctrl_data_shadow;
  529. *R_SYNC_SERIAL_PRESCALE = sync_serial_prescale_shadow;
  530. if (dev)
  531. SETS(gen_config_ii_shadow, R_GEN_CONFIG_II, sermode3, sync);
  532. else
  533. SETS(gen_config_ii_shadow, R_GEN_CONFIG_II, sermode1, sync);
  535. *R_GEN_CONFIG_II = gen_config_ii_shadow;
  536. return return_val;
  537. }
  539. static ssize_t sync_serial_manual_write(struct file * file, const char * buf, 
  540.                                         size_t count, loff_t *ppos)
  541. {
  542. int dev = MINOR(file->f_dentry->d_inode->i_rdev);
  543. DECLARE_WAITQUEUE(wait, current);
  544. sync_port* port;
  546. if (dev < 0 || dev >= NUMBER_OF_PORTS || !ports[dev].enabled)
  547. {
  548. DEBUG(printk("Invalid minor %dn", dev));
  549. return -ENODEV;
  550. }
  552. port = &ports[dev];
  553. copy_from_user(port->out_buffer, buf, count);
  554. port->outp = port->out_buffer;
  555. port->out_count = count;
  556. port->odd_output = 1;
  557. add_wait_queue(&port->out_wait_q, &wait);
  558. set_current_state(TASK_INTERRUPTIBLE);
  559. *R_IRQ_MASK1_SET = 1 << port->ready_irq_bit; /* transmitter ready IRQ on */
  560. send_word(port); /* Start sender by sending first word */
  561. schedule();
  562. set_current_state(TASK_RUNNING);
  563. remove_wait_queue(&port->out_wait_q, &wait);
  564. if (signal_pending(current))
  565. {
  566. return -EINTR;
  567. }
  568. return count;
  569. }
  571. static ssize_t sync_serial_write(struct file * file, const char * buf, 
  572.                                  size_t count, loff_t *ppos)
  573. {
  574. int dev = MINOR(file->f_dentry->d_inode->i_rdev);
  575. DECLARE_WAITQUEUE(wait, current);
  576. sync_port *port;
  578. if (dev < 0 || dev >= NUMBER_OF_PORTS || !ports[dev].enabled)
  579. {
  580. DEBUG(printk("Invalid minor %dn", dev));
  581. return -ENODEV;
  582. }
  583. port = &ports[dev];
  585. DEBUG(printk("Write dev %d count %dn", port->port_nbr, count));
  587. count = count > OUT_BUFFER_SIZE ? OUT_BUFFER_SIZE : count;
  589. /* Make sure transmitter is running */
  590. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, clk_halt, running);
  591. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, tr_enable, enable);
  592. *port->ctrl_data = port->ctrl_data_shadow;
  594. if (!port->use_dma)
  595. {
  596. return sync_serial_manual_write(file, buf, count, ppos); 
  597. }
  598.   
  599. copy_from_user(port->out_buffer, buf, count);
  600. add_wait_queue(&port->out_wait_q, &wait);
  601. set_current_state(TASK_INTERRUPTIBLE);
  602. start_dma(port, buf, count);
  603. schedule();
  604. set_current_state(TASK_RUNNING);
  605. remove_wait_queue(&port->out_wait_q, &wait);
  606. if (signal_pending(current))
  607. {
  608. return -EINTR;
  609. }
  610. return count;
  611. }
  613. static ssize_t sync_serial_read(struct file * file, char * buf, 
  614. size_t count, loff_t *ppos)
  615. {
  616. int dev = MINOR(file->f_dentry->d_inode->i_rdev);
  617. int avail;
  618. sync_port *port;
  619. char* start; 
  620. char* end;
  621. unsigned long flags;
  623. if (dev < 0 || dev >= NUMBER_OF_PORTS || !ports[dev].enabled)
  624. {
  625. DEBUG(printk("Invalid minor %dn", dev));
  626. return -ENODEV;
  627. }
  628. port = &ports[dev];
  630. DEBUG(printk("Read dev %d count %dn", dev, count));
  632. /* Make sure receiver is running */
  633. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, clk_halt, running);
  634. SETS(port->ctrl_data_shadow, R_SYNC_SERIAL1_CTRL, rec_enable, enable);
  635. *port->ctrl_data = port->ctrl_data_shadow;
  637. /* Calculate number of available bytes */
  638. while (port->readp == port->writep) /* No data */
  639. {
  640. if (file->f_flags & O_NONBLOCK)
  641. return -EAGAIN;
  642. interruptible_sleep_on(&port->in_wait_q);
  643. if (signal_pending(current))
  644. {
  645. return -EINTR;
  646. }
  647. }
  649. /* Save pointers to avoid that they are modified by interrupt */
  650. start = port->readp;
  651. end = port->writep;
  653. /* Lazy read, never return wrapped data. */
  654. if (end > start)
  655. avail = end - start;
  656. else 
  657. avail = port->in_buffer + IN_BUFFER_SIZE - start;
  658.   
  659. count = count > avail ? avail : count;
  660. copy_to_user(buf, start, count);
  662. /* Disable interrupts while updating readp */
  663. save_flags(flags);
  664. cli();
  665. port->readp += count;
  666. if (port->readp == port->in_buffer + IN_BUFFER_SIZE) /* Wrap? */
  667. port->readp = port->in_buffer;
  668. restore_flags(flags);
  670. DEBUG(printk("%d bytes readn", count));
  671. return count;
  672. }
  674. static void send_word(sync_port* port)
  675. {
  676. switch(port->ctrl_data_shadow & IO_MASK(R_SYNC_SERIAL1_CTRL, wordsize))
  677. {
  678. case IO_STATE(R_SYNC_SERIAL1_CTRL, wordsize, size8bit):
  679. port->out_count--;
  680. *port->data_out = *port->outp++;
  681. break;
  682. case IO_STATE(R_SYNC_SERIAL1_CTRL, wordsize, size12bit):
  683. port->out_count--;
  684. if (port->odd_output)
  685. *port->data_out = ((*port->outp) << 16) | (*(unsigned short *)(port->outp + 1));
  686. else
  687. *port->data_out = ((*(unsigned short *)port->outp) << 8) | (*(port->outp + 1));
  688. port->odd_output = !port->odd_output;
  689. port->outp++;
  690. break;
  691. case IO_STATE(R_SYNC_SERIAL1_CTRL, wordsize, size16bit):
  692. port->out_count-=2;
  693. *port->data_out = *(unsigned short *)port->outp;
  694. port->outp+=2;
  695. break;
  696. case IO_STATE(R_SYNC_SERIAL1_CTRL, wordsize, size24bit):
  697. port->out_count-=3;
  698. *port->data_out = *(unsigned int *)port->outp;
  699. port->outp+=3;
  700. break;
  701. case IO_STATE(R_SYNC_SERIAL1_CTRL, wordsize, size32bit):
  702. port->out_count-=4;
  703. *port->data_out = *(unsigned int *)port->outp;
  704. port->outp+=4;
  705. break;
  706. }
  707. }
  709. static void start_dma(struct sync_port* port, const char* data, int count)
  710. {
  711. port->out_descr.hw_len = 0;
  712. port->out_descr.next = 0;
  713. port->out_descr.ctrl = d_int | d_eol | d_eop | d_wait;
  714. port->out_descr.sw_len = count;
  715. port->out_descr.buf = virt_to_phys(port->out_buffer);
  716. port->out_descr.status = 0;
  718. *port->output_dma_first = virt_to_phys(&port->out_descr);
  719. *port->output_dma_cmd = IO_STATE(R_DMA_CH0_CMD, cmd, start);
  720. }
  722. static void start_dma_in(sync_port* port)
  723. {
  724. if (port->writep > port->in_buffer + IN_BUFFER_SIZE)
  725. {
  726. panic("Offset too large in sync serial drivern");
  727. return;
  728. }
  729. port->in_descr1.hw_len = 0;
  730. port->in_descr1.ctrl = d_int;
  731. port->in_descr1.status = 0;
  732. port->in_descr1.next = virt_to_phys(&port->in_descr2);
  733. port->in_descr2.hw_len = 0;
  734. port->in_descr2.next = virt_to_phys(&port->in_descr1);
  735. port->in_descr2.ctrl = d_int;
  736. port->in_descr2.status = 0;
  738. /* Find out which descriptor to start */
  739. if (port->writep >= port->in_buffer + IN_BUFFER_SIZE/2)
  740. {
  741. /* Start descriptor 2 */
  742. port->in_descr1.sw_len = IN_BUFFER_SIZE/2; /* All data available in 1 */
  743. port->in_descr1.buf = virt_to_phys(port->in_buffer);
  744. port->in_descr2.sw_len = port->in_buffer + IN_BUFFER_SIZE - port->writep;
  745. port->in_descr2.buf = virt_to_phys(port->writep);
  746. *port->input_dma_first = virt_to_phys(&port->in_descr2);
  747. }
  748. else
  749. {
  750. /* Start descriptor 1 */
  751. port->in_descr1.sw_len = port->in_buffer + IN_BUFFER_SIZE/2 - port->writep;
  752. port->in_descr1.buf = virt_to_phys(port->writep);
  753. port->in_descr2.sw_len = IN_BUFFER_SIZE/2;
  754. port->in_descr2.buf = virt_to_phys(port->in_buffer + IN_BUFFER_SIZE / 2);
  755. *port->input_dma_first = virt_to_phys(&port->in_descr1);
  756. }
  757. *port->input_dma_cmd = IO_STATE(R_DMA_CH0_CMD, cmd, start);
  758. }
  760. static void tr_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  761. {
  762. unsigned long ireg = *R_IRQ_MASK2_RD;
  763. int i;
  765. for (i = 0; i < NUMBER_OF_PORTS; i++) 
  766. {
  767. sync_port *port = &ports[i];
  768. if (ireg & (1 << port->output_dma_bit)) /* IRQ active for the port? */
  769. {
  770. /* Clear IRQ */
  771. *port->output_dma_clr_irq = 
  772.   IO_STATE(R_DMA_CH0_CLR_INTR, clr_eop, do) |
  773.   IO_STATE(R_DMA_CH0_CLR_INTR, clr_descr, do);
  774. wake_up_interruptible(&port->out_wait_q); /* wake up the waiting process */
  775. } 
  776. }
  777. }
  779. static void rx_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  780. {
  781. unsigned long ireg = *R_IRQ_MASK2_RD;
  782. int i;
  784. for (i = 0; i < NUMBER_OF_PORTS; i++) 
  785. {
  786. int update = 0;
  787. sync_port *port = &ports[i];
  789. if (!port->enabled)
  790. {
  791. continue;
  792. }    
  794. if (ireg & (1 << port->input_dma_descr_bit)) /* Descriptor interrupt */
  795. {
  796. /* DMA has reached end of descriptor */
  797. *port->input_dma_clr_irq = 
  798.   IO_STATE(R_DMA_CH0_CLR_INTR, clr_eop, do) | 
  799.   IO_STATE(R_DMA_CH0_CLR_INTR, clr_descr, do);
  801. /* Find out which descriptor that is ready */
  802. if (port->writep >= port->in_buffer + IN_BUFFER_SIZE/2) 
  803. {
  804. /* Descr 2 was ready. Restart DMA at descriptor 1 */
  805. port->writep = port->in_buffer;
  807. /* Throw away data? */
  808. if (port->readp < port->in_buffer + IN_BUFFER_SIZE/2)
  809. port->readp = port->in_buffer + IN_BUFFER_SIZE/2;
  810. }
  811. else
  812. {
  813. /* Descr 1 was ready. Restart DMA at descriptor 2 */
  814. port->writep = port->in_buffer + IN_BUFFER_SIZE/2;
  816. /* Throw away data? */
  817. if (port->readp >= port->in_buffer + IN_BUFFER_SIZE/2)
  818. port->readp = port->in_buffer;
  819. }
  820. start_dma_in(port);
  821. wake_up_interruptible(&port->in_wait_q); /* wake up the waiting process */
  822. }
  823. }
  824. }
  826. static void manual_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  827. {
  828. int i;
  830. for (i = 0; i < NUMBER_OF_PORTS; i++)
  831. {
  832. sync_port* port = &ports[i];
  834. if (!port->enabled)
  835. {
  836. continue;
  837. }
  839. if (*R_IRQ_MASK1_RD & (1 << port->data_avail_bit)) /* Data received? */
  840. {
  841. /* Read data */
  842. switch(port->ctrl_data_shadow & IO_MASK(R_SYNC_SERIAL1_CTRL, wordsize))
  843. {
  844. case IO_STATE(R_SYNC_SERIAL1_CTRL, wordsize, size8bit):
  845. *port->writep++ = *(volatile char *)port->data_in;
  846. break;
  847. case IO_STATE(R_SYNC_SERIAL1_CTRL, wordsize, size12bit):
  848. {
  849. int data = *(unsigned short *)port->data_in;
  850. if (port->odd_input)
  851. {
  852. *port->writep |= (data & 0x0f00) >> 8;
  853. *(port->writep + 1) = data & 0xff;
  854. }
  855. else
  856. {
  857. *port->writep = (data & 0x0ff0) >> 4;
  858. *(port->writep + 1) = (data & 0x0f) << 4;
  859. }
  860. port->odd_input = !port->odd_input;
  861. port->writep+=1;
  862. }
  863. break;
  864. case IO_STATE(R_SYNC_SERIAL1_CTRL, wordsize, size16bit):
  865. *(unsigned short*)port->writep = *(volatile unsigned short *)port->data_in;
  866. port->writep+=2;
  867. break;
  868. case IO_STATE(R_SYNC_SERIAL1_CTRL, wordsize, size24bit):
  869. *(unsigned int*)port->writep = *port->data_in;
  870. port->writep+=3;
  871. break;
  872. case IO_STATE(R_SYNC_SERIAL1_CTRL, wordsize, size32bit):
  873. *(unsigned int*)port->writep = *port->data_in;
  874. port->writep+=4;
  875. break;
  876. }
  878. if (port->writep > port->in_buffer + IN_BUFFER_SIZE) /* Wrap? */
  879. port->writep = port->in_buffer;
  880. wake_up_interruptible(&port->in_wait_q); /* Wake up application */
  881. }
  883. if (*R_IRQ_MASK1_RD & (1 << port->transmitter_ready_bit)) /* Transmitter ready? */
  884. {
  885. if (port->out_count) /* More data to send */
  886. send_word(port);
  887. else /* transmission finished */
  888. {
  889. *R_IRQ_MASK1_CLR = 1 << port->ready_irq_bit; /* Turn off IRQ */
  890. wake_up_interruptible(&port->out_wait_q); /* Wake up application */
  891. }
  892. }
  893. }
  894. }
  896. module_init(etrax_sync_serial_init);