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

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

嵌入式Linux

开发平台：

Unix_Linux

baycom_epp.c：源码内容
  1. /*****************************************************************************/
  3. /*
  4.  * baycom_epp.c  -- baycom epp radio modem driver.
  5.  *
  6.  * Copyright (C) 1998-2000
  7.  *          Thomas Sailer (sailer@ife.ee.ethz.ch)
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22.  *
  23.  *  Please note that the GPL allows you to use the driver, NOT the radio.
  24.  *  In order to use the radio, you need a license from the communications
  25.  *  authority of your country.
  26.  *
  27.  *
  28.  *  History:
  29.  *   0.1  xx.xx.1998  Initial version by Matthias Welwarsky (dg2fef)
  30.  *   0.2  21.04.1998  Massive rework by Thomas Sailer
  31.  *                    Integrated FPGA EPP modem configuration routines
  32.  *   0.3  11.05.1998  Took FPGA config out and moved it into a separate program
  33.  *   0.4  26.07.1999  Adapted to new lowlevel parport driver interface
  34.  *   0.5  03.08.1999  adapt to Linus' new __setup/__initcall
  35.  *                    removed some pre-2.2 kernel compatibility cruft
  36.  *   0.6  10.08.1999  Check if parport can do SPP and is safe to access during interrupt contexts
  37.  *   0.7  12.02.2000  adapted to softnet driver interface
  38.  *
  39.  */
  41. /*****************************************************************************/
  43. #include <linux/config.h>
  44. #include <linux/module.h>
  45. #include <linux/kernel.h>
  46. #include <linux/init.h>
  47. #include <linux/string.h>
  48. #include <linux/tqueue.h>
  49. #include <linux/fs.h>
  50. #include <linux/parport.h>
  51. #include <linux/smp_lock.h>
  52. #include <asm/uaccess.h>
  53. #include <linux/if_arp.h>
  54. #include <linux/kmod.h>
  55. #include <linux/hdlcdrv.h>
  56. #include <linux/baycom.h>
  57. #include <linux/soundmodem.h>
  58. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  59. /* prototypes for ax25_encapsulate and ax25_rebuild_header */
  60. #include <net/ax25.h> 
  61. #endif /* CONFIG_AX25 || CONFIG_AX25_MODULE */
  63. #define __KERNEL_SYSCALLS__
  64. #include <linux/unistd.h>
  66. /* --------------------------------------------------------------------- */
  68. #define BAYCOM_DEBUG
  69. #define BAYCOM_MAGIC 19730510
  71. /* --------------------------------------------------------------------- */
  73. static const char paranoia_str[] = KERN_ERR 
  74. "baycom_epp: bad magic number for hdlcdrv_state struct in routine %sn";
  76. #define baycom_paranoia_check(dev,routine,retval)                                              
  77. ({                                                                                             
  78. if (!dev || !dev->priv || ((struct baycom_state *)dev->priv)->magic != BAYCOM_MAGIC) { 
  79. printk(paranoia_str, routine);                                                 
  80. return retval;                                                                 
  81. }                                                                                      
  82. })
  84. #define baycom_paranoia_check_void(dev,routine)                                                
  85. ({                                                                                             
  86. if (!dev || !dev->priv || ((struct baycom_state *)dev->priv)->magic != BAYCOM_MAGIC) { 
  87. printk(paranoia_str, routine);                                                 
  88. return;                                                                        
  89. }                                                                                      
  90. })
  92. /* --------------------------------------------------------------------- */
  94. static const char bc_drvname[] = "baycom_epp";
  95. static const char bc_drvinfo[] = KERN_INFO "baycom_epp: (C) 1998-2000 Thomas Sailer, HB9JNX/AE4WAn"
  96. KERN_INFO "baycom_epp: version 0.7 compiled " __TIME__ " " __DATE__ "n";
  98. /* --------------------------------------------------------------------- */
  100. #define NR_PORTS 4
  102. static struct net_device baycom_device[NR_PORTS];
  104. /* --------------------------------------------------------------------- */
  106. /* EPP status register */
  107. #define EPP_DCDBIT      0x80
  108. #define EPP_PTTBIT      0x08
  109. #define EPP_NREF        0x01
  110. #define EPP_NRAEF       0x02
  111. #define EPP_NRHF        0x04
  112. #define EPP_NTHF        0x20
  113. #define EPP_NTAEF       0x10
  114. #define EPP_NTEF        EPP_PTTBIT
  116. /* EPP control register */
  117. #define EPP_TX_FIFO_ENABLE 0x10
  118. #define EPP_RX_FIFO_ENABLE 0x08
  119. #define EPP_MODEM_ENABLE   0x20
  120. #define EPP_LEDS           0xC0
  121. #define EPP_IRQ_ENABLE     0x10
  123. /* LPT registers */
  124. #define LPTREG_ECONTROL       0x402
  125. #define LPTREG_CONFIGB        0x401
  126. #define LPTREG_CONFIGA        0x400
  127. #define LPTREG_EPPDATA        0x004
  128. #define LPTREG_EPPADDR        0x003
  129. #define LPTREG_CONTROL        0x002
  130. #define LPTREG_STATUS         0x001
  131. #define LPTREG_DATA           0x000
  133. /* LPT control register */
  134. #define LPTCTRL_PROGRAM       0x04   /* 0 to reprogram */
  135. #define LPTCTRL_WRITE         0x01
  136. #define LPTCTRL_ADDRSTB       0x08
  137. #define LPTCTRL_DATASTB       0x02
  138. #define LPTCTRL_INTEN         0x10
  140. /* LPT status register */
  141. #define LPTSTAT_SHIFT_NINTR   6
  142. #define LPTSTAT_WAIT          0x80
  143. #define LPTSTAT_NINTR         (1<<LPTSTAT_SHIFT_NINTR)
  144. #define LPTSTAT_PE            0x20
  145. #define LPTSTAT_DONE          0x10
  146. #define LPTSTAT_NERROR        0x08
  147. #define LPTSTAT_EPPTIMEOUT    0x01
  149. /* LPT data register */
  150. #define LPTDATA_SHIFT_TDI     0
  151. #define LPTDATA_SHIFT_TMS     2
  152. #define LPTDATA_TDI           (1<<LPTDATA_SHIFT_TDI)
  153. #define LPTDATA_TCK           0x02
  154. #define LPTDATA_TMS           (1<<LPTDATA_SHIFT_TMS)
  155. #define LPTDATA_INITBIAS      0x80
  158. /* EPP modem config/status bits */
  159. #define EPP_DCDBIT            0x80
  160. #define EPP_PTTBIT            0x08
  161. #define EPP_RXEBIT            0x01
  162. #define EPP_RXAEBIT           0x02
  163. #define EPP_RXHFULL           0x04
  165. #define EPP_NTHF              0x20
  166. #define EPP_NTAEF             0x10
  167. #define EPP_NTEF              EPP_PTTBIT
  169. #define EPP_TX_FIFO_ENABLE    0x10
  170. #define EPP_RX_FIFO_ENABLE    0x08
  171. #define EPP_MODEM_ENABLE      0x20
  172. #define EPP_LEDS              0xC0
  173. #define EPP_IRQ_ENABLE        0x10
  175. /* Xilinx 4k JTAG instructions */
  176. #define XC4K_IRLENGTH   3
  177. #define XC4K_EXTEST     0
  178. #define XC4K_PRELOAD    1
  179. #define XC4K_CONFIGURE  5
  180. #define XC4K_BYPASS     7
  182. #define EPP_CONVENTIONAL  0
  183. #define EPP_FPGA          1
  184. #define EPP_FPGAEXTSTATUS 2
  186. #define TXBUFFER_SIZE     ((HDLCDRV_MAXFLEN*6/5)+8)
  188. /* ---------------------------------------------------------------------- */
  189. /*
  190.  * Information that need to be kept for each board.
  191.  */
  193. struct baycom_state {
  194. int magic;
  196.         struct pardevice *pdev;
  197. unsigned int bh_running;
  198. struct tq_struct run_bh;
  199. unsigned int modem;
  200. unsigned int bitrate;
  201. unsigned char stat;
  203. struct {
  204. unsigned int intclk;
  205. unsigned int fclk;
  206. unsigned int bps;
  207. unsigned int extmodem;
  208. unsigned int loopback;
  209. } cfg;
  211.         struct hdlcdrv_channel_params ch_params;
  213.         struct {
  214. unsigned int bitbuf, bitstream, numbits, state;
  215. unsigned char *bufptr;
  216. int bufcnt;
  217. unsigned char buf[TXBUFFER_SIZE];
  218.         } hdlcrx;
  220.         struct {
  221. int calibrate;
  222.                 int slotcnt;
  223. int flags;
  224. enum { tx_idle = 0, tx_keyup, tx_data, tx_tail } state;
  225. unsigned char *bufptr;
  226. int bufcnt;
  227. unsigned char buf[TXBUFFER_SIZE];
  228.         } hdlctx;
  230.         struct net_device_stats stats;
  231. unsigned int ptt_keyed;
  232. struct sk_buff *skb;  /* next transmit packet  */
  234. #ifdef BAYCOM_DEBUG
  235. struct debug_vals {
  236. unsigned long last_jiffies;
  237. unsigned cur_intcnt;
  238. unsigned last_intcnt;
  239. int cur_pllcorr;
  240. int last_pllcorr;
  241. unsigned int mod_cycles;
  242. unsigned int demod_cycles;
  243. } debug_vals;
  244. #endif /* BAYCOM_DEBUG */
  245. };
  247. /* --------------------------------------------------------------------- */
  249. #define KISS_VERBOSE
  251. /* --------------------------------------------------------------------- */
  253. #define PARAM_TXDELAY   1
  254. #define PARAM_PERSIST   2
  255. #define PARAM_SLOTTIME  3
  256. #define PARAM_TXTAIL    4
  257. #define PARAM_FULLDUP   5
  258. #define PARAM_HARDWARE  6
  259. #define PARAM_RETURN    255
  261. /* --------------------------------------------------------------------- */
  262. /*
  263.  * the CRC routines are stolen from WAMPES
  264.  * by Dieter Deyke
  265.  */
  267. static const unsigned short crc_ccitt_table[] = {
  268. 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
  269. 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
  270. 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
  271. 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
  272. 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
  273. 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
  274. 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
  275. 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
  276. 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
  277. 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
  278. 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
  279. 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
  280. 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
  281. 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
  282. 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
  283. 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
  284. 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
  285. 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
  286. 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
  287. 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
  288. 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
  289. 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
  290. 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
  291. 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
  292. 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
  293. 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
  294. 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
  295. 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
  296. 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
  297. 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
  298. 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
  299. 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
  300. };
  302. /*---------------------------------------------------------------------------*/
  304. #if 0
  305. extern inline void append_crc_ccitt(unsigned char *buffer, int len)
  306. {
  307.   unsigned int crc = 0xffff;
  309. for (;len>0;len--)
  310. crc = (crc >> 8) ^ crc_ccitt_table[(crc ^ *buffer++) & 0xff];
  311. crc ^= 0xffff;
  312. *buffer++ = crc;
  313. *buffer++ = crc >> 8;
  314. }
  315. #endif
  317. /*---------------------------------------------------------------------------*/
  319. extern inline int check_crc_ccitt(const unsigned char *buf, int cnt)
  320. {
  321. unsigned int crc = 0xffff;
  323. for (; cnt > 0; cnt--)
  324. crc = (crc >> 8) ^ crc_ccitt_table[(crc ^ *buf++) & 0xff];
  325. return (crc & 0xffff) == 0xf0b8;
  326. }
  328. /*---------------------------------------------------------------------------*/
  330. extern inline int calc_crc_ccitt(const unsigned char *buf, int cnt)
  331. {
  332. unsigned int crc = 0xffff;
  334. for (; cnt > 0; cnt--)
  335. crc = (crc >> 8) ^ crc_ccitt_table[(crc ^ *buf++) & 0xff];
  336. crc ^= 0xffff;
  337. return (crc & 0xffff);
  338. }
  340. /* ---------------------------------------------------------------------- */
  342. #define tenms_to_flags(bc,tenms) ((tenms * bc->bitrate) / 800)
  344. /* --------------------------------------------------------------------- */
  346. static void inline baycom_int_freq(struct baycom_state *bc)
  347. {
  348. #ifdef BAYCOM_DEBUG
  349. unsigned long cur_jiffies = jiffies;
  350. /*
  351.  * measure the interrupt frequency
  352.  */
  353. bc->debug_vals.cur_intcnt++;
  354. if ((cur_jiffies - bc->debug_vals.last_jiffies) >= HZ) {
  355. bc->debug_vals.last_jiffies = cur_jiffies;
  356. bc->debug_vals.last_intcnt = bc->debug_vals.cur_intcnt;
  357. bc->debug_vals.cur_intcnt = 0;
  358. bc->debug_vals.last_pllcorr = bc->debug_vals.cur_pllcorr;
  359. bc->debug_vals.cur_pllcorr = 0;
  360. }
  361. #endif /* BAYCOM_DEBUG */
  362. }
  364. /* ---------------------------------------------------------------------- */
  365. /*
  366.  *    eppconfig_path should be setable  via /proc/sys.
  367.  */
  369. static char eppconfig_path[256] = "/usr/sbin/eppfpga";
  371. static char *envp[] = { "HOME=/", "TERM=linux", "PATH=/usr/bin:/bin", NULL };
  373. static int errno;
  375. static int exec_eppfpga(void *b)
  376. {
  377. struct baycom_state *bc = (struct baycom_state *)b;
  378. char modearg[256];
  379. char portarg[16];
  380.         char *argv[] = { eppconfig_path, "-s", "-p", portarg, "-m", modearg, NULL};
  381.         int i;
  383. /* set up arguments */
  384. sprintf(modearg, "%sclk,%smodem,fclk=%d,bps=%d,divider=%d%s,extstat",
  385. bc->cfg.intclk ? "int" : "ext",
  386. bc->cfg.extmodem ? "ext" : "int", bc->cfg.fclk, bc->cfg.bps,
  387. (bc->cfg.fclk + 8 * bc->cfg.bps) / (16 * bc->cfg.bps),
  388. bc->cfg.loopback ? ",loopback" : "");
  389. sprintf(portarg, "%ld", bc->pdev->port->base);
  390. printk(KERN_DEBUG "%s: %s -s -p %s -m %sn", bc_drvname, eppconfig_path, portarg, modearg);
  392. i = exec_usermodehelper(eppconfig_path, argv, envp);
  393. if (i < 0) {
  394.                 printk(KERN_ERR "%s: failed to exec %s -s -p %s -m %s, errno = %dn",
  395.                        bc_drvname, eppconfig_path, portarg, modearg, i);
  396.                 return i;
  397.         }
  398.         return 0;
  399. }
  402. /* eppconfig: called during ifconfig up to configure the modem */
  404. static int eppconfig(struct baycom_state *bc)
  405. {
  406.         int i, pid, r;
  407. mm_segment_t fs;
  409.         pid = kernel_thread(exec_eppfpga, bc, CLONE_FS);
  410.         if (pid < 0) {
  411.                 printk(KERN_ERR "%s: fork failed, errno %dn", bc_drvname, -pid);
  412.                 return pid;
  413.         }
  414. fs = get_fs();
  415.         set_fs(KERNEL_DS);      /* Allow i to be in kernel space. */
  416. r = waitpid(pid, &i, __WCLONE);
  417. set_fs(fs);
  418.         if (r != pid) {
  419.                 printk(KERN_ERR "%s: waitpid(%d) failed, returning %dn",
  420.        bc_drvname, pid, r);
  421. return -1;
  422.         }
  423. printk(KERN_DEBUG "%s: eppfpga returned %dn", bc_drvname, i);
  424. return i;
  425. }
  427. /* ---------------------------------------------------------------------- */
  429. static void epp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  430. {
  431. }
  433. /* ---------------------------------------------------------------------- */
  435. static void inline do_kiss_params(struct baycom_state *bc,
  436.   unsigned char *data, unsigned long len)
  437. {
  439. #ifdef KISS_VERBOSE
  440. #define PKP(a,b) printk(KERN_INFO "baycomm_epp: channel params: " a "n", b)
  441. #else /* KISS_VERBOSE */       
  442. #define PKP(a,b) 
  443. #endif /* KISS_VERBOSE */       
  445. if (len < 2)
  446. return;
  447. switch(data[0]) {
  448. case PARAM_TXDELAY:
  449. bc->ch_params.tx_delay = data[1];
  450. PKP("TX delay = %ums", 10 * bc->ch_params.tx_delay);
  451. break;
  452. case PARAM_PERSIST:   
  453. bc->ch_params.ppersist = data[1];
  454. PKP("p persistence = %u", bc->ch_params.ppersist);
  455. break;
  456. case PARAM_SLOTTIME:  
  457. bc->ch_params.slottime = data[1];
  458. PKP("slot time = %ums", bc->ch_params.slottime);
  459. break;
  460. case PARAM_TXTAIL:    
  461. bc->ch_params.tx_tail = data[1];
  462. PKP("TX tail = %ums", bc->ch_params.tx_tail);
  463. break;
  464. case PARAM_FULLDUP:   
  465. bc->ch_params.fulldup = !!data[1];
  466. PKP("%s duplex", bc->ch_params.fulldup ? "full" : "half");
  467. break;
  468. default:
  469. break;
  470. }
  471. #undef PKP
  472. }
  474. /* --------------------------------------------------------------------- */
  475. /*
  476.  * high performance HDLC encoder
  477.  * yes, it's ugly, but generates pretty good code
  478.  */
  480. #define ENCODEITERA(j)                         
  481. ({                                             
  482.         if (!(notbitstream & (0x1f0 << j)))    
  483.                 goto stuff##j;                 
  484.   encodeend##j:                                
  485. })
  487. #define ENCODEITERB(j)                                          
  488. ({                                                              
  489.   stuff##j:                                                     
  490.         bitstream &= ~(0x100 << j);                             
  491.         bitbuf = (bitbuf & (((2 << j) << numbit) - 1)) |        
  492.                 ((bitbuf & ~(((2 << j) << numbit) - 1)) << 1);  
  493.         numbit++;                                               
  494.         notbitstream = ~bitstream;                              
  495.         goto encodeend##j;                                      
  496. })
  499. static void encode_hdlc(struct baycom_state *bc)
  500. {
  501. struct sk_buff *skb;
  502. unsigned char *wp, *bp;
  503. int pkt_len;
  504.         unsigned bitstream, notbitstream, bitbuf, numbit, crc;
  505. unsigned char crcarr[2];
  507. if (bc->hdlctx.bufcnt > 0)
  508. return;
  509. skb = bc->skb;
  510. if (!skb)
  511. return;
  512. bc->skb = NULL;
  513. pkt_len = skb->len-1; /* strip KISS byte */
  514. wp = bc->hdlctx.buf;
  515. bp = skb->data+1;
  516. crc = calc_crc_ccitt(bp, pkt_len);
  517. crcarr[0] = crc;
  518. crcarr[1] = crc >> 8;
  519. *wp++ = 0x7e;
  520. bitstream = bitbuf = numbit = 0;
  521. while (pkt_len > -2) {
  522. bitstream >>= 8;
  523. bitstream |= ((unsigned int)*bp) << 8;
  524. bitbuf |= ((unsigned int)*bp) << numbit;
  525. notbitstream = ~bitstream;
  526. bp++;
  527. pkt_len--;
  528. if (!pkt_len)
  529. bp = crcarr;
  530. ENCODEITERA(0);
  531. ENCODEITERA(1);
  532. ENCODEITERA(2);
  533. ENCODEITERA(3);
  534. ENCODEITERA(4);
  535. ENCODEITERA(5);
  536. ENCODEITERA(6);
  537. ENCODEITERA(7);
  538. goto enditer;
  539. ENCODEITERB(0);
  540. ENCODEITERB(1);
  541. ENCODEITERB(2);
  542. ENCODEITERB(3);
  543. ENCODEITERB(4);
  544. ENCODEITERB(5);
  545. ENCODEITERB(6);
  546. ENCODEITERB(7);
  547. enditer:
  548. numbit += 8;
  549. while (numbit >= 8) {
  550. *wp++ = bitbuf;
  551. bitbuf >>= 8;
  552. numbit -= 8;
  553. }
  554. }
  555. bitbuf |= 0x7e7e << numbit;
  556. numbit += 16;
  557. while (numbit >= 8) {
  558. *wp++ = bitbuf;
  559. bitbuf >>= 8;
  560. numbit -= 8;
  561. }
  562. bc->hdlctx.bufptr = bc->hdlctx.buf;
  563. bc->hdlctx.bufcnt = wp - bc->hdlctx.buf;
  564. dev_kfree_skb(skb);
  565. bc->stats.tx_packets++;
  566. }
  568. /* ---------------------------------------------------------------------- */
  570. static unsigned short random_seed;
  572. static inline unsigned short random_num(void)
  573. {
  574. random_seed = 28629 * random_seed + 157;
  575. return random_seed;
  576. }
  578. /* ---------------------------------------------------------------------- */
  580. static int transmit(struct baycom_state *bc, int cnt, unsigned char stat)
  581. {
  582. struct parport *pp = bc->pdev->port;
  583. unsigned char tmp[128];
  584. int i, j;
  586. if (bc->hdlctx.state == tx_tail && !(stat & EPP_PTTBIT))
  587. bc->hdlctx.state = tx_idle;
  588. if (bc->hdlctx.state == tx_idle && bc->hdlctx.calibrate <= 0) {
  589. if (bc->hdlctx.bufcnt <= 0)
  590. encode_hdlc(bc);
  591. if (bc->hdlctx.bufcnt <= 0)
  592. return 0;
  593. if (!bc->ch_params.fulldup) {
  594. if (!(stat & EPP_DCDBIT)) {
  595. bc->hdlctx.slotcnt = bc->ch_params.slottime;
  596. return 0;
  597. }
  598. if ((--bc->hdlctx.slotcnt) > 0)
  599. return 0;
  600. bc->hdlctx.slotcnt = bc->ch_params.slottime;
  601. if ((random_num() % 256) > bc->ch_params.ppersist)
  602. return 0;
  603. }
  604. }
  605. if (bc->hdlctx.state == tx_idle && bc->hdlctx.bufcnt > 0) {
  606. bc->hdlctx.state = tx_keyup;
  607. bc->hdlctx.flags = tenms_to_flags(bc, bc->ch_params.tx_delay);
  608. bc->ptt_keyed++;
  609. }
  610. while (cnt > 0) {
  611. switch (bc->hdlctx.state) {
  612. case tx_keyup:
  613. i = min_t(int, cnt, bc->hdlctx.flags);
  614. cnt -= i;
  615. bc->hdlctx.flags -= i;
  616. if (bc->hdlctx.flags <= 0)
  617. bc->hdlctx.state = tx_data;
  618. memset(tmp, 0x7e, sizeof(tmp));
  619. while (i > 0) {
  620. j = (i > sizeof(tmp)) ? sizeof(tmp) : i;
  621. if (j != pp->ops->epp_write_data(pp, tmp, j, 0))
  622. return -1;
  623. i -= j;
  624. }
  625. break;
  627. case tx_data:
  628. if (bc->hdlctx.bufcnt <= 0) {
  629. encode_hdlc(bc);
  630. if (bc->hdlctx.bufcnt <= 0) {
  631. bc->hdlctx.state = tx_tail;
  632. bc->hdlctx.flags = tenms_to_flags(bc, bc->ch_params.tx_tail);
  633. break;
  634. }
  635. }
  636. i = min_t(int, cnt, bc->hdlctx.bufcnt);
  637. bc->hdlctx.bufcnt -= i;
  638. cnt -= i;
  639. if (i != pp->ops->epp_write_data(pp, bc->hdlctx.bufptr, i, 0))
  640. return -1;
  641. bc->hdlctx.bufptr += i;
  642. break;
  644. case tx_tail:
  645. encode_hdlc(bc);
  646. if (bc->hdlctx.bufcnt > 0) {
  647. bc->hdlctx.state = tx_data;
  648. break;
  649. }
  650. i = min_t(int, cnt, bc->hdlctx.flags);
  651. if (i) {
  652. cnt -= i;
  653. bc->hdlctx.flags -= i;
  654. memset(tmp, 0x7e, sizeof(tmp));
  655. while (i > 0) {
  656. j = (i > sizeof(tmp)) ? sizeof(tmp) : i;
  657. if (j != pp->ops->epp_write_data(pp, tmp, j, 0))
  658. return -1;
  659. i -= j;
  660. }
  661. break;
  662. }
  664. default:  /* fall through */
  665. if (bc->hdlctx.calibrate <= 0)
  666. return 0;
  667. i = min_t(int, cnt, bc->hdlctx.calibrate);
  668. cnt -= i;
  669. bc->hdlctx.calibrate -= i;
  670. memset(tmp, 0, sizeof(tmp));
  671. while (i > 0) {
  672. j = (i > sizeof(tmp)) ? sizeof(tmp) : i;
  673. if (j != pp->ops->epp_write_data(pp, tmp, j, 0))
  674. return -1;
  675. i -= j;
  676. }
  677. break;
  678. }
  679. }
  680. return 0;
  681. }
  683. /* ---------------------------------------------------------------------- */
  685. static void do_rxpacket(struct net_device *dev)
  686. {
  687. struct baycom_state *bc = (struct baycom_state *)dev->priv;
  688. struct sk_buff *skb;
  689. unsigned char *cp;
  690. unsigned pktlen;
  692. if (bc->hdlcrx.bufcnt < 4) 
  693. return;
  694. if (!check_crc_ccitt(bc->hdlcrx.buf, bc->hdlcrx.bufcnt)) 
  695. return;
  696. pktlen = bc->hdlcrx.bufcnt-2+1; /* KISS kludge */
  697. if (!(skb = dev_alloc_skb(pktlen))) {
  698. printk("%s: memory squeeze, dropping packetn", dev->name);
  699. bc->stats.rx_dropped++;
  700. return;
  701. }
  702. skb->dev = dev;
  703. cp = skb_put(skb, pktlen);
  704. *cp++ = 0; /* KISS kludge */
  705. memcpy(cp, bc->hdlcrx.buf, pktlen - 1);
  706. skb->protocol = htons(ETH_P_AX25);
  707. skb->mac.raw = skb->data;
  708. netif_rx(skb);
  709. bc->stats.rx_packets++;
  710. }
  712. #define DECODEITERA(j)                                                        
  713. ({                                                                            
  714.         if (!(notbitstream & (0x0fc << j)))              /* flag or abort */  
  715.                 goto flgabrt##j;                                              
  716.         if ((bitstream & (0x1f8 << j)) == (0xf8 << j))   /* stuffed bit */    
  717.                 goto stuff##j;                                                
  718.   enditer##j:                                                                 
  719. })
  721. #define DECODEITERB(j)                                                                 
  722. ({                                                                                     
  723.   flgabrt##j:                                                                          
  724.         if (!(notbitstream & (0x1fc << j))) {              /* abort received */        
  725.                 state = 0;                                                             
  726.                 goto enditer##j;                                                       
  727.         }                                                                              
  728.         if ((bitstream & (0x1fe << j)) != (0x0fc << j))   /* flag received */          
  729.                 goto enditer##j;                                                       
  730.         if (state)                                                                     
  731.                 do_rxpacket(dev);                                                      
  732.         bc->hdlcrx.bufcnt = 0;                                                         
  733.         bc->hdlcrx.bufptr = bc->hdlcrx.buf;                                            
  734.         state = 1;                                                                     
  735.         numbits = 7-j;                                                                 
  736.         goto enditer##j;                                                               
  737.   stuff##j:                                                                            
  738.         numbits--;                                                                     
  739.         bitbuf = (bitbuf & ((~0xff) << j)) | ((bitbuf & ~((~0xff) << j)) << 1);        
  740.         goto enditer##j;                                                               
  741. })
  742.         
  743. static int receive(struct net_device *dev, int cnt)
  744. {
  745. struct baycom_state *bc = (struct baycom_state *)dev->priv;
  746. struct parport *pp = bc->pdev->port;
  747.         unsigned int bitbuf, notbitstream, bitstream, numbits, state;
  748. unsigned char tmp[128];
  749.         unsigned char *cp;
  750. int cnt2, ret = 0;
  751.         
  752.         numbits = bc->hdlcrx.numbits;
  753. state = bc->hdlcrx.state;
  754. bitstream = bc->hdlcrx.bitstream;
  755. bitbuf = bc->hdlcrx.bitbuf;
  756. while (cnt > 0) {
  757. cnt2 = (cnt > sizeof(tmp)) ? sizeof(tmp) : cnt;
  758. cnt -= cnt2;
  759. if (cnt2 != pp->ops->epp_read_data(pp, tmp, cnt2, 0)) {
  760. ret = -1;
  761. break;
  762. }
  763. cp = tmp;
  764. for (; cnt2 > 0; cnt2--, cp++) {
  765. bitstream >>= 8;
  766. bitstream |= (*cp) << 8;
  767. bitbuf >>= 8;
  768. bitbuf |= (*cp) << 8;
  769. numbits += 8;
  770. notbitstream = ~bitstream;
  771. DECODEITERA(0);
  772. DECODEITERA(1);
  773. DECODEITERA(2);
  774. DECODEITERA(3);
  775. DECODEITERA(4);
  776. DECODEITERA(5);
  777. DECODEITERA(6);
  778. DECODEITERA(7);
  779. goto enddec;
  780. DECODEITERB(0);
  781. DECODEITERB(1);
  782. DECODEITERB(2);
  783. DECODEITERB(3);
  784. DECODEITERB(4);
  785. DECODEITERB(5);
  786. DECODEITERB(6);
  787. DECODEITERB(7);
  788. enddec:
  789. while (state && numbits >= 8) {
  790. if (bc->hdlcrx.bufcnt >= TXBUFFER_SIZE) {
  791. state = 0;
  792. } else {
  793. *(bc->hdlcrx.bufptr)++ = bitbuf >> (16-numbits);
  794. bc->hdlcrx.bufcnt++;
  795. numbits -= 8;
  796. }
  797. }
  798. }
  799. }
  800.         bc->hdlcrx.numbits = numbits;
  801. bc->hdlcrx.state = state;
  802. bc->hdlcrx.bitstream = bitstream;
  803. bc->hdlcrx.bitbuf = bitbuf;
  804. return ret;
  805. }
  807. /* --------------------------------------------------------------------- */
  809. #ifdef __i386__
  810. #define GETTICK(x)                                                
  811. ({                                                                
  812. if (cpu_has_tsc)                                          
  813. __asm__ __volatile__("rdtsc" : "=a" (x) : : "dx");
  814. })
  815. #else /* __i386__ */
  816. #define GETTICK(x)
  817. #endif /* __i386__ */
  819. static void epp_bh(struct net_device *dev)
  820. {
  821. struct baycom_state *bc;
  822. struct parport *pp;
  823. unsigned char stat;
  824. unsigned char tmp[2];
  825. unsigned int time1 = 0, time2 = 0, time3 = 0;
  826. int cnt, cnt2;
  828. baycom_paranoia_check_void(dev, "epp_bh");
  829. bc = (struct baycom_state *)dev->priv;
  830. if (!bc->bh_running)
  831. return;
  832. baycom_int_freq(bc);
  833. pp = bc->pdev->port;
  834. /* update status */
  835. if (pp->ops->epp_read_addr(pp, &stat, 1, 0) != 1)
  836. goto epptimeout;
  837. bc->stat = stat;
  838. bc->debug_vals.last_pllcorr = stat;
  839. GETTICK(time1);
  840. if (bc->modem == EPP_FPGAEXTSTATUS) {
  841. /* get input count */
  842. tmp[0] = EPP_TX_FIFO_ENABLE|EPP_RX_FIFO_ENABLE|EPP_MODEM_ENABLE|1;
  843. if (pp->ops->epp_write_addr(pp, tmp, 1, 0) != 1)
  844. goto epptimeout;
  845. if (pp->ops->epp_read_addr(pp, tmp, 2, 0) != 2)
  846. goto epptimeout;
  847. cnt = tmp[0] | (tmp[1] << 8);
  848. cnt &= 0x7fff;
  849. /* get output count */
  850. tmp[0] = EPP_TX_FIFO_ENABLE|EPP_RX_FIFO_ENABLE|EPP_MODEM_ENABLE|2;
  851. if (pp->ops->epp_write_addr(pp, tmp, 1, 0) != 1)
  852. goto epptimeout;
  853. if (pp->ops->epp_read_addr(pp, tmp, 2, 0) != 2)
  854. goto epptimeout;
  855. cnt2 = tmp[0] | (tmp[1] << 8);
  856. cnt2 = 16384 - (cnt2 & 0x7fff);
  857. /* return to normal */
  858. tmp[0] = EPP_TX_FIFO_ENABLE|EPP_RX_FIFO_ENABLE|EPP_MODEM_ENABLE;
  859. if (pp->ops->epp_write_addr(pp, tmp, 1, 0) != 1)
  860. goto epptimeout;
  861. if (transmit(bc, cnt2, stat))
  862. goto epptimeout;
  863. GETTICK(time2);
  864. if (receive(dev, cnt))
  865. goto epptimeout;
  866. if (pp->ops->epp_read_addr(pp, &stat, 1, 0) != 1)
  867. goto epptimeout;
  868. bc->stat = stat;
  869. } else {
  870. /* try to tx */
  871. switch (stat & (EPP_NTAEF|EPP_NTHF)) {
  872. case EPP_NTHF:
  873. cnt = 2048 - 256;
  874. break;
  876. case EPP_NTAEF:
  877. cnt = 2048 - 1793;
  878. break;
  880. case 0:
  881. cnt = 0;
  882. break;
  884. default:
  885. cnt = 2048 - 1025;
  886. break;
  887. }
  888. if (transmit(bc, cnt, stat))
  889. goto epptimeout;
  890. GETTICK(time2);
  891. /* do receiver */
  892. while ((stat & (EPP_NRAEF|EPP_NRHF)) != EPP_NRHF) {
  893. switch (stat & (EPP_NRAEF|EPP_NRHF)) {
  894. case EPP_NRAEF:
  895. cnt = 1025;
  896. break;
  898. case 0:
  899. cnt = 1793;
  900. break;
  902. default:
  903. cnt = 256;
  904. break;
  905. }
  906. if (receive(dev, cnt))
  907. goto epptimeout;
  908. if (pp->ops->epp_read_addr(pp, &stat, 1, 0) != 1)
  909. goto epptimeout;
  910. }
  911. cnt = 0;
  912. if (bc->bitrate < 50000)
  913. cnt = 256;
  914. else if (bc->bitrate < 100000)
  915. cnt = 128;
  916. while (cnt > 0 && stat & EPP_NREF) {
  917. if (receive(dev, 1))
  918. goto epptimeout;
  919. cnt--;
  920. if (pp->ops->epp_read_addr(pp, &stat, 1, 0) != 1)
  921. goto epptimeout;
  922. }
  923. }
  924. GETTICK(time3);
  925. #ifdef BAYCOM_DEBUG
  926. bc->debug_vals.mod_cycles = time2 - time1;
  927. bc->debug_vals.demod_cycles = time3 - time2;
  928. #endif /* BAYCOM_DEBUG */
  929. queue_task(&bc->run_bh, &tq_timer);
  930. if (!bc->skb)
  931. netif_wake_queue(dev);
  932. return;
  933.  epptimeout:
  934. printk(KERN_ERR "%s: EPP timeout!n", bc_drvname);
  935. }
  937. /* ---------------------------------------------------------------------- */
  938. /*
  939.  * ===================== network driver interface =========================
  940.  */
  942. static int baycom_send_packet(struct sk_buff *skb, struct net_device *dev)
  943. {
  944. struct baycom_state *bc;
  946. baycom_paranoia_check(dev, "baycom_send_packet", 0);
  947. bc = (struct baycom_state *)dev->priv;
  948. if (skb->data[0] != 0) {
  949. do_kiss_params(bc, skb->data, skb->len);
  950. dev_kfree_skb(skb);
  951. return 0;
  952. }
  953. if (bc->skb)
  954. return -1;
  955. /* strip KISS byte */
  956. if (skb->len >= HDLCDRV_MAXFLEN+1 || skb->len < 3) {
  957. dev_kfree_skb(skb);
  958. return 0;
  959. }
  960. netif_stop_queue(dev);
  961. bc->skb = skb;
  962. return 0;
  963. }
  965. /* --------------------------------------------------------------------- */
  967. static int baycom_set_mac_address(struct net_device *dev, void *addr)
  968. {
  969. struct sockaddr *sa = (struct sockaddr *)addr;
  971. /* addr is an AX.25 shifted ASCII mac address */
  972. memcpy(dev->dev_addr, sa->sa_data, dev->addr_len); 
  973. return 0;                                         
  974. }
  976. /* --------------------------------------------------------------------- */
  978. static struct net_device_stats *baycom_get_stats(struct net_device *dev)
  979. {
  980. struct baycom_state *bc;
  982. baycom_paranoia_check(dev, "baycom_get_stats", NULL);
  983. bc = (struct baycom_state *)dev->priv;
  984. /* 
  985.  * Get the current statistics.  This may be called with the
  986.  * card open or closed. 
  987.  */
  988. return &bc->stats;
  989. }
  991. /* --------------------------------------------------------------------- */
  993. static void epp_wakeup(void *handle)
  994. {
  995.         struct net_device *dev = (struct net_device *)handle;
  996.         struct baycom_state *bc;
  998. baycom_paranoia_check_void(dev, "epp_wakeup");
  999.         bc = (struct baycom_state *)dev->priv;
  1000.         printk(KERN_DEBUG "baycom_epp: %s: why am I being woken up?n", dev->name);
  1001.         if (!parport_claim(bc->pdev))
  1002.                 printk(KERN_DEBUG "baycom_epp: %s: I'm broken.n", dev->name);
  1003. }
  1005. /* --------------------------------------------------------------------- */
  1007. /*
  1008.  * Open/initialize the board. This is called (in the current kernel)
  1009.  * sometime after booting when the 'ifconfig' program is run.
  1010.  *
  1011.  * This routine should set everything up anew at each open, even
  1012.  * registers that "should" only need to be set once at boot, so that
  1013.  * there is non-reboot way to recover if something goes wrong.
  1014.  */
  1016. static int epp_open(struct net_device *dev)
  1017. {
  1018. struct baycom_state *bc;
  1019.         struct parport *pp;
  1020. const struct tq_struct run_bh = {
  1021. routine: (void *)(void *)epp_bh,
  1022. data: dev
  1023. };
  1024. unsigned int i, j;
  1025. unsigned char tmp[128];
  1026. unsigned char stat;
  1027. unsigned long tstart;
  1029. baycom_paranoia_check(dev, "epp_open", -ENXIO);
  1030. bc = (struct baycom_state *)dev->priv;
  1031.         pp = parport_enumerate();
  1032.         while (pp && pp->base != dev->base_addr) 
  1033.                 pp = pp->next;
  1034.         if (!pp) {
  1035.                 printk(KERN_ERR "%s: parport at 0x%lx unknownn", bc_drvname, dev->base_addr);
  1036.                 return -ENXIO;
  1037.         }
  1038. #if 0
  1039.         if (pp->irq < 0) {
  1040.                 printk(KERN_ERR "%s: parport at 0x%lx has no irqn", bc_drvname, pp->base);
  1041.                 return -ENXIO;
  1042.         }
  1043. #endif
  1044. if ((~pp->modes) & (PARPORT_MODE_TRISTATE | PARPORT_MODE_PCSPP | PARPORT_MODE_SAFEININT)) {
  1045.                 printk(KERN_ERR "%s: parport at 0x%lx cannot be usedn",
  1046.        bc_drvname, pp->base);
  1047.                 return -EIO;
  1048. }
  1049. memset(&bc->modem, 0, sizeof(bc->modem));
  1050.         if (!(bc->pdev = parport_register_device(pp, dev->name, NULL, epp_wakeup, 
  1051.                                                  epp_interrupt, PARPORT_DEV_EXCL, dev))) {
  1052.                 printk(KERN_ERR "%s: cannot register parport at 0x%lxn", bc_drvname, pp->base);
  1053.                 return -ENXIO;
  1054.         }
  1055.         if (parport_claim(bc->pdev)) {
  1056.                 printk(KERN_ERR "%s: parport at 0x%lx busyn", bc_drvname, pp->base);
  1057.                 parport_unregister_device(bc->pdev);
  1058.                 return -EBUSY;
  1059.         }
  1060.         dev->irq = /*pp->irq*/ 0;
  1061. bc->run_bh = run_bh;
  1062. bc->bh_running = 1;
  1063. bc->modem = EPP_CONVENTIONAL;
  1064. if (eppconfig(bc))
  1065. printk(KERN_INFO "%s: no FPGA detected, assuming conventional EPP modemn", bc_drvname);
  1066. else
  1067. bc->modem = /*EPP_FPGA*/ EPP_FPGAEXTSTATUS;
  1068. parport_write_control(pp, LPTCTRL_PROGRAM); /* prepare EPP mode; we aren't using interrupts */
  1069. /* reset the modem */
  1070. tmp[0] = 0;
  1071. tmp[1] = EPP_TX_FIFO_ENABLE|EPP_RX_FIFO_ENABLE|EPP_MODEM_ENABLE;
  1072. if (pp->ops->epp_write_addr(pp, tmp, 2, 0) != 2)
  1073. goto epptimeout;
  1074. /* autoprobe baud rate */
  1075. tstart = jiffies;
  1076. i = 0;
  1077. while ((signed)(jiffies-tstart-HZ/3) < 0) {
  1078. if (pp->ops->epp_read_addr(pp, &stat, 1, 0) != 1)
  1079. goto epptimeout;
  1080. if ((stat & (EPP_NRAEF|EPP_NRHF)) == EPP_NRHF) {
  1081. schedule();
  1082. continue;
  1083. }
  1084. if (pp->ops->epp_read_data(pp, tmp, 128, 0) != 128)
  1085. goto epptimeout;
  1086. if (pp->ops->epp_read_data(pp, tmp, 128, 0) != 128)
  1087. goto epptimeout;
  1088. i += 256;
  1089. }
  1090. for (j = 0; j < 256; j++) {
  1091. if (pp->ops->epp_read_addr(pp, &stat, 1, 0) != 1)
  1092. goto epptimeout;
  1093. if (!(stat & EPP_NREF))
  1094. break;
  1095. if (pp->ops->epp_read_data(pp, tmp, 1, 0) != 1)
  1096. goto epptimeout;
  1097. i++;
  1098. }
  1099. tstart = jiffies - tstart;
  1100. bc->bitrate = i * (8 * HZ) / tstart;
  1101. j = 1;
  1102. i = bc->bitrate >> 3;
  1103. while (j < 7 && i > 150) {
  1104. j++;
  1105. i >>= 1;
  1106. }
  1107. printk(KERN_INFO "%s: autoprobed bitrate: %d  int divider: %d  int rate: %dn", 
  1108.        bc_drvname, bc->bitrate, j, bc->bitrate >> (j+2));
  1109. tmp[0] = EPP_TX_FIFO_ENABLE|EPP_RX_FIFO_ENABLE|EPP_MODEM_ENABLE/*|j*/;
  1110. if (pp->ops->epp_write_addr(pp, tmp, 1, 0) != 1)
  1111. goto epptimeout;
  1112. /*
  1113.  * initialise hdlc variables
  1114.  */
  1115. bc->hdlcrx.state = 0;
  1116. bc->hdlcrx.numbits = 0;
  1117. bc->hdlctx.state = tx_idle;
  1118. bc->hdlctx.bufcnt = 0;
  1119. bc->hdlctx.slotcnt = bc->ch_params.slottime;
  1120. bc->hdlctx.calibrate = 0;
  1121. /* start the bottom half stuff */
  1122. queue_task(&bc->run_bh, &tq_timer);
  1123. netif_start_queue(dev);
  1124. MOD_INC_USE_COUNT;
  1125. return 0;
  1127.  epptimeout:
  1128. printk(KERN_ERR "%s: epp timeout during bitrate proben", bc_drvname);
  1129. parport_write_control(pp, 0); /* reset the adapter */
  1130.         parport_release(bc->pdev);
  1131.         parport_unregister_device(bc->pdev);
  1132. return -EIO;
  1133. }
  1135. /* --------------------------------------------------------------------- */
  1137. static int epp_close(struct net_device *dev)
  1138. {
  1139. struct baycom_state *bc;
  1140. struct parport *pp;
  1141. unsigned char tmp[1];
  1143. baycom_paranoia_check(dev, "epp_close", -EINVAL);
  1144. bc = (struct baycom_state *)dev->priv;
  1145. pp = bc->pdev->port;
  1146. bc->bh_running = 0;
  1147. run_task_queue(&tq_timer);  /* dequeue bottom half */
  1148. bc->stat = EPP_DCDBIT;
  1149. tmp[0] = 0;
  1150. pp->ops->epp_write_addr(pp, tmp, 1, 0);
  1151. parport_write_control(pp, 0); /* reset the adapter */
  1152.         parport_release(bc->pdev);
  1153.         parport_unregister_device(bc->pdev);
  1154. if (bc->skb)
  1155. dev_kfree_skb(bc->skb);
  1156. bc->skb = NULL;
  1157. printk(KERN_INFO "%s: close epp at iobase 0x%lx irq %un",
  1158.        bc_drvname, dev->base_addr, dev->irq);
  1159. MOD_DEC_USE_COUNT;
  1160. return 0;
  1161. }
  1163. /* --------------------------------------------------------------------- */
  1165. static int baycom_setmode(struct baycom_state *bc, const char *modestr)
  1166. {
  1167. const char *cp;
  1169. if (strstr(modestr,"intclk"))
  1170. bc->cfg.intclk = 1;
  1171. if (strstr(modestr,"extclk"))
  1172. bc->cfg.intclk = 0;
  1173. if (strstr(modestr,"intmodem"))
  1174. bc->cfg.extmodem = 0;
  1175. if (strstr(modestr,"extmodem"))
  1176. bc->cfg.extmodem = 1;
  1177. if (strstr(modestr,"noloopback"))
  1178. bc->cfg.loopback = 0;
  1179. if (strstr(modestr,"loopback"))
  1180. bc->cfg.loopback = 1;
  1181. if ((cp = strstr(modestr,"fclk="))) {
  1182. bc->cfg.fclk = simple_strtoul(cp+5, NULL, 0);
  1183. if (bc->cfg.fclk < 1000000)
  1184. bc->cfg.fclk = 1000000;
  1185. if (bc->cfg.fclk > 25000000)
  1186. bc->cfg.fclk = 25000000;
  1187. }
  1188. if ((cp = strstr(modestr,"bps="))) {
  1189. bc->cfg.bps = simple_strtoul(cp+4, NULL, 0);
  1190. if (bc->cfg.bps < 1000)
  1191. bc->cfg.bps = 1000;
  1192. if (bc->cfg.bps > 1500000)
  1193. bc->cfg.bps = 1500000;
  1194. }
  1195. return 0;
  1196. }
  1198. /* --------------------------------------------------------------------- */
  1200. static int baycom_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
  1201. {
  1202. struct baycom_state *bc;
  1203. struct baycom_ioctl bi;
  1204. struct hdlcdrv_ioctl hi;
  1205. struct sm_ioctl si;
  1207. baycom_paranoia_check(dev, "baycom_ioctl", -EINVAL);
  1208. bc = (struct baycom_state *)dev->priv;
  1209. if (cmd != SIOCDEVPRIVATE)
  1210. return -ENOIOCTLCMD;
  1211. if (get_user(cmd, (int *)ifr->ifr_data))
  1212. return -EFAULT;
  1213. #ifdef BAYCOM_DEBUG
  1214. if (cmd == BAYCOMCTL_GETDEBUG) {
  1215. bi.data.dbg.debug1 = bc->ptt_keyed;
  1216. bi.data.dbg.debug2 = bc->debug_vals.last_intcnt;
  1217. bi.data.dbg.debug3 = bc->debug_vals.last_pllcorr;
  1218. bc->debug_vals.last_intcnt = 0;
  1219. if (copy_to_user(ifr->ifr_data, &bi, sizeof(bi)))
  1220. return -EFAULT;
  1221. return 0;
  1222. }
  1223. if (cmd == SMCTL_GETDEBUG) {
  1224.                 si.data.dbg.int_rate = bc->debug_vals.last_intcnt;
  1225.                 si.data.dbg.mod_cycles = bc->debug_vals.mod_cycles;
  1226.                 si.data.dbg.demod_cycles = bc->debug_vals.demod_cycles;
  1227.                 si.data.dbg.dma_residue = 0;
  1228.                 bc->debug_vals.mod_cycles = bc->debug_vals.demod_cycles = 0;
  1229. bc->debug_vals.last_intcnt = 0;
  1230.                 if (copy_to_user(ifr->ifr_data, &si, sizeof(si)))
  1231.                         return -EFAULT;
  1232.                 return 0;
  1233. }
  1234. #endif /* BAYCOM_DEBUG */
  1236. if (copy_from_user(&hi, ifr->ifr_data, sizeof(hi)))
  1237. return -EFAULT;
  1238. switch (hi.cmd) {
  1239. default:
  1240. return -ENOIOCTLCMD;
  1242. case HDLCDRVCTL_GETCHANNELPAR:
  1243. hi.data.cp.tx_delay = bc->ch_params.tx_delay;
  1244. hi.data.cp.tx_tail = bc->ch_params.tx_tail;
  1245. hi.data.cp.slottime = bc->ch_params.slottime;
  1246. hi.data.cp.ppersist = bc->ch_params.ppersist;
  1247. hi.data.cp.fulldup = bc->ch_params.fulldup;
  1248. break;
  1250. case HDLCDRVCTL_SETCHANNELPAR:
  1251. if (!capable(CAP_NET_ADMIN))
  1252. return -EACCES;
  1253. bc->ch_params.tx_delay = hi.data.cp.tx_delay;
  1254. bc->ch_params.tx_tail = hi.data.cp.tx_tail;
  1255. bc->ch_params.slottime = hi.data.cp.slottime;
  1256. bc->ch_params.ppersist = hi.data.cp.ppersist;
  1257. bc->ch_params.fulldup = hi.data.cp.fulldup;
  1258. bc->hdlctx.slotcnt = 1;
  1259. return 0;
  1261. case HDLCDRVCTL_GETMODEMPAR:
  1262. hi.data.mp.iobase = dev->base_addr;
  1263. hi.data.mp.irq = dev->irq;
  1264. hi.data.mp.dma = dev->dma;
  1265. hi.data.mp.dma2 = 0;
  1266. hi.data.mp.seriobase = 0;
  1267. hi.data.mp.pariobase = 0;
  1268. hi.data.mp.midiiobase = 0;
  1269. break;
  1271. case HDLCDRVCTL_SETMODEMPAR:
  1272. if ((!capable(CAP_SYS_RAWIO)) || netif_running(dev))
  1273. return -EACCES;
  1274. dev->base_addr = hi.data.mp.iobase;
  1275. dev->irq = /*hi.data.mp.irq*/0;
  1276. dev->dma = /*hi.data.mp.dma*/0;
  1277. return 0;
  1279. case HDLCDRVCTL_GETSTAT:
  1280. hi.data.cs.ptt = !!(bc->stat & EPP_PTTBIT);
  1281. hi.data.cs.dcd = !(bc->stat & EPP_DCDBIT);
  1282. hi.data.cs.ptt_keyed = bc->ptt_keyed;
  1283. hi.data.cs.tx_packets = bc->stats.tx_packets;
  1284. hi.data.cs.tx_errors = bc->stats.tx_errors;
  1285. hi.data.cs.rx_packets = bc->stats.rx_packets;
  1286. hi.data.cs.rx_errors = bc->stats.rx_errors;
  1287. break;
  1289. case HDLCDRVCTL_OLDGETSTAT:
  1290. hi.data.ocs.ptt = !!(bc->stat & EPP_PTTBIT);
  1291. hi.data.ocs.dcd = !(bc->stat & EPP_DCDBIT);
  1292. hi.data.ocs.ptt_keyed = bc->ptt_keyed;
  1293. break;
  1295. case HDLCDRVCTL_CALIBRATE:
  1296. if (!capable(CAP_SYS_RAWIO))
  1297. return -EACCES;
  1298. bc->hdlctx.calibrate = hi.data.calibrate * bc->bitrate / 8;
  1299. return 0;
  1301. case HDLCDRVCTL_DRIVERNAME:
  1302. strncpy(hi.data.drivername, "baycom_epp", sizeof(hi.data.drivername));
  1303. break;
  1305. case HDLCDRVCTL_GETMODE:
  1306. sprintf(hi.data.modename, "%sclk,%smodem,fclk=%d,bps=%d%s", 
  1307. bc->cfg.intclk ? "int" : "ext",
  1308. bc->cfg.extmodem ? "ext" : "int", bc->cfg.fclk, bc->cfg.bps,
  1309. bc->cfg.loopback ? ",loopback" : "");
  1310. break;
  1312. case HDLCDRVCTL_SETMODE:
  1313. if (!capable(CAP_NET_ADMIN) || netif_running(dev))
  1314. return -EACCES;
  1315. hi.data.modename[sizeof(hi.data.modename)-1] = '';
  1316. return baycom_setmode(bc, hi.data.modename);
  1318. case HDLCDRVCTL_MODELIST:
  1319. strncpy(hi.data.modename, "intclk,extclk,intmodem,extmodem,divider=x",
  1320. sizeof(hi.data.modename));
  1321. break;
  1323. case HDLCDRVCTL_MODEMPARMASK:
  1324. return HDLCDRV_PARMASK_IOBASE;
  1326. }
  1327. if (copy_to_user(ifr->ifr_data, &hi, sizeof(hi)))
  1328. return -EFAULT;
  1329. return 0;
  1330. }
  1332. /* --------------------------------------------------------------------- */
  1334. /*
  1335.  * Check for a network adaptor of this type, and return '0' if one exists.
  1336.  * If dev->base_addr == 0, probe all likely locations.
  1337.  * If dev->base_addr == 1, always return failure.
  1338.  * If dev->base_addr == 2, allocate space for the device and return success
  1339.  * (detachable devices only).
  1340.  */
  1341. static int baycom_probe(struct net_device *dev)
  1342. {
  1343. static char ax25_bcast[AX25_ADDR_LEN] = {
  1344. 'Q' << 1, 'S' << 1, 'T' << 1, ' ' << 1, ' ' << 1, ' ' << 1, '0' << 1
  1345. };
  1346. static char ax25_nocall[AX25_ADDR_LEN] = {
  1347. 'L' << 1, 'I' << 1, 'N' << 1, 'U' << 1, 'X' << 1, ' ' << 1, '1' << 1
  1348. };
  1349. const struct hdlcdrv_channel_params dflt_ch_params = { 
  1350. 20, 2, 10, 40, 0 
  1351. };
  1352. struct baycom_state *bc;
  1354. if (!dev)
  1355. return -ENXIO;
  1356. baycom_paranoia_check(dev, "baycom_probe", -ENXIO);
  1357. /*
  1358.  * not a real probe! only initialize data structures
  1359.  */
  1360. bc = (struct baycom_state *)dev->priv;
  1361. /*
  1362.  * initialize the baycom_state struct
  1363.  */
  1364. bc->ch_params = dflt_ch_params;
  1365. bc->ptt_keyed = 0;
  1367. /*
  1368.  * initialize the device struct
  1369.  */
  1370. dev->open = epp_open;
  1371. dev->stop = epp_close;
  1372. dev->do_ioctl = baycom_ioctl;
  1373. dev->hard_start_xmit = baycom_send_packet;
  1374. dev->get_stats = baycom_get_stats;
  1376. /* Fill in the fields of the device structure */
  1377. bc->skb = NULL;
  1379. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  1380. dev->hard_header = ax25_encapsulate;
  1381. dev->rebuild_header = ax25_rebuild_header;
  1382. #else /* CONFIG_AX25 || CONFIG_AX25_MODULE */
  1383. dev->hard_header = NULL;
  1384. dev->rebuild_header = NULL;
  1385. #endif /* CONFIG_AX25 || CONFIG_AX25_MODULE */
  1386. dev->set_mac_address = baycom_set_mac_address;
  1388. dev->type = ARPHRD_AX25;           /* AF_AX25 device */
  1389. dev->hard_header_len = AX25_MAX_HEADER_LEN + AX25_BPQ_HEADER_LEN;
  1390. dev->mtu = AX25_DEF_PACLEN;        /* eth_mtu is the default */
  1391. dev->addr_len = AX25_ADDR_LEN;     /* sizeof an ax.25 address */
  1392. memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
  1393. memcpy(dev->dev_addr, ax25_nocall, AX25_ADDR_LEN);
  1394. dev->tx_queue_len = 16;
  1396. /* New style flags */
  1397. dev->flags = 0;
  1399. return 0;
  1400. }
  1402. /* --------------------------------------------------------------------- */
  1404. /*
  1405.  * command line settable parameters
  1406.  */
  1407. static const char *mode[NR_PORTS] = { "", };
  1408. static int iobase[NR_PORTS] = { 0x378, };
  1410. MODULE_PARM(mode, "1-" __MODULE_STRING(NR_PORTS) "s");
  1411. MODULE_PARM_DESC(mode, "baycom operating mode");
  1412. MODULE_PARM(iobase, "1-" __MODULE_STRING(NR_PORTS) "i");
  1413. MODULE_PARM_DESC(iobase, "baycom io base address");
  1415. MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
  1416. MODULE_DESCRIPTION("Baycom epp amateur radio modem driver");
  1417. MODULE_LICENSE("GPL");
  1419. /* --------------------------------------------------------------------- */
  1421. static int __init init_baycomepp(void)
  1422. {
  1423. struct net_device *dev;
  1424. int i, found = 0;
  1425. char set_hw = 1;
  1426. struct baycom_state *bc;
  1428. printk(bc_drvinfo);
  1429. /*
  1430.  * register net devices
  1431.  */
  1432. for (i = 0; i < NR_PORTS; i++) {
  1433. dev = baycom_device+i;
  1434. if (!mode[i])
  1435. set_hw = 0;
  1436. if (!set_hw)
  1437. iobase[i] = 0;
  1438. memset(dev, 0, sizeof(struct net_device));
  1439. if (!(bc = dev->priv = kmalloc(sizeof(struct baycom_state), GFP_KERNEL)))
  1440. return -ENOMEM;
  1441. /*
  1442.  * initialize part of the baycom_state struct
  1443.  */
  1444. memset(bc, 0, sizeof(struct baycom_state));
  1445. bc->magic = BAYCOM_MAGIC;
  1446. sprintf(dev->name, "bce%d", i);
  1447. bc->cfg.fclk = 19666600;
  1448. bc->cfg.bps = 9600;
  1449. /*
  1450.  * initialize part of the device struct
  1451.  */
  1452. dev->if_port = 0;
  1453. dev->init = baycom_probe;
  1454. dev->base_addr = iobase[i];
  1455. dev->irq = 0;
  1456. dev->dma = 0;
  1457. if (register_netdev(dev)) {
  1458. printk(KERN_WARNING "%s: cannot register net device %sn", bc_drvname, dev->name);
  1459. kfree(dev->priv);
  1460. return -ENXIO;
  1461. }
  1462. if (set_hw && baycom_setmode(bc, mode[i]))
  1463. set_hw = 0;
  1464. found++;
  1465. }
  1466. if (!found)
  1467. return -ENXIO;
  1468. return 0;
  1469. }
  1471. static void __exit cleanup_baycomepp(void)
  1472. {
  1473. struct net_device *dev;
  1474. struct baycom_state *bc;
  1475. int i;
  1477. for(i = 0; i < NR_PORTS; i++) {
  1478. dev = baycom_device+i;
  1479. bc = (struct baycom_state *)dev->priv;
  1480. if (bc) {
  1481. if (bc->magic == BAYCOM_MAGIC) {
  1482. unregister_netdev(dev);
  1483. kfree(dev->priv);
  1484. } else
  1485. printk(paranoia_str, "cleanup_module");
  1486. }
  1487. }
  1488. }
  1490. module_init(init_baycomepp);
  1491. module_exit(cleanup_baycomepp);
  1493. /* --------------------------------------------------------------------- */
  1495. #ifndef MODULE
  1497. /*
  1498.  * format: baycom_epp=io,mode
  1499.  * mode: fpga config options
  1500.  */
  1502. static int __init baycom_epp_setup(char *str)
  1503. {
  1504.         static unsigned __initdata nr_dev = 0;
  1505. int ints[2];
  1507.         if (nr_dev >= NR_PORTS)
  1508.                 return 0;
  1509. str = get_options(str, 2, ints);
  1510. if (ints[0] < 1)
  1511. return 0;
  1512. mode[nr_dev] = str;
  1513. iobase[nr_dev] = ints[1];
  1514. nr_dev++;
  1515. return 1;
  1516. }
  1518. __setup("baycom_epp=", baycom_epp_setup);
  1520. #endif /* MODULE */
  1521. /* --------------------------------------------------------------------- */