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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
comx-hw-mixcom.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：24k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

comx-hw-mixcom.c：源码内容
  1. /* 
  2.  * Hardware driver for the MixCom synchronous serial board 
  3.  *
  4.  * Author: Gergely Madarasz <gorgo@itc.hu>
  5.  *
  6.  * based on skeleton driver code and a preliminary hscx driver by 
  7.  * Tivadar Szemethy <tiv@itc.hu>
  8.  *
  9.  * Copyright (C) 1998-1999 ITConsult-Pro Co. <info@itc.hu>
  10.  *
  11.  * Contributors:
  12.  * Arnaldo Carvalho de Melo <acme@conectiva.com.br> (0.65)
  13.  *
  14.  * This program is free software; you can redistribute it and/or
  15.  * modify it under the terms of the GNU General Public License
  16.  * as published by the Free Software Foundation; either version
  17.  * 2 of the License, or (at your option) any later version.
  18.  *
  19.  * Version 0.60 (99/06/11):
  20.  * - ported to the kernel, now works as builtin code
  21.  *
  22.  * Version 0.61 (99/06/11):
  23.  * - recognize the one-channel MixCOM card (id byte = 0x13)
  24.  * - printk fixes
  25.  * 
  26.  * Version 0.62 (99/07/15):
  27.  * - fixes according to the new hw docs 
  28.  * - report line status when open
  29.  *
  30.  * Version 0.63 (99/09/21):
  31.  * - line status report fixes
  32.  *
  33.  * Version 0.64 (99/12/01):
  34.  * - some more cosmetical fixes
  35.  *
  36.  * Version 0.65 (00/08/15)
  37.  * - resource release on failure at MIXCOM_init
  38.  */
  40. #define VERSION "0.65"
  42. #include <linux/module.h>
  43. #include <linux/version.h>
  44. #include <linux/types.h>
  45. #include <linux/sched.h>
  46. #include <linux/netdevice.h>
  47. #include <linux/proc_fs.h>
  48. #include <asm/types.h>
  49. #include <asm/uaccess.h>
  50. #include <asm/io.h>
  51. #include <linux/ioport.h>
  52. #include <linux/delay.h>
  53. #include <linux/init.h>
  55. #include "comx.h"
  56. #include "mixcom.h"
  57. #include "hscx.h"
  59. MODULE_AUTHOR("Gergely Madarasz <gorgo@itc.hu>");
  60. MODULE_DESCRIPTION("Hardware-level driver for the serial port of the MixCom board");
  61. MODULE_LICENSE("GPL");
  63. #define MIXCOM_DATA(d) ((struct mixcom_privdata *)(COMX_CHANNEL(d)-> 
  64. HW_privdata))
  66. #define MIXCOM_BOARD_BASE(d) (d->base_addr - MIXCOM_SERIAL_OFFSET - 
  67. (1 - MIXCOM_DATA(d)->channel) * MIXCOM_CHANNEL_OFFSET)
  69. #define MIXCOM_DEV_BASE(port,channel) (port + MIXCOM_SERIAL_OFFSET + 
  70. (1 - channel) * MIXCOM_CHANNEL_OFFSET)
  72. /* Values used to set the IRQ line */
  73. static unsigned char mixcom_set_irq[]={0xFF, 0xFF, 0xFF, 0x0, 0xFF, 0x2, 0x4, 0x6, 0xFF, 0xFF, 0x8, 0xA, 0xC, 0xFF, 0xE, 0xFF};
  75. static unsigned char* hscx_versions[]={"A1", NULL, "A2", NULL, "A3", "2.1"};
  77. struct mixcom_privdata {
  78. u16 clock;
  79. char channel;
  80. long txbusy;
  81. struct sk_buff *sending;
  82. unsigned tx_ptr;
  83. struct sk_buff *recving;
  84. unsigned rx_ptr;
  85. unsigned char status;
  86. char card_has_status;
  87. };
  89. static inline void wr_hscx(struct net_device *dev, int reg, unsigned char val) 
  90. {
  91. outb(val, dev->base_addr + reg);
  92. }
  94. static inline unsigned char rd_hscx(struct net_device *dev, int reg)
  95. {
  96. return inb(dev->base_addr + reg);
  97. }
  99. static inline void hscx_cmd(struct net_device *dev, int cmd)
  100. {
  101. unsigned long jiffs = jiffies;
  102. unsigned char cec;
  103. unsigned delay = 0;
  105. while ((cec = (rd_hscx(dev, HSCX_STAR) & HSCX_CEC) != 0) && 
  106.     (jiffs + HZ > jiffies)) {
  107. udelay(1);
  108. if (++delay > (100000 / HZ)) break;
  109. }
  110. if (cec) {
  111. printk(KERN_WARNING "%s: CEC stuck, probably no clock!n",dev->name);
  112. } else {
  113. wr_hscx(dev, HSCX_CMDR, cmd);
  114. }
  115. }
  117. static inline void hscx_fill_fifo(struct net_device *dev)
  118. {
  119. struct comx_channel *ch = dev->priv;
  120. struct mixcom_privdata *hw = ch->HW_privdata;
  121. register word to_send = hw->sending->len - hw->tx_ptr;
  124. outsb(dev->base_addr + HSCX_FIFO,
  125.          &(hw->sending->data[hw->tx_ptr]), min_t(unsigned int, to_send, 32));
  126. if (to_send <= 32) {
  127.          hscx_cmd(dev, HSCX_XTF | HSCX_XME);
  128.         kfree_skb(hw->sending);
  129.          hw->sending = NULL; 
  130.          hw->tx_ptr = 0;
  131.         } else {
  132.         hscx_cmd(dev, HSCX_XTF);
  133.          hw->tx_ptr += 32;
  134.         }
  135. }
  137. static inline void hscx_empty_fifo(struct net_device *dev, int cnt)
  138. {
  139. struct comx_channel *ch = dev->priv;
  140. struct mixcom_privdata *hw = ch->HW_privdata;
  142. if (hw->recving == NULL) {
  143.          if (!(hw->recving = dev_alloc_skb(HSCX_MTU + 16))) {
  144.                 ch->stats.rx_dropped++;
  145.                  hscx_cmd(dev, HSCX_RHR);
  146.                 } else {
  147.                 skb_reserve(hw->recving, 16);
  148.                  skb_put(hw->recving, HSCX_MTU);
  149.                 }
  150.         hw->rx_ptr = 0;
  151.         }
  152. if (cnt > 32 || !cnt || hw->recving == NULL) {
  153.          printk(KERN_ERR "hscx_empty_fifo: cnt is %d, hw->recving %pn",
  154.         cnt, (void *)hw->recving);
  155.         return;
  156.         }
  157.         
  158. insb(dev->base_addr + HSCX_FIFO, &(hw->recving->data[hw->rx_ptr]),cnt);
  159. hw->rx_ptr += cnt;
  160. hscx_cmd(dev, HSCX_RMC);
  161. }
  164. static int MIXCOM_txe(struct net_device *dev)
  165. {
  166. struct comx_channel *ch = dev->priv;
  167. struct mixcom_privdata *hw = ch->HW_privdata;
  169. return !test_bit(0, &hw->txbusy);
  170. }
  172. static int mixcom_probe(struct net_device *dev)
  173. {
  174. unsigned long flags;
  175. int id, vstr, ret=0;
  177. save_flags(flags); cli();
  179. id=inb_p(MIXCOM_BOARD_BASE(dev) + MIXCOM_ID_OFFSET) & 0x7f;
  181.   if (id != MIXCOM_ID ) {
  182. ret=-ENODEV;
  183. printk(KERN_WARNING "%s: no MixCOM board found at 0x%04lxn",dev->name, dev->base_addr);
  184. goto out;
  185. }
  187. vstr=inb_p(dev->base_addr + HSCX_VSTR) & 0x0f;
  188. if(vstr>=sizeof(hscx_versions)/sizeof(char*) || 
  189.     hscx_versions[vstr]==NULL) {
  190. printk(KERN_WARNING "%s: board found but no HSCX chip detected at 0x%4lx (vstr = 0x%1x)n",dev->name,dev->base_addr,vstr);
  191. ret = -ENODEV;
  192. } else {
  193. printk(KERN_INFO "%s: HSCX chip version %sn",dev->name,hscx_versions[vstr]);
  194. ret = 0;
  195. }
  197. out:
  199. restore_flags(flags);
  200. return ret;
  201. }
  203. #if 0
  204. static void MIXCOM_set_clock(struct net_device *dev)
  205. {
  206. struct comx_channel *ch = dev->priv;
  207. struct mixcom_privdata *hw = ch->HW_privdata;
  209. if (hw->clock) {
  210. ;
  211. } else {
  212. ;
  213. }
  214. }
  215. #endif
  217. static void mixcom_board_on(struct net_device *dev)
  218. {
  219. outb_p(MIXCOM_OFF , MIXCOM_BOARD_BASE(dev) + MIXCOM_IT_OFFSET);
  220. udelay(1000);
  221. outb_p(mixcom_set_irq[dev->irq] | MIXCOM_ON, 
  222. MIXCOM_BOARD_BASE(dev) + MIXCOM_IT_OFFSET);
  223. udelay(1000);
  224. }
  226. static void mixcom_board_off(struct net_device *dev)
  227. {
  228. outb_p(MIXCOM_OFF , MIXCOM_BOARD_BASE(dev) + MIXCOM_IT_OFFSET);
  229. udelay(1000);
  230. }
  232. static void mixcom_off(struct net_device *dev)
  233. {
  234. wr_hscx(dev, HSCX_CCR1, 0x0);
  235. }
  237. static void mixcom_on(struct net_device *dev)
  238. {
  239. struct comx_channel *ch = dev->priv;
  241. wr_hscx(dev, HSCX_CCR1, HSCX_PU | HSCX_ODS | HSCX_ITF); // power up, push-pull
  242. wr_hscx(dev, HSCX_CCR2, HSCX_CIE /* | HSCX_RIE */ );
  243. wr_hscx(dev, HSCX_MODE, HSCX_TRANS | HSCX_ADM8 | HSCX_RAC | HSCX_RTS );
  244. wr_hscx(dev, HSCX_RLCR, HSCX_RC | 47); // 1504 bytes
  245. wr_hscx(dev, HSCX_MASK, HSCX_RSC | HSCX_TIN );
  246. hscx_cmd(dev, HSCX_XRES | HSCX_RHR);
  248. if (ch->HW_set_clock) ch->HW_set_clock(dev);
  250. }
  252. static int MIXCOM_send_packet(struct net_device *dev, struct sk_buff *skb) 
  253. {
  254. struct comx_channel *ch = dev->priv;
  255. struct mixcom_privdata *hw = ch->HW_privdata;
  256. unsigned long flags;
  258. if (ch->debug_flags & DEBUG_HW_TX) {
  259. comx_debug_bytes(dev, skb->data, skb->len, "MIXCOM_send_packet");
  260. }
  262. if (!(ch->line_status & LINE_UP)) {
  263. return FRAME_DROPPED;
  264. }
  266. if (skb->len > HSCX_MTU) {
  267. ch->stats.tx_errors++;
  268. return FRAME_ERROR;
  269. }
  271. save_flags(flags); cli();
  273. if (test_and_set_bit(0, &hw->txbusy)) {
  274. printk(KERN_ERR "%s: transmitter called while busy... dropping frame (length %d)n", dev->name, skb->len);
  275. restore_flags(flags);
  276. return FRAME_DROPPED;
  277. }
  280. hw->sending = skb;
  281. hw->tx_ptr = 0;
  282. hw->txbusy = 1;
  283. // atomic_inc(&skb->users); // save it
  284. hscx_fill_fifo(dev);
  285. restore_flags(flags);
  287. ch->stats.tx_packets++;
  288. ch->stats.tx_bytes += skb->len; 
  290. if (ch->debug_flags & DEBUG_HW_TX) {
  291. comx_debug(dev, "MIXCOM_send_packet was successfulnn");
  292. }
  294. return FRAME_ACCEPTED;
  295. }
  297. static inline void mixcom_receive_frame(struct net_device *dev) 
  298. {
  299. struct comx_channel *ch=dev->priv;
  300. struct mixcom_privdata *hw=ch->HW_privdata;
  301. register byte rsta;
  302. register word length;
  304. rsta = rd_hscx(dev, HSCX_RSTA) & (HSCX_VFR | HSCX_RDO | 
  305. HSCX_CRC | HSCX_RAB);
  306. length = ((rd_hscx(dev, HSCX_RBCH) & 0x0f) << 8) | 
  307. rd_hscx(dev, HSCX_RBCL);
  309. if ( length > hw->rx_ptr ) {
  310. hscx_empty_fifo(dev, length - hw->rx_ptr);
  311. }
  313. if (!(rsta & HSCX_VFR)) {
  314. ch->stats.rx_length_errors++;
  315. }
  316. if (rsta & HSCX_RDO) {
  317. ch->stats.rx_over_errors++;
  318. }
  319. if (!(rsta & HSCX_CRC)) {
  320. ch->stats.rx_crc_errors++;
  321. }
  322. if (rsta & HSCX_RAB) {
  323. ch->stats.rx_frame_errors++;
  324. }
  325. ch->stats.rx_packets++; 
  326. ch->stats.rx_bytes += length;
  328. if (rsta == (HSCX_VFR | HSCX_CRC) && hw->recving) {
  329. skb_trim(hw->recving, hw->rx_ptr - 1);
  330. if (ch->debug_flags & DEBUG_HW_RX) {
  331. comx_debug_skb(dev, hw->recving,
  332. "MIXCOM_interrupt receiving");
  333. }
  334. hw->recving->dev = dev;
  335. if (ch->LINE_rx) {
  336. ch->LINE_rx(dev, hw->recving);
  337. }
  338. }
  339. else if(hw->recving) {
  340. kfree_skb(hw->recving);
  341. }
  342. hw->recving = NULL; 
  343. hw->rx_ptr = 0;
  344. }
  347. static inline void mixcom_extended_interrupt(struct net_device *dev) 
  348. {
  349. struct comx_channel *ch=dev->priv;
  350. struct mixcom_privdata *hw=ch->HW_privdata;
  351. register byte exir;
  353. exir = rd_hscx(dev, HSCX_EXIR) & (HSCX_XDU | HSCX_RFO | HSCX_CSC );
  355. if (exir & HSCX_RFO) {
  356. ch->stats.rx_over_errors++;
  357. if (hw->rx_ptr) {
  358. kfree_skb(hw->recving);
  359. hw->recving = NULL; hw->rx_ptr = 0;
  360. }
  361. printk(KERN_ERR "MIXCOM: rx overrunn");
  362. hscx_cmd(dev, HSCX_RHR);
  363. }
  365. if (exir & HSCX_XDU) { // xmit underrun
  366. ch->stats.tx_errors++;
  367. ch->stats.tx_aborted_errors++;
  368. if (hw->tx_ptr) {
  369. kfree_skb(hw->sending);
  370. hw->sending = NULL; 
  371. hw->tx_ptr = 0;
  372. }
  373. hscx_cmd(dev, HSCX_XRES);
  374. clear_bit(0, &hw->txbusy);
  375. if (ch->LINE_tx) {
  376. ch->LINE_tx(dev);
  377. }
  378. printk(KERN_ERR "MIXCOM: tx underrunn");
  379. }
  381. if (exir & HSCX_CSC) {        
  382. ch->stats.tx_carrier_errors++;
  383. if ((rd_hscx(dev, HSCX_STAR) & HSCX_CTS) == 0) { // Vonal le
  384. if (test_and_clear_bit(0, &ch->lineup_pending)) {
  385.                 del_timer(&ch->lineup_timer);
  386. } else if (ch->line_status & LINE_UP) {
  387.                  ch->line_status &= ~LINE_UP;
  388.                  if (ch->LINE_status) {
  389.                        ch->LINE_status(dev,ch->line_status);
  390.                        }
  391.        }
  392. }
  393. if (!(ch->line_status & LINE_UP) && (rd_hscx(dev, HSCX_STAR) & 
  394.     HSCX_CTS)) { // Vonal fol
  395. if (!test_and_set_bit(0,&ch->lineup_pending)) {
  396. ch->lineup_timer.function = comx_lineup_func;
  397.                  ch->lineup_timer.data = (unsigned long)dev;
  398.                   ch->lineup_timer.expires = jiffies + HZ * 
  399.                   ch->lineup_delay;
  400.                  add_timer(&ch->lineup_timer);
  401.                 hscx_cmd(dev, HSCX_XRES);
  402.                  clear_bit(0, &hw->txbusy);
  403.                  if (hw->sending) {
  404. kfree_skb(hw->sending);
  405. }
  406. hw->sending=NULL;
  407. hw->tx_ptr = 0;
  408. }
  409. }
  410. }
  411. }
  414. static void MIXCOM_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  415. {
  416. unsigned long flags;
  417. struct net_device *dev = (struct net_device *)dev_id;
  418. struct comx_channel *ch, *twin_ch;
  419. struct mixcom_privdata *hw, *twin_hw;
  420. register unsigned char ista;
  422. if (dev==NULL) {
  423. printk(KERN_ERR "comx_interrupt: irq %d for unknown devicen",irq);
  424. return;
  425. }
  427. ch = dev->priv; 
  428. hw = ch->HW_privdata;
  430. save_flags(flags); cli(); 
  432. while((ista = (rd_hscx(dev, HSCX_ISTA) & (HSCX_RME | HSCX_RPF | 
  433.     HSCX_XPR | HSCX_EXB | HSCX_EXA | HSCX_ICA)))) {
  434. register byte ista2 = 0;
  436. if (ista & HSCX_RME) {
  437. mixcom_receive_frame(dev);
  438. }
  439. if (ista & HSCX_RPF) {
  440. hscx_empty_fifo(dev, 32);
  441. }
  442. if (ista & HSCX_XPR) {
  443. if (hw->tx_ptr) {
  444. hscx_fill_fifo(dev);
  445. } else {
  446. clear_bit(0, &hw->txbusy);
  447.                 ch->LINE_tx(dev);
  448. }
  449. }
  451. if (ista & HSCX_EXB) {
  452. mixcom_extended_interrupt(dev);
  453. }
  455. if ((ista & HSCX_EXA) && ch->twin)  {
  456. mixcom_extended_interrupt(ch->twin);
  457. }
  459. if ((ista & HSCX_ICA) && ch->twin &&
  460.     (ista2 = rd_hscx(ch->twin, HSCX_ISTA) &
  461.     (HSCX_RME | HSCX_RPF | HSCX_XPR ))) {
  462. if (ista2 & HSCX_RME) {
  463. mixcom_receive_frame(ch->twin);
  464. }
  465. if (ista2 & HSCX_RPF) {
  466. hscx_empty_fifo(ch->twin, 32);
  467. }
  468. if (ista2 & HSCX_XPR) {
  469. twin_ch=ch->twin->priv;
  470. twin_hw=twin_ch->HW_privdata;
  471. if (twin_hw->tx_ptr) {
  472. hscx_fill_fifo(ch->twin);
  473. } else {
  474. clear_bit(0, &twin_hw->txbusy);
  475. ch->LINE_tx(ch->twin);
  476. }
  477. }
  478. }
  479. }
  481. restore_flags(flags);
  482. return;
  483. }
  485. static int MIXCOM_open(struct net_device *dev)
  486. {
  487. struct comx_channel *ch = dev->priv;
  488. struct mixcom_privdata *hw = ch->HW_privdata;
  489. struct proc_dir_entry *procfile = ch->procdir->subdir;
  490. unsigned long flags; 
  491. int ret = -ENODEV;
  493. if (!dev->base_addr || !dev->irq)
  494. goto err_ret;
  497. if(hw->channel==1) {
  498. if(!TWIN(dev) || !(COMX_CHANNEL(TWIN(dev))->init_status & 
  499.     IRQ_ALLOCATED)) {
  500. printk(KERN_ERR "%s: channel 0 not yet initializedn",dev->name);
  501. ret = -EAGAIN;
  502. goto err_ret;
  503. }
  504. }
  507. /* Is our hw present at all ? Not checking for channel 0 if it is already 
  508.    open */
  509. if(hw->channel!=0 || !(ch->init_status & IRQ_ALLOCATED)) {
  510. if (!request_region(dev->base_addr, MIXCOM_IO_EXTENT, dev->name)) {
  511. ret = -EAGAIN;
  512. goto err_ret;
  513. }
  514. if (mixcom_probe(dev)) {
  515. ret = -ENODEV;
  516. goto err_release_region;
  517. }
  518. }
  520. if(hw->channel==0 && !(ch->init_status & IRQ_ALLOCATED)) {
  521. if (request_irq(dev->irq, MIXCOM_interrupt, 0, 
  522.     dev->name, (void *)dev)) {
  523. printk(KERN_ERR "MIXCOM: unable to obtain irq %dn", dev->irq);
  524. ret = -EAGAIN;
  525. goto err_release_region;
  526. }
  527. }
  529. save_flags(flags); cli();
  531. if(hw->channel==0 && !(ch->init_status & IRQ_ALLOCATED)) {
  532. ch->init_status|=IRQ_ALLOCATED;
  533. mixcom_board_on(dev);
  534. }
  536. mixcom_on(dev);
  539. hw->status=inb(MIXCOM_BOARD_BASE(dev) + MIXCOM_STATUS_OFFSET);
  540. if(hw->status != 0xff) {
  541. printk(KERN_DEBUG "%s: board has status register, goodn", dev->name);
  542. hw->card_has_status=1;
  543. }
  545. hw->txbusy = 0;
  546. ch->init_status |= HW_OPEN;
  548. if (rd_hscx(dev, HSCX_STAR) & HSCX_CTS) {
  549. ch->line_status |= LINE_UP;
  550. } else {
  551. ch->line_status &= ~LINE_UP;
  552. }
  554. restore_flags(flags);
  556. ch->LINE_status(dev, ch->line_status);
  558. for (; procfile ; procfile = procfile->next) {
  559. if (strcmp(procfile->name, FILENAME_IO) == 0 ||
  560.     strcmp(procfile->name, FILENAME_CHANNEL) == 0 ||
  561.     strcmp(procfile->name, FILENAME_CLOCK) == 0 ||
  562.     strcmp(procfile->name, FILENAME_IRQ) == 0) {
  563. procfile->mode = S_IFREG |  0444;
  564. }
  565. }
  567. return 0;
  569. err_release_region:
  570. release_region(dev->base_addr, MIXCOM_IO_EXTENT);
  571. err_ret:
  572. return ret;
  573. }
  575. static int MIXCOM_close(struct net_device *dev)
  576. {
  577. struct comx_channel *ch = dev->priv;
  578. struct mixcom_privdata *hw = ch->HW_privdata;
  579. struct proc_dir_entry *procfile = ch->procdir->subdir;
  580. unsigned long flags;
  583. save_flags(flags); cli();
  585. mixcom_off(dev);
  587. /* This is channel 0, twin is not open, we can safely turn off everything */
  588. if(hw->channel==0 && (!(TWIN(dev)) || 
  589.     !(COMX_CHANNEL(TWIN(dev))->init_status & HW_OPEN))) {
  590. mixcom_board_off(dev);
  591. free_irq(dev->irq, dev);
  592. release_region(dev->base_addr, MIXCOM_IO_EXTENT);
  593. ch->init_status &= ~IRQ_ALLOCATED;
  594. }
  596. /* This is channel 1, channel 0 has already been shutdown, we can release
  597.    this one too */
  598. if(hw->channel==1 && !(COMX_CHANNEL(TWIN(dev))->init_status & HW_OPEN)) {
  599. if(COMX_CHANNEL(TWIN(dev))->init_status & IRQ_ALLOCATED) {
  600. mixcom_board_off(TWIN(dev));
  601. free_irq(TWIN(dev)->irq, TWIN(dev));
  602. release_region(TWIN(dev)->base_addr, MIXCOM_IO_EXTENT);
  603. COMX_CHANNEL(TWIN(dev))->init_status &= ~IRQ_ALLOCATED;
  604. }
  605. }
  607. /* the ioports for channel 1 can be safely released */
  608. if(hw->channel==1) {
  609. release_region(dev->base_addr, MIXCOM_IO_EXTENT);
  610. }
  612. restore_flags(flags);
  614. /* If we don't hold any hardware open */
  615. if(!(ch->init_status & IRQ_ALLOCATED)) {
  616. for (; procfile ; procfile = procfile->next) {
  617. if (strcmp(procfile->name, FILENAME_IO) == 0 ||
  618.     strcmp(procfile->name, FILENAME_CHANNEL) == 0 ||
  619.     strcmp(procfile->name, FILENAME_CLOCK) == 0 ||
  620.     strcmp(procfile->name, FILENAME_IRQ) == 0) {
  621. procfile->mode = S_IFREG |  0644;
  622. }
  623. }
  624. }
  626. /* channel 0 was only waiting for us to close channel 1 
  627.    close it completely */
  628.    
  629. if(hw->channel==1 && !(COMX_CHANNEL(TWIN(dev))->init_status & HW_OPEN)) {
  630. for (procfile=COMX_CHANNEL(TWIN(dev))->procdir->subdir; 
  631.     procfile ; procfile = procfile->next) {
  632. if (strcmp(procfile->name, FILENAME_IO) == 0 ||
  633.     strcmp(procfile->name, FILENAME_CHANNEL) == 0 ||
  634.     strcmp(procfile->name, FILENAME_CLOCK) == 0 ||
  635.     strcmp(procfile->name, FILENAME_IRQ) == 0) {
  636. procfile->mode = S_IFREG |  0644;
  637. }
  638. }
  639. }
  641. ch->init_status &= ~HW_OPEN;
  642. return 0;
  643. }
  645. static int MIXCOM_statistics(struct net_device *dev,char *page)
  646. {
  647. struct comx_channel *ch = dev->priv;
  648. // struct mixcom_privdata *hw = ch->HW_privdata;
  649. int len = 0;
  651. if(ch->init_status && IRQ_ALLOCATED) {
  652. len += sprintf(page + len, "Mixcom board: hardware openn");
  653. }
  655. return len;
  656. }
  658. static int MIXCOM_dump(struct net_device *dev) {
  659. return 0;
  660. }
  662. static int mixcom_read_proc(char *page, char **start, off_t off, int count,
  663. int *eof, void *data)
  664. {
  665. struct proc_dir_entry *file = (struct proc_dir_entry *)data;
  666. struct net_device *dev = file->parent->data;
  667. struct comx_channel *ch = dev->priv;
  668. struct mixcom_privdata *hw = ch->HW_privdata;
  669. int len = 0;
  671. if (strcmp(file->name, FILENAME_IO) == 0) {
  672. len = sprintf(page, "0x%xn", 
  673. (unsigned int)MIXCOM_BOARD_BASE(dev));
  674. } else if (strcmp(file->name, FILENAME_IRQ) == 0) {
  675. len = sprintf(page, "%dn", (unsigned int)dev->irq);
  676. } else if (strcmp(file->name, FILENAME_CLOCK) == 0) {
  677. if (hw->clock) len = sprintf(page, "%dn", hw->clock);
  678. else len = sprintf(page, "externaln");
  679. } else if (strcmp(file->name, FILENAME_CHANNEL) == 0) {
  680. len = sprintf(page, "%01dn", hw->channel);
  681. } else if (strcmp(file->name, FILENAME_TWIN) == 0) {
  682. if (ch->twin) {
  683. len = sprintf(page, "%sn",ch->twin->name);
  684. } else {
  685. len = sprintf(page, "nonen");
  686. }
  687. } else {
  688. printk(KERN_ERR "mixcom_read_proc: internal error, filename %sn", file->name);
  689. return -EBADF;
  690. }
  692. if (off >= len) {
  693. *eof = 1;
  694. return 0;
  695. }
  696. *start = page + off;
  697. if (count >= len - off) *eof = 1;
  698. return min_t(int, count, len - off);
  699. }
  702. static struct net_device *mixcom_twin_check(struct net_device *dev)
  703. {
  704. struct comx_channel *ch = dev->priv;
  705. struct proc_dir_entry *procfile = ch->procdir->parent->subdir;
  706. struct mixcom_privdata *hw = ch->HW_privdata;
  708. struct net_device *twin;
  709. struct comx_channel *ch_twin;
  710. struct mixcom_privdata *hw_twin;
  713. for ( ; procfile ; procfile = procfile->next) {
  714. if(!S_ISDIR(procfile->mode)) continue;
  715.                 
  716.          twin = procfile->data;
  717.         ch_twin = twin->priv;
  718.          hw_twin = ch_twin->HW_privdata;
  721.         if (twin != dev && dev->irq && dev->base_addr && 
  722.              dev->irq == twin->irq && 
  723.              ch->hardware == ch_twin->hardware &&
  724.     dev->base_addr == twin->base_addr + 
  725.     (1-2*hw->channel)*MIXCOM_CHANNEL_OFFSET &&
  726.     hw->channel == (1 - hw_twin->channel)) {
  727.          if  (!TWIN(twin) || TWIN(twin)==dev) {
  728.          return twin;
  729.          }
  730. }
  731.         }
  732. return NULL;
  733. }
  736. static void setup_twin(struct net_device* dev) 
  737. {
  739. if(TWIN(dev) && TWIN(TWIN(dev))) {
  740. TWIN(TWIN(dev))=NULL;
  741. }
  742. if ((TWIN(dev) = mixcom_twin_check(dev)) != NULL) {
  743. if (TWIN(TWIN(dev)) && TWIN(TWIN(dev)) != dev) {
  744. TWIN(dev)=NULL;
  745. } else {
  746. TWIN(TWIN(dev))=dev;
  747. }
  748. }
  749. }
  751. static int mixcom_write_proc(struct file *file, const char *buffer,
  752. u_long count, void *data)
  753. {
  754. struct proc_dir_entry *entry = (struct proc_dir_entry *)data;
  755. struct net_device *dev = (struct net_device *)entry->parent->data;
  756. struct comx_channel *ch = dev->priv;
  757. struct mixcom_privdata *hw = ch->HW_privdata;
  758. char *page;
  759. int value;
  761. if (!(page = (char *)__get_free_page(GFP_KERNEL))) {
  762. return -ENOMEM;
  763. }
  765. copy_from_user(page, buffer, count = min_t(unsigned long, count, PAGE_SIZE));
  766. if (*(page + count - 1) == 'n') {
  767. *(page + count - 1) = 0;
  768. }
  770. if (strcmp(entry->name, FILENAME_IO) == 0) {
  771. value = simple_strtoul(page, NULL, 0);
  772. if (value != 0x180 && value != 0x280 && value != 0x380) {
  773. printk(KERN_ERR "MIXCOM: incorrect io address!n");
  774. } else {
  775. dev->base_addr = MIXCOM_DEV_BASE(value,hw->channel);
  776. }
  777. } else if (strcmp(entry->name, FILENAME_IRQ) == 0) {
  778. value = simple_strtoul(page, NULL, 0); 
  779. if (value < 0 || value > 15 || mixcom_set_irq[value]==0xFF) {
  780. printk(KERN_ERR "MIXCOM: incorrect irq value!n");
  781. } else {
  782. dev->irq = value;
  783. }
  784. } else if (strcmp(entry->name, FILENAME_CLOCK) == 0) {
  785. if (strncmp("ext", page, 3) == 0) {
  786. hw->clock = 0;
  787. } else {
  788. int kbps;
  790. kbps = simple_strtoul(page, NULL, 0);
  791. if (!kbps) {
  792. hw->clock = 0;
  793. } else {
  794. hw->clock = kbps;
  795. }
  796. if (hw->clock < 32 || hw->clock > 2000) {
  797. hw->clock = 0;
  798. printk(KERN_ERR "MIXCOM: invalid clock rate!n");
  799. }
  800. }
  801. if (ch->init_status & HW_OPEN && ch->HW_set_clock) {
  802. ch->HW_set_clock(dev);
  803. }
  804. } else if (strcmp(entry->name, FILENAME_CHANNEL) == 0) {
  805. value = simple_strtoul(page, NULL, 0);
  806.          if (value > 2) {
  807.                  printk(KERN_ERR "Invalid channel numbern");
  808.         } else {
  809.          dev->base_addr+=(hw->channel - value) * MIXCOM_CHANNEL_OFFSET;
  810.          hw->channel = value;
  811. }         
  812. } else {
  813. printk(KERN_ERR "hw_read_proc: internal error, filename %sn", 
  814. entry->name);
  815. return -EBADF;
  816. }
  818. setup_twin(dev);
  820. free_page((unsigned long)page);
  821. return count;
  822. }
  824. static int MIXCOM_init(struct net_device *dev) {
  825. struct comx_channel *ch = dev->priv;
  826. struct mixcom_privdata *hw;
  827. struct proc_dir_entry *new_file;
  829. if ((ch->HW_privdata = kmalloc(sizeof(struct mixcom_privdata), 
  830.     GFP_KERNEL)) == NULL) {
  831.      return -ENOMEM;
  832. }
  834. memset(hw = ch->HW_privdata, 0, sizeof(struct mixcom_privdata));
  836. if ((new_file = create_proc_entry(FILENAME_IO, S_IFREG | 0644, 
  837.     ch->procdir)) == NULL) {
  838. goto cleanup_HW_privdata;
  839. }
  840. new_file->data = (void *)new_file;
  841. new_file->read_proc = &mixcom_read_proc;
  842. new_file->write_proc = &mixcom_write_proc;
  843. new_file->nlink = 1;
  845. if ((new_file = create_proc_entry(FILENAME_IRQ, S_IFREG | 0644, 
  846.     ch->procdir)) == NULL) {
  847.      goto cleanup_filename_io;
  848. }
  849. new_file->data = (void *)new_file;
  850. new_file->read_proc = &mixcom_read_proc;
  851. new_file->write_proc = &mixcom_write_proc;
  852. new_file->nlink = 1;
  854. #if 0
  855. if ((new_file = create_proc_entry(FILENAME_CLOCK, S_IFREG | 0644, 
  856.     ch->procdir)) == NULL) {
  857.      return -EIO;
  858. }
  859. new_file->data = (void *)new_file;
  860. new_file->read_proc = &mixcom_read_proc;
  861. new_file->write_proc = &mixcom_write_proc;
  862. new_file->nlink = 1;
  863. #endif
  865. if ((new_file = create_proc_entry(FILENAME_CHANNEL, S_IFREG | 0644, 
  866.     ch->procdir)) == NULL) {
  867.      goto cleanup_filename_irq;
  868. }
  869. new_file->data = (void *)new_file;
  870. new_file->read_proc = &mixcom_read_proc;
  871. new_file->write_proc = &mixcom_write_proc;
  872. new_file->nlink = 1;
  874. if ((new_file = create_proc_entry(FILENAME_TWIN, S_IFREG | 0444, 
  875.     ch->procdir)) == NULL) {
  876.      goto cleanup_filename_channel;
  877. }
  878. new_file->data = (void *)new_file;
  879. new_file->read_proc = &mixcom_read_proc;
  880. new_file->write_proc = &mixcom_write_proc;
  881. new_file->nlink = 1;
  883. setup_twin(dev);
  885. /* Fill in ch_struct hw specific pointers */
  886. ch->HW_access_board = NULL;
  887. ch->HW_release_board = NULL;
  888. ch->HW_txe = MIXCOM_txe;
  889. ch->HW_open = MIXCOM_open;
  890. ch->HW_close = MIXCOM_close;
  891. ch->HW_send_packet = MIXCOM_send_packet;
  892. ch->HW_statistics = MIXCOM_statistics;
  893. ch->HW_set_clock = NULL;
  895. dev->base_addr = MIXCOM_DEV_BASE(MIXCOM_DEFAULT_IO,0);
  896. dev->irq = MIXCOM_DEFAULT_IRQ;
  898. MOD_INC_USE_COUNT;
  899. return 0;
  900. cleanup_filename_channel:
  901. remove_proc_entry(FILENAME_CHANNEL, ch->procdir);
  902. cleanup_filename_irq:
  903. remove_proc_entry(FILENAME_IRQ, ch->procdir);
  904. cleanup_filename_io:
  905. remove_proc_entry(FILENAME_IO, ch->procdir);
  906. cleanup_HW_privdata:
  907. kfree(ch->HW_privdata);
  908. return -EIO;
  909. }
  911. static int MIXCOM_exit(struct net_device *dev)
  912. {
  913. struct comx_channel *ch = dev->priv;
  914. struct mixcom_privdata *hw = ch->HW_privdata;
  916. if(hw->channel==0 && TWIN(dev)) {
  917. return -EBUSY;
  918. }
  920. if(hw->channel==1 && TWIN(dev)) {
  921. TWIN(TWIN(dev))=NULL;
  922. }
  924. kfree(ch->HW_privdata);
  925. remove_proc_entry(FILENAME_IO, ch->procdir);
  926. remove_proc_entry(FILENAME_IRQ, ch->procdir);
  927. #if 0
  928. remove_proc_entry(FILENAME_CLOCK, ch->procdir);
  929. #endif
  930. remove_proc_entry(FILENAME_CHANNEL, ch->procdir);
  931. remove_proc_entry(FILENAME_TWIN, ch->procdir);
  933. MOD_DEC_USE_COUNT;
  934. return 0;
  935. }
  937. static struct comx_hardware mixcomhw = {
  938. "mixcom",
  939. VERSION,
  940. MIXCOM_init, 
  941. MIXCOM_exit,
  942. MIXCOM_dump,
  943. NULL
  944. };
  946. /* Module management */
  948. #ifdef MODULE
  949. #define comx_hw_mixcom_init init_module
  950. #endif
  952. int __init comx_hw_mixcom_init(void)
  953. {
  954. return(comx_register_hardware(&mixcomhw));
  955. }
  957. #ifdef MODULE
  958. void
  959. cleanup_module(void)
  960. {
  961. comx_unregister_hardware("mixcom");
  962. }
  963. #endif