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

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

Linux/Unix编程

开发平台：

Unix_Linux

hdlc.c：源码内容
  1. /*
  2.  * Generic HDLC support routines for Linux
  3.  *
  4.  * Copyright (C) 1999, 2000 Krzysztof Halasa <khc@pm.waw.pl>
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify it
  7.  * under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * Current status:
  12.  *    - this is work in progress
  13.  *    - not heavily tested on SMP
  14.  *    - currently supported:
  15.  * * raw IP-in-HDLC
  16.  * * Cisco HDLC
  17.  * * Frame Relay with ANSI or CCITT LMI (both user and network side)
  18.  * * PPP (using syncppp.c)
  19.  * * X.25
  20.  *
  21.  * Use sethdlc utility to set line parameters, protocol and PVCs
  22.  */
  24. #include <linux/config.h>
  25. #include <linux/module.h>
  26. #include <linux/kernel.h>
  27. #include <linux/slab.h>
  28. #include <linux/poll.h>
  29. #include <linux/sched.h>
  30. #include <linux/errno.h>
  31. #include <linux/if_arp.h>
  32. #include <linux/init.h>
  33. #include <linux/skbuff.h>
  34. #include <linux/pkt_sched.h>
  35. #include <linux/inetdevice.h>
  36. #include <linux/lapb.h>
  37. #include <linux/rtnetlink.h>
  38. #include <linux/hdlc.h>
  40. /* #define DEBUG_PKT */
  41. /* #define DEBUG_HARD_HEADER */
  42. /* #define DEBUG_FECN */
  43. /* #define DEBUG_BECN */
  45. static const char* version = "HDLC support module revision 1.02 for Linux 2.4";
  48. #define CISCO_MULTICAST 0x8F /* Cisco multicast address */
  49. #define CISCO_UNICAST 0x0F /* Cisco unicast address */
  50. #define CISCO_KEEPALIVE 0x8035 /* Cisco keepalive protocol */
  51. #define CISCO_SYS_INFO 0x2000 /* Cisco interface/system info */
  52. #define CISCO_ADDR_REQ 0 /* Cisco address request */
  53. #define CISCO_ADDR_REPLY 1 /* Cisco address reply */
  54. #define CISCO_KEEPALIVE_REQ 2 /* Cisco keepalive request */
  56. static int hdlc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
  58. /********************************************************
  59.  *
  60.  * Cisco HDLC support
  61.  *
  62.  *******************************************************/
  64. static int cisco_hard_header(struct sk_buff *skb, struct net_device *dev,
  65.      u16 type, void *daddr, void *saddr,
  66.      unsigned int len)
  67. {
  68. hdlc_header *data;
  69. #ifdef DEBUG_HARD_HEADER
  70. printk(KERN_DEBUG "%s: cisco_hard_header calledn", dev->name);
  71. #endif
  73. skb_push(skb, sizeof(hdlc_header));
  74. data = (hdlc_header*)skb->data;
  75. if (type == CISCO_KEEPALIVE)
  76. data->address = CISCO_MULTICAST;
  77. else
  78. data->address = CISCO_UNICAST;
  79. data->control = 0;
  80. data->protocol = htons(type);
  82. return sizeof(hdlc_header);
  83. }
  87. static void cisco_keepalive_send(hdlc_device *hdlc, u32 type,
  88.  u32 par1, u32 par2)
  89. {
  90. struct sk_buff *skb;
  91. cisco_packet *data;
  93. skb = dev_alloc_skb(sizeof(hdlc_header)+sizeof(cisco_packet));
  94. if (!skb) {
  95. printk(KERN_WARNING "%s: Memory squeeze on cisco_keepalive_send()n",
  96.        hdlc_to_name(hdlc));
  97. return;
  98. }
  99. skb_reserve(skb, 4);
  100. cisco_hard_header(skb, hdlc_to_dev(hdlc), CISCO_KEEPALIVE,
  101.   NULL, NULL, 0);
  102. data = (cisco_packet*)skb->tail;
  104. data->type = htonl(type);
  105. data->par1 = htonl(par1);
  106. data->par2 = htonl(par2);
  107. data->rel = 0xFFFF;
  108. data->time = htonl(jiffies * 1000 / HZ);
  110. skb_put(skb, sizeof(cisco_packet));
  111. skb->priority = TC_PRIO_CONTROL;
  112. skb->dev = hdlc_to_dev(hdlc);
  114. dev_queue_xmit(skb);
  115. }
  119. static void cisco_netif(hdlc_device *hdlc, struct sk_buff *skb)
  120. {
  121. hdlc_header *data = (hdlc_header*)skb->data;
  122. cisco_packet *cisco_data;
  123. struct in_device *in_dev;
  124. u32 addr, mask;
  126. if (skb->len<sizeof(hdlc_header))
  127. goto rx_error;
  129. if (data->address != CISCO_MULTICAST &&
  130.     data->address != CISCO_UNICAST)
  131. goto rx_error;
  133. skb_pull(skb, sizeof(hdlc_header));
  135. switch(ntohs(data->protocol)) {
  136. case ETH_P_IP:
  137. case ETH_P_IPX:
  138. case ETH_P_IPV6:
  139. skb->protocol = data->protocol;
  140. skb->dev = hdlc_to_dev(hdlc);
  141. netif_rx(skb);
  142. return;
  144. case CISCO_SYS_INFO:
  145. /* Packet is not needed, drop it. */
  146. dev_kfree_skb_any(skb);
  147. return;
  149. case CISCO_KEEPALIVE:
  150. if (skb->len != CISCO_PACKET_LEN &&
  151.     skb->len != CISCO_BIG_PACKET_LEN) {
  152. printk(KERN_INFO "%s: Invalid length of Cisco "
  153.        "control packet (%d bytes)n",
  154.        hdlc_to_name(hdlc), skb->len);
  155. goto rx_error;
  156. }
  158. cisco_data = (cisco_packet*)skb->data;
  160. switch(ntohl (cisco_data->type)) {
  161. case CISCO_ADDR_REQ: /* Stolen from syncppp.c :-) */
  162. in_dev = hdlc_to_dev(hdlc)->ip_ptr;
  163. addr = 0;
  164. mask = ~0; /* is the mask correct? */
  166. if (in_dev != NULL) {
  167. struct in_ifaddr **ifap = &in_dev->ifa_list;
  169. while (*ifap != NULL) {
  170. if (strcmp(hdlc_to_name(hdlc),
  171.    (*ifap)->ifa_label) == 0) {
  172. addr = (*ifap)->ifa_local;
  173. mask = (*ifap)->ifa_mask;
  174. break;
  175. }
  176. ifap = &(*ifap)->ifa_next;
  177. }
  179. cisco_keepalive_send(hdlc, CISCO_ADDR_REPLY,
  180.      addr, mask);
  181. }
  182. dev_kfree_skb_any(skb);
  183. return;
  185. case CISCO_ADDR_REPLY:
  186. printk(KERN_INFO "%s: Unexpected Cisco IP address "
  187.        "replyn", hdlc_to_name(hdlc));
  188. goto rx_error;
  190. case CISCO_KEEPALIVE_REQ:
  191. hdlc->lmi.rxseq = ntohl(cisco_data->par1);
  192. if (ntohl(cisco_data->par2) == hdlc->lmi.txseq) {
  193. hdlc->lmi.last_poll = jiffies;
  194. if (!(hdlc->lmi.state & LINK_STATE_RELIABLE)) {
  195. u32 sec, min, hrs, days;
  196. sec = ntohl(cisco_data->time) / 1000;
  197. min = sec / 60; sec -= min * 60;
  198. hrs = min / 60; min -= hrs * 60;
  199. days = hrs / 24; hrs -= days * 24;
  200. printk(KERN_INFO "%s: Link up (peer "
  201.        "uptime %ud%uh%um%us)n",
  202.        hdlc_to_name(hdlc), days, hrs,
  203.        min, sec);
  204. }
  205. hdlc->lmi.state |= LINK_STATE_RELIABLE;
  206. }
  208. dev_kfree_skb_any(skb);
  209. return;
  210. } /* switch(keepalive type) */
  211. } /* switch(protocol) */
  213. printk(KERN_INFO "%s: Unsupported protocol %xn", hdlc_to_name(hdlc),
  214.        data->protocol);
  215. dev_kfree_skb_any(skb);
  216. return;
  218.  rx_error:
  219. hdlc->stats.rx_errors++; /* Mark error */
  220. dev_kfree_skb_any(skb);
  221. }
  225. static void cisco_timer(unsigned long arg)
  226. {
  227. hdlc_device *hdlc = (hdlc_device*)arg;
  229. if ((hdlc->lmi.state & LINK_STATE_RELIABLE) &&
  230.     (jiffies - hdlc->lmi.last_poll >= hdlc->lmi.T392 * HZ)) {
  231. hdlc->lmi.state &= ~LINK_STATE_RELIABLE;
  232. printk(KERN_INFO "%s: Link downn", hdlc_to_name(hdlc));
  233. }
  235. cisco_keepalive_send(hdlc, CISCO_KEEPALIVE_REQ, ++hdlc->lmi.txseq,
  236.      hdlc->lmi.rxseq);
  237. hdlc->timer.expires = jiffies + hdlc->lmi.T391*HZ;
  239. hdlc->timer.function = cisco_timer;
  240. hdlc->timer.data = arg;
  241. add_timer(&hdlc->timer);
  242. }
  246. /******************************************************************
  247.  *
  248.  *     generic Frame Relay routines
  249.  *
  250.  *****************************************************************/
  253. static int fr_hard_header(struct sk_buff *skb, struct net_device *dev,
  254.   u16 type, void *daddr, void *saddr, unsigned int len)
  255. {
  256. u16 head_len;
  258. if (!daddr)
  259. daddr = dev->broadcast;
  261. #ifdef DEBUG_HARD_HEADER
  262. printk(KERN_DEBUG "%s: fr_hard_header calledn", dev->name);
  263. #endif
  265. switch(type) {
  266. case ETH_P_IP:
  267. head_len = 4;
  268. skb_push(skb, head_len);
  269. skb->data[3] = NLPID_IP;
  270. break;
  272. case ETH_P_IPV6:
  273. head_len = 4;
  274. skb_push(skb, head_len);
  275. skb->data[3] = NLPID_IPV6;
  276. break;
  278. case LMI_PROTO:
  279. head_len = 4;
  280. skb_push(skb, head_len);
  281. skb->data[3] = LMI_PROTO;
  282. break;
  284. default:
  285. head_len = 10;
  286. skb_push(skb, head_len);
  287. skb->data[3] = FR_PAD;
  288. skb->data[4] = NLPID_SNAP;
  289. skb->data[5] = FR_PAD;
  290. skb->data[6] = FR_PAD;
  291. skb->data[7] = FR_PAD;
  292. skb->data[8] = type>>8;
  293. skb->data[9] = (u8)type;
  294. }
  296. memcpy(skb->data, daddr, 2);
  297. skb->data[2] = FR_UI;
  299. return head_len;
  300. }
  304. static inline void fr_log_dlci_active(pvc_device *pvc)
  305. {
  306. printk(KERN_INFO "%s: %sactive%sn", pvc_to_name(pvc),
  307.        pvc->state & PVC_STATE_ACTIVE ? "" : "in",
  308.        pvc->state & PVC_STATE_NEW ? " new" : "");
  309. }
  313. static inline u8 fr_lmi_nextseq(u8 x)
  314. {
  315. x++;
  316. return x ? x : 1;
  317. }
  321. static void fr_lmi_send(hdlc_device *hdlc, int fullrep)
  322. {
  323. struct sk_buff *skb;
  324. pvc_device *pvc = hdlc->first_pvc;
  325. int len = mode_is(hdlc, MODE_FR_ANSI) ? LMI_ANSI_LENGTH : LMI_LENGTH;
  326. int stat_len = 3;
  327. u8 *data;
  328. int i = 0;
  330. if (mode_is(hdlc, MODE_DCE) && fullrep) {
  331. len += hdlc->pvc_count * (2 + stat_len);
  332. if (len > HDLC_MAX_MTU) {
  333. printk(KERN_WARNING "%s: Too many PVCs while sending "
  334.        "LMI full reportn", hdlc_to_name(hdlc));
  335. return;
  336. }
  337. }
  339. skb = dev_alloc_skb(len);
  340. if (!skb) {
  341. printk(KERN_WARNING "%s: Memory squeeze on fr_lmi_send()n",
  342.        hdlc_to_name(hdlc));
  343. return;
  344. }
  345. memset(skb->data, 0, len);
  346. skb_reserve(skb, 4);
  347. fr_hard_header(skb, hdlc_to_dev(hdlc), LMI_PROTO, NULL, NULL, 0);
  348. data = skb->tail;
  349. data[i++] = LMI_CALLREF;
  350. data[i++] = mode_is(hdlc, MODE_DCE) ? LMI_STATUS : LMI_STATUS_ENQUIRY;
  351. if (mode_is(hdlc, MODE_FR_ANSI))
  352. data[i++] = LMI_ANSI_LOCKSHIFT;
  353. data[i++] = mode_is(hdlc, MODE_FR_CCITT) ? LMI_CCITT_REPTYPE :
  354. LMI_REPTYPE;
  355. data[i++] = LMI_REPT_LEN;
  356. data[i++] = fullrep ? LMI_FULLREP : LMI_INTEGRITY;
  358. data[i++] = mode_is(hdlc, MODE_FR_CCITT) ? LMI_CCITT_ALIVE : LMI_ALIVE;
  359. data[i++] = LMI_INTEG_LEN;
  360. data[i++] = hdlc->lmi.txseq = fr_lmi_nextseq(hdlc->lmi.txseq);
  361. data[i++] = hdlc->lmi.rxseq;
  363. if (mode_is(hdlc, MODE_DCE) && fullrep) {
  364. while (pvc) {
  365. data[i++] = mode_is(hdlc, MODE_FR_CCITT) ?
  366. LMI_CCITT_PVCSTAT:LMI_PVCSTAT;
  367. data[i++] = stat_len;
  369. if ((hdlc->lmi.state & LINK_STATE_RELIABLE) &&
  370.     (pvc->netdev.flags & IFF_UP) &&
  371.     !(pvc->state & (PVC_STATE_ACTIVE|PVC_STATE_NEW))) {
  372. pvc->state |= PVC_STATE_NEW;
  373. fr_log_dlci_active(pvc);
  374. }
  376. dlci_to_status(hdlc, netdev_dlci(&pvc->netdev),
  377.        data+i, pvc->state);
  378. i += stat_len;
  379. pvc = pvc->next;
  380. }
  381. }
  383. skb_put(skb, i);
  384. skb->priority = TC_PRIO_CONTROL;
  385. skb->dev = hdlc_to_dev(hdlc);
  387. dev_queue_xmit(skb);
  388. }
  392. static void fr_timer(unsigned long arg)
  393. {
  394. hdlc_device *hdlc = (hdlc_device*)arg;
  395. int i, cnt = 0, reliable;
  396. u32 list;
  398. if (mode_is(hdlc, MODE_DCE))
  399. reliable = (jiffies - hdlc->lmi.last_poll < hdlc->lmi.T392*HZ);
  400. else {
  401. hdlc->lmi.last_errors <<= 1; /* Shift the list */
  402. if (hdlc->lmi.state & LINK_STATE_REQUEST) {
  403. printk(KERN_INFO "%s: No LMI status reply receivedn",
  404.        hdlc_to_name(hdlc));
  405. hdlc->lmi.last_errors |= 1;
  406. }
  408. for (i = 0, list = hdlc->lmi.last_errors; i < hdlc->lmi.N393;
  409.      i++, list >>= 1)
  410. cnt += (list & 1); /* errors count */
  412. reliable = (cnt < hdlc->lmi.N392);
  413. }
  415. if ((hdlc->lmi.state & LINK_STATE_RELIABLE) !=
  416.     (reliable ? LINK_STATE_RELIABLE : 0)) {
  417. pvc_device *pvc = hdlc->first_pvc;
  419. while (pvc) {/* Deactivate all PVCs */
  420. pvc->state &= ~(PVC_STATE_NEW | PVC_STATE_ACTIVE);
  421. pvc = pvc->next;
  422. }
  424. hdlc->lmi.state ^= LINK_STATE_RELIABLE;
  425. printk(KERN_INFO "%s: Link %sreliablen", hdlc_to_name(hdlc),
  426.        reliable ? "" : "un");
  428. if (reliable) {
  429. hdlc->lmi.N391cnt = 0; /* Request full status */
  430. hdlc->lmi.state |= LINK_STATE_CHANGED;
  431. }
  432. }
  434. if (mode_is(hdlc, MODE_DCE))
  435. hdlc->timer.expires = jiffies + hdlc->lmi.T392*HZ;
  436. else {
  437. if (hdlc->lmi.N391cnt)
  438. hdlc->lmi.N391cnt--;
  440. fr_lmi_send(hdlc, hdlc->lmi.N391cnt == 0);
  442. hdlc->lmi.state |= LINK_STATE_REQUEST;
  443. hdlc->timer.expires = jiffies + hdlc->lmi.T391*HZ;
  444. }
  446. hdlc->timer.function = fr_timer;
  447. hdlc->timer.data = arg;
  448. add_timer(&hdlc->timer);
  449. }
  453. static int fr_lmi_recv(hdlc_device *hdlc, struct sk_buff *skb)
  454. {
  455. int stat_len;
  456. pvc_device *pvc;
  457. int reptype = -1, error;
  458. u8 rxseq, txseq;
  459. int i;
  461. if (skb->len < (mode_is(hdlc, MODE_FR_ANSI) ?
  462. LMI_ANSI_LENGTH : LMI_LENGTH)) {
  463. printk(KERN_INFO "%s: Short LMI framen", hdlc_to_name(hdlc));
  464. return 1;
  465. }
  467. if (skb->data[5] != (!mode_is(hdlc, MODE_DCE) ?
  468.      LMI_STATUS : LMI_STATUS_ENQUIRY)) {
  469. printk(KERN_INFO "%s: LMI msgtype=%x, Not LMI status %sn",
  470.        hdlc_to_name(hdlc), skb->data[2],
  471.        mode_is(hdlc, MODE_DCE) ? "enquiry" : "reply");
  472. return 1;
  473. }
  475. i = mode_is(hdlc, MODE_FR_ANSI) ? 7 : 6;
  477. if (skb->data[i] !=
  478.     (mode_is(hdlc, MODE_FR_CCITT) ? LMI_CCITT_REPTYPE : LMI_REPTYPE)) {
  479. printk(KERN_INFO "%s: Not a report type=%xn",
  480.        hdlc_to_name(hdlc), skb->data[i]);
  481. return 1;
  482. }
  483. i++;
  485. i++; /* Skip length field */
  487. reptype = skb->data[i++];
  489. if (skb->data[i]!=
  490.     (mode_is(hdlc, MODE_FR_CCITT) ? LMI_CCITT_ALIVE : LMI_ALIVE)) {
  491. printk(KERN_INFO "%s: Unsupported status element=%xn",
  492.        hdlc_to_name(hdlc), skb->data[i]);
  493. return 1;
  494. }
  495. i++;
  497. i++; /* Skip length field */
  499. hdlc->lmi.rxseq = skb->data[i++]; /* TX sequence from peer */
  500. rxseq = skb->data[i++]; /* Should confirm our sequence */
  502. txseq = hdlc->lmi.txseq;
  504. if (mode_is(hdlc, MODE_DCE)) {
  505. if (reptype != LMI_FULLREP && reptype != LMI_INTEGRITY) {
  506. printk(KERN_INFO "%s: Unsupported report type=%xn",
  507.        hdlc_to_name(hdlc), reptype);
  508. return 1;
  509. }
  510. }
  512. error = 0;
  513. if (!(hdlc->lmi.state & LINK_STATE_RELIABLE))
  514. error = 1;
  516. if (rxseq == 0 || rxseq != txseq) {
  517. hdlc->lmi.N391cnt = 0; /* Ask for full report next time */
  518. error = 1;
  519. }
  521. if (mode_is(hdlc, MODE_DCE)) {
  522. if ((hdlc->lmi.state & LINK_STATE_FULLREP_SENT) && !error) {
  523. /* Stop sending full report - the last one has been confirmed by DTE */
  524. hdlc->lmi.state &= ~LINK_STATE_FULLREP_SENT;
  525. pvc = hdlc->first_pvc;
  526. while (pvc) {
  527. if (pvc->state & PVC_STATE_NEW) {
  528. pvc->state &= ~PVC_STATE_NEW;
  529. pvc->state |= PVC_STATE_ACTIVE;
  530. fr_log_dlci_active(pvc);
  532. /* Tell DTE that new PVC is now active */
  533. hdlc->lmi.state |= LINK_STATE_CHANGED;
  534. }
  535. pvc = pvc->next;
  536. }
  537. }
  539. if (hdlc->lmi.state & LINK_STATE_CHANGED) {
  540. reptype = LMI_FULLREP;
  541. hdlc->lmi.state |= LINK_STATE_FULLREP_SENT;
  542. hdlc->lmi.state &= ~LINK_STATE_CHANGED;
  543. }
  545. fr_lmi_send(hdlc, reptype == LMI_FULLREP ? 1 : 0);
  546. return 0;
  547. }
  549. /* DTE */
  551. if (reptype != LMI_FULLREP || error)
  552. return 0;
  554. stat_len = 3;
  555. pvc = hdlc->first_pvc;
  557. while (pvc) {
  558. pvc->newstate = 0;
  559. pvc = pvc->next;
  560. }
  562. while (skb->len >= i + 2 + stat_len) {
  563. u16 dlci;
  564. u8 state = 0;
  566. if (skb->data[i] != (mode_is(hdlc, MODE_FR_CCITT) ?
  567.      LMI_CCITT_PVCSTAT : LMI_PVCSTAT)) {
  568. printk(KERN_WARNING "%s: Invalid PVCSTAT ID: %xn",
  569.        hdlc_to_name(hdlc), skb->data[i]);
  570. return 1;
  571. }
  572. i++;
  574. if (skb->data[i] != stat_len) {
  575. printk(KERN_WARNING "%s: Invalid PVCSTAT length: %xn",
  576.        hdlc_to_name(hdlc), skb->data[i]);
  577. return 1;
  578. }
  579. i++;
  581. dlci = status_to_dlci(hdlc, skb->data+i, &state);
  582. pvc = find_pvc(hdlc, dlci);
  584. if (pvc)
  585. pvc->newstate = state;
  586. else if (state == PVC_STATE_NEW)
  587. printk(KERN_INFO "%s: new PVC available, DLCI=%un",
  588.        hdlc_to_name(hdlc), dlci);
  590. i += stat_len;
  591. }
  593. pvc = hdlc->first_pvc;
  595. while (pvc) {
  596. if (pvc->newstate == PVC_STATE_NEW)
  597. pvc->newstate = PVC_STATE_ACTIVE;
  599. pvc->newstate |= (pvc->state &
  600.   ~(PVC_STATE_NEW|PVC_STATE_ACTIVE));
  601. if (pvc->state != pvc->newstate) {
  602. pvc->state = pvc->newstate;
  603. fr_log_dlci_active(pvc);
  604. }
  605. pvc = pvc->next;
  606. }
  608. /* Next full report after N391 polls */
  609. hdlc->lmi.N391cnt = hdlc->lmi.N391;
  611. return 0;
  612. }
  616. static void fr_netif(hdlc_device *hdlc, struct sk_buff *skb)
  617. {
  618. fr_hdr *fh = (fr_hdr*)skb->data;
  619. u8 *data = skb->data;
  620. u16 dlci;
  621. pvc_device *pvc;
  623. if (skb->len<4 || fh->ea1 || data[2] != FR_UI)
  624. goto rx_error;
  626. dlci = q922_to_dlci(skb->data);
  628. if (dlci == LMI_DLCI) {
  629. if (data[3] == LMI_PROTO) {
  630. if (fr_lmi_recv(hdlc, skb))
  631. goto rx_error;
  632. else {
  633. /* No request pending */
  634. hdlc->lmi.state &= ~LINK_STATE_REQUEST;
  635. hdlc->lmi.last_poll = jiffies;
  636. dev_kfree_skb_any(skb);
  637. return;
  638. }
  639. }
  641. printk(KERN_INFO "%s: Received non-LMI frame with LMI DLCIn",
  642.        hdlc_to_name(hdlc));
  643. goto rx_error;
  644. }
  646. pvc = find_pvc(hdlc, dlci);
  647. if (!pvc) {
  648. #ifdef DEBUG_PKT
  649. printk(KERN_INFO "%s: No PVC for received frame's DLCI %dn",
  650.        hdlc_to_name(hdlc), dlci);
  651. #endif
  652. goto rx_error;
  653. }
  655. if ((pvc->netdev.flags & IFF_UP) == 0) {
  656. #ifdef DEBUG_PKT
  657. printk(KERN_INFO "%s: PVC for received frame's DLCI %d is downn",
  658.        hdlc_to_name(hdlc), dlci);
  659. #endif
  660. goto rx_error;
  661. }
  663. pvc->stats.rx_packets++; /* PVC traffic */
  664. pvc->stats.rx_bytes += skb->len;
  666. if ((pvc->state & PVC_STATE_FECN) != (fh->fecn ? PVC_STATE_FECN : 0)) {
  667. #ifdef DEBUG_FECN
  668. printk(KERN_DEBUG "%s: FECN O%sn", pvc_to_name(pvc),
  669.        fh->fecn ? "N" : "FF");
  670. #endif
  671. pvc->state ^= PVC_STATE_FECN;
  672. }
  674. if ((pvc->state & PVC_STATE_BECN) != (fh->becn ? PVC_STATE_BECN : 0)) {
  675. #ifdef DEBUG_FECN
  676. printk(KERN_DEBUG "%s: BECN O%sn", pvc_to_name(pvc),
  677.        fh->becn ? "N" : "FF");
  678. #endif
  679. pvc->state ^= PVC_STATE_BECN;
  680. }
  682. if (pvc->state & PVC_STATE_BECN)
  683. pvc->stats.rx_compressed++;
  685. if (data[3] == NLPID_IP) {
  686. skb_pull(skb, 4); /* Remove 4-byte header (hdr, UI, NLPID) */
  687. skb->protocol = htons(ETH_P_IP);
  688. skb->dev = &pvc->netdev;
  689. netif_rx(skb);
  690. return;
  691. }
  694. if (data[3] == NLPID_IPV6) {
  695. skb_pull(skb, 4); /* Remove 4-byte header (hdr, UI, NLPID) */
  696. skb->protocol = htons(ETH_P_IPV6);
  697. skb->dev = &pvc->netdev;
  698. netif_rx(skb);
  699. return;
  700. }
  702. if (data[3] == FR_PAD && data[4] == NLPID_SNAP && data[5] == FR_PAD &&
  703.     data[6] == FR_PAD && data[7] == FR_PAD &&
  704.     ((data[8]<<8) | data[9]) == ETH_P_ARP) {
  705. skb_pull(skb, 10);
  706. skb->protocol = htons(ETH_P_ARP);
  707. skb->dev = &pvc->netdev;
  708. netif_rx(skb);
  709. return;
  710. }
  712. printk(KERN_INFO "%s: Unusupported protocol %xn",
  713.        hdlc_to_name(hdlc), data[3]);
  714. dev_kfree_skb_any(skb);
  715. return;
  717.  rx_error:
  718. hdlc->stats.rx_errors++; /* Mark error */
  719. dev_kfree_skb_any(skb);
  720. }
  724. static void fr_cisco_open(hdlc_device *hdlc)
  725. {
  726. hdlc->lmi.state = LINK_STATE_CHANGED;
  727. hdlc->lmi.txseq = hdlc->lmi.rxseq = 0;
  728. hdlc->lmi.last_errors = 0xFFFFFFFF;
  729. hdlc->lmi.N391cnt = 0;
  731. init_timer(&hdlc->timer);
  732. hdlc->timer.expires = jiffies + HZ; /* First poll after 1 second */
  733. hdlc->timer.function = mode_is(hdlc, MODE_FR) ? fr_timer : cisco_timer;
  734. hdlc->timer.data = (unsigned long)hdlc;
  735. add_timer(&hdlc->timer);
  736. }
  740. static void fr_cisco_close(hdlc_device *hdlc)
  741. {
  742. pvc_device *pvc = hdlc->first_pvc;
  744. del_timer_sync(&hdlc->timer);
  746. while(pvc) { /* NULL in Cisco mode */
  747. dev_close(&pvc->netdev); /* Shutdown all PVCs for this FRAD */
  748. pvc = pvc->next;
  749. }
  750. }
  754. /******************************************************************
  755.  *
  756.  *     generic HDLC routines
  757.  *
  758.  *****************************************************************/
  762. static int hdlc_change_mtu(struct net_device *dev, int new_mtu)
  763. {
  764. if ((new_mtu < 68) || (new_mtu > HDLC_MAX_MTU))
  765. return -EINVAL;
  766. dev->mtu = new_mtu;
  767. return 0;
  768. }
  772. /********************************************************
  773.  *
  774.  * PVC device routines
  775.  *
  776.  *******************************************************/
  778. static int pvc_open(struct net_device *dev)
  779. {
  780. pvc_device *pvc = dev_to_pvc(dev);
  781. int result = 0;
  783. if ((hdlc_to_dev(pvc->master)->flags & IFF_UP) == 0)
  784. return -EIO;  /* Master must be UP in order to activate PVC */
  786. memset(&(pvc->stats), 0, sizeof(struct net_device_stats));
  787. pvc->state = 0;
  789. if (!mode_is(pvc->master, MODE_SOFT) && pvc->master->open_pvc)
  790. result = pvc->master->open_pvc(pvc);
  791. if (result)
  792. return result;
  794. pvc->master->lmi.state |= LINK_STATE_CHANGED;
  795. return 0;
  796. }
  800. static int pvc_close(struct net_device *dev)
  801. {
  802. pvc_device *pvc = dev_to_pvc(dev);
  803. pvc->state = 0;
  805. if (!mode_is(pvc->master, MODE_SOFT) && pvc->master->close_pvc)
  806. pvc->master->close_pvc(pvc);
  808. pvc->master->lmi.state |= LINK_STATE_CHANGED;
  809. return 0;
  810. }
  814. static int pvc_xmit(struct sk_buff *skb, struct net_device *dev)
  815. {
  816. pvc_device *pvc = dev_to_pvc(dev);
  818. if (pvc->state & PVC_STATE_ACTIVE) {
  819. skb->dev = hdlc_to_dev(pvc->master);
  820. pvc->stats.tx_bytes += skb->len;
  821. pvc->stats.tx_packets++;
  822. if (pvc->state & PVC_STATE_FECN)
  823. pvc->stats.tx_compressed++; /* TX Congestion counter */
  824. dev_queue_xmit(skb);
  825. } else {
  826. pvc->stats.tx_dropped++;
  827. dev_kfree_skb(skb);
  828. }
  830. return 0;
  831. }
  835. static struct net_device_stats *pvc_get_stats(struct net_device *dev)
  836. {
  837. pvc_device *pvc = dev_to_pvc(dev);
  838. return &pvc->stats;
  839. }
  843. static int pvc_change_mtu(struct net_device *dev, int new_mtu)
  844. {
  845. if ((new_mtu < 68) || (new_mtu > HDLC_MAX_MTU))
  846. return -EINVAL;
  847. dev->mtu = new_mtu;
  848. return 0;
  849. }
  853. static void destroy_pvc_list(hdlc_device *hdlc)
  854. {
  855. pvc_device *pvc = hdlc->first_pvc;
  856. while(pvc) {
  857. pvc_device *next = pvc->next;
  858. unregister_netdevice(&pvc->netdev);
  859. kfree(pvc);
  860. pvc = next;
  861. }
  863. hdlc->first_pvc = NULL; /* All PVCs destroyed */
  864. hdlc->pvc_count = 0;
  865. hdlc->lmi.state |= LINK_STATE_CHANGED;
  866. }
  870. /********************************************************
  871.  *
  872.  * X.25 protocol support routines
  873.  *
  874.  *******************************************************/
  876. #ifdef CONFIG_HDLC_X25
  877. /* These functions are callbacks called by LAPB layer */
  879. void x25_connect_disconnect(void *token, int reason, int code)
  880. {
  881. hdlc_device *hdlc = token;
  882. struct sk_buff *skb;
  883. unsigned char *ptr;
  885. if ((skb = dev_alloc_skb(1)) == NULL) {
  886. printk(KERN_ERR "%s: out of memoryn", hdlc_to_name(hdlc));
  887. return;
  888. }
  890. ptr = skb_put(skb, 1);
  891. *ptr = code;
  893. skb->dev = hdlc_to_dev(hdlc);
  894. skb->protocol = htons(ETH_P_X25);
  895. skb->mac.raw = skb->data;
  896. skb->pkt_type = PACKET_HOST;
  898. netif_rx(skb);
  899. }
  901. void x25_connected(void *token, int reason)
  902. {
  903. x25_connect_disconnect(token, reason, 1);
  904. }
  906. void x25_disconnected(void *token, int reason)
  907. {
  908. x25_connect_disconnect(token, reason, 2);
  909. }
  912. int x25_data_indication(void *token, struct sk_buff *skb)
  913. {
  914. hdlc_device *hdlc = token;
  915. unsigned char *ptr;
  917. ptr = skb_push(skb, 1);
  918. *ptr = 0;
  920. skb->dev = hdlc_to_dev(hdlc);
  921. skb->protocol = htons(ETH_P_X25);
  922. skb->mac.raw = skb->data;
  923. skb->pkt_type = PACKET_HOST;
  925. return netif_rx(skb);
  926. }
  929. void x25_data_transmit(void *token, struct sk_buff *skb)
  930. {
  931. hdlc_device *hdlc = token;
  932. hdlc->xmit(hdlc, skb); /* Ignore return value :-( */
  933. }
  934. #endif /* CONFIG_HDLC_X25 */
  937. /********************************************************
  938.  *
  939.  * HDLC device routines
  940.  *
  941.  *******************************************************/
  943. static int hdlc_open(struct net_device *dev)
  944. {
  945. hdlc_device *hdlc = dev_to_hdlc(dev);
  946. int result;
  948. if (hdlc->mode == MODE_NONE)
  949. return -ENOSYS;
  951. memset(&(hdlc->stats), 0, sizeof(struct net_device_stats));
  953. if (mode_is(hdlc, MODE_FR | MODE_SOFT) ||
  954.     mode_is(hdlc, MODE_CISCO | MODE_SOFT))
  955. fr_cisco_open(hdlc);
  956. #ifdef CONFIG_HDLC_PPP
  957. else if (mode_is(hdlc, MODE_PPP | MODE_SOFT)) {
  958. sppp_attach(&hdlc->pppdev);
  959. /* sppp_attach nukes them. We don't need syncppp's ioctl */
  960. dev->do_ioctl = hdlc_ioctl;
  961. hdlc->pppdev.sppp.pp_flags &= ~PP_CISCO;
  962. dev->type = ARPHRD_PPP;
  963. result = sppp_open(dev);
  964. if (result) {
  965. sppp_detach(dev);
  966. return result;
  967. }
  968. }
  969. #endif
  970. #ifdef CONFIG_HDLC_X25
  971. else if (mode_is(hdlc, MODE_X25)) {
  972. struct lapb_register_struct cb;
  974. cb.connect_confirmation = x25_connected;
  975. cb.connect_indication = x25_connected;
  976. cb.disconnect_confirmation = x25_disconnected;
  977. cb.disconnect_indication = x25_disconnected;
  978. cb.data_indication = x25_data_indication;
  979. cb.data_transmit = x25_data_transmit;
  981. result = lapb_register(hdlc, &cb);
  982. if (result != LAPB_OK)
  983. return result;
  984. }
  985. #endif
  986. result = hdlc->open(hdlc);
  987. if (result) {
  988. if (mode_is(hdlc, MODE_FR | MODE_SOFT) ||
  989.     mode_is(hdlc, MODE_CISCO | MODE_SOFT))
  990. fr_cisco_close(hdlc);
  991. #ifdef CONFIG_HDLC_PPP
  992. else if (mode_is(hdlc, MODE_PPP | MODE_SOFT)) {
  993. sppp_close(dev);
  994. sppp_detach(dev);
  995. dev->rebuild_header = NULL;
  996. dev->change_mtu = hdlc_change_mtu;
  997. dev->mtu = HDLC_MAX_MTU;
  998. dev->hard_header_len = 16;
  999. }
  1000. #endif
  1001. #ifdef CONFIG_HDLC_X25
  1002. else if (mode_is(hdlc, MODE_X25))
  1003. lapb_unregister(hdlc);
  1004. #endif
  1005. }
  1007. return result;
  1008. }
  1012. static int hdlc_close(struct net_device *dev)
  1013. {
  1014. hdlc_device *hdlc = dev_to_hdlc(dev);
  1016. hdlc->close(hdlc);
  1018. if (mode_is(hdlc, MODE_FR | MODE_SOFT) ||
  1019.     mode_is(hdlc, MODE_CISCO | MODE_SOFT))
  1020. fr_cisco_close(hdlc);
  1021. #ifdef CONFIG_HDLC_PPP
  1022. else if (mode_is(hdlc, MODE_PPP | MODE_SOFT)) {
  1023. sppp_close(dev);
  1024. sppp_detach(dev);
  1025. dev->rebuild_header = NULL;
  1026. dev->change_mtu = hdlc_change_mtu;
  1027. dev->mtu = HDLC_MAX_MTU;
  1028. dev->hard_header_len = 16;
  1029. }
  1030. #endif
  1031. #ifdef CONFIG_HDLC_X25
  1032. else if (mode_is(hdlc, MODE_X25))
  1033. lapb_unregister(hdlc);
  1034. #endif
  1035. return 0;
  1036. }
  1040. static int hdlc_xmit(struct sk_buff *skb, struct net_device *dev)
  1041. {
  1042. hdlc_device *hdlc = dev_to_hdlc(dev);
  1044. #ifdef CONFIG_HDLC_X25
  1045. if (mode_is(hdlc, MODE_X25 | MODE_SOFT)) {
  1046. int result;
  1049. /* X.25 to LAPB */
  1050. switch (skb->data[0]) {
  1051. case 0: /* Data to be transmitted */
  1052. skb_pull(skb, 1);
  1053. if ((result = lapb_data_request(hdlc, skb)) != LAPB_OK)
  1054. dev_kfree_skb(skb);
  1055. return 0;
  1057. case 1:
  1058. if ((result = lapb_connect_request(hdlc))!= LAPB_OK) {
  1059. if (result == LAPB_CONNECTED) {
  1060. /* Send connect confirm. msg to level 3 */
  1061. x25_connected(hdlc, 0);
  1062. } else {
  1063. printk(KERN_ERR "%s: LAPB connect "
  1064.        "request failed, error code = "
  1065.        "%in", hdlc_to_name(hdlc),
  1066.        result);
  1067. }
  1068. }
  1069. break;
  1071. case 2:
  1072. if ((result=lapb_disconnect_request(hdlc))!=LAPB_OK) {
  1073. if (result == LAPB_NOTCONNECTED) {
  1074. /* Send disconnect confirm. msg to level 3 */
  1075. x25_disconnected(hdlc, 0);
  1076. } else {
  1077. printk(KERN_ERR "%s: LAPB disconnect "
  1078.        "request failed, error code = "
  1079.        "%in", hdlc_to_name(hdlc),
  1080.        result);
  1081. }
  1082. }
  1083. break;
  1085. default:
  1086. /* to be defined */
  1087. break;
  1088. }
  1090. dev_kfree_skb(skb);
  1091. return 0;
  1092. } /* MODE_X25 */
  1093. #endif /* CONFIG_HDLC_X25 */
  1095. return hdlc->xmit(hdlc, skb);
  1096. }
  1100. void hdlc_netif_rx(hdlc_device *hdlc, struct sk_buff *skb)
  1101. {
  1102. /* skb contains raw HDLC frame, in both hard- and software modes */
  1103. skb->mac.raw = skb->data;
  1105. switch(hdlc->mode & MODE_MASK) {
  1106. case MODE_HDLC:
  1107. skb->protocol = htons(ETH_P_IP);
  1108. skb->dev = hdlc_to_dev(hdlc);
  1109. netif_rx(skb);
  1110. return;
  1112. case MODE_FR:
  1113. fr_netif(hdlc, skb);
  1114. return;
  1116. case MODE_CISCO:
  1117. cisco_netif(hdlc, skb);
  1118. return;
  1120. #ifdef CONFIG_HDLC_PPP
  1121. case MODE_PPP:
  1122. #if 0
  1123. sppp_input(hdlc_to_dev(hdlc), skb);
  1124. #else
  1125. skb->protocol = htons(ETH_P_WAN_PPP);
  1126. skb->dev = hdlc_to_dev(hdlc);
  1127. netif_rx(skb);
  1128. #endif
  1129. return;
  1130. #endif
  1131. #ifdef CONFIG_HDLC_X25
  1132. case MODE_X25:
  1133. skb->dev = hdlc_to_dev(hdlc);
  1134. if (lapb_data_received(hdlc, skb) == LAPB_OK)
  1135. return;
  1136. break;
  1137. #endif
  1138. }
  1140. hdlc->stats.rx_errors++;
  1141. dev_kfree_skb_any(skb);
  1142. }
  1146. static struct net_device_stats *hdlc_get_stats(struct net_device *dev)
  1147. {
  1148. return &dev_to_hdlc(dev)->stats;
  1149. }
  1153. static int hdlc_set_mode(hdlc_device *hdlc, int mode)
  1154. {
  1155. int result = -1; /* Default to soft modes */
  1156. struct net_device *dev = hdlc_to_dev(hdlc);
  1158. if(!capable(CAP_NET_ADMIN))
  1159. return -EPERM;
  1161. if(dev->flags & IFF_UP)
  1162. return -EBUSY;
  1164. dev->addr_len = 0;
  1165. dev->hard_header = NULL;
  1166. hdlc->mode = MODE_NONE;
  1168. if (!(mode & MODE_SOFT))
  1169. switch(mode & MODE_MASK) {
  1170. case MODE_HDLC:
  1171. result = hdlc->set_mode ?
  1172. hdlc->set_mode(hdlc, MODE_HDLC) : 0;
  1173. break;
  1175. case MODE_CISCO: /* By card */
  1176. #ifdef CONFIG_HDLC_PPP
  1177. case MODE_PPP:
  1178. #endif
  1179. #ifdef CONFIG_HDLC_X25
  1180. case MODE_X25:
  1181. #endif
  1182. case MODE_FR:
  1183. result = hdlc->set_mode ?
  1184. hdlc->set_mode(hdlc, mode) : -ENOSYS;
  1185. break;
  1187. default:
  1188. return -EINVAL;
  1189. }
  1191. if (result) {
  1192. mode |= MODE_SOFT; /* Try "host software" protocol */
  1194. switch(mode & MODE_MASK) {
  1195. case MODE_CISCO:
  1196. dev->hard_header = cisco_hard_header;
  1197. break;
  1199. #ifdef CONFIG_HDLC_PPP
  1200. case MODE_PPP:
  1201. break;
  1202. #endif
  1203. #ifdef CONFIG_HDLC_X25
  1204. case MODE_X25:
  1205. break;
  1206. #endif
  1208. case MODE_FR:
  1209. dev->hard_header = fr_hard_header;
  1210. dev->addr_len = 2;
  1211. *(u16*)dev->dev_addr = htons(LMI_DLCI);
  1212. dlci_to_q922(dev->broadcast, LMI_DLCI);
  1213. break;
  1215. default:
  1216. return -EINVAL;
  1217. }
  1219. result = hdlc->set_mode ?
  1220. hdlc->set_mode(hdlc, MODE_HDLC) : 0;
  1221. }
  1223. if (result)
  1224. return result;
  1226. hdlc->mode = mode;
  1227. switch(mode & MODE_MASK) {
  1228. #ifdef CONFIG_HDLC_PPP
  1229. case MODE_PPP:   dev->type = ARPHRD_PPP;   break;
  1230. #endif
  1231. #ifdef CONFIG_HDLC_X25
  1232. case MODE_X25:   dev->type = ARPHRD_X25;   break;
  1233. #endif
  1234. case MODE_FR:    dev->type = ARPHRD_FRAD;  break;
  1235. case MODE_CISCO: dev->type = ARPHRD_CISCO; break;
  1236. default:         dev->type = ARPHRD_RAWHDLC;
  1237. }
  1239. memset(&(hdlc->stats), 0, sizeof(struct net_device_stats));
  1240. destroy_pvc_list(hdlc);
  1241. return 0;
  1242. }
  1246. static int hdlc_fr_pvc(hdlc_device *hdlc, int dlci)
  1247. {
  1248. pvc_device **pvc_p = &hdlc->first_pvc;
  1249. pvc_device *pvc;
  1250. int result, create = 1; /* Create or delete PVC */
  1252. if(!capable(CAP_NET_ADMIN))
  1253. return -EPERM;
  1255. if(dlci<0) {
  1256. dlci = -dlci;
  1257. create = 0;
  1258. }
  1260. if(dlci <= 0 || dlci >= 1024)
  1261. return -EINVAL; /* Only 10 bits for DLCI, DLCI=0 is reserved */
  1263. if(!mode_is(hdlc, MODE_FR))
  1264. return -EINVAL; /* Only meaningfull on FR */
  1266. while(*pvc_p) {
  1267. if (netdev_dlci(&(*pvc_p)->netdev) == dlci)
  1268. break;
  1269. pvc_p = &(*pvc_p)->next;
  1270. }
  1272. if (create) { /* Create PVC */
  1273. if (*pvc_p != NULL)
  1274. return -EEXIST;
  1276. pvc = *pvc_p = kmalloc(sizeof(pvc_device), GFP_KERNEL);
  1277. if (!pvc) {
  1278. printk(KERN_WARNING "%s: Memory squeeze on "
  1279.        "hdlc_fr_pvc()n", hdlc_to_name(hdlc));
  1280. return -ENOBUFS;
  1281. }
  1282. memset(pvc, 0, sizeof(pvc_device));
  1284. pvc->netdev.hard_start_xmit = pvc_xmit;
  1285. pvc->netdev.get_stats = pvc_get_stats;
  1286. pvc->netdev.open = pvc_open;
  1287. pvc->netdev.stop = pvc_close;
  1288. pvc->netdev.change_mtu = pvc_change_mtu;
  1289. pvc->netdev.mtu = HDLC_MAX_MTU;
  1291. pvc->netdev.type = ARPHRD_DLCI;
  1292. pvc->netdev.hard_header_len = 16;
  1293. pvc->netdev.hard_header = fr_hard_header;
  1294. pvc->netdev.tx_queue_len = 0;
  1295. pvc->netdev.flags = IFF_POINTOPOINT;
  1297. pvc->master = hdlc;
  1298. *(u16*)pvc->netdev.dev_addr = htons(dlci);
  1299. dlci_to_q922(pvc->netdev.broadcast, dlci);
  1300. pvc->netdev.addr_len = 2;
  1301. pvc->netdev.irq = hdlc_to_dev(hdlc)->irq;
  1303. result = dev_alloc_name(&pvc->netdev, "pvc%d");
  1304. if (result < 0) {
  1305. kfree(pvc);
  1306. *pvc_p = NULL;
  1307. return result;
  1308. }
  1310. if (register_netdevice(&pvc->netdev) != 0) {
  1311. kfree(pvc);
  1312. *pvc_p = NULL;
  1313. return -EIO;
  1314. }
  1316. if (!mode_is(hdlc, MODE_SOFT) && hdlc->create_pvc) {
  1317. result = hdlc->create_pvc(pvc);
  1318. if (result) {
  1319. unregister_netdevice(&pvc->netdev);
  1320. kfree(pvc);
  1321. *pvc_p = NULL;
  1322. return result;
  1323. }
  1324. }
  1326. hdlc->lmi.state |= LINK_STATE_CHANGED;
  1327. hdlc->pvc_count++;
  1328. return 0;
  1329. }
  1331. if (*pvc_p == NULL) /* Delete PVC */
  1332. return -ENOENT;
  1334. pvc = *pvc_p;
  1336. if (pvc->netdev.flags & IFF_UP)
  1337. return -EBUSY; /* PVC in use */
  1339. if (!mode_is(hdlc, MODE_SOFT) && hdlc->destroy_pvc)
  1340. hdlc->destroy_pvc(pvc);
  1342. hdlc->lmi.state |= LINK_STATE_CHANGED;
  1343. hdlc->pvc_count--;
  1344. *pvc_p = pvc->next;
  1345. unregister_netdevice(&pvc->netdev);
  1346. kfree(pvc);
  1347. return 0;
  1348. }
  1352. static int hdlc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
  1353. {
  1354. hdlc_device *hdlc = dev_to_hdlc(dev);
  1356. switch(cmd) {
  1357. case HDLCGMODE:
  1358. ifr->ifr_ifru.ifru_ivalue = hdlc->mode;
  1359. return 0;
  1361. case HDLCSMODE:
  1362. return hdlc_set_mode(hdlc, ifr->ifr_ifru.ifru_ivalue);
  1364. case HDLCPVC:
  1365. return hdlc_fr_pvc(hdlc, ifr->ifr_ifru.ifru_ivalue);
  1367. default:
  1368. if (hdlc->ioctl != NULL)
  1369. return hdlc->ioctl(hdlc, ifr, cmd);
  1370. }
  1372. return -EINVAL;
  1373. }
  1377. static int hdlc_init(struct net_device *dev)
  1378. {
  1379. hdlc_device *hdlc = dev_to_hdlc(dev);
  1381. memset(&(hdlc->stats), 0, sizeof(struct net_device_stats));
  1383. dev->get_stats = hdlc_get_stats;
  1384. dev->open = hdlc_open;
  1385. dev->stop = hdlc_close;
  1386. dev->hard_start_xmit = hdlc_xmit;
  1387. dev->do_ioctl = hdlc_ioctl;
  1388. dev->change_mtu = hdlc_change_mtu;
  1389. dev->mtu = HDLC_MAX_MTU;
  1391. dev->type = ARPHRD_RAWHDLC;
  1392. dev->hard_header_len = 16;
  1394. dev->flags = IFF_POINTOPOINT | IFF_NOARP;
  1396. return 0;
  1397. }
  1401. int register_hdlc_device(hdlc_device *hdlc)
  1402. {
  1403. int result;
  1404. struct net_device *dev = hdlc_to_dev(hdlc);
  1406. dev->init = hdlc_init;
  1407. dev->priv = &hdlc->syncppp_ptr;
  1408. hdlc->syncppp_ptr = &hdlc->pppdev;
  1409. hdlc->pppdev.dev = dev;
  1410. hdlc->mode = MODE_NONE;
  1411. hdlc->lmi.T391 = 10; /* polling verification timer */
  1412. hdlc->lmi.T392 = 15; /* link integrity verification polling timer */
  1413. hdlc->lmi.N391 = 6; /* full status polling counter */
  1414. hdlc->lmi.N392 = 3; /* error threshold */
  1415. hdlc->lmi.N393 = 4; /* monitored events count */
  1417. result = dev_alloc_name(dev, "hdlc%d");
  1418. if (result<0)
  1419. return result;
  1421. result = register_netdev(dev);
  1422. if (result != 0)
  1423. return -EIO;
  1425. MOD_INC_USE_COUNT;
  1426. return 0;
  1427. }
  1431. void unregister_hdlc_device(hdlc_device *hdlc)
  1432. {
  1433. destroy_pvc_list(hdlc);
  1434. unregister_netdev(hdlc_to_dev(hdlc));
  1435. MOD_DEC_USE_COUNT;
  1436. }
  1438. MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>");
  1439. MODULE_DESCRIPTION("HDLC support module");
  1440. MODULE_LICENSE("GPL");
  1442. EXPORT_SYMBOL(hdlc_netif_rx);
  1443. EXPORT_SYMBOL(register_hdlc_device);
  1444. EXPORT_SYMBOL(unregister_hdlc_device);
  1446. static int __init hdlc_module_init(void)
  1447. {
  1448. printk(KERN_INFO "%sn", version);
  1449. return 0;
  1450. }
  1453. module_init(hdlc_module_init);