drivers/net/wan/hdlc_fr.c

   1 /*
   2  * Generic HDLC support routines for Linux
   3  * Frame Relay support
   4  *
   5  * Copyright (C) 1999 - 2006 Krzysztof Halasa <khc@pm.waw.pl>
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of version 2 of the GNU General Public License
   9  * as published by the Free Software Foundation.
  10  *
  11
  12             Theory of PVC state
  13
  14  DCE mode:
  15
  16  (exist,new) -> 0,0 when "PVC create" or if "link unreliable"
  17          0,x -> 1,1 if "link reliable" when sending FULL STATUS
  18          1,1 -> 1,0 if received FULL STATUS ACK
  19
  20  (active)    -> 0 when "ifconfig PVC down" or "link unreliable" or "PVC create"
  21              -> 1 when "PVC up" and (exist,new) = 1,0
  22
  23  DTE mode:
  24  (exist,new,active) = FULL STATUS if "link reliable"
  25                     = 0, 0, 0 if "link unreliable"
  26  No LMI:
  27  active = open and "link reliable"
  28  exist = new = not used
  29
  30  CCITT LMI: ITU-T Q.933 Annex A
  31  ANSI LMI: ANSI T1.617 Annex D
  32  CISCO LMI: the original, aka "Gang of Four" LMI
  33
  34 */
  35
  36 #include <linux/module.h>
  37 #include <linux/kernel.h>
  38 #include <linux/slab.h>
  39 #include <linux/poll.h>
  40 #include <linux/errno.h>
  41 #include <linux/if_arp.h>
  42 #include <linux/init.h>
  43 #include <linux/skbuff.h>
  44 #include <linux/pkt_sched.h>
  45 #include <linux/random.h>
  46 #include <linux/inetdevice.h>
  47 #include <linux/lapb.h>
  48 #include <linux/rtnetlink.h>
  49 #include <linux/etherdevice.h>
  50 #include <linux/hdlc.h>
  51
  52 #undef DEBUG_PKT
  53 #undef DEBUG_ECN
  54 #undef DEBUG_LINK
  55 #undef DEBUG_PROTO
  56 #undef DEBUG_PVC
  57
  58 #define FR_UI                   0x03
  59 #define FR_PAD                  0x00
  60
  61 #define NLPID_IP                0xCC
  62 #define NLPID_IPV6              0x8E
  63 #define NLPID_SNAP              0x80
  64 #define NLPID_PAD               0x00
  65 #define NLPID_CCITT_ANSI_LMI    0x08
  66 #define NLPID_CISCO_LMI         0x09
  67
  68
  69 #define LMI_CCITT_ANSI_DLCI        0 /* LMI DLCI */
  70 #define LMI_CISCO_DLCI          1023
  71
  72 #define LMI_CALLREF             0x00 /* Call Reference */
  73 #define LMI_ANSI_LOCKSHIFT      0x95 /* ANSI locking shift */
  74 #define LMI_ANSI_CISCO_REPTYPE  0x01 /* report type */
  75 #define LMI_CCITT_REPTYPE       0x51
  76 #define LMI_ANSI_CISCO_ALIVE    0x03 /* keep alive */
  77 #define LMI_CCITT_ALIVE         0x53
  78 #define LMI_ANSI_CISCO_PVCSTAT  0x07 /* PVC status */
  79 #define LMI_CCITT_PVCSTAT       0x57
  80
  81 #define LMI_FULLREP             0x00 /* full report  */
  82 #define LMI_INTEGRITY           0x01 /* link integrity report */
  83 #define LMI_SINGLE              0x02 /* single PVC report */
  84
  85 #define LMI_STATUS_ENQUIRY      0x75
  86 #define LMI_STATUS              0x7D /* reply */
  87
  88 #define LMI_REPT_LEN               1 /* report type element length */
  89 #define LMI_INTEG_LEN              2 /* link integrity element length */
  90
  91 #define LMI_CCITT_CISCO_LENGTH    13 /* LMI frame lengths */
  92 #define LMI_ANSI_LENGTH           14
  93
  94
  95 typedef struct {
  96 #if defined(__LITTLE_ENDIAN_BITFIELD)
  97         unsigned ea1:   1;
  98         unsigned cr:    1;
  99         unsigned dlcih: 6;
 100
 101         unsigned ea2:   1;
 102         unsigned de:    1;
 103         unsigned becn:  1;
 104         unsigned fecn:  1;
 105         unsigned dlcil: 4;
 106 #else
 107         unsigned dlcih: 6;
 108         unsigned cr:    1;
 109         unsigned ea1:   1;
 110
 111         unsigned dlcil: 4;
 112         unsigned fecn:  1;
 113         unsigned becn:  1;
 114         unsigned de:    1;
 115         unsigned ea2:   1;
 116 #endif
 117 }__attribute__ ((packed)) fr_hdr;
 118
 119
 120 typedef struct pvc_device_struct {
 121         struct net_device *frad;
 122         struct net_device *main;
 123         struct net_device *ether;       /* bridged Ethernet interface   */
 124         struct pvc_device_struct *next; /* Sorted in ascending DLCI order */
 125         int dlci;
 126         int open_count;
 127
 128         struct {
 129                 unsigned int new: 1;
 130                 unsigned int active: 1;
 131                 unsigned int exist: 1;
 132                 unsigned int deleted: 1;
 133                 unsigned int fecn: 1;
 134                 unsigned int becn: 1;
 135                 unsigned int bandwidth; /* Cisco LMI reporting only */
 136         }state;
 137 }pvc_device;
 138
 139
 140 struct frad_state {
 141         fr_proto settings;
 142         pvc_device *first_pvc;
 143         int dce_pvc_count;
 144
 145         struct timer_list timer;
 146         unsigned long last_poll;
 147         int reliable;
 148         int dce_changed;
 149         int request;
 150         int fullrep_sent;
 151         u32 last_errors; /* last errors bit list */
 152         u8 n391cnt;
 153         u8 txseq; /* TX sequence number */
 154         u8 rxseq; /* RX sequence number */
 155 };
 156
 157
 158 static int fr_ioctl(struct net_device *dev, struct ifreq *ifr);
 159
 160
 161 static inline u16 q922_to_dlci(u8 *hdr)
 162 {
 163         return ((hdr[0] & 0xFC) << 2) | ((hdr[1] & 0xF0) >> 4);
 164 }
 165
 166
 167 static inline void dlci_to_q922(u8 *hdr, u16 dlci)
 168 {
 169         hdr[0] = (dlci >> 2) & 0xFC;
 170         hdr[1] = ((dlci << 4) & 0xF0) | 0x01;
 171 }
 172
 173
 174 static inline struct frad_state * state(hdlc_device *hdlc)
 175 {
 176         return(struct frad_state *)(hdlc->state);
 177 }
 178
 179
 180 static __inline__ pvc_device* dev_to_pvc(struct net_device *dev)
 181 {
 182         return dev->priv;
 183 }
 184
 185
 186 static inline pvc_device* find_pvc(hdlc_device *hdlc, u16 dlci)
 187 {
 188         pvc_device *pvc = state(hdlc)->first_pvc;
 189
 190         while (pvc) {
 191                 if (pvc->dlci == dlci)
 192                         return pvc;
 193                 if (pvc->dlci > dlci)
 194                         return NULL; /* the listed is sorted */
 195                 pvc = pvc->next;
 196         }
 197
 198         return NULL;
 199 }
 200
 201
 202 static pvc_device* add_pvc(struct net_device *dev, u16 dlci)
 203 {
 204         hdlc_device *hdlc = dev_to_hdlc(dev);
 205         pvc_device *pvc, **pvc_p = &state(hdlc)->first_pvc;
 206
 207         while (*pvc_p) {
 208                 if ((*pvc_p)->dlci == dlci)
 209                         return *pvc_p;
 210                 if ((*pvc_p)->dlci > dlci)
 211                         break;  /* the list is sorted */
 212                 pvc_p = &(*pvc_p)->next;
 213         }
 214
 215         pvc = kzalloc(sizeof(pvc_device), GFP_ATOMIC);
 216 #ifdef DEBUG_PVC
 217         printk(KERN_DEBUG "add_pvc: allocated pvc %p, frad %p\n", pvc, dev);
 218 #endif
 219         if (!pvc)
 220                 return NULL;
 221
 222         pvc->dlci = dlci;
 223         pvc->frad = dev;
 224         pvc->next = *pvc_p;     /* Put it in the chain */
 225         *pvc_p = pvc;
 226         return pvc;
 227 }
 228
 229
 230 static inline int pvc_is_used(pvc_device *pvc)
 231 {
 232         return pvc->main || pvc->ether;
 233 }
 234
 235
 236 static inline void pvc_carrier(int on, pvc_device *pvc)
 237 {
 238         if (on) {
 239                 if (pvc->main)
 240                         if (!netif_carrier_ok(pvc->main))
 241                                 netif_carrier_on(pvc->main);
 242                 if (pvc->ether)
 243                         if (!netif_carrier_ok(pvc->ether))
 244                                 netif_carrier_on(pvc->ether);
 245         } else {
 246                 if (pvc->main)
 247                         if (netif_carrier_ok(pvc->main))
 248                                 netif_carrier_off(pvc->main);
 249                 if (pvc->ether)
 250                         if (netif_carrier_ok(pvc->ether))
 251                                 netif_carrier_off(pvc->ether);
 252         }
 253 }
 254
 255
 256 static inline void delete_unused_pvcs(hdlc_device *hdlc)
 257 {
 258         pvc_device **pvc_p = &state(hdlc)->first_pvc;
 259
 260         while (*pvc_p) {
 261                 if (!pvc_is_used(*pvc_p)) {
 262                         pvc_device *pvc = *pvc_p;
 263 #ifdef DEBUG_PVC
 264                         printk(KERN_DEBUG "freeing unused pvc: %p\n", pvc);
 265 #endif
 266                         *pvc_p = pvc->next;
 267                         kfree(pvc);
 268                         continue;
 269                 }
 270                 pvc_p = &(*pvc_p)->next;
 271         }
 272 }
 273
 274
 275 static inline struct net_device** get_dev_p(pvc_device *pvc, int type)
 276 {
 277         if (type == ARPHRD_ETHER)
 278                 return &pvc->ether;
 279         else
 280                 return &pvc->main;
 281 }
 282
 283
 284 static int fr_hard_header(struct sk_buff **skb_p, u16 dlci)
 285 {
 286         u16 head_len;
 287         struct sk_buff *skb = *skb_p;
 288
 289         switch (skb->protocol) {
 290         case __constant_htons(NLPID_CCITT_ANSI_LMI):
 291                 head_len = 4;
 292                 skb_push(skb, head_len);
 293                 skb->data[3] = NLPID_CCITT_ANSI_LMI;
 294                 break;
 295
 296         case __constant_htons(NLPID_CISCO_LMI):
 297                 head_len = 4;
 298                 skb_push(skb, head_len);
 299                 skb->data[3] = NLPID_CISCO_LMI;
 300                 break;
 301
 302         case __constant_htons(ETH_P_IP):
 303                 head_len = 4;
 304                 skb_push(skb, head_len);
 305                 skb->data[3] = NLPID_IP;
 306                 break;
 307
 308         case __constant_htons(ETH_P_IPV6):
 309                 head_len = 4;
 310                 skb_push(skb, head_len);
 311                 skb->data[3] = NLPID_IPV6;
 312                 break;
 313
 314         case __constant_htons(ETH_P_802_3):
 315                 head_len = 10;
 316                 if (skb_headroom(skb) < head_len) {
 317                         struct sk_buff *skb2 = skb_realloc_headroom(skb,
 318                                                                     head_len);
 319                         if (!skb2)
 320                                 return -ENOBUFS;
 321                         dev_kfree_skb(skb);
 322                         skb = *skb_p = skb2;
 323                 }
 324                 skb_push(skb, head_len);
 325                 skb->data[3] = FR_PAD;
 326                 skb->data[4] = NLPID_SNAP;
 327                 skb->data[5] = FR_PAD;
 328                 skb->data[6] = 0x80;
 329                 skb->data[7] = 0xC2;
 330                 skb->data[8] = 0x00;
 331                 skb->data[9] = 0x07; /* bridged Ethernet frame w/out FCS */
 332                 break;
 333
 334         default:
 335                 head_len = 10;
 336                 skb_push(skb, head_len);
 337                 skb->data[3] = FR_PAD;
 338                 skb->data[4] = NLPID_SNAP;
 339                 skb->data[5] = FR_PAD;
 340                 skb->data[6] = FR_PAD;
 341                 skb->data[7] = FR_PAD;
 342                 *(__be16*)(skb->data + 8) = skb->protocol;
 343         }
 344
 345         dlci_to_q922(skb->data, dlci);
 346         skb->data[2] = FR_UI;
 347         return 0;
 348 }
 349
 350
 351
 352 static int pvc_open(struct net_device *dev)
 353 {
 354         pvc_device *pvc = dev_to_pvc(dev);
 355
 356         if ((pvc->frad->flags & IFF_UP) == 0)
 357                 return -EIO;  /* Frad must be UP in order to activate PVC */
 358
 359         if (pvc->open_count++ == 0) {
 360                 hdlc_device *hdlc = dev_to_hdlc(pvc->frad);
 361                 if (state(hdlc)->settings.lmi == LMI_NONE)
 362                         pvc->state.active = netif_carrier_ok(pvc->frad);
 363
 364                 pvc_carrier(pvc->state.active, pvc);
 365                 state(hdlc)->dce_changed = 1;
 366         }
 367         return 0;
 368 }
 369
 370
 371
 372 static int pvc_close(struct net_device *dev)
 373 {
 374         pvc_device *pvc = dev_to_pvc(dev);
 375
 376         if (--pvc->open_count == 0) {
 377                 hdlc_device *hdlc = dev_to_hdlc(pvc->frad);
 378                 if (state(hdlc)->settings.lmi == LMI_NONE)
 379                         pvc->state.active = 0;
 380
 381                 if (state(hdlc)->settings.dce) {
 382                         state(hdlc)->dce_changed = 1;
 383                         pvc->state.active = 0;
 384                 }
 385         }
 386         return 0;
 387 }
 388
 389
 390
 391 static int pvc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 392 {
 393         pvc_device *pvc = dev_to_pvc(dev);
 394         fr_proto_pvc_info info;
 395
 396         if (ifr->ifr_settings.type == IF_GET_PROTO) {
 397                 if (dev->type == ARPHRD_ETHER)
 398                         ifr->ifr_settings.type = IF_PROTO_FR_ETH_PVC;
 399                 else
 400                         ifr->ifr_settings.type = IF_PROTO_FR_PVC;
 401
 402                 if (ifr->ifr_settings.size < sizeof(info)) {
 403                         /* data size wanted */
 404                         ifr->ifr_settings.size = sizeof(info);
 405                         return -ENOBUFS;
 406                 }
 407
 408                 info.dlci = pvc->dlci;
 409                 memcpy(info.master, pvc->frad->name, IFNAMSIZ);
 410                 if (copy_to_user(ifr->ifr_settings.ifs_ifsu.fr_pvc_info,
 411                                  &info, sizeof(info)))
 412                         return -EFAULT;
 413                 return 0;
 414         }
 415
 416         return -EINVAL;
 417 }
 418
 419
 420 static inline struct net_device_stats *pvc_get_stats(struct net_device *dev)
 421 {
 422         return &dev_to_desc(dev)->stats;
 423 }
 424
 425
 426
 427 static int pvc_xmit(struct sk_buff *skb, struct net_device *dev)
 428 {
 429         pvc_device *pvc = dev_to_pvc(dev);
 430         struct net_device_stats *stats = pvc_get_stats(dev);
 431
 432         if (pvc->state.active) {
 433                 if (dev->type == ARPHRD_ETHER) {
 434                         int pad = ETH_ZLEN - skb->len;
 435                         if (pad > 0) { /* Pad the frame with zeros */
 436                                 int len = skb->len;
 437                                 if (skb_tailroom(skb) < pad)
 438                                         if (pskb_expand_head(skb, 0, pad,
 439                                                              GFP_ATOMIC)) {
 440                                                 stats->tx_dropped++;
 441                                                 dev_kfree_skb(skb);
 442                                                 return 0;
 443                                         }
 444                                 skb_put(skb, pad);
 445                                 memset(skb->data + len, 0, pad);
 446                         }
 447                         skb->protocol = __constant_htons(ETH_P_802_3);
 448                 }
 449                 if (!fr_hard_header(&skb, pvc->dlci)) {
 450                         stats->tx_bytes += skb->len;
 451                         stats->tx_packets++;
 452                         if (pvc->state.fecn) /* TX Congestion counter */
 453                                 stats->tx_compressed++;
 454                         skb->dev = pvc->frad;
 455                         dev_queue_xmit(skb);
 456                         return 0;
 457                 }
 458         }
 459
 460         stats->tx_dropped++;
 461         dev_kfree_skb(skb);
 462         return 0;
 463 }
 464
 465
 466
 467 static int pvc_change_mtu(struct net_device *dev, int new_mtu)
 468 {
 469         if ((new_mtu < 68) || (new_mtu > HDLC_MAX_MTU))
 470                 return -EINVAL;
 471         dev->mtu = new_mtu;
 472         return 0;
 473 }
 474
 475
 476
 477 static inline void fr_log_dlci_active(pvc_device *pvc)
 478 {
 479         printk(KERN_INFO "%s: DLCI %d [%s%s%s]%s %s\n",
 480                pvc->frad->name,
 481                pvc->dlci,
 482                pvc->main ? pvc->main->name : "",
 483                pvc->main && pvc->ether ? " " : "",
 484                pvc->ether ? pvc->ether->name : "",
 485                pvc->state.new ? " new" : "",
 486                !pvc->state.exist ? "deleted" :
 487                pvc->state.active ? "active" : "inactive");
 488 }
 489
 490
 491
 492 static inline u8 fr_lmi_nextseq(u8 x)
 493 {
 494         x++;
 495         return x ? x : 1;
 496 }
 497
 498
 499 static void fr_lmi_send(struct net_device *dev, int fullrep)
 500 {
 501         hdlc_device *hdlc = dev_to_hdlc(dev);
 502         struct sk_buff *skb;
 503         pvc_device *pvc = state(hdlc)->first_pvc;
 504         int lmi = state(hdlc)->settings.lmi;
 505         int dce = state(hdlc)->settings.dce;
 506         int len = lmi == LMI_ANSI ? LMI_ANSI_LENGTH : LMI_CCITT_CISCO_LENGTH;
 507         int stat_len = (lmi == LMI_CISCO) ? 6 : 3;
 508         u8 *data;
 509         int i = 0;
 510
 511         if (dce && fullrep) {
 512                 len += state(hdlc)->dce_pvc_count * (2 + stat_len);
 513                 if (len > HDLC_MAX_MRU) {
 514                         printk(KERN_WARNING "%s: Too many PVCs while sending "
 515                                "LMI full report\n", dev->name);
 516                         return;
 517                 }
 518         }
 519
 520         skb = dev_alloc_skb(len);
 521         if (!skb) {
 522                 printk(KERN_WARNING "%s: Memory squeeze on fr_lmi_send()\n",
 523                        dev->name);
 524                 return;
 525         }
 526         memset(skb->data, 0, len);
 527         skb_reserve(skb, 4);
 528         if (lmi == LMI_CISCO) {
 529                 skb->protocol = __constant_htons(NLPID_CISCO_LMI);
 530                 fr_hard_header(&skb, LMI_CISCO_DLCI);
 531         } else {
 532                 skb->protocol = __constant_htons(NLPID_CCITT_ANSI_LMI);
 533                 fr_hard_header(&skb, LMI_CCITT_ANSI_DLCI);
 534         }
 535         data = skb_tail_pointer(skb);
 536         data[i++] = LMI_CALLREF;
 537         data[i++] = dce ? LMI_STATUS : LMI_STATUS_ENQUIRY;
 538         if (lmi == LMI_ANSI)
 539                 data[i++] = LMI_ANSI_LOCKSHIFT;
 540         data[i++] = lmi == LMI_CCITT ? LMI_CCITT_REPTYPE :
 541                 LMI_ANSI_CISCO_REPTYPE;
 542         data[i++] = LMI_REPT_LEN;
 543         data[i++] = fullrep ? LMI_FULLREP : LMI_INTEGRITY;
 544         data[i++] = lmi == LMI_CCITT ? LMI_CCITT_ALIVE : LMI_ANSI_CISCO_ALIVE;
 545         data[i++] = LMI_INTEG_LEN;
 546         data[i++] = state(hdlc)->txseq =
 547                 fr_lmi_nextseq(state(hdlc)->txseq);
 548         data[i++] = state(hdlc)->rxseq;
 549
 550         if (dce && fullrep) {
 551                 while (pvc) {
 552                         data[i++] = lmi == LMI_CCITT ? LMI_CCITT_PVCSTAT :
 553                                 LMI_ANSI_CISCO_PVCSTAT;
 554                         data[i++] = stat_len;
 555
 556                         /* LMI start/restart */
 557                         if (state(hdlc)->reliable && !pvc->state.exist) {
 558                                 pvc->state.exist = pvc->state.new = 1;
 559                                 fr_log_dlci_active(pvc);
 560                         }
 561
 562                         /* ifconfig PVC up */
 563                         if (pvc->open_count && !pvc->state.active &&
 564                             pvc->state.exist && !pvc->state.new) {
 565                                 pvc_carrier(1, pvc);
 566                                 pvc->state.active = 1;
 567                                 fr_log_dlci_active(pvc);
 568                         }
 569
 570                         if (lmi == LMI_CISCO) {
 571                                 data[i] = pvc->dlci >> 8;
 572                                 data[i + 1] = pvc->dlci & 0xFF;
 573                         } else {
 574                                 data[i] = (pvc->dlci >> 4) & 0x3F;
 575                                 data[i + 1] = ((pvc->dlci << 3) & 0x78) | 0x80;
 576                                 data[i + 2] = 0x80;
 577                         }
 578
 579                         if (pvc->state.new)
 580                                 data[i + 2] |= 0x08;
 581                         else if (pvc->state.active)
 582                                 data[i + 2] |= 0x02;
 583
 584                         i += stat_len;
 585                         pvc = pvc->next;
 586                 }
 587         }
 588
 589         skb_put(skb, i);
 590         skb->priority = TC_PRIO_CONTROL;
 591         skb->dev = dev;
 592         skb_reset_network_header(skb);
 593
 594         dev_queue_xmit(skb);
 595 }
 596
 597
 598
 599 static void fr_set_link_state(int reliable, struct net_device *dev)
 600 {
 601         hdlc_device *hdlc = dev_to_hdlc(dev);
 602         pvc_device *pvc = state(hdlc)->first_pvc;
 603
 604         state(hdlc)->reliable = reliable;
 605         if (reliable) {
 606                 netif_dormant_off(dev);
 607                 state(hdlc)->n391cnt = 0; /* Request full status */
 608                 state(hdlc)->dce_changed = 1;
 609
 610                 if (state(hdlc)->settings.lmi == LMI_NONE) {
 611                         while (pvc) {   /* Activate all PVCs */
 612                                 pvc_carrier(1, pvc);
 613                                 pvc->state.exist = pvc->state.active = 1;
 614                                 pvc->state.new = 0;
 615                                 pvc = pvc->next;
 616                         }
 617                 }
 618         } else {
 619                 netif_dormant_on(dev);
 620                 while (pvc) {           /* Deactivate all PVCs */
 621                         pvc_carrier(0, pvc);
 622                         pvc->state.exist = pvc->state.active = 0;
 623                         pvc->state.new = 0;
 624                         if (!state(hdlc)->settings.dce)
 625                                 pvc->state.bandwidth = 0;
 626                         pvc = pvc->next;
 627                 }
 628         }
 629 }
 630
 631
 632 static void fr_timer(unsigned long arg)
 633 {
 634         struct net_device *dev = (struct net_device *)arg;
 635         hdlc_device *hdlc = dev_to_hdlc(dev);
 636         int i, cnt = 0, reliable;
 637         u32 list;
 638
 639         if (state(hdlc)->settings.dce) {
 640                 reliable = state(hdlc)->request &&
 641                         time_before(jiffies, state(hdlc)->last_poll +
 642                                     state(hdlc)->settings.t392 * HZ);
 643                 state(hdlc)->request = 0;
 644         } else {
 645                 state(hdlc)->last_errors <<= 1; /* Shift the list */
 646                 if (state(hdlc)->request) {
 647                         if (state(hdlc)->reliable)
 648                                 printk(KERN_INFO "%s: No LMI status reply "
 649                                        "received\n", dev->name);
 650                         state(hdlc)->last_errors |= 1;
 651                 }
 652
 653                 list = state(hdlc)->last_errors;
 654                 for (i = 0; i < state(hdlc)->settings.n393; i++, list >>= 1)
 655                         cnt += (list & 1);      /* errors count */
 656
 657                 reliable = (cnt < state(hdlc)->settings.n392);
 658         }
 659
 660         if (state(hdlc)->reliable != reliable) {
 661                 printk(KERN_INFO "%s: Link %sreliable\n", dev->name,
 662                        reliable ? "" : "un");
 663                 fr_set_link_state(reliable, dev);
 664         }
 665
 666         if (state(hdlc)->settings.dce)
 667                 state(hdlc)->timer.expires = jiffies +
 668                         state(hdlc)->settings.t392 * HZ;
 669         else {
 670                 if (state(hdlc)->n391cnt)
 671                         state(hdlc)->n391cnt--;
 672
 673                 fr_lmi_send(dev, state(hdlc)->n391cnt == 0);
 674
 675                 state(hdlc)->last_poll = jiffies;
 676                 state(hdlc)->request = 1;
 677                 state(hdlc)->timer.expires = jiffies +
 678                         state(hdlc)->settings.t391 * HZ;
 679         }
 680
 681         state(hdlc)->timer.function = fr_timer;
 682         state(hdlc)->timer.data = arg;
 683         add_timer(&state(hdlc)->timer);
 684 }
 685
 686
 687 static int fr_lmi_recv(struct net_device *dev, struct sk_buff *skb)
 688 {
 689         hdlc_device *hdlc = dev_to_hdlc(dev);
 690         pvc_device *pvc;
 691         u8 rxseq, txseq;
 692         int lmi = state(hdlc)->settings.lmi;
 693         int dce = state(hdlc)->settings.dce;
 694         int stat_len = (lmi == LMI_CISCO) ? 6 : 3, reptype, error, no_ram, i;
 695
 696         if (skb->len < (lmi == LMI_ANSI ? LMI_ANSI_LENGTH :
 697                         LMI_CCITT_CISCO_LENGTH)) {
 698                 printk(KERN_INFO "%s: Short LMI frame\n", dev->name);
 699                 return 1;
 700         }
 701
 702         if (skb->data[3] != (lmi == LMI_CISCO ? NLPID_CISCO_LMI :
 703                              NLPID_CCITT_ANSI_LMI)) {
 704                 printk(KERN_INFO "%s: Received non-LMI frame with LMI DLCI\n",
 705                        dev->name);
 706                 return 1;
 707         }
 708
 709         if (skb->data[4] != LMI_CALLREF) {
 710                 printk(KERN_INFO "%s: Invalid LMI Call reference (0x%02X)\n",
 711                        dev->name, skb->data[4]);
 712                 return 1;
 713         }
 714
 715         if (skb->data[5] != (dce ? LMI_STATUS_ENQUIRY : LMI_STATUS)) {
 716                 printk(KERN_INFO "%s: Invalid LMI Message type (0x%02X)\n",
 717                        dev->name, skb->data[5]);
 718                 return 1;
 719         }
 720
 721         if (lmi == LMI_ANSI) {
 722                 if (skb->data[6] != LMI_ANSI_LOCKSHIFT) {
 723                         printk(KERN_INFO "%s: Not ANSI locking shift in LMI"
 724                                " message (0x%02X)\n", dev->name, skb->data[6]);
 725                         return 1;
 726                 }
 727                 i = 7;
 728         } else
 729                 i = 6;
 730
 731         if (skb->data[i] != (lmi == LMI_CCITT ? LMI_CCITT_REPTYPE :
 732                              LMI_ANSI_CISCO_REPTYPE)) {
 733                 printk(KERN_INFO "%s: Not an LMI Report type IE (0x%02X)\n",
 734                        dev->name, skb->data[i]);
 735                 return 1;
 736         }
 737
 738         if (skb->data[++i] != LMI_REPT_LEN) {
 739                 printk(KERN_INFO "%s: Invalid LMI Report type IE length"
 740                        " (%u)\n", dev->name, skb->data[i]);
 741                 return 1;
 742         }
 743
 744         reptype = skb->data[++i];
 745         if (reptype != LMI_INTEGRITY && reptype != LMI_FULLREP) {
 746                 printk(KERN_INFO "%s: Unsupported LMI Report type (0x%02X)\n",
 747                        dev->name, reptype);
 748                 return 1;
 749         }
 750
 751         if (skb->data[++i] != (lmi == LMI_CCITT ? LMI_CCITT_ALIVE :
 752                                LMI_ANSI_CISCO_ALIVE)) {
 753                 printk(KERN_INFO "%s: Not an LMI Link integrity verification"
 754                        " IE (0x%02X)\n", dev->name, skb->data[i]);
 755                 return 1;
 756         }
 757
 758         if (skb->data[++i] != LMI_INTEG_LEN) {
 759                 printk(KERN_INFO "%s: Invalid LMI Link integrity verification"
 760                        " IE length (%u)\n", dev->name, skb->data[i]);
 761                 return 1;
 762         }
 763         i++;
 764
 765         state(hdlc)->rxseq = skb->data[i++]; /* TX sequence from peer */
 766         rxseq = skb->data[i++]; /* Should confirm our sequence */
 767
 768         txseq = state(hdlc)->txseq;
 769
 770         if (dce)
 771                 state(hdlc)->last_poll = jiffies;
 772
 773         error = 0;
 774         if (!state(hdlc)->reliable)
 775                 error = 1;
 776
 777         if (rxseq == 0 || rxseq != txseq) { /* Ask for full report next time */
 778                 state(hdlc)->n391cnt = 0;
 779                 error = 1;
 780         }
 781
 782         if (dce) {
 783                 if (state(hdlc)->fullrep_sent && !error) {
 784 /* Stop sending full report - the last one has been confirmed by DTE */
 785                         state(hdlc)->fullrep_sent = 0;
 786                         pvc = state(hdlc)->first_pvc;
 787                         while (pvc) {
 788                                 if (pvc->state.new) {
 789                                         pvc->state.new = 0;
 790
 791 /* Tell DTE that new PVC is now active */
 792                                         state(hdlc)->dce_changed = 1;
 793                                 }
 794                                 pvc = pvc->next;
 795                         }
 796                 }
 797
 798                 if (state(hdlc)->dce_changed) {
 799                         reptype = LMI_FULLREP;
 800                         state(hdlc)->fullrep_sent = 1;
 801                         state(hdlc)->dce_changed = 0;
 802                 }
 803
 804                 state(hdlc)->request = 1; /* got request */
 805                 fr_lmi_send(dev, reptype == LMI_FULLREP ? 1 : 0);
 806                 return 0;
 807         }
 808
 809         /* DTE */
 810
 811         state(hdlc)->request = 0; /* got response, no request pending */
 812
 813         if (error)
 814                 return 0;
 815
 816         if (reptype != LMI_FULLREP)
 817                 return 0;
 818
 819         pvc = state(hdlc)->first_pvc;
 820
 821         while (pvc) {
 822                 pvc->state.deleted = 1;
 823                 pvc = pvc->next;
 824         }
 825
 826         no_ram = 0;
 827         while (skb->len >= i + 2 + stat_len) {
 828                 u16 dlci;
 829                 u32 bw;
 830                 unsigned int active, new;
 831
 832                 if (skb->data[i] != (lmi == LMI_CCITT ? LMI_CCITT_PVCSTAT :
 833                                        LMI_ANSI_CISCO_PVCSTAT)) {
 834                         printk(KERN_INFO "%s: Not an LMI PVC status IE"
 835                                " (0x%02X)\n", dev->name, skb->data[i]);
 836                         return 1;
 837                 }
 838
 839                 if (skb->data[++i] != stat_len) {
 840                         printk(KERN_INFO "%s: Invalid LMI PVC status IE length"
 841                                " (%u)\n", dev->name, skb->data[i]);
 842                         return 1;
 843                 }
 844                 i++;
 845
 846                 new = !! (skb->data[i + 2] & 0x08);
 847                 active = !! (skb->data[i + 2] & 0x02);
 848                 if (lmi == LMI_CISCO) {
 849                         dlci = (skb->data[i] << 8) | skb->data[i + 1];
 850                         bw = (skb->data[i + 3] << 16) |
 851                                 (skb->data[i + 4] << 8) |
 852                                 (skb->data[i + 5]);
 853                 } else {
 854                         dlci = ((skb->data[i] & 0x3F) << 4) |
 855                                 ((skb->data[i + 1] & 0x78) >> 3);
 856                         bw = 0;
 857                 }
 858
 859                 pvc = add_pvc(dev, dlci);
 860
 861                 if (!pvc && !no_ram) {
 862                         printk(KERN_WARNING
 863                                "%s: Memory squeeze on fr_lmi_recv()\n",
 864                                dev->name);
 865                         no_ram = 1;
 866                 }
 867
 868                 if (pvc) {
 869                         pvc->state.exist = 1;
 870                         pvc->state.deleted = 0;
 871                         if (active != pvc->state.active ||
 872                             new != pvc->state.new ||
 873                             bw != pvc->state.bandwidth ||
 874                             !pvc->state.exist) {
 875                                 pvc->state.new = new;
 876                                 pvc->state.active = active;
 877                                 pvc->state.bandwidth = bw;
 878                                 pvc_carrier(active, pvc);
 879                                 fr_log_dlci_active(pvc);
 880                         }
 881                 }
 882
 883                 i += stat_len;
 884         }
 885
 886         pvc = state(hdlc)->first_pvc;
 887
 888         while (pvc) {
 889                 if (pvc->state.deleted && pvc->state.exist) {
 890                         pvc_carrier(0, pvc);
 891                         pvc->state.active = pvc->state.new = 0;
 892                         pvc->state.exist = 0;
 893                         pvc->state.bandwidth = 0;
 894                         fr_log_dlci_active(pvc);
 895                 }
 896                 pvc = pvc->next;
 897         }
 898
 899         /* Next full report after N391 polls */
 900         state(hdlc)->n391cnt = state(hdlc)->settings.n391;
 901
 902         return 0;
 903 }
 904
 905
 906 static int fr_rx(struct sk_buff *skb)
 907 {
 908         struct net_device *frad = skb->dev;
 909         hdlc_device *hdlc = dev_to_hdlc(frad);
 910         fr_hdr *fh = (fr_hdr*)skb->data;
 911         u8 *data = skb->data;
 912         u16 dlci;
 913         pvc_device *pvc;
 914         struct net_device *dev = NULL;
 915
 916         if (skb->len <= 4 || fh->ea1 || data[2] != FR_UI)
 917                 goto rx_error;
 918
 919         dlci = q922_to_dlci(skb->data);
 920
 921         if ((dlci == LMI_CCITT_ANSI_DLCI &&
 922              (state(hdlc)->settings.lmi == LMI_ANSI ||
 923               state(hdlc)->settings.lmi == LMI_CCITT)) ||
 924             (dlci == LMI_CISCO_DLCI &&
 925              state(hdlc)->settings.lmi == LMI_CISCO)) {
 926                 if (fr_lmi_recv(frad, skb))
 927                         goto rx_error;
 928                 dev_kfree_skb_any(skb);
 929                 return NET_RX_SUCCESS;
 930         }
 931
 932         pvc = find_pvc(hdlc, dlci);
 933         if (!pvc) {
 934 #ifdef DEBUG_PKT
 935                 printk(KERN_INFO "%s: No PVC for received frame's DLCI %d\n",
 936                        frad->name, dlci);
 937 #endif
 938                 dev_kfree_skb_any(skb);
 939                 return NET_RX_DROP;
 940         }
 941
 942         if (pvc->state.fecn != fh->fecn) {
 943 #ifdef DEBUG_ECN
 944                 printk(KERN_DEBUG "%s: DLCI %d FECN O%s\n", frad->name,
 945                        dlci, fh->fecn ? "N" : "FF");
 946 #endif
 947                 pvc->state.fecn ^= 1;
 948         }
 949
 950         if (pvc->state.becn != fh->becn) {
 951 #ifdef DEBUG_ECN
 952                 printk(KERN_DEBUG "%s: DLCI %d BECN O%s\n", frad->name,
 953                        dlci, fh->becn ? "N" : "FF");
 954 #endif
 955                 pvc->state.becn ^= 1;
 956         }
 957
 958
 959         if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) {
 960                 dev_to_desc(frad)->stats.rx_dropped++;
 961                 return NET_RX_DROP;
 962         }
 963
 964         if (data[3] == NLPID_IP) {
 965                 skb_pull(skb, 4); /* Remove 4-byte header (hdr, UI, NLPID) */
 966                 dev = pvc->main;
 967                 skb->protocol = htons(ETH_P_IP);
 968
 969         } else if (data[3] == NLPID_IPV6) {
 970                 skb_pull(skb, 4); /* Remove 4-byte header (hdr, UI, NLPID) */
 971                 dev = pvc->main;
 972                 skb->protocol = htons(ETH_P_IPV6);
 973
 974         } else if (skb->len > 10 && data[3] == FR_PAD &&
 975                    data[4] == NLPID_SNAP && data[5] == FR_PAD) {
 976                 u16 oui = ntohs(*(__be16*)(data + 6));
 977                 u16 pid = ntohs(*(__be16*)(data + 8));
 978                 skb_pull(skb, 10);
 979
 980                 switch ((((u32)oui) << 16) | pid) {
 981                 case ETH_P_ARP: /* routed frame with SNAP */
 982                 case ETH_P_IPX:
 983                 case ETH_P_IP:  /* a long variant */
 984                 case ETH_P_IPV6:
 985                         dev = pvc->main;
 986                         skb->protocol = htons(pid);
 987                         break;
 988
 989                 case 0x80C20007: /* bridged Ethernet frame */
 990                         if ((dev = pvc->ether) != NULL)
 991                                 skb->protocol = eth_type_trans(skb, dev);
 992                         break;
 993
 994                 default:
 995                         printk(KERN_INFO "%s: Unsupported protocol, OUI=%x "
 996                                "PID=%x\n", frad->name, oui, pid);
 997                         dev_kfree_skb_any(skb);
 998                         return NET_RX_DROP;
 999                 }
1000         } else {
1001                 printk(KERN_INFO "%s: Unsupported protocol, NLPID=%x "
1002                        "length = %i\n", frad->name, data[3], skb->len);
1003                 dev_kfree_skb_any(skb);
1004                 return NET_RX_DROP;
1005         }
1006
1007         if (dev) {
1008                 struct net_device_stats *stats = pvc_get_stats(dev);
1009                 stats->rx_packets++; /* PVC traffic */
1010                 stats->rx_bytes += skb->len;
1011                 if (pvc->state.becn)
1012                         stats->rx_compressed++;
1013                 netif_rx(skb);
1014                 return NET_RX_SUCCESS;
1015         } else {
1016                 dev_kfree_skb_any(skb);
1017                 return NET_RX_DROP;
1018         }
1019
1020  rx_error:
1021         dev_to_desc(frad)->stats.rx_errors++; /* Mark error */
1022         dev_kfree_skb_any(skb);
1023         return NET_RX_DROP;
1024 }
1025
1026
1027
1028 static void fr_start(struct net_device *dev)
1029 {
1030         hdlc_device *hdlc = dev_to_hdlc(dev);
1031 #ifdef DEBUG_LINK
1032         printk(KERN_DEBUG "fr_start\n");
1033 #endif
1034         if (state(hdlc)->settings.lmi != LMI_NONE) {
1035                 state(hdlc)->reliable = 0;
1036                 state(hdlc)->dce_changed = 1;
1037                 state(hdlc)->request = 0;
1038                 state(hdlc)->fullrep_sent = 0;
1039                 state(hdlc)->last_errors = 0xFFFFFFFF;
1040                 state(hdlc)->n391cnt = 0;
1041                 state(hdlc)->txseq = state(hdlc)->rxseq = 0;
1042
1043                 init_timer(&state(hdlc)->timer);
1044                 /* First poll after 1 s */
1045                 state(hdlc)->timer.expires = jiffies + HZ;
1046                 state(hdlc)->timer.function = fr_timer;
1047                 state(hdlc)->timer.data = (unsigned long)dev;
1048                 add_timer(&state(hdlc)->timer);
1049         } else
1050                 fr_set_link_state(1, dev);
1051 }
1052
1053
1054 static void fr_stop(struct net_device *dev)
1055 {
1056         hdlc_device *hdlc = dev_to_hdlc(dev);
1057 #ifdef DEBUG_LINK
1058         printk(KERN_DEBUG "fr_stop\n");
1059 #endif
1060         if (state(hdlc)->settings.lmi != LMI_NONE)
1061                 del_timer_sync(&state(hdlc)->timer);
1062         fr_set_link_state(0, dev);
1063 }
1064
1065
1066 static void fr_close(struct net_device *dev)
1067 {
1068         hdlc_device *hdlc = dev_to_hdlc(dev);
1069         pvc_device *pvc = state(hdlc)->first_pvc;
1070
1071         while (pvc) {           /* Shutdown all PVCs for this FRAD */
1072                 if (pvc->main)
1073                         dev_close(pvc->main);
1074                 if (pvc->ether)
1075                         dev_close(pvc->ether);
1076                 pvc = pvc->next;
1077         }
1078 }
1079
1080
1081 static void pvc_setup(struct net_device *dev)
1082 {
1083         dev->type = ARPHRD_DLCI;
1084         dev->flags = IFF_POINTOPOINT;
1085         dev->hard_header_len = 10;
1086         dev->addr_len = 2;
1087 }
1088
1089 static int fr_add_pvc(struct net_device *frad, unsigned int dlci, int type)
1090 {
1091         hdlc_device *hdlc = dev_to_hdlc(frad);
1092         pvc_device *pvc = NULL;
1093         struct net_device *dev;
1094         int result, used;
1095         char * prefix = "pvc%d";
1096
1097         if (type == ARPHRD_ETHER)
1098                 prefix = "pvceth%d";
1099
1100         if ((pvc = add_pvc(frad, dlci)) == NULL) {
1101                 printk(KERN_WARNING "%s: Memory squeeze on fr_add_pvc()\n",
1102                        frad->name);
1103                 return -ENOBUFS;
1104         }
1105
1106         if (*get_dev_p(pvc, type))
1107                 return -EEXIST;
1108
1109         used = pvc_is_used(pvc);
1110
1111         if (type == ARPHRD_ETHER)
1112                 dev = alloc_netdev(sizeof(struct net_device_stats),
1113                                    "pvceth%d", ether_setup);
1114         else
1115                 dev = alloc_netdev(sizeof(struct net_device_stats),
1116                                    "pvc%d", pvc_setup);
1117
1118         if (!dev) {
1119                 printk(KERN_WARNING "%s: Memory squeeze on fr_pvc()\n",
1120                        frad->name);
1121                 delete_unused_pvcs(hdlc);
1122                 return -ENOBUFS;
1123         }
1124
1125         if (type == ARPHRD_ETHER) {
1126                 memcpy(dev->dev_addr, "\x00\x01", 2);
1127                 get_random_bytes(dev->dev_addr + 2, ETH_ALEN - 2);
1128         } else {
1129                 *(__be16*)dev->dev_addr = htons(dlci);
1130                 dlci_to_q922(dev->broadcast, dlci);
1131         }
1132         dev->hard_start_xmit = pvc_xmit;
1133         dev->get_stats = pvc_get_stats;
1134         dev->open = pvc_open;
1135         dev->stop = pvc_close;
1136         dev->do_ioctl = pvc_ioctl;
1137         dev->change_mtu = pvc_change_mtu;
1138         dev->mtu = HDLC_MAX_MTU;
1139         dev->tx_queue_len = 0;
1140         dev->priv = pvc;
1141
1142         result = dev_alloc_name(dev, dev->name);
1143         if (result < 0) {
1144                 free_netdev(dev);
1145                 delete_unused_pvcs(hdlc);
1146                 return result;
1147         }
1148
1149         if (register_netdevice(dev) != 0) {
1150                 free_netdev(dev);
1151                 delete_unused_pvcs(hdlc);
1152                 return -EIO;
1153         }
1154
1155         dev->destructor = free_netdev;
1156         *get_dev_p(pvc, type) = dev;
1157         if (!used) {
1158                 state(hdlc)->dce_changed = 1;
1159                 state(hdlc)->dce_pvc_count++;
1160         }
1161         return 0;
1162 }
1163
1164
1165
1166 static int fr_del_pvc(hdlc_device *hdlc, unsigned int dlci, int type)
1167 {
1168         pvc_device *pvc;
1169         struct net_device *dev;
1170
1171         if ((pvc = find_pvc(hdlc, dlci)) == NULL)
1172                 return -ENOENT;
1173
1174         if ((dev = *get_dev_p(pvc, type)) == NULL)
1175                 return -ENOENT;
1176
1177         if (dev->flags & IFF_UP)
1178                 return -EBUSY;          /* PVC in use */
1179
1180         unregister_netdevice(dev); /* the destructor will free_netdev(dev) */
1181         *get_dev_p(pvc, type) = NULL;
1182
1183         if (!pvc_is_used(pvc)) {
1184                 state(hdlc)->dce_pvc_count--;
1185                 state(hdlc)->dce_changed = 1;
1186         }
1187         delete_unused_pvcs(hdlc);
1188         return 0;
1189 }
1190
1191
1192
1193 static void fr_destroy(struct net_device *frad)
1194 {
1195         hdlc_device *hdlc = dev_to_hdlc(frad);
1196         pvc_device *pvc = state(hdlc)->first_pvc;
1197         state(hdlc)->first_pvc = NULL; /* All PVCs destroyed */
1198         state(hdlc)->dce_pvc_count = 0;
1199         state(hdlc)->dce_changed = 1;
1200
1201         while (pvc) {
1202                 pvc_device *next = pvc->next;
1203                 /* destructors will free_netdev() main and ether */
1204                 if (pvc->main)
1205                         unregister_netdevice(pvc->main);
1206
1207                 if (pvc->ether)
1208                         unregister_netdevice(pvc->ether);
1209
1210                 kfree(pvc);
1211                 pvc = next;
1212         }
1213 }
1214
1215
1216 static struct hdlc_proto proto = {
1217         .close          = fr_close,
1218         .start          = fr_start,
1219         .stop           = fr_stop,
1220         .detach         = fr_destroy,
1221         .ioctl          = fr_ioctl,
1222         .module         = THIS_MODULE,
1223 };
1224
1225
1226 static int fr_ioctl(struct net_device *dev, struct ifreq *ifr)
1227 {
1228         fr_proto __user *fr_s = ifr->ifr_settings.ifs_ifsu.fr;
1229         const size_t size = sizeof(fr_proto);
1230         fr_proto new_settings;
1231         hdlc_device *hdlc = dev_to_hdlc(dev);
1232         fr_proto_pvc pvc;
1233         int result;
1234
1235         switch (ifr->ifr_settings.type) {
1236         case IF_GET_PROTO:
1237                 if (dev_to_hdlc(dev)->proto != &proto) /* Different proto */
1238                         return -EINVAL;
1239                 ifr->ifr_settings.type = IF_PROTO_FR;
1240                 if (ifr->ifr_settings.size < size) {
1241                         ifr->ifr_settings.size = size; /* data size wanted */
1242                         return -ENOBUFS;
1243                 }
1244                 if (copy_to_user(fr_s, &state(hdlc)->settings, size))
1245                         return -EFAULT;
1246                 return 0;
1247
1248         case IF_PROTO_FR:
1249                 if(!capable(CAP_NET_ADMIN))
1250                         return -EPERM;
1251
1252                 if(dev->flags & IFF_UP)
1253                         return -EBUSY;
1254
1255                 if (copy_from_user(&new_settings, fr_s, size))
1256                         return -EFAULT;
1257
1258                 if (new_settings.lmi == LMI_DEFAULT)
1259                         new_settings.lmi = LMI_ANSI;
1260
1261                 if ((new_settings.lmi != LMI_NONE &&
1262                      new_settings.lmi != LMI_ANSI &&
1263                      new_settings.lmi != LMI_CCITT &&
1264                      new_settings.lmi != LMI_CISCO) ||
1265                     new_settings.t391 < 1 ||
1266                     new_settings.t392 < 2 ||
1267                     new_settings.n391 < 1 ||
1268                     new_settings.n392 < 1 ||
1269                     new_settings.n393 < new_settings.n392 ||
1270                     new_settings.n393 > 32 ||
1271                     (new_settings.dce != 0 &&
1272                      new_settings.dce != 1))
1273                         return -EINVAL;
1274
1275                 result=hdlc->attach(dev, ENCODING_NRZ,PARITY_CRC16_PR1_CCITT);
1276                 if (result)
1277                         return result;
1278
1279                 if (dev_to_hdlc(dev)->proto != &proto) { /* Different proto */
1280                         result = attach_hdlc_protocol(dev, &proto, fr_rx,
1281                                                       sizeof(struct frad_state));
1282                         if (result)
1283                                 return result;
1284                         state(hdlc)->first_pvc = NULL;
1285                         state(hdlc)->dce_pvc_count = 0;
1286                 }
1287                 memcpy(&state(hdlc)->settings, &new_settings, size);
1288
1289                 dev->hard_start_xmit = hdlc->xmit;
1290                 dev->type = ARPHRD_FRAD;
1291                 return 0;
1292
1293         case IF_PROTO_FR_ADD_PVC:
1294         case IF_PROTO_FR_DEL_PVC:
1295         case IF_PROTO_FR_ADD_ETH_PVC:
1296         case IF_PROTO_FR_DEL_ETH_PVC:
1297                 if (dev_to_hdlc(dev)->proto != &proto) /* Different proto */
1298                         return -EINVAL;
1299
1300                 if(!capable(CAP_NET_ADMIN))
1301                         return -EPERM;
1302
1303                 if (copy_from_user(&pvc, ifr->ifr_settings.ifs_ifsu.fr_pvc,
1304                                    sizeof(fr_proto_pvc)))
1305                         return -EFAULT;
1306
1307                 if (pvc.dlci <= 0 || pvc.dlci >= 1024)
1308                         return -EINVAL; /* Only 10 bits, DLCI 0 reserved */
1309
1310                 if (ifr->ifr_settings.type == IF_PROTO_FR_ADD_ETH_PVC ||
1311                     ifr->ifr_settings.type == IF_PROTO_FR_DEL_ETH_PVC)
1312                         result = ARPHRD_ETHER; /* bridged Ethernet device */
1313                 else
1314                         result = ARPHRD_DLCI;
1315
1316                 if (ifr->ifr_settings.type == IF_PROTO_FR_ADD_PVC ||
1317                     ifr->ifr_settings.type == IF_PROTO_FR_ADD_ETH_PVC)
1318                         return fr_add_pvc(dev, pvc.dlci, result);
1319                 else
1320                         return fr_del_pvc(hdlc, pvc.dlci, result);
1321         }
1322
1323         return -EINVAL;
1324 }
1325
1326
1327 static int __init mod_init(void)
1328 {
1329         register_hdlc_protocol(&proto);
1330         return 0;
1331 }
1332
1333
1334 static void __exit mod_exit(void)
1335 {
1336         unregister_hdlc_protocol(&proto);
1337 }
1338
1339
1340 module_init(mod_init);
1341 module_exit(mod_exit);
1342
1343 MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>");
1344 MODULE_DESCRIPTION("Frame-Relay protocol support for generic HDLC");
1345 MODULE_LICENSE("GPL v2");