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

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

Linux/Unix编程

开发平台：

Unix_Linux

hdlcdrv.c：源码内容
  1. /*****************************************************************************/
  3. /*
  4.  * hdlcdrv.c  -- HDLC packet radio network driver.
  5.  *
  6.  * Copyright (C) 1996-2000  Thomas Sailer (sailer@ife.ee.ethz.ch)
  7.  *
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation; either version 2 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  *
  22.  *  Please note that the GPL allows you to use the driver, NOT the radio.
  23.  *  In order to use the radio, you need a license from the communications
  24.  *  authority of your country.
  25.  *
  26.  *  The driver was derived from Donald Beckers skeleton.c
  27.  * Written 1993-94 by Donald Becker.
  28.  *
  29.  *  History:
  30.  *   0.1  21.09.1996  Started
  31.  *        18.10.1996  Changed to new user space access routines 
  32.  *                    (copy_{to,from}_user)
  33.  *   0.2  21.11.1996  various small changes
  34.  *   0.3  03.03.1997  fixed (hopefully) IP not working with ax.25 as a module
  35.  *   0.4  16.04.1997  init code/data tagged
  36.  *   0.5  30.07.1997  made HDLC buffers bigger (solves a problem with the
  37.  *                    soundmodem driver)
  38.  *   0.6  05.04.1998  add spinlocks
  39.  *   0.7  03.08.1999  removed some old compatibility cruft
  40.  *   0.8  12.02.2000  adapted to softnet driver interface
  41.  */
  43. /*****************************************************************************/
  45. #include <linux/config.h>
  46. #include <linux/version.h>
  47. #include <linux/module.h>
  48. #include <linux/types.h>
  49. #include <linux/net.h>
  50. #include <linux/in.h>
  51. #include <linux/if.h>
  52. #include <linux/slab.h>
  53. #include <linux/errno.h>
  54. #include <linux/init.h>
  55. #include <asm/bitops.h>
  56. #include <asm/uaccess.h>
  58. #include <linux/netdevice.h>
  59. #include <linux/if_arp.h>
  60. #include <linux/etherdevice.h>
  61. #include <linux/skbuff.h>
  62. #include <linux/hdlcdrv.h>
  63. /* prototypes for ax25_encapsulate and ax25_rebuild_header */
  64. #include <net/ax25.h> 
  66. /* make genksyms happy */
  67. #include <linux/ip.h>
  68. #include <linux/udp.h>
  69. #include <linux/tcp.h>
  71. /* --------------------------------------------------------------------- */
  73. /*
  74.  * The name of the card. Is used for messages and in the requests for
  75.  * io regions, irqs and dma channels
  76.  */
  78. static char ax25_bcast[AX25_ADDR_LEN] =
  79. {'Q' << 1, 'S' << 1, 'T' << 1, ' ' << 1, ' ' << 1, ' ' << 1, '0' << 1};
  80. static char ax25_nocall[AX25_ADDR_LEN] =
  81. {'L' << 1, 'I' << 1, 'N' << 1, 'U' << 1, 'X' << 1, ' ' << 1, '1' << 1};
  83. /* --------------------------------------------------------------------- */
  85. #define KISS_VERBOSE
  87. /* --------------------------------------------------------------------- */
  89. #define PARAM_TXDELAY   1
  90. #define PARAM_PERSIST   2
  91. #define PARAM_SLOTTIME  3
  92. #define PARAM_TXTAIL    4
  93. #define PARAM_FULLDUP   5
  94. #define PARAM_HARDWARE  6
  95. #define PARAM_RETURN    255
  97. /* --------------------------------------------------------------------- */
  98. /*
  99.  * the CRC routines are stolen from WAMPES
  100.  * by Dieter Deyke
  101.  */
  103. static const unsigned short crc_ccitt_table[] = {
  104. 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
  105. 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
  106. 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
  107. 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
  108. 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
  109. 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
  110. 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
  111. 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
  112. 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
  113. 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
  114. 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
  115. 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
  116. 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
  117. 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
  118. 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
  119. 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
  120. 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
  121. 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
  122. 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
  123. 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
  124. 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
  125. 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
  126. 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
  127. 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
  128. 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
  129. 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
  130. 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
  131. 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
  132. 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
  133. 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
  134. 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
  135. 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
  136. };
  138. /*---------------------------------------------------------------------------*/
  140. static inline void append_crc_ccitt(unsigned char *buffer, int len)
  141. {
  142.   unsigned int crc = 0xffff;
  144. for (;len>0;len--)
  145. crc = (crc >> 8) ^ crc_ccitt_table[(crc ^ *buffer++) & 0xff];
  146. crc ^= 0xffff;
  147. *buffer++ = crc;
  148. *buffer++ = crc >> 8;
  149. }
  151. /*---------------------------------------------------------------------------*/
  153. static inline int check_crc_ccitt(const unsigned char *buf, int cnt)
  154. {
  155. unsigned int crc = 0xffff;
  157. for (; cnt > 0; cnt--)
  158. crc = (crc >> 8) ^ crc_ccitt_table[(crc ^ *buf++) & 0xff];
  159. return (crc & 0xffff) == 0xf0b8;
  160. }
  162. /*---------------------------------------------------------------------------*/
  164. #if 0
  165. static int calc_crc_ccitt(const unsigned char *buf, int cnt)
  166. {
  167. unsigned int crc = 0xffff;
  169. for (; cnt > 0; cnt--)
  170. crc = (crc >> 8) ^ crc_ccitt_table[(crc ^ *buf++) & 0xff];
  171. crc ^= 0xffff;
  172. return (crc & 0xffff);
  173. }
  174. #endif
  176. /* ---------------------------------------------------------------------- */
  178. #define tenms_to_2flags(s,tenms) ((tenms * s->par.bitrate) / 100 / 16)
  180. /* ---------------------------------------------------------------------- */
  181. /*
  182.  * The HDLC routines
  183.  */
  185. static int hdlc_rx_add_bytes(struct hdlcdrv_state *s, unsigned int bits, 
  186.      int num)
  187. {
  188. int added = 0;
  190. while (s->hdlcrx.rx_state && num >= 8) {
  191. if (s->hdlcrx.len >= sizeof(s->hdlcrx.buffer)) {
  192. s->hdlcrx.rx_state = 0;
  193. return 0;
  194. }
  195. *s->hdlcrx.bp++ = bits >> (32-num);
  196. s->hdlcrx.len++;
  197. num -= 8;
  198. added += 8;
  199. }
  200. return added;
  201. }
  203. static void hdlc_rx_flag(struct net_device *dev, struct hdlcdrv_state *s)
  204. {
  205. struct sk_buff *skb;
  206. int pkt_len;
  207. unsigned char *cp;
  209. if (s->hdlcrx.len < 4) 
  210. return;
  211. if (!check_crc_ccitt(s->hdlcrx.buffer, s->hdlcrx.len)) 
  212. return;
  213. pkt_len = s->hdlcrx.len - 2 + 1; /* KISS kludge */
  214. if (!(skb = dev_alloc_skb(pkt_len))) {
  215. printk("%s: memory squeeze, dropping packetn", dev->name);
  216. s->stats.rx_dropped++;
  217. return;
  218. }
  219. skb->dev = dev;
  220. cp = skb_put(skb, pkt_len);
  221. *cp++ = 0; /* KISS kludge */
  222. memcpy(cp, s->hdlcrx.buffer, pkt_len - 1);
  223. skb->protocol = htons(ETH_P_AX25);
  224. skb->mac.raw = skb->data;
  225. netif_rx(skb);
  226. s->stats.rx_packets++;
  227. }
  229. void hdlcdrv_receiver(struct net_device *dev, struct hdlcdrv_state *s)
  230. {
  231. int i;
  232. unsigned int mask1, mask2, mask3, mask4, mask5, mask6, word;
  234. if (!s || s->magic != HDLCDRV_MAGIC) 
  235. return;
  236. if (test_and_set_bit(0, &s->hdlcrx.in_hdlc_rx))
  237. return;
  239. while (!hdlcdrv_hbuf_empty(&s->hdlcrx.hbuf)) {
  240. word = hdlcdrv_hbuf_get(&s->hdlcrx.hbuf);
  242. #ifdef HDLCDRV_DEBUG
  243. hdlcdrv_add_bitbuffer_word(&s->bitbuf_hdlc, word);
  244. #endif /* HDLCDRV_DEBUG */
  245.         s->hdlcrx.bitstream >>= 16;
  246. s->hdlcrx.bitstream |= word << 16;
  247. s->hdlcrx.bitbuf >>= 16;
  248. s->hdlcrx.bitbuf |= word << 16;
  249. s->hdlcrx.numbits += 16;
  250. for(i = 15, mask1 = 0x1fc00, mask2 = 0x1fe00, mask3 = 0x0fc00,
  251.     mask4 = 0x1f800, mask5 = 0xf800, mask6 = 0xffff; 
  252.     i >= 0; 
  253.     i--, mask1 <<= 1, mask2 <<= 1, mask3 <<= 1, mask4 <<= 1, 
  254.     mask5 <<= 1, mask6 = (mask6 << 1) | 1) {
  255. if ((s->hdlcrx.bitstream & mask1) == mask1)
  256. s->hdlcrx.rx_state = 0; /* abort received */
  257. else if ((s->hdlcrx.bitstream & mask2) == mask3) {
  258. /* flag received */
  259. if (s->hdlcrx.rx_state) {
  260. hdlc_rx_add_bytes(s, s->hdlcrx.bitbuf 
  261.   << (8+i),
  262.   s->hdlcrx.numbits
  263.   -8-i);
  264. hdlc_rx_flag(dev, s);
  265. }
  266. s->hdlcrx.len = 0;
  267. s->hdlcrx.bp = s->hdlcrx.buffer;
  268. s->hdlcrx.rx_state = 1;
  269. s->hdlcrx.numbits = i;
  270. } else if ((s->hdlcrx.bitstream & mask4) == mask5) {
  271. /* stuffed bit */
  272. s->hdlcrx.numbits--;
  273. s->hdlcrx.bitbuf = (s->hdlcrx.bitbuf & (~mask6)) |
  274. ((s->hdlcrx.bitbuf & mask6) << 1);
  275. }
  276. }
  277. s->hdlcrx.numbits -= hdlc_rx_add_bytes(s, s->hdlcrx.bitbuf,
  278.        s->hdlcrx.numbits);
  279. }
  280. clear_bit(0, &s->hdlcrx.in_hdlc_rx);
  281. }
  283. /* ---------------------------------------------------------------------- */
  285. static inline void do_kiss_params(struct hdlcdrv_state *s,
  286.   unsigned char *data, unsigned long len)
  287. {
  289. #ifdef KISS_VERBOSE
  290. #define PKP(a,b) printk(KERN_INFO "hdlcdrv.c: channel params: " a "n", b)
  291. #else /* KISS_VERBOSE */       
  292. #define PKP(a,b) 
  293. #endif /* KISS_VERBOSE */       
  295. if (len < 2)
  296. return;
  297. switch(data[0]) {
  298. case PARAM_TXDELAY:
  299. s->ch_params.tx_delay = data[1];
  300. PKP("TX delay = %ums", 10 * s->ch_params.tx_delay);
  301. break;
  302. case PARAM_PERSIST:   
  303. s->ch_params.ppersist = data[1];
  304. PKP("p persistence = %u", s->ch_params.ppersist);
  305. break;
  306. case PARAM_SLOTTIME:  
  307. s->ch_params.slottime = data[1];
  308. PKP("slot time = %ums", s->ch_params.slottime);
  309. break;
  310. case PARAM_TXTAIL:    
  311. s->ch_params.tx_tail = data[1];
  312. PKP("TX tail = %ums", s->ch_params.tx_tail);
  313. break;
  314. case PARAM_FULLDUP:   
  315. s->ch_params.fulldup = !!data[1];
  316. PKP("%s duplex", s->ch_params.fulldup ? "full" : "half");
  317. break;
  318. default:
  319. break;
  320. }
  321. #undef PKP
  322. }
  324. /* ---------------------------------------------------------------------- */
  326. void hdlcdrv_transmitter(struct net_device *dev, struct hdlcdrv_state *s)
  327. {
  328. unsigned int mask1, mask2, mask3;
  329. int i;
  330. struct sk_buff *skb;
  331. int pkt_len;
  333. if (!s || s->magic != HDLCDRV_MAGIC) 
  334. return;
  335. if (test_and_set_bit(0, &s->hdlctx.in_hdlc_tx))
  336. return;
  337. for (;;) {
  338. if (s->hdlctx.numbits >= 16) {
  339. if (hdlcdrv_hbuf_full(&s->hdlctx.hbuf)) {
  340. clear_bit(0, &s->hdlctx.in_hdlc_tx);
  341. return;
  342. }
  343. hdlcdrv_hbuf_put(&s->hdlctx.hbuf, s->hdlctx.bitbuf);
  344. s->hdlctx.bitbuf >>= 16;
  345. s->hdlctx.numbits -= 16;
  346. }
  347. switch (s->hdlctx.tx_state) {
  348. default:
  349. clear_bit(0, &s->hdlctx.in_hdlc_tx);
  350. return;
  351. case 0:
  352. case 1:
  353. if (s->hdlctx.numflags) {
  354. s->hdlctx.numflags--;
  355. s->hdlctx.bitbuf |= 
  356. 0x7e7e << s->hdlctx.numbits;
  357. s->hdlctx.numbits += 16;
  358. break;
  359. }
  360. if (s->hdlctx.tx_state == 1) {
  361. clear_bit(0, &s->hdlctx.in_hdlc_tx);
  362. return;
  363. }
  364. if (!(skb = s->skb)) {
  365. int flgs = tenms_to_2flags(s, s->ch_params.tx_tail);
  366. if (flgs < 2)
  367. flgs = 2;
  368. s->hdlctx.tx_state = 1;
  369. s->hdlctx.numflags = flgs;
  370. break;
  371. }
  372. s->skb = NULL;
  373. netif_wake_queue(dev);
  374. pkt_len = skb->len-1; /* strip KISS byte */
  375. if (pkt_len >= HDLCDRV_MAXFLEN || pkt_len < 2) {
  376. s->hdlctx.tx_state = 0;
  377. s->hdlctx.numflags = 1;
  378. dev_kfree_skb_irq(skb);
  379. break;
  380. }
  381. memcpy(s->hdlctx.buffer, skb->data+1, pkt_len);
  382. dev_kfree_skb_irq(skb);
  383. s->hdlctx.bp = s->hdlctx.buffer;
  384. append_crc_ccitt(s->hdlctx.buffer, pkt_len);
  385. s->hdlctx.len = pkt_len+2; /* the appended CRC */
  386. s->hdlctx.tx_state = 2;
  387. s->hdlctx.bitstream = 0;
  388. s->stats.tx_packets++;
  389. break;
  390. case 2:
  391. if (!s->hdlctx.len) {
  392. s->hdlctx.tx_state = 0;
  393. s->hdlctx.numflags = 1;
  394. break;
  395. }
  396. s->hdlctx.len--;
  397. s->hdlctx.bitbuf |= *s->hdlctx.bp <<
  398. s->hdlctx.numbits;
  399. s->hdlctx.bitstream >>= 8;
  400. s->hdlctx.bitstream |= (*s->hdlctx.bp++) << 16;
  401. mask1 = 0x1f000;
  402. mask2 = 0x10000;
  403. mask3 = 0xffffffff >> (31-s->hdlctx.numbits);
  404. s->hdlctx.numbits += 8;
  405. for(i = 0; i < 8; i++, mask1 <<= 1, mask2 <<= 1, 
  406.     mask3 = (mask3 << 1) | 1) {
  407. if ((s->hdlctx.bitstream & mask1) != mask1) 
  408. continue;
  409. s->hdlctx.bitstream &= ~mask2;
  410. s->hdlctx.bitbuf = 
  411. (s->hdlctx.bitbuf & mask3) |
  412. ((s->hdlctx.bitbuf & 
  413.  (~mask3)) << 1);
  414. s->hdlctx.numbits++;
  415. mask3 = (mask3 << 1) | 1;
  416. }
  417. break;
  418. }
  419. }
  420. }
  422. /* ---------------------------------------------------------------------- */
  424. static void start_tx(struct net_device *dev, struct hdlcdrv_state *s)
  425. {
  426. s->hdlctx.tx_state = 0;
  427. s->hdlctx.numflags = tenms_to_2flags(s, s->ch_params.tx_delay);
  428. s->hdlctx.bitbuf = s->hdlctx.bitstream = s->hdlctx.numbits = 0;
  429. hdlcdrv_transmitter(dev, s);
  430. s->hdlctx.ptt = 1;
  431. s->ptt_keyed++;
  432. }
  434. /* ---------------------------------------------------------------------- */
  436. static unsigned short random_seed;
  438. static inline unsigned short random_num(void)
  439. {
  440. random_seed = 28629 * random_seed + 157;
  441. return random_seed;
  442. }
  444. /* ---------------------------------------------------------------------- */
  446. void hdlcdrv_arbitrate(struct net_device *dev, struct hdlcdrv_state *s)
  447. {
  448. if (!s || s->magic != HDLCDRV_MAGIC || s->hdlctx.ptt || !s->skb) 
  449. return;
  450. if (s->ch_params.fulldup) {
  451. start_tx(dev, s);
  452. return;
  453. }
  454. if (s->hdlcrx.dcd) {
  455. s->hdlctx.slotcnt = s->ch_params.slottime;
  456. return;
  457. }
  458. if ((--s->hdlctx.slotcnt) > 0)
  459. return;
  460. s->hdlctx.slotcnt = s->ch_params.slottime;
  461. if ((random_num() % 256) > s->ch_params.ppersist)
  462. return;
  463. start_tx(dev, s);
  464. }
  466. /* --------------------------------------------------------------------- */
  467. /*
  468.  * ===================== network driver interface =========================
  469.  */
  471. static inline int hdlcdrv_paranoia_check(struct net_device *dev,
  472. const char *routine)
  473. {
  474. if (!dev || !dev->priv || 
  475.     ((struct hdlcdrv_state *)dev->priv)->magic != HDLCDRV_MAGIC) {
  476. printk(KERN_ERR "hdlcdrv: bad magic number for hdlcdrv_state "
  477.        "struct in routine %sn", routine);
  478. return 1;
  479. }
  480. return 0;
  481. }
  483. /* --------------------------------------------------------------------- */
  485. static int hdlcdrv_send_packet(struct sk_buff *skb, struct net_device *dev)
  486. {
  487. struct hdlcdrv_state *sm;
  489. if (hdlcdrv_paranoia_check(dev, "hdlcdrv_send_packet"))
  490. return 0;
  491. sm = (struct hdlcdrv_state *)dev->priv;
  492. if (skb->data[0] != 0) {
  493. do_kiss_params(sm, skb->data, skb->len);
  494. dev_kfree_skb(skb);
  495. return 0;
  496. }
  497. if (sm->skb)
  498. return -1;
  499. netif_stop_queue(dev);
  500. sm->skb = skb;
  501. return 0;
  502. }
  504. /* --------------------------------------------------------------------- */
  506. static int hdlcdrv_set_mac_address(struct net_device *dev, void *addr)
  507. {
  508. struct sockaddr *sa = (struct sockaddr *)addr;
  510. /* addr is an AX.25 shifted ASCII mac address */
  511. memcpy(dev->dev_addr, sa->sa_data, dev->addr_len); 
  512. return 0;                                         
  513. }
  515. /* --------------------------------------------------------------------- */
  517. static struct net_device_stats *hdlcdrv_get_stats(struct net_device *dev)
  518. {
  519. struct hdlcdrv_state *sm;
  521. if (hdlcdrv_paranoia_check(dev, "hdlcdrv_get_stats"))
  522. return NULL;
  523. sm = (struct hdlcdrv_state *)dev->priv;
  524. /* 
  525.  * Get the current statistics.  This may be called with the
  526.  * card open or closed. 
  527.  */
  528. return &sm->stats;
  529. }
  531. /* --------------------------------------------------------------------- */
  532. /*
  533.  * Open/initialize the board. This is called (in the current kernel)
  534.  * sometime after booting when the 'ifconfig' program is run.
  535.  *
  536.  * This routine should set everything up anew at each open, even
  537.  * registers that "should" only need to be set once at boot, so that
  538.  * there is non-reboot way to recover if something goes wrong.
  539.  */
  541. static int hdlcdrv_open(struct net_device *dev)
  542. {
  543. struct hdlcdrv_state *s;
  544. int i;
  546. if (hdlcdrv_paranoia_check(dev, "hdlcdrv_open"))
  547. return -EINVAL;
  548. s = (struct hdlcdrv_state *)dev->priv;
  550. if (!s->ops || !s->ops->open)
  551. return -ENODEV;
  553. /*
  554.  * initialise some variables
  555.  */
  556. s->hdlcrx.hbuf.rd = s->hdlcrx.hbuf.wr = 0;
  557. s->hdlcrx.in_hdlc_rx = 0;
  558. s->hdlcrx.rx_state = 0;
  560. s->hdlctx.hbuf.rd = s->hdlctx.hbuf.wr = 0;
  561. s->hdlctx.in_hdlc_tx = 0;
  562. s->hdlctx.tx_state = 1;
  563. s->hdlctx.numflags = 0;
  564. s->hdlctx.bitstream = s->hdlctx.bitbuf = s->hdlctx.numbits = 0;
  565. s->hdlctx.ptt = 0;
  566. s->hdlctx.slotcnt = s->ch_params.slottime;
  567. s->hdlctx.calibrate = 0;
  569. i = s->ops->open(dev);
  570. if (i)
  571. return i;
  572. netif_start_queue(dev);
  573. return 0;
  574. }
  576. /* --------------------------------------------------------------------- */
  577. /* 
  578.  * The inverse routine to hdlcdrv_open(). 
  579.  */
  581. static int hdlcdrv_close(struct net_device *dev)
  582. {
  583. struct hdlcdrv_state *s;
  584. int i = 0;
  586. if (hdlcdrv_paranoia_check(dev, "hdlcdrv_close"))
  587. return -EINVAL;
  588. s = (struct hdlcdrv_state *)dev->priv;
  590. if (s->ops && s->ops->close)
  591. i = s->ops->close(dev);
  592. if (s->skb)
  593. dev_kfree_skb(s->skb);
  594. s->skb = NULL;
  595. return i;
  596. }
  598. /* --------------------------------------------------------------------- */
  600. static int hdlcdrv_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
  601. {
  602. struct hdlcdrv_state *s;
  603. struct hdlcdrv_ioctl bi;
  605. if (hdlcdrv_paranoia_check(dev, "hdlcdrv_ioctl"))
  606. return -EINVAL;
  607. s = (struct hdlcdrv_state *)dev->priv;
  609. if (cmd != SIOCDEVPRIVATE) {
  610. if (s->ops && s->ops->ioctl)
  611. return s->ops->ioctl(dev, ifr, &bi, cmd);
  612. return -ENOIOCTLCMD;
  613. }
  614. if (copy_from_user(&bi, ifr->ifr_data, sizeof(bi)))
  615. return -EFAULT;
  617. switch (bi.cmd) {
  618. default:
  619. if (s->ops && s->ops->ioctl)
  620. return s->ops->ioctl(dev, ifr, &bi, cmd);
  621. return -ENOIOCTLCMD;
  623. case HDLCDRVCTL_GETCHANNELPAR:
  624. bi.data.cp.tx_delay = s->ch_params.tx_delay;
  625. bi.data.cp.tx_tail = s->ch_params.tx_tail;
  626. bi.data.cp.slottime = s->ch_params.slottime;
  627. bi.data.cp.ppersist = s->ch_params.ppersist;
  628. bi.data.cp.fulldup = s->ch_params.fulldup;
  629. break;
  631. case HDLCDRVCTL_SETCHANNELPAR:
  632. if (!capable(CAP_NET_ADMIN))
  633. return -EACCES;
  634. s->ch_params.tx_delay = bi.data.cp.tx_delay;
  635. s->ch_params.tx_tail = bi.data.cp.tx_tail;
  636. s->ch_params.slottime = bi.data.cp.slottime;
  637. s->ch_params.ppersist = bi.data.cp.ppersist;
  638. s->ch_params.fulldup = bi.data.cp.fulldup;
  639. s->hdlctx.slotcnt = 1;
  640. return 0;
  642. case HDLCDRVCTL_GETMODEMPAR:
  643. bi.data.mp.iobase = dev->base_addr;
  644. bi.data.mp.irq = dev->irq;
  645. bi.data.mp.dma = dev->dma;
  646. bi.data.mp.dma2 = s->ptt_out.dma2;
  647. bi.data.mp.seriobase = s->ptt_out.seriobase;
  648. bi.data.mp.pariobase = s->ptt_out.pariobase;
  649. bi.data.mp.midiiobase = s->ptt_out.midiiobase;
  650. break;
  652. case HDLCDRVCTL_SETMODEMPAR:
  653. if ((!capable(CAP_SYS_RAWIO)) || netif_running(dev))
  654. return -EACCES;
  655. dev->base_addr = bi.data.mp.iobase;
  656. dev->irq = bi.data.mp.irq;
  657. dev->dma = bi.data.mp.dma;
  658. s->ptt_out.dma2 = bi.data.mp.dma2;
  659. s->ptt_out.seriobase = bi.data.mp.seriobase;
  660. s->ptt_out.pariobase = bi.data.mp.pariobase;
  661. s->ptt_out.midiiobase = bi.data.mp.midiiobase;
  662. return 0;
  664. case HDLCDRVCTL_GETSTAT:
  665. bi.data.cs.ptt = hdlcdrv_ptt(s);
  666. bi.data.cs.dcd = s->hdlcrx.dcd;
  667. bi.data.cs.ptt_keyed = s->ptt_keyed;
  668. bi.data.cs.tx_packets = s->stats.tx_packets;
  669. bi.data.cs.tx_errors = s->stats.tx_errors;
  670. bi.data.cs.rx_packets = s->stats.rx_packets;
  671. bi.data.cs.rx_errors = s->stats.rx_errors;
  672. break;
  674. case HDLCDRVCTL_OLDGETSTAT:
  675. bi.data.ocs.ptt = hdlcdrv_ptt(s);
  676. bi.data.ocs.dcd = s->hdlcrx.dcd;
  677. bi.data.ocs.ptt_keyed = s->ptt_keyed;
  678. break;
  680. case HDLCDRVCTL_CALIBRATE:
  681. if(!capable(CAP_SYS_RAWIO))
  682. return -EPERM;
  683. s->hdlctx.calibrate = bi.data.calibrate * s->par.bitrate / 16;
  684. return 0;
  686. case HDLCDRVCTL_GETSAMPLES:
  687. #ifndef HDLCDRV_DEBUG
  688. return -EPERM;
  689. #else /* HDLCDRV_DEBUG */
  690. if (s->bitbuf_channel.rd == s->bitbuf_channel.wr) 
  691. return -EAGAIN;
  692. bi.data.bits = 
  693. s->bitbuf_channel.buffer[s->bitbuf_channel.rd];
  694. s->bitbuf_channel.rd = (s->bitbuf_channel.rd+1) %
  695. sizeof(s->bitbuf_channel.buffer);
  696. break;
  697. #endif /* HDLCDRV_DEBUG */
  699. case HDLCDRVCTL_GETBITS:
  700. #ifndef HDLCDRV_DEBUG
  701. return -EPERM;
  702. #else /* HDLCDRV_DEBUG */
  703. if (s->bitbuf_hdlc.rd == s->bitbuf_hdlc.wr) 
  704. return -EAGAIN;
  705. bi.data.bits = 
  706. s->bitbuf_hdlc.buffer[s->bitbuf_hdlc.rd];
  707. s->bitbuf_hdlc.rd = (s->bitbuf_hdlc.rd+1) %
  708. sizeof(s->bitbuf_hdlc.buffer);
  709. break;
  710. #endif /* HDLCDRV_DEBUG */
  712. case HDLCDRVCTL_DRIVERNAME:
  713. if (s->ops && s->ops->drvname) {
  714. strncpy(bi.data.drivername, s->ops->drvname, 
  715. sizeof(bi.data.drivername));
  716. break;
  717. }
  718. bi.data.drivername[0] = '';
  719. break;
  721. }
  722. if (copy_to_user(ifr->ifr_data, &bi, sizeof(bi)))
  723. return -EFAULT;
  724. return 0;
  726. }
  728. /* --------------------------------------------------------------------- */
  730. /*
  731.  * Check for a network adaptor of this type, and return '0' if one exists.
  732.  * If dev->base_addr == 0, probe all likely locations.
  733.  * If dev->base_addr == 1, always return failure.
  734.  * If dev->base_addr == 2, allocate space for the device and return success
  735.  * (detachable devices only).
  736.  */
  737. static int hdlcdrv_probe(struct net_device *dev)
  738. {
  739. const struct hdlcdrv_channel_params dflt_ch_params = { 
  740. 20, 2, 10, 40, 0 
  741. };
  742. struct hdlcdrv_state *s;
  744. if (!dev)
  745. return -ENXIO;
  746. /*
  747.  * not a real probe! only initialize data structures
  748.  */
  749. s = (struct hdlcdrv_state *)dev->priv;
  750. /*
  751.  * initialize the hdlcdrv_state struct
  752.  */
  753. s->ch_params = dflt_ch_params;
  754. s->ptt_keyed = 0;
  756. spin_lock_init(&s->hdlcrx.hbuf.lock);
  757. s->hdlcrx.hbuf.rd = s->hdlcrx.hbuf.wr = 0;
  758. s->hdlcrx.in_hdlc_rx = 0;
  759. s->hdlcrx.rx_state = 0;
  761. spin_lock_init(&s->hdlctx.hbuf.lock);
  762. s->hdlctx.hbuf.rd = s->hdlctx.hbuf.wr = 0;
  763. s->hdlctx.in_hdlc_tx = 0;
  764. s->hdlctx.tx_state = 1;
  765. s->hdlctx.numflags = 0;
  766. s->hdlctx.bitstream = s->hdlctx.bitbuf = s->hdlctx.numbits = 0;
  767. s->hdlctx.ptt = 0;
  768. s->hdlctx.slotcnt = s->ch_params.slottime;
  769. s->hdlctx.calibrate = 0;
  771. #ifdef HDLCDRV_DEBUG
  772. s->bitbuf_channel.rd = s->bitbuf_channel.wr = 0;
  773. s->bitbuf_channel.shreg = 0x80;
  775. s->bitbuf_hdlc.rd = s->bitbuf_hdlc.wr = 0;
  776. s->bitbuf_hdlc.shreg = 0x80;
  777. #endif /* HDLCDRV_DEBUG */
  779. /*
  780.  * initialize the device struct
  781.  */
  782. dev->open = hdlcdrv_open;
  783. dev->stop = hdlcdrv_close;
  784. dev->do_ioctl = hdlcdrv_ioctl;
  785. dev->hard_start_xmit = hdlcdrv_send_packet;
  786. dev->get_stats = hdlcdrv_get_stats;
  788. /* Fill in the fields of the device structure */
  790. s->skb = NULL;
  792. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  793. dev->hard_header = ax25_encapsulate;
  794. dev->rebuild_header = ax25_rebuild_header;
  795. #else /* CONFIG_AX25 || CONFIG_AX25_MODULE */
  796. dev->hard_header = NULL;
  797. dev->rebuild_header = NULL;
  798. #endif /* CONFIG_AX25 || CONFIG_AX25_MODULE */
  799. dev->set_mac_address = hdlcdrv_set_mac_address;
  801. dev->type = ARPHRD_AX25;           /* AF_AX25 device */
  802. dev->hard_header_len = AX25_MAX_HEADER_LEN + AX25_BPQ_HEADER_LEN;
  803. dev->mtu = AX25_DEF_PACLEN;        /* eth_mtu is the default */
  804. dev->addr_len = AX25_ADDR_LEN;     /* sizeof an ax.25 address */
  805. memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
  806. memcpy(dev->dev_addr, ax25_nocall, AX25_ADDR_LEN);
  807. dev->tx_queue_len = 16;
  809. /* New style flags */
  810. dev->flags = 0;
  812. return 0;
  813. }
  815. /* --------------------------------------------------------------------- */
  817. int hdlcdrv_register_hdlcdrv(struct net_device *dev, const struct hdlcdrv_ops *ops,
  818.      unsigned int privsize, char *ifname,
  819.      unsigned int baseaddr, unsigned int irq, 
  820.      unsigned int dma) 
  821. {
  822. struct hdlcdrv_state *s;
  824. if (!dev || !ops)
  825. return -EACCES;
  826. if (privsize < sizeof(struct hdlcdrv_state))
  827. privsize = sizeof(struct hdlcdrv_state);
  828. memset(dev, 0, sizeof(struct net_device));
  829. if (!(s = dev->priv = kmalloc(privsize, GFP_KERNEL)))
  830. return -ENOMEM;
  831. /*
  832.  * initialize part of the hdlcdrv_state struct
  833.  */
  834. memset(s, 0, privsize);
  835. s->magic = HDLCDRV_MAGIC;
  836. strncpy(dev->name, ifname, sizeof(dev->name));
  837. s->ops = ops;
  838. /*
  839.  * initialize part of the device struct
  840.  */
  841. dev->if_port = 0;
  842. dev->init = hdlcdrv_probe;
  843. dev->base_addr = baseaddr;
  844. dev->irq = irq;
  845. dev->dma = dma;
  846. if (register_netdev(dev)) {
  847. printk(KERN_WARNING "hdlcdrv: cannot register net "
  848.        "device %sn", dev->name);
  849. kfree(dev->priv);
  850. return -ENXIO;
  851. }
  852. MOD_INC_USE_COUNT;
  853. return 0;
  854. }
  856. /* --------------------------------------------------------------------- */
  858. int hdlcdrv_unregister_hdlcdrv(struct net_device *dev) 
  859. {
  860. struct hdlcdrv_state *s;
  862. if (!dev)
  863. return -EINVAL;
  864. if (!(s = (struct hdlcdrv_state *)dev->priv))
  865. return -EINVAL;
  866. if (s->magic != HDLCDRV_MAGIC)
  867. return -EINVAL;
  868. if (s->ops->close)
  869. s->ops->close(dev);
  870. unregister_netdev(dev);
  871. kfree(s);
  872. MOD_DEC_USE_COUNT;
  873. return 0;
  874. }
  876. /* --------------------------------------------------------------------- */
  878. EXPORT_SYMBOL(hdlcdrv_receiver);
  879. EXPORT_SYMBOL(hdlcdrv_transmitter);
  880. EXPORT_SYMBOL(hdlcdrv_arbitrate);
  881. EXPORT_SYMBOL(hdlcdrv_register_hdlcdrv);
  882. EXPORT_SYMBOL(hdlcdrv_unregister_hdlcdrv);
  884. /* --------------------------------------------------------------------- */
  886. static int __init hdlcdrv_init_driver(void)
  887. {
  888. printk(KERN_INFO "hdlcdrv: (C) 1996-2000 Thomas Sailer HB9JNX/AE4WAn");
  889. printk(KERN_INFO "hdlcdrv: version 0.8 compiled " __TIME__ " " __DATE__ "n");
  890. return 0;
  891. }
  893. /* --------------------------------------------------------------------- */
  895. static void __exit hdlcdrv_cleanup_driver(void)
  896. {
  897. printk(KERN_INFO "hdlcdrv: cleanupn");
  898. }
  900. /* --------------------------------------------------------------------- */
  902. MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
  903. MODULE_DESCRIPTION("Packet Radio network interface HDLC encoder/decoder");
  904. MODULE_LICENSE("GPL");
  905. module_init(hdlcdrv_init_driver);
  906. module_exit(hdlcdrv_cleanup_driver);
  908. /* --------------------------------------------------------------------- */