git.oblomov.eu Git - linux-2.6/blob - drivers/net/wan/ixp4xx_hss.c

   1 /*
   2  * Intel IXP4xx HSS (synchronous serial port) driver for Linux
   3  *
   4  * Copyright (C) 2007-2008 Krzysztof Hałasa <khc@pm.waw.pl>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of version 2 of the GNU General Public License
   8  * as published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/bitops.h>
  12 #include <linux/cdev.h>
  13 #include <linux/dma-mapping.h>
  14 #include <linux/dmapool.h>
  15 #include <linux/fs.h>
  16 #include <linux/hdlc.h>
  17 #include <linux/io.h>
  18 #include <linux/kernel.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/poll.h>
  21 #include <mach/npe.h>
  22 #include <mach/qmgr.h>
  23
  24 #define DEBUG_DESC              0
  25 #define DEBUG_RX                0
  26 #define DEBUG_TX                0
  27 #define DEBUG_PKT_BYTES         0
  28 #define DEBUG_CLOSE             0
  29
  30 #define DRV_NAME                "ixp4xx_hss"
  31
  32 #define PKT_EXTRA_FLAGS         0 /* orig 1 */
  33 #define PKT_NUM_PIPES           1 /* 1, 2 or 4 */
  34 #define PKT_PIPE_FIFO_SIZEW     4 /* total 4 dwords per HSS */
  35
  36 #define RX_DESCS                16 /* also length of all RX queues */
  37 #define TX_DESCS                16 /* also length of all TX queues */
  38
  39 #define POOL_ALLOC_SIZE         (sizeof(struct desc) * (RX_DESCS + TX_DESCS))
  40 #define RX_SIZE                 (HDLC_MAX_MRU + 4) /* NPE needs more space */
  41 #define MAX_CLOSE_WAIT          1000 /* microseconds */
  42 #define HSS_COUNT               2
  43 #define FRAME_SIZE              256 /* doesn't matter at this point */
  44 #define FRAME_OFFSET            0
  45 #define MAX_CHANNELS            (FRAME_SIZE / 8)
  46
  47 #define NAPI_WEIGHT             16
  48
  49 /* Queue IDs */
  50 #define HSS0_CHL_RXTRIG_QUEUE   12      /* orig size = 32 dwords */
  51 #define HSS0_PKT_RX_QUEUE       13      /* orig size = 32 dwords */
  52 #define HSS0_PKT_TX0_QUEUE      14      /* orig size = 16 dwords */
  53 #define HSS0_PKT_TX1_QUEUE      15
  54 #define HSS0_PKT_TX2_QUEUE      16
  55 #define HSS0_PKT_TX3_QUEUE      17
  56 #define HSS0_PKT_RXFREE0_QUEUE  18      /* orig size = 16 dwords */
  57 #define HSS0_PKT_RXFREE1_QUEUE  19
  58 #define HSS0_PKT_RXFREE2_QUEUE  20
  59 #define HSS0_PKT_RXFREE3_QUEUE  21
  60 #define HSS0_PKT_TXDONE_QUEUE   22      /* orig size = 64 dwords */
  61
  62 #define HSS1_CHL_RXTRIG_QUEUE   10
  63 #define HSS1_PKT_RX_QUEUE       0
  64 #define HSS1_PKT_TX0_QUEUE      5
  65 #define HSS1_PKT_TX1_QUEUE      6
  66 #define HSS1_PKT_TX2_QUEUE      7
  67 #define HSS1_PKT_TX3_QUEUE      8
  68 #define HSS1_PKT_RXFREE0_QUEUE  1
  69 #define HSS1_PKT_RXFREE1_QUEUE  2
  70 #define HSS1_PKT_RXFREE2_QUEUE  3
  71 #define HSS1_PKT_RXFREE3_QUEUE  4
  72 #define HSS1_PKT_TXDONE_QUEUE   9
  73
  74 #define NPE_PKT_MODE_HDLC               0
  75 #define NPE_PKT_MODE_RAW                1
  76 #define NPE_PKT_MODE_56KMODE            2
  77 #define NPE_PKT_MODE_56KENDIAN_MSB      4
  78
  79 /* PKT_PIPE_HDLC_CFG_WRITE flags */
  80 #define PKT_HDLC_IDLE_ONES              0x1 /* default = flags */
  81 #define PKT_HDLC_CRC_32                 0x2 /* default = CRC-16 */
  82 #define PKT_HDLC_MSB_ENDIAN             0x4 /* default = LE */
  83
  84
  85 /* hss_config, PCRs */
  86 /* Frame sync sampling, default = active low */
  87 #define PCR_FRM_SYNC_ACTIVE_HIGH        0x40000000
  88 #define PCR_FRM_SYNC_FALLINGEDGE        0x80000000
  89 #define PCR_FRM_SYNC_RISINGEDGE         0xC0000000
  90
  91 /* Frame sync pin: input (default) or output generated off a given clk edge */
  92 #define PCR_FRM_SYNC_OUTPUT_FALLING     0x20000000
  93 #define PCR_FRM_SYNC_OUTPUT_RISING      0x30000000
  94
  95 /* Frame and data clock sampling on edge, default = falling */
  96 #define PCR_FCLK_EDGE_RISING            0x08000000
  97 #define PCR_DCLK_EDGE_RISING            0x04000000
  98
  99 /* Clock direction, default = input */
 100 #define PCR_SYNC_CLK_DIR_OUTPUT         0x02000000
 101
 102 /* Generate/Receive frame pulses, default = enabled */
 103 #define PCR_FRM_PULSE_DISABLED          0x01000000
 104
 105  /* Data rate is full (default) or half the configured clk speed */
 106 #define PCR_HALF_CLK_RATE               0x00200000
 107
 108 /* Invert data between NPE and HSS FIFOs? (default = no) */
 109 #define PCR_DATA_POLARITY_INVERT        0x00100000
 110
 111 /* TX/RX endianness, default = LSB */
 112 #define PCR_MSB_ENDIAN                  0x00080000
 113
 114 /* Normal (default) / open drain mode (TX only) */
 115 #define PCR_TX_PINS_OPEN_DRAIN          0x00040000
 116
 117 /* No framing bit transmitted and expected on RX? (default = framing bit) */
 118 #define PCR_SOF_NO_FBIT                 0x00020000
 119
 120 /* Drive data pins? */
 121 #define PCR_TX_DATA_ENABLE              0x00010000
 122
 123 /* Voice 56k type: drive the data pins low (default), high, high Z */
 124 #define PCR_TX_V56K_HIGH                0x00002000
 125 #define PCR_TX_V56K_HIGH_IMP            0x00004000
 126
 127 /* Unassigned type: drive the data pins low (default), high, high Z */
 128 #define PCR_TX_UNASS_HIGH               0x00000800
 129 #define PCR_TX_UNASS_HIGH_IMP           0x00001000
 130
 131 /* T1 @ 1.544MHz only: Fbit dictated in FIFO (default) or high Z */
 132 #define PCR_TX_FB_HIGH_IMP              0x00000400
 133
 134 /* 56k data endiannes - which bit unused: high (default) or low */
 135 #define PCR_TX_56KE_BIT_0_UNUSED        0x00000200
 136
 137 /* 56k data transmission type: 32/8 bit data (default) or 56K data */
 138 #define PCR_TX_56KS_56K_DATA            0x00000100
 139
 140 /* hss_config, cCR */
 141 /* Number of packetized clients, default = 1 */
 142 #define CCR_NPE_HFIFO_2_HDLC            0x04000000
 143 #define CCR_NPE_HFIFO_3_OR_4HDLC        0x08000000
 144
 145 /* default = no loopback */
 146 #define CCR_LOOPBACK                    0x02000000
 147
 148 /* HSS number, default = 0 (first) */
 149 #define CCR_SECOND_HSS                  0x01000000
 150
 151
 152 /* hss_config, clkCR: main:10, num:10, denom:12 */
 153 #define CLK42X_SPEED_EXP        ((0x3FF << 22) | (  2 << 12) |   15) /*65 KHz*/
 154
 155 #define CLK42X_SPEED_512KHZ     ((  130 << 22) | (  2 << 12) |   15)
 156 #define CLK42X_SPEED_1536KHZ    ((   43 << 22) | ( 18 << 12) |   47)
 157 #define CLK42X_SPEED_1544KHZ    ((   43 << 22) | ( 33 << 12) |  192)
 158 #define CLK42X_SPEED_2048KHZ    ((   32 << 22) | ( 34 << 12) |   63)
 159 #define CLK42X_SPEED_4096KHZ    ((   16 << 22) | ( 34 << 12) |  127)
 160 #define CLK42X_SPEED_8192KHZ    ((    8 << 22) | ( 34 << 12) |  255)
 161
 162 #define CLK46X_SPEED_512KHZ     ((  130 << 22) | ( 24 << 12) |  127)
 163 #define CLK46X_SPEED_1536KHZ    ((   43 << 22) | (152 << 12) |  383)
 164 #define CLK46X_SPEED_1544KHZ    ((   43 << 22) | ( 66 << 12) |  385)
 165 #define CLK46X_SPEED_2048KHZ    ((   32 << 22) | (280 << 12) |  511)
 166 #define CLK46X_SPEED_4096KHZ    ((   16 << 22) | (280 << 12) | 1023)
 167 #define CLK46X_SPEED_8192KHZ    ((    8 << 22) | (280 << 12) | 2047)
 168
 169
 170 /* hss_config, LUT entries */
 171 #define TDMMAP_UNASSIGNED       0
 172 #define TDMMAP_HDLC             1       /* HDLC - packetized */
 173 #define TDMMAP_VOICE56K         2       /* Voice56K - 7-bit channelized */
 174 #define TDMMAP_VOICE64K         3       /* Voice64K - 8-bit channelized */
 175
 176 /* offsets into HSS config */
 177 #define HSS_CONFIG_TX_PCR       0x00 /* port configuration registers */
 178 #define HSS_CONFIG_RX_PCR       0x04
 179 #define HSS_CONFIG_CORE_CR      0x08 /* loopback control, HSS# */
 180 #define HSS_CONFIG_CLOCK_CR     0x0C /* clock generator control */
 181 #define HSS_CONFIG_TX_FCR       0x10 /* frame configuration registers */
 182 #define HSS_CONFIG_RX_FCR       0x14
 183 #define HSS_CONFIG_TX_LUT       0x18 /* channel look-up tables */
 184 #define HSS_CONFIG_RX_LUT       0x38
 185
 186
 187 /* NPE command codes */
 188 /* writes the ConfigWord value to the location specified by offset */
 189 #define PORT_CONFIG_WRITE               0x40
 190
 191 /* triggers the NPE to load the contents of the configuration table */
 192 #define PORT_CONFIG_LOAD                0x41
 193
 194 /* triggers the NPE to return an HssErrorReadResponse message */
 195 #define PORT_ERROR_READ                 0x42
 196
 197 /* triggers the NPE to reset internal status and enable the HssPacketized
 198    operation for the flow specified by pPipe */
 199 #define PKT_PIPE_FLOW_ENABLE            0x50
 200 #define PKT_PIPE_FLOW_DISABLE           0x51
 201 #define PKT_NUM_PIPES_WRITE             0x52
 202 #define PKT_PIPE_FIFO_SIZEW_WRITE       0x53
 203 #define PKT_PIPE_HDLC_CFG_WRITE         0x54
 204 #define PKT_PIPE_IDLE_PATTERN_WRITE     0x55
 205 #define PKT_PIPE_RX_SIZE_WRITE          0x56
 206 #define PKT_PIPE_MODE_WRITE             0x57
 207
 208 /* HDLC packet status values - desc->status */
 209 #define ERR_SHUTDOWN            1 /* stop or shutdown occurrance */
 210 #define ERR_HDLC_ALIGN          2 /* HDLC alignment error */
 211 #define ERR_HDLC_FCS            3 /* HDLC Frame Check Sum error */
 212 #define ERR_RXFREE_Q_EMPTY      4 /* RX-free queue became empty while receiving
 213                                      this packet (if buf_len < pkt_len) */
 214 #define ERR_HDLC_TOO_LONG       5 /* HDLC frame size too long */
 215 #define ERR_HDLC_ABORT          6 /* abort sequence received */
 216 #define ERR_DISCONNECTING       7 /* disconnect is in progress */
 217
 218
 219 #ifdef __ARMEB__
 220 typedef struct sk_buff buffer_t;
 221 #define free_buffer dev_kfree_skb
 222 #define free_buffer_irq dev_kfree_skb_irq
 223 #else
 224 typedef void buffer_t;
 225 #define free_buffer kfree
 226 #define free_buffer_irq kfree
 227 #endif
 228
 229 struct port {
 230         struct device *dev;
 231         struct npe *npe;
 232         struct net_device *netdev;
 233         struct napi_struct napi;
 234         struct hss_plat_info *plat;
 235         buffer_t *rx_buff_tab[RX_DESCS], *tx_buff_tab[TX_DESCS];
 236         struct desc *desc_tab;  /* coherent */
 237         u32 desc_tab_phys;
 238         unsigned int id;
 239         unsigned int clock_type, clock_rate, loopback;
 240         unsigned int initialized, carrier;
 241         u8 hdlc_cfg;
 242 };
 243
 244 /* NPE message structure */
 245 struct msg {
 246 #ifdef __ARMEB__
 247         u8 cmd, unused, hss_port, index;
 248         union {
 249                 struct { u8 data8a, data8b, data8c, data8d; };
 250                 struct { u16 data16a, data16b; };
 251                 struct { u32 data32; };
 252         };
 253 #else
 254         u8 index, hss_port, unused, cmd;
 255         union {
 256                 struct { u8 data8d, data8c, data8b, data8a; };
 257                 struct { u16 data16b, data16a; };
 258                 struct { u32 data32; };
 259         };
 260 #endif
 261 };
 262
 263 /* HDLC packet descriptor */
 264 struct desc {
 265         u32 next;               /* pointer to next buffer, unused */
 266
 267 #ifdef __ARMEB__
 268         u16 buf_len;            /* buffer length */
 269         u16 pkt_len;            /* packet length */
 270         u32 data;               /* pointer to data buffer in RAM */
 271         u8 status;
 272         u8 error_count;
 273         u16 __reserved;
 274 #else
 275         u16 pkt_len;            /* packet length */
 276         u16 buf_len;            /* buffer length */
 277         u32 data;               /* pointer to data buffer in RAM */
 278         u16 __reserved;
 279         u8 error_count;
 280         u8 status;
 281 #endif
 282         u32 __reserved1[4];
 283 };
 284
 285
 286 #define rx_desc_phys(port, n)   ((port)->desc_tab_phys +                \
 287                                  (n) * sizeof(struct desc))
 288 #define rx_desc_ptr(port, n)    (&(port)->desc_tab[n])
 289
 290 #define tx_desc_phys(port, n)   ((port)->desc_tab_phys +                \
 291                                  ((n) + RX_DESCS) * sizeof(struct desc))
 292 #define tx_desc_ptr(port, n)    (&(port)->desc_tab[(n) + RX_DESCS])
 293
 294 /*****************************************************************************
 295  * global variables
 296  ****************************************************************************/
 297
 298 static int ports_open;
 299 static struct dma_pool *dma_pool;
 300 static spinlock_t npe_lock;
 301
 302 static const struct {
 303         int tx, txdone, rx, rxfree;
 304 }queue_ids[2] = {{HSS0_PKT_TX0_QUEUE, HSS0_PKT_TXDONE_QUEUE, HSS0_PKT_RX_QUEUE,
 305                   HSS0_PKT_RXFREE0_QUEUE},
 306                  {HSS1_PKT_TX0_QUEUE, HSS1_PKT_TXDONE_QUEUE, HSS1_PKT_RX_QUEUE,
 307                   HSS1_PKT_RXFREE0_QUEUE},
 308 };
 309
 310 /*****************************************************************************
 311  * utility functions
 312  ****************************************************************************/
 313
 314 static inline struct port* dev_to_port(struct net_device *dev)
 315 {
 316         return dev_to_hdlc(dev)->priv;
 317 }
 318
 319 #ifndef __ARMEB__
 320 static inline void memcpy_swab32(u32 *dest, u32 *src, int cnt)
 321 {
 322         int i;
 323         for (i = 0; i < cnt; i++)
 324                 dest[i] = swab32(src[i]);
 325 }
 326 #endif
 327
 328 /*****************************************************************************
 329  * HSS access
 330  ****************************************************************************/
 331
 332 static void hss_npe_send(struct port *port, struct msg *msg, const char* what)
 333 {
 334         u32 *val = (u32*)msg;
 335         if (npe_send_message(port->npe, msg, what)) {
 336                 printk(KERN_CRIT "HSS-%i: unable to send command [%08X:%08X]"
 337                        " to %s\n", port->id, val[0], val[1],
 338                        npe_name(port->npe));
 339                 BUG();
 340         }
 341 }
 342
 343 static void hss_config_set_lut(struct port *port)
 344 {
 345         struct msg msg;
 346         int ch;
 347
 348         memset(&msg, 0, sizeof(msg));
 349         msg.cmd = PORT_CONFIG_WRITE;
 350         msg.hss_port = port->id;
 351
 352         for (ch = 0; ch < MAX_CHANNELS; ch++) {
 353                 msg.data32 >>= 2;
 354                 msg.data32 |= TDMMAP_HDLC << 30;
 355
 356                 if (ch % 16 == 15) {
 357                         msg.index = HSS_CONFIG_TX_LUT + ((ch / 4) & ~3);
 358                         hss_npe_send(port, &msg, "HSS_SET_TX_LUT");
 359
 360                         msg.index += HSS_CONFIG_RX_LUT - HSS_CONFIG_TX_LUT;
 361                         hss_npe_send(port, &msg, "HSS_SET_RX_LUT");
 362                 }
 363         }
 364 }
 365
 366 static void hss_config(struct port *port)
 367 {
 368         struct msg msg;
 369
 370         memset(&msg, 0, sizeof(msg));
 371         msg.cmd = PORT_CONFIG_WRITE;
 372         msg.hss_port = port->id;
 373         msg.index = HSS_CONFIG_TX_PCR;
 374         msg.data32 = PCR_FRM_SYNC_OUTPUT_RISING | PCR_MSB_ENDIAN |
 375                 PCR_TX_DATA_ENABLE | PCR_SOF_NO_FBIT;
 376         if (port->clock_type == CLOCK_INT)
 377                 msg.data32 |= PCR_SYNC_CLK_DIR_OUTPUT;
 378         hss_npe_send(port, &msg, "HSS_SET_TX_PCR");
 379
 380         msg.index = HSS_CONFIG_RX_PCR;
 381         msg.data32 ^= PCR_TX_DATA_ENABLE | PCR_DCLK_EDGE_RISING;
 382         hss_npe_send(port, &msg, "HSS_SET_RX_PCR");
 383
 384         memset(&msg, 0, sizeof(msg));
 385         msg.cmd = PORT_CONFIG_WRITE;
 386         msg.hss_port = port->id;
 387         msg.index = HSS_CONFIG_CORE_CR;
 388         msg.data32 = (port->loopback ? CCR_LOOPBACK : 0) |
 389                 (port->id ? CCR_SECOND_HSS : 0);
 390         hss_npe_send(port, &msg, "HSS_SET_CORE_CR");
 391
 392         memset(&msg, 0, sizeof(msg));
 393         msg.cmd = PORT_CONFIG_WRITE;
 394         msg.hss_port = port->id;
 395         msg.index = HSS_CONFIG_CLOCK_CR;
 396         msg.data32 = CLK42X_SPEED_2048KHZ /* FIXME */;
 397         hss_npe_send(port, &msg, "HSS_SET_CLOCK_CR");
 398
 399         memset(&msg, 0, sizeof(msg));
 400         msg.cmd = PORT_CONFIG_WRITE;
 401         msg.hss_port = port->id;
 402         msg.index = HSS_CONFIG_TX_FCR;
 403         msg.data16a = FRAME_OFFSET;
 404         msg.data16b = FRAME_SIZE - 1;
 405         hss_npe_send(port, &msg, "HSS_SET_TX_FCR");
 406
 407         memset(&msg, 0, sizeof(msg));
 408         msg.cmd = PORT_CONFIG_WRITE;
 409         msg.hss_port = port->id;
 410         msg.index = HSS_CONFIG_RX_FCR;
 411         msg.data16a = FRAME_OFFSET;
 412         msg.data16b = FRAME_SIZE - 1;
 413         hss_npe_send(port, &msg, "HSS_SET_RX_FCR");
 414
 415         hss_config_set_lut(port);
 416
 417         memset(&msg, 0, sizeof(msg));
 418         msg.cmd = PORT_CONFIG_LOAD;
 419         msg.hss_port = port->id;
 420         hss_npe_send(port, &msg, "HSS_LOAD_CONFIG");
 421
 422         if (npe_recv_message(port->npe, &msg, "HSS_LOAD_CONFIG") ||
 423             /* HSS_LOAD_CONFIG for port #1 returns port_id = #4 */
 424             msg.cmd != PORT_CONFIG_LOAD || msg.data32) {
 425                 printk(KERN_CRIT "HSS-%i: HSS_LOAD_CONFIG failed\n",
 426                        port->id);
 427                 BUG();
 428         }
 429
 430         /* HDLC may stop working without this - check FIXME */
 431         npe_recv_message(port->npe, &msg, "FLUSH_IT");
 432 }
 433
 434 static void hss_set_hdlc_cfg(struct port *port)
 435 {
 436         struct msg msg;
 437
 438         memset(&msg, 0, sizeof(msg));
 439         msg.cmd = PKT_PIPE_HDLC_CFG_WRITE;
 440         msg.hss_port = port->id;
 441         msg.data8a = port->hdlc_cfg; /* rx_cfg */
 442         msg.data8b = port->hdlc_cfg | (PKT_EXTRA_FLAGS << 3); /* tx_cfg */
 443         hss_npe_send(port, &msg, "HSS_SET_HDLC_CFG");
 444 }
 445
 446 static u32 hss_get_status(struct port *port)
 447 {
 448         struct msg msg;
 449
 450         memset(&msg, 0, sizeof(msg));
 451         msg.cmd = PORT_ERROR_READ;
 452         msg.hss_port = port->id;
 453         hss_npe_send(port, &msg, "PORT_ERROR_READ");
 454         if (npe_recv_message(port->npe, &msg, "PORT_ERROR_READ")) {
 455                 printk(KERN_CRIT "HSS-%i: unable to read HSS status\n",
 456                        port->id);
 457                 BUG();
 458         }
 459
 460         return msg.data32;
 461 }
 462
 463 static void hss_start_hdlc(struct port *port)
 464 {
 465         struct msg msg;
 466
 467         memset(&msg, 0, sizeof(msg));
 468         msg.cmd = PKT_PIPE_FLOW_ENABLE;
 469         msg.hss_port = port->id;
 470         msg.data32 = 0;
 471         hss_npe_send(port, &msg, "HSS_ENABLE_PKT_PIPE");
 472 }
 473
 474 static void hss_stop_hdlc(struct port *port)
 475 {
 476         struct msg msg;
 477
 478         memset(&msg, 0, sizeof(msg));
 479         msg.cmd = PKT_PIPE_FLOW_DISABLE;
 480         msg.hss_port = port->id;
 481         hss_npe_send(port, &msg, "HSS_DISABLE_PKT_PIPE");
 482         hss_get_status(port); /* make sure it's halted */
 483 }
 484
 485 static int hss_load_firmware(struct port *port)
 486 {
 487         struct msg msg;
 488         int err;
 489
 490         if (port->initialized)
 491                 return 0;
 492
 493         if (!npe_running(port->npe) &&
 494             (err = npe_load_firmware(port->npe, npe_name(port->npe),
 495                                      port->dev)))
 496                 return err;
 497
 498         /* HDLC mode configuration */
 499         memset(&msg, 0, sizeof(msg));
 500         msg.cmd = PKT_NUM_PIPES_WRITE;
 501         msg.hss_port = port->id;
 502         msg.data8a = PKT_NUM_PIPES;
 503         hss_npe_send(port, &msg, "HSS_SET_PKT_PIPES");
 504
 505         msg.cmd = PKT_PIPE_FIFO_SIZEW_WRITE;
 506         msg.data8a = PKT_PIPE_FIFO_SIZEW;
 507         hss_npe_send(port, &msg, "HSS_SET_PKT_FIFO");
 508
 509         msg.cmd = PKT_PIPE_MODE_WRITE;
 510         msg.data8a = NPE_PKT_MODE_HDLC;
 511         /* msg.data8b = inv_mask */
 512         /* msg.data8c = or_mask */
 513         hss_npe_send(port, &msg, "HSS_SET_PKT_MODE");
 514
 515         msg.cmd = PKT_PIPE_RX_SIZE_WRITE;
 516         msg.data16a = HDLC_MAX_MRU; /* including CRC */
 517         hss_npe_send(port, &msg, "HSS_SET_PKT_RX_SIZE");
 518
 519         msg.cmd = PKT_PIPE_IDLE_PATTERN_WRITE;
 520         msg.data32 = 0x7F7F7F7F; /* ??? FIXME */
 521         hss_npe_send(port, &msg, "HSS_SET_PKT_IDLE");
 522
 523         port->initialized = 1;
 524         return 0;
 525 }
 526
 527 /*****************************************************************************
 528  * packetized (HDLC) operation
 529  ****************************************************************************/
 530
 531 static inline void debug_pkt(struct net_device *dev, const char *func,
 532                              u8 *data, int len)
 533 {
 534 #if DEBUG_PKT_BYTES
 535         int i;
 536
 537         printk(KERN_DEBUG "%s: %s(%i)", dev->name, func, len);
 538         for (i = 0; i < len; i++) {
 539                 if (i >= DEBUG_PKT_BYTES)
 540                         break;
 541                 printk("%s%02X", !(i % 4) ? " " : "", data[i]);
 542         }
 543         printk("\n");
 544 #endif
 545 }
 546
 547
 548 static inline void debug_desc(u32 phys, struct desc *desc)
 549 {
 550 #if DEBUG_DESC
 551         printk(KERN_DEBUG "%X: %X %3X %3X %08X %X %X\n",
 552                phys, desc->next, desc->buf_len, desc->pkt_len,
 553                desc->data, desc->status, desc->error_count);
 554 #endif
 555 }
 556
 557 static inline int queue_get_desc(unsigned int queue, struct port *port,
 558                                  int is_tx)
 559 {
 560         u32 phys, tab_phys, n_desc;
 561         struct desc *tab;
 562
 563         if (!(phys = qmgr_get_entry(queue)))
 564                 return -1;
 565
 566         BUG_ON(phys & 0x1F);
 567         tab_phys = is_tx ? tx_desc_phys(port, 0) : rx_desc_phys(port, 0);
 568         tab = is_tx ? tx_desc_ptr(port, 0) : rx_desc_ptr(port, 0);
 569         n_desc = (phys - tab_phys) / sizeof(struct desc);
 570         BUG_ON(n_desc >= (is_tx ? TX_DESCS : RX_DESCS));
 571         debug_desc(phys, &tab[n_desc]);
 572         BUG_ON(tab[n_desc].next);
 573         return n_desc;
 574 }
 575
 576 static inline void queue_put_desc(unsigned int queue, u32 phys,
 577                                   struct desc *desc)
 578 {
 579         debug_desc(phys, desc);
 580         BUG_ON(phys & 0x1F);
 581         qmgr_put_entry(queue, phys);
 582         /* Don't check for queue overflow here, we've allocated sufficient
 583            length and queues >= 32 don't support this check anyway. */
 584 }
 585
 586
 587 static inline void dma_unmap_tx(struct port *port, struct desc *desc)
 588 {
 589 #ifdef __ARMEB__
 590         dma_unmap_single(&port->netdev->dev, desc->data,
 591                          desc->buf_len, DMA_TO_DEVICE);
 592 #else
 593         dma_unmap_single(&port->netdev->dev, desc->data & ~3,
 594                          ALIGN((desc->data & 3) + desc->buf_len, 4),
 595                          DMA_TO_DEVICE);
 596 #endif
 597 }
 598
 599
 600 static void hss_hdlc_set_carrier(void *pdev, int carrier)
 601 {
 602         struct net_device *netdev = pdev;
 603         struct port *port = dev_to_port(netdev);
 604         unsigned long flags;
 605
 606         spin_lock_irqsave(&npe_lock, flags);
 607         port->carrier = carrier;
 608         if (!port->loopback) {
 609                 if (carrier)
 610                         netif_carrier_on(netdev);
 611                 else
 612                         netif_carrier_off(netdev);
 613         }
 614         spin_unlock_irqrestore(&npe_lock, flags);
 615 }
 616
 617 static void hss_hdlc_rx_irq(void *pdev)
 618 {
 619         struct net_device *dev = pdev;
 620         struct port *port = dev_to_port(dev);
 621
 622 #if DEBUG_RX
 623         printk(KERN_DEBUG "%s: hss_hdlc_rx_irq\n", dev->name);
 624 #endif
 625         qmgr_disable_irq(queue_ids[port->id].rx);
 626         napi_schedule(&port->napi);
 627 }
 628
 629 static int hss_hdlc_poll(struct napi_struct *napi, int budget)
 630 {
 631         struct port *port = container_of(napi, struct port, napi);
 632         struct net_device *dev = port->netdev;
 633         unsigned int rxq = queue_ids[port->id].rx;
 634         unsigned int rxfreeq = queue_ids[port->id].rxfree;
 635         int received = 0;
 636
 637 #if DEBUG_RX
 638         printk(KERN_DEBUG "%s: hss_hdlc_poll\n", dev->name);
 639 #endif
 640
 641         while (received < budget) {
 642                 struct sk_buff *skb;
 643                 struct desc *desc;
 644                 int n;
 645 #ifdef __ARMEB__
 646                 struct sk_buff *temp;
 647                 u32 phys;
 648 #endif
 649
 650                 if ((n = queue_get_desc(rxq, port, 0)) < 0) {
 651 #if DEBUG_RX
 652                         printk(KERN_DEBUG "%s: hss_hdlc_poll"
 653                                " napi_complete\n", dev->name);
 654 #endif
 655                         napi_complete(napi);
 656                         qmgr_enable_irq(rxq);
 657                         if (!qmgr_stat_empty(rxq) &&
 658                             napi_reschedule(napi)) {
 659 #if DEBUG_RX
 660                                 printk(KERN_DEBUG "%s: hss_hdlc_poll"
 661                                        " napi_reschedule succeeded\n",
 662                                        dev->name);
 663 #endif
 664                                 qmgr_disable_irq(rxq);
 665                                 continue;
 666                         }
 667 #if DEBUG_RX
 668                         printk(KERN_DEBUG "%s: hss_hdlc_poll all done\n",
 669                                dev->name);
 670 #endif
 671                         return received; /* all work done */
 672                 }
 673
 674                 desc = rx_desc_ptr(port, n);
 675 #if 0 /* FIXME - error_count counts modulo 256, perhaps we should use it */
 676                 if (desc->error_count)
 677                         printk(KERN_DEBUG "%s: hss_hdlc_poll status 0x%02X"
 678                                " errors %u\n", dev->name, desc->status,
 679                                desc->error_count);
 680 #endif
 681                 skb = NULL;
 682                 switch (desc->status) {
 683                 case 0:
 684 #ifdef __ARMEB__
 685                         if ((skb = netdev_alloc_skb(dev, RX_SIZE)) != NULL) {
 686                                 phys = dma_map_single(&dev->dev, skb->data,
 687                                                       RX_SIZE,
 688                                                       DMA_FROM_DEVICE);
 689                                 if (dma_mapping_error(&dev->dev, phys)) {
 690                                         dev_kfree_skb(skb);
 691                                         skb = NULL;
 692                                 }
 693                         }
 694 #else
 695                         skb = netdev_alloc_skb(dev, desc->pkt_len);
 696 #endif
 697                         if (!skb)
 698                                 dev->stats.rx_dropped++;
 699                         break;
 700                 case ERR_HDLC_ALIGN:
 701                 case ERR_HDLC_ABORT:
 702                         dev->stats.rx_frame_errors++;
 703                         dev->stats.rx_errors++;
 704                         break;
 705                 case ERR_HDLC_FCS:
 706                         dev->stats.rx_crc_errors++;
 707                         dev->stats.rx_errors++;
 708                         break;
 709                 case ERR_HDLC_TOO_LONG:
 710                         dev->stats.rx_length_errors++;
 711                         dev->stats.rx_errors++;
 712                         break;
 713                 default:        /* FIXME - remove printk */
 714                         printk(KERN_ERR "%s: hss_hdlc_poll: status 0x%02X"
 715                                " errors %u\n", dev->name, desc->status,
 716                                desc->error_count);
 717                         dev->stats.rx_errors++;
 718                 }
 719
 720                 if (!skb) {
 721                         /* put the desc back on RX-ready queue */
 722                         desc->buf_len = RX_SIZE;
 723                         desc->pkt_len = desc->status = 0;
 724                         queue_put_desc(rxfreeq, rx_desc_phys(port, n), desc);
 725                         continue;
 726                 }
 727
 728                 /* process received frame */
 729 #ifdef __ARMEB__
 730                 temp = skb;
 731                 skb = port->rx_buff_tab[n];
 732                 dma_unmap_single(&dev->dev, desc->data,
 733                                  RX_SIZE, DMA_FROM_DEVICE);
 734 #else
 735                 dma_sync_single(&dev->dev, desc->data,
 736                                 RX_SIZE, DMA_FROM_DEVICE);
 737                 memcpy_swab32((u32 *)skb->data, (u32 *)port->rx_buff_tab[n],
 738                               ALIGN(desc->pkt_len, 4) / 4);
 739 #endif
 740                 skb_put(skb, desc->pkt_len);
 741
 742                 debug_pkt(dev, "hss_hdlc_poll", skb->data, skb->len);
 743
 744                 skb->protocol = hdlc_type_trans(skb, dev);
 745                 dev->stats.rx_packets++;
 746                 dev->stats.rx_bytes += skb->len;
 747                 netif_receive_skb(skb);
 748
 749                 /* put the new buffer on RX-free queue */
 750 #ifdef __ARMEB__
 751                 port->rx_buff_tab[n] = temp;
 752                 desc->data = phys;
 753 #endif
 754                 desc->buf_len = RX_SIZE;
 755                 desc->pkt_len = 0;
 756                 queue_put_desc(rxfreeq, rx_desc_phys(port, n), desc);
 757                 received++;
 758         }
 759 #if DEBUG_RX
 760         printk(KERN_DEBUG "hss_hdlc_poll: end, not all work done\n");
 761 #endif
 762         return received;        /* not all work done */
 763 }
 764
 765
 766 static void hss_hdlc_txdone_irq(void *pdev)
 767 {
 768         struct net_device *dev = pdev;
 769         struct port *port = dev_to_port(dev);
 770         int n_desc;
 771
 772 #if DEBUG_TX
 773         printk(KERN_DEBUG DRV_NAME ": hss_hdlc_txdone_irq\n");
 774 #endif
 775         while ((n_desc = queue_get_desc(queue_ids[port->id].txdone,
 776                                         port, 1)) >= 0) {
 777                 struct desc *desc;
 778                 int start;
 779
 780                 desc = tx_desc_ptr(port, n_desc);
 781
 782                 dev->stats.tx_packets++;
 783                 dev->stats.tx_bytes += desc->pkt_len;
 784
 785                 dma_unmap_tx(port, desc);
 786 #if DEBUG_TX
 787                 printk(KERN_DEBUG "%s: hss_hdlc_txdone_irq free %p\n",
 788                        dev->name, port->tx_buff_tab[n_desc]);
 789 #endif
 790                 free_buffer_irq(port->tx_buff_tab[n_desc]);
 791                 port->tx_buff_tab[n_desc] = NULL;
 792
 793                 /* really empty in fact */
 794                 start = qmgr_stat_nearly_empty(port->plat->txreadyq);
 795                 queue_put_desc(port->plat->txreadyq,
 796                                tx_desc_phys(port, n_desc), desc);
 797                 if (start) {
 798 #if DEBUG_TX
 799                         printk(KERN_DEBUG "%s: hss_hdlc_txdone_irq xmit"
 800                                " ready\n", dev->name);
 801 #endif
 802                         netif_wake_queue(dev);
 803                 }
 804         }
 805 }
 806
 807 static int hss_hdlc_xmit(struct sk_buff *skb, struct net_device *dev)
 808 {
 809         struct port *port = dev_to_port(dev);
 810         unsigned int txreadyq = port->plat->txreadyq;
 811         int len, offset, bytes, n;
 812         void *mem;
 813         u32 phys;
 814         struct desc *desc;
 815
 816 #if DEBUG_TX
 817         printk(KERN_DEBUG "%s: hss_hdlc_xmit\n", dev->name);
 818 #endif
 819
 820         if (unlikely(skb->len > HDLC_MAX_MRU)) {
 821                 dev_kfree_skb(skb);
 822                 dev->stats.tx_errors++;
 823                 return NETDEV_TX_OK;
 824         }
 825
 826         debug_pkt(dev, "hss_hdlc_xmit", skb->data, skb->len);
 827
 828         len = skb->len;
 829 #ifdef __ARMEB__
 830         offset = 0; /* no need to keep alignment */
 831         bytes = len;
 832         mem = skb->data;
 833 #else
 834         offset = (int)skb->data & 3; /* keep 32-bit alignment */
 835         bytes = ALIGN(offset + len, 4);
 836         if (!(mem = kmalloc(bytes, GFP_ATOMIC))) {
 837                 dev_kfree_skb(skb);
 838                 dev->stats.tx_dropped++;
 839                 return NETDEV_TX_OK;
 840         }
 841         memcpy_swab32(mem, (u32 *)((int)skb->data & ~3), bytes / 4);
 842         dev_kfree_skb(skb);
 843 #endif
 844
 845         phys = dma_map_single(&dev->dev, mem, bytes, DMA_TO_DEVICE);
 846         if (dma_mapping_error(&dev->dev, phys)) {
 847 #ifdef __ARMEB__
 848                 dev_kfree_skb(skb);
 849 #else
 850                 kfree(mem);
 851 #endif
 852                 dev->stats.tx_dropped++;
 853                 return NETDEV_TX_OK;
 854         }
 855
 856         n = queue_get_desc(txreadyq, port, 1);
 857         BUG_ON(n < 0);
 858         desc = tx_desc_ptr(port, n);
 859
 860 #ifdef __ARMEB__
 861         port->tx_buff_tab[n] = skb;
 862 #else
 863         port->tx_buff_tab[n] = mem;
 864 #endif
 865         desc->data = phys + offset;
 866         desc->buf_len = desc->pkt_len = len;
 867
 868         wmb();
 869         queue_put_desc(queue_ids[port->id].tx, tx_desc_phys(port, n), desc);
 870         dev->trans_start = jiffies;
 871
 872         if (qmgr_stat_nearly_empty(txreadyq)) { /* really empty in fact */
 873 #if DEBUG_TX
 874                 printk(KERN_DEBUG "%s: hss_hdlc_xmit queue full\n", dev->name);
 875 #endif
 876                 netif_stop_queue(dev);
 877                 /* we could miss TX ready interrupt */
 878                 if (!qmgr_stat_nearly_empty(txreadyq)) {
 879 #if DEBUG_TX
 880                         printk(KERN_DEBUG "%s: hss_hdlc_xmit ready again\n",
 881                                dev->name);
 882 #endif
 883                         netif_wake_queue(dev);
 884                 }
 885         }
 886
 887 #if DEBUG_TX
 888         printk(KERN_DEBUG "%s: hss_hdlc_xmit end\n", dev->name);
 889 #endif
 890         return NETDEV_TX_OK;
 891 }
 892
 893
 894 static int request_hdlc_queues(struct port *port)
 895 {
 896         int err;
 897
 898         err = qmgr_request_queue(queue_ids[port->id].rxfree, RX_DESCS, 0, 0,
 899                                  "%s:RX-free", port->netdev->name);
 900         if (err)
 901                 return err;
 902
 903         err = qmgr_request_queue(queue_ids[port->id].rx, RX_DESCS, 0, 0,
 904                                  "%s:RX", port->netdev->name);
 905         if (err)
 906                 goto rel_rxfree;
 907
 908         err = qmgr_request_queue(queue_ids[port->id].tx, TX_DESCS, 0, 0,
 909                                  "%s:TX", port->netdev->name);
 910         if (err)
 911                 goto rel_rx;
 912
 913         err = qmgr_request_queue(port->plat->txreadyq, TX_DESCS, 0, 0,
 914                                  "%s:TX-ready", port->netdev->name);
 915         if (err)
 916                 goto rel_tx;
 917
 918         err = qmgr_request_queue(queue_ids[port->id].txdone, TX_DESCS, 0, 0,
 919                                  "%s:TX-done", port->netdev->name);
 920         if (err)
 921                 goto rel_txready;
 922         return 0;
 923
 924 rel_txready:
 925         qmgr_release_queue(port->plat->txreadyq);
 926 rel_tx:
 927         qmgr_release_queue(queue_ids[port->id].tx);
 928 rel_rx:
 929         qmgr_release_queue(queue_ids[port->id].rx);
 930 rel_rxfree:
 931         qmgr_release_queue(queue_ids[port->id].rxfree);
 932         printk(KERN_DEBUG "%s: unable to request hardware queues\n",
 933                port->netdev->name);
 934         return err;
 935 }
 936
 937 static void release_hdlc_queues(struct port *port)
 938 {
 939         qmgr_release_queue(queue_ids[port->id].rxfree);
 940         qmgr_release_queue(queue_ids[port->id].rx);
 941         qmgr_release_queue(queue_ids[port->id].txdone);
 942         qmgr_release_queue(queue_ids[port->id].tx);
 943         qmgr_release_queue(port->plat->txreadyq);
 944 }
 945
 946 static int init_hdlc_queues(struct port *port)
 947 {
 948         int i;
 949
 950         if (!ports_open)
 951                 if (!(dma_pool = dma_pool_create(DRV_NAME, NULL,
 952                                                  POOL_ALLOC_SIZE, 32, 0)))
 953                         return -ENOMEM;
 954
 955         if (!(port->desc_tab = dma_pool_alloc(dma_pool, GFP_KERNEL,
 956                                               &port->desc_tab_phys)))
 957                 return -ENOMEM;
 958         memset(port->desc_tab, 0, POOL_ALLOC_SIZE);
 959         memset(port->rx_buff_tab, 0, sizeof(port->rx_buff_tab)); /* tables */
 960         memset(port->tx_buff_tab, 0, sizeof(port->tx_buff_tab));
 961
 962         /* Setup RX buffers */
 963         for (i = 0; i < RX_DESCS; i++) {
 964                 struct desc *desc = rx_desc_ptr(port, i);
 965                 buffer_t *buff;
 966                 void *data;
 967 #ifdef __ARMEB__
 968                 if (!(buff = netdev_alloc_skb(port->netdev, RX_SIZE)))
 969                         return -ENOMEM;
 970                 data = buff->data;
 971 #else
 972                 if (!(buff = kmalloc(RX_SIZE, GFP_KERNEL)))
 973                         return -ENOMEM;
 974                 data = buff;
 975 #endif
 976                 desc->buf_len = RX_SIZE;
 977                 desc->data = dma_map_single(&port->netdev->dev, data,
 978                                             RX_SIZE, DMA_FROM_DEVICE);
 979                 if (dma_mapping_error(&port->netdev->dev, desc->data)) {
 980                         free_buffer(buff);
 981                         return -EIO;
 982                 }
 983                 port->rx_buff_tab[i] = buff;
 984         }
 985
 986         return 0;
 987 }
 988
 989 static void destroy_hdlc_queues(struct port *port)
 990 {
 991         int i;
 992
 993         if (port->desc_tab) {
 994                 for (i = 0; i < RX_DESCS; i++) {
 995                         struct desc *desc = rx_desc_ptr(port, i);
 996                         buffer_t *buff = port->rx_buff_tab[i];
 997                         if (buff) {
 998                                 dma_unmap_single(&port->netdev->dev,
 999                                                  desc->data, RX_SIZE,
1000                                                  DMA_FROM_DEVICE);
1001                                 free_buffer(buff);
1002                         }
1003                 }
1004                 for (i = 0; i < TX_DESCS; i++) {
1005                         struct desc *desc = tx_desc_ptr(port, i);
1006                         buffer_t *buff = port->tx_buff_tab[i];
1007                         if (buff) {
1008                                 dma_unmap_tx(port, desc);
1009                                 free_buffer(buff);
1010                         }
1011                 }
1012                 dma_pool_free(dma_pool, port->desc_tab, port->desc_tab_phys);
1013                 port->desc_tab = NULL;
1014         }
1015
1016         if (!ports_open && dma_pool) {
1017                 dma_pool_destroy(dma_pool);
1018                 dma_pool = NULL;
1019         }
1020 }
1021
1022 static int hss_hdlc_open(struct net_device *dev)
1023 {
1024         struct port *port = dev_to_port(dev);
1025         unsigned long flags;
1026         int i, err = 0;
1027
1028         if ((err = hdlc_open(dev)))
1029                 return err;
1030
1031         if ((err = hss_load_firmware(port)))
1032                 goto err_hdlc_close;
1033
1034         if ((err = request_hdlc_queues(port)))
1035                 goto err_hdlc_close;
1036
1037         if ((err = init_hdlc_queues(port)))
1038                 goto err_destroy_queues;
1039
1040         spin_lock_irqsave(&npe_lock, flags);
1041         if (port->plat->open)
1042                 if ((err = port->plat->open(port->id, dev,
1043                                             hss_hdlc_set_carrier)))
1044                         goto err_unlock;
1045         spin_unlock_irqrestore(&npe_lock, flags);
1046
1047         /* Populate queues with buffers, no failure after this point */
1048         for (i = 0; i < TX_DESCS; i++)
1049                 queue_put_desc(port->plat->txreadyq,
1050                                tx_desc_phys(port, i), tx_desc_ptr(port, i));
1051
1052         for (i = 0; i < RX_DESCS; i++)
1053                 queue_put_desc(queue_ids[port->id].rxfree,
1054                                rx_desc_phys(port, i), rx_desc_ptr(port, i));
1055
1056         napi_enable(&port->napi);
1057         netif_start_queue(dev);
1058
1059         qmgr_set_irq(queue_ids[port->id].rx, QUEUE_IRQ_SRC_NOT_EMPTY,
1060                      hss_hdlc_rx_irq, dev);
1061
1062         qmgr_set_irq(queue_ids[port->id].txdone, QUEUE_IRQ_SRC_NOT_EMPTY,
1063                      hss_hdlc_txdone_irq, dev);
1064         qmgr_enable_irq(queue_ids[port->id].txdone);
1065
1066         ports_open++;
1067
1068         hss_set_hdlc_cfg(port);
1069         hss_config(port);
1070
1071         hss_start_hdlc(port);
1072
1073         /* we may already have RX data, enables IRQ */
1074         napi_schedule(&port->napi);
1075         return 0;
1076
1077 err_unlock:
1078         spin_unlock_irqrestore(&npe_lock, flags);
1079 err_destroy_queues:
1080         destroy_hdlc_queues(port);
1081         release_hdlc_queues(port);
1082 err_hdlc_close:
1083         hdlc_close(dev);
1084         return err;
1085 }
1086
1087 static int hss_hdlc_close(struct net_device *dev)
1088 {
1089         struct port *port = dev_to_port(dev);
1090         unsigned long flags;
1091         int i, buffs = RX_DESCS; /* allocated RX buffers */
1092
1093         spin_lock_irqsave(&npe_lock, flags);
1094         ports_open--;
1095         qmgr_disable_irq(queue_ids[port->id].rx);
1096         netif_stop_queue(dev);
1097         napi_disable(&port->napi);
1098
1099         hss_stop_hdlc(port);
1100
1101         while (queue_get_desc(queue_ids[port->id].rxfree, port, 0) >= 0)
1102                 buffs--;
1103         while (queue_get_desc(queue_ids[port->id].rx, port, 0) >= 0)
1104                 buffs--;
1105
1106         if (buffs)
1107                 printk(KERN_CRIT "%s: unable to drain RX queue, %i buffer(s)"
1108                        " left in NPE\n", dev->name, buffs);
1109
1110         buffs = TX_DESCS;
1111         while (queue_get_desc(queue_ids[port->id].tx, port, 1) >= 0)
1112                 buffs--; /* cancel TX */
1113
1114         i = 0;
1115         do {
1116                 while (queue_get_desc(port->plat->txreadyq, port, 1) >= 0)
1117                         buffs--;
1118                 if (!buffs)
1119                         break;
1120         } while (++i < MAX_CLOSE_WAIT);
1121
1122         if (buffs)
1123                 printk(KERN_CRIT "%s: unable to drain TX queue, %i buffer(s) "
1124                        "left in NPE\n", dev->name, buffs);
1125 #if DEBUG_CLOSE
1126         if (!buffs)
1127                 printk(KERN_DEBUG "Draining TX queues took %i cycles\n", i);
1128 #endif
1129         qmgr_disable_irq(queue_ids[port->id].txdone);
1130
1131         if (port->plat->close)
1132                 port->plat->close(port->id, dev);
1133         spin_unlock_irqrestore(&npe_lock, flags);
1134
1135         destroy_hdlc_queues(port);
1136         release_hdlc_queues(port);
1137         hdlc_close(dev);
1138         return 0;
1139 }
1140
1141
1142 static int hss_hdlc_attach(struct net_device *dev, unsigned short encoding,
1143                            unsigned short parity)
1144 {
1145         struct port *port = dev_to_port(dev);
1146
1147         if (encoding != ENCODING_NRZ)
1148                 return -EINVAL;
1149
1150         switch(parity) {
1151         case PARITY_CRC16_PR1_CCITT:
1152                 port->hdlc_cfg = 0;
1153                 return 0;
1154
1155         case PARITY_CRC32_PR1_CCITT:
1156                 port->hdlc_cfg = PKT_HDLC_CRC_32;
1157                 return 0;
1158
1159         default:
1160                 return -EINVAL;
1161         }
1162 }
1163
1164
1165 static int hss_hdlc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1166 {
1167         const size_t size = sizeof(sync_serial_settings);
1168         sync_serial_settings new_line;
1169         sync_serial_settings __user *line = ifr->ifr_settings.ifs_ifsu.sync;
1170         struct port *port = dev_to_port(dev);
1171         unsigned long flags;
1172         int clk;
1173
1174         if (cmd != SIOCWANDEV)
1175                 return hdlc_ioctl(dev, ifr, cmd);
1176
1177         switch(ifr->ifr_settings.type) {
1178         case IF_GET_IFACE:
1179                 ifr->ifr_settings.type = IF_IFACE_V35;
1180                 if (ifr->ifr_settings.size < size) {
1181                         ifr->ifr_settings.size = size; /* data size wanted */
1182                         return -ENOBUFS;
1183                 }
1184                 memset(&new_line, 0, sizeof(new_line));
1185                 new_line.clock_type = port->clock_type;
1186                 new_line.clock_rate = 2048000; /* FIXME */
1187                 new_line.loopback = port->loopback;
1188                 if (copy_to_user(line, &new_line, size))
1189                         return -EFAULT;
1190                 return 0;
1191
1192         case IF_IFACE_SYNC_SERIAL:
1193         case IF_IFACE_V35:
1194                 if(!capable(CAP_NET_ADMIN))
1195                         return -EPERM;
1196                 if (copy_from_user(&new_line, line, size))
1197                         return -EFAULT;
1198
1199                 clk = new_line.clock_type;
1200                 if (port->plat->set_clock)
1201                         clk = port->plat->set_clock(port->id, clk);
1202
1203                 if (clk != CLOCK_EXT && clk != CLOCK_INT)
1204                         return -EINVAL; /* No such clock setting */
1205
1206                 if (new_line.loopback != 0 && new_line.loopback != 1)
1207                         return -EINVAL;
1208
1209                 port->clock_type = clk; /* Update settings */
1210                 /* FIXME port->clock_rate = new_line.clock_rate */;
1211                 port->loopback = new_line.loopback;
1212
1213                 spin_lock_irqsave(&npe_lock, flags);
1214
1215                 if (dev->flags & IFF_UP)
1216                         hss_config(port);
1217
1218                 if (port->loopback || port->carrier)
1219                         netif_carrier_on(port->netdev);
1220                 else
1221                         netif_carrier_off(port->netdev);
1222                 spin_unlock_irqrestore(&npe_lock, flags);
1223
1224                 return 0;
1225
1226         default:
1227                 return hdlc_ioctl(dev, ifr, cmd);
1228         }
1229 }
1230
1231 /*****************************************************************************
1232  * initialization
1233  ****************************************************************************/
1234
1235 static const struct net_device_ops hss_hdlc_ops = {
1236         .ndo_open       = hss_hdlc_open,
1237         .ndo_stop       = hss_hdlc_close,
1238         .ndo_change_mtu = hdlc_change_mtu,
1239         .ndo_start_xmit = hdlc_start_xmit,
1240         .ndo_do_ioctl   = hss_hdlc_ioctl,
1241 };
1242
1243 static int __devinit hss_init_one(struct platform_device *pdev)
1244 {
1245         struct port *port;
1246         struct net_device *dev;
1247         hdlc_device *hdlc;
1248         int err;
1249
1250         if ((port = kzalloc(sizeof(*port), GFP_KERNEL)) == NULL)
1251                 return -ENOMEM;
1252
1253         if ((port->npe = npe_request(0)) == NULL) {
1254                 err = -ENODEV;
1255                 goto err_free;
1256         }
1257
1258         if ((port->netdev = dev = alloc_hdlcdev(port)) == NULL) {
1259                 err = -ENOMEM;
1260                 goto err_plat;
1261         }
1262
1263         SET_NETDEV_DEV(dev, &pdev->dev);
1264         hdlc = dev_to_hdlc(dev);
1265         hdlc->attach = hss_hdlc_attach;
1266         hdlc->xmit = hss_hdlc_xmit;
1267         dev->netdev_ops = &hss_hdlc_ops;
1268         dev->tx_queue_len = 100;
1269         port->clock_type = CLOCK_EXT;
1270         port->clock_rate = 2048000;
1271         port->id = pdev->id;
1272         port->dev = &pdev->dev;
1273         port->plat = pdev->dev.platform_data;
1274         netif_napi_add(dev, &port->napi, hss_hdlc_poll, NAPI_WEIGHT);
1275
1276         if ((err = register_hdlc_device(dev)))
1277                 goto err_free_netdev;
1278
1279         platform_set_drvdata(pdev, port);
1280
1281         printk(KERN_INFO "%s: HSS-%i\n", dev->name, port->id);
1282         return 0;
1283
1284 err_free_netdev:
1285         free_netdev(dev);
1286 err_plat:
1287         npe_release(port->npe);
1288 err_free:
1289         kfree(port);
1290         return err;
1291 }
1292
1293 static int __devexit hss_remove_one(struct platform_device *pdev)
1294 {
1295         struct port *port = platform_get_drvdata(pdev);
1296
1297         unregister_hdlc_device(port->netdev);
1298         free_netdev(port->netdev);
1299         npe_release(port->npe);
1300         platform_set_drvdata(pdev, NULL);
1301         kfree(port);
1302         return 0;
1303 }
1304
1305 static struct platform_driver ixp4xx_hss_driver = {
1306         .driver.name    = DRV_NAME,
1307         .probe          = hss_init_one,
1308         .remove         = hss_remove_one,
1309 };
1310
1311 static int __init hss_init_module(void)
1312 {
1313         if ((ixp4xx_read_feature_bits() &
1314              (IXP4XX_FEATURE_HDLC | IXP4XX_FEATURE_HSS)) !=
1315             (IXP4XX_FEATURE_HDLC | IXP4XX_FEATURE_HSS))
1316                 return -ENODEV;
1317
1318         spin_lock_init(&npe_lock);
1319
1320         return platform_driver_register(&ixp4xx_hss_driver);
1321 }
1322
1323 static void __exit hss_cleanup_module(void)
1324 {
1325         platform_driver_unregister(&ixp4xx_hss_driver);
1326 }
1327
1328 MODULE_AUTHOR("Krzysztof Halasa");
1329 MODULE_DESCRIPTION("Intel IXP4xx HSS driver");
1330 MODULE_LICENSE("GPL v2");
1331 MODULE_ALIAS("platform:ixp4xx_hss");
1332 module_init(hss_init_module);
1333 module_exit(hss_cleanup_module);