drivers/usb/gadget/rndis.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * RNDIS MSG parser
   4  *
   5  * Authors:     Benedikt Spranger, Pengutronix
   6  *              Robert Schwebel, Pengutronix
   7  *
   8  *              This software was originally developed in conformance with
   9  *              Microsoft's Remote NDIS Specification License Agreement.
  10  *
  11  * 03/12/2004 Kai-Uwe Bloem <linux-development@auerswald.de>
  12  *              Fixed message length bug in init_response
  13  *
  14  * 03/25/2004 Kai-Uwe Bloem <linux-development@auerswald.de>
  15  *              Fixed rndis_rm_hdr length bug.
  16  *
  17  * Copyright (C) 2004 by David Brownell
  18  *              updates to merge with Linux 2.6, better match RNDIS spec
  19  */
  20
  21 #include <common.h>
  22 #include <net.h>
  23 #include <malloc.h>
  24 #include <linux/types.h>
  25 #include <linux/list.h>
  26 #include <linux/netdevice.h>
  27
  28 #include <asm/byteorder.h>
  29 #include <asm/unaligned.h>
  30 #include <linux/errno.h>
  31
  32 #undef  RNDIS_PM
  33 #undef  RNDIS_WAKEUP
  34 #undef  VERBOSE
  35
  36 #include "rndis.h"
  37
  38 /*
  39  * The driver for your USB chip needs to support ep0 OUT to work with
  40  * RNDIS, plus all three CDC Ethernet endpoints (interrupt not optional).
  41  *
  42  * Windows hosts need an INF file like Documentation/usb/linux.inf
  43  * and will be happier if you provide the host_addr module parameter.
  44  */
  45
  46 #define RNDIS_MAX_CONFIGS       1
  47
  48 static rndis_params rndis_per_dev_params[RNDIS_MAX_CONFIGS];
  49
  50 /* Driver Version */
  51 static const __le32 rndis_driver_version = __constant_cpu_to_le32(1);
  52
  53 /* Function Prototypes */
  54 static rndis_resp_t *rndis_add_response(int configNr, u32 length);
  55
  56
  57 /* supported OIDs */
  58 static const u32 oid_supported_list[] = {
  59         /* the general stuff */
  60         OID_GEN_SUPPORTED_LIST,
  61         OID_GEN_HARDWARE_STATUS,
  62         OID_GEN_MEDIA_SUPPORTED,
  63         OID_GEN_MEDIA_IN_USE,
  64         OID_GEN_MAXIMUM_FRAME_SIZE,
  65         OID_GEN_LINK_SPEED,
  66         OID_GEN_TRANSMIT_BLOCK_SIZE,
  67         OID_GEN_RECEIVE_BLOCK_SIZE,
  68         OID_GEN_VENDOR_ID,
  69         OID_GEN_VENDOR_DESCRIPTION,
  70         OID_GEN_VENDOR_DRIVER_VERSION,
  71         OID_GEN_CURRENT_PACKET_FILTER,
  72         OID_GEN_MAXIMUM_TOTAL_SIZE,
  73         OID_GEN_MEDIA_CONNECT_STATUS,
  74         OID_GEN_PHYSICAL_MEDIUM,
  75 #if 0
  76         OID_GEN_RNDIS_CONFIG_PARAMETER,
  77 #endif
  78
  79         /* the statistical stuff */
  80         OID_GEN_XMIT_OK,
  81         OID_GEN_RCV_OK,
  82         OID_GEN_XMIT_ERROR,
  83         OID_GEN_RCV_ERROR,
  84         OID_GEN_RCV_NO_BUFFER,
  85 #ifdef  RNDIS_OPTIONAL_STATS
  86         OID_GEN_DIRECTED_BYTES_XMIT,
  87         OID_GEN_DIRECTED_FRAMES_XMIT,
  88         OID_GEN_MULTICAST_BYTES_XMIT,
  89         OID_GEN_MULTICAST_FRAMES_XMIT,
  90         OID_GEN_BROADCAST_BYTES_XMIT,
  91         OID_GEN_BROADCAST_FRAMES_XMIT,
  92         OID_GEN_DIRECTED_BYTES_RCV,
  93         OID_GEN_DIRECTED_FRAMES_RCV,
  94         OID_GEN_MULTICAST_BYTES_RCV,
  95         OID_GEN_MULTICAST_FRAMES_RCV,
  96         OID_GEN_BROADCAST_BYTES_RCV,
  97         OID_GEN_BROADCAST_FRAMES_RCV,
  98         OID_GEN_RCV_CRC_ERROR,
  99         OID_GEN_TRANSMIT_QUEUE_LENGTH,
 100 #endif  /* RNDIS_OPTIONAL_STATS */
 101
 102         /* mandatory 802.3 */
 103         /* the general stuff */
 104         OID_802_3_PERMANENT_ADDRESS,
 105         OID_802_3_CURRENT_ADDRESS,
 106         OID_802_3_MULTICAST_LIST,
 107         OID_802_3_MAC_OPTIONS,
 108         OID_802_3_MAXIMUM_LIST_SIZE,
 109
 110         /* the statistical stuff */
 111         OID_802_3_RCV_ERROR_ALIGNMENT,
 112         OID_802_3_XMIT_ONE_COLLISION,
 113         OID_802_3_XMIT_MORE_COLLISIONS,
 114 #ifdef  RNDIS_OPTIONAL_STATS
 115         OID_802_3_XMIT_DEFERRED,
 116         OID_802_3_XMIT_MAX_COLLISIONS,
 117         OID_802_3_RCV_OVERRUN,
 118         OID_802_3_XMIT_UNDERRUN,
 119         OID_802_3_XMIT_HEARTBEAT_FAILURE,
 120         OID_802_3_XMIT_TIMES_CRS_LOST,
 121         OID_802_3_XMIT_LATE_COLLISIONS,
 122 #endif  /* RNDIS_OPTIONAL_STATS */
 123
 124 #ifdef  RNDIS_PM
 125         /* PM and wakeup are mandatory for USB: */
 126
 127         /* power management */
 128         OID_PNP_CAPABILITIES,
 129         OID_PNP_QUERY_POWER,
 130         OID_PNP_SET_POWER,
 131
 132 #ifdef  RNDIS_WAKEUP
 133         /* wake up host */
 134         OID_PNP_ENABLE_WAKE_UP,
 135         OID_PNP_ADD_WAKE_UP_PATTERN,
 136         OID_PNP_REMOVE_WAKE_UP_PATTERN,
 137 #endif  /* RNDIS_WAKEUP */
 138 #endif  /* RNDIS_PM */
 139 };
 140
 141
 142 /* NDIS Functions */
 143 static int gen_ndis_query_resp(int configNr, u32 OID, u8 *buf,
 144                                 unsigned buf_len, rndis_resp_t *r)
 145 {
 146         int                             retval = -ENOTSUPP;
 147         u32                             length = 4;     /* usually */
 148         __le32                          *outbuf;
 149         int                             i, count;
 150         rndis_query_cmplt_type          *resp;
 151         rndis_params                    *params;
 152
 153         if (!r)
 154                 return -ENOMEM;
 155         resp = (rndis_query_cmplt_type *) r->buf;
 156
 157         if (!resp)
 158                 return -ENOMEM;
 159
 160 #if defined(DEBUG) && defined(DEBUG_VERBOSE)
 161         if (buf_len) {
 162                 debug("query OID %08x value, len %d:\n", OID, buf_len);
 163                 for (i = 0; i < buf_len; i += 16) {
 164                         debug("%03d: %08x %08x %08x %08x\n", i,
 165                                 get_unaligned_le32(&buf[i]),
 166                                 get_unaligned_le32(&buf[i + 4]),
 167                                 get_unaligned_le32(&buf[i + 8]),
 168                                 get_unaligned_le32(&buf[i + 12]));
 169                 }
 170         }
 171 #endif
 172
 173         /* response goes here, right after the header */
 174         outbuf = (__le32 *) &resp[1];
 175         resp->InformationBufferOffset = __constant_cpu_to_le32(16);
 176
 177         params = &rndis_per_dev_params[configNr];
 178         switch (OID) {
 179
 180         /* general oids (table 4-1) */
 181
 182         /* mandatory */
 183         case OID_GEN_SUPPORTED_LIST:
 184                 debug("%s: OID_GEN_SUPPORTED_LIST\n", __func__);
 185                 length = sizeof(oid_supported_list);
 186                 count  = length / sizeof(u32);
 187                 for (i = 0; i < count; i++)
 188                         outbuf[i] = cpu_to_le32(oid_supported_list[i]);
 189                 retval = 0;
 190                 break;
 191
 192         /* mandatory */
 193         case OID_GEN_HARDWARE_STATUS:
 194                 debug("%s: OID_GEN_HARDWARE_STATUS\n", __func__);
 195                 /*
 196                  * Bogus question!
 197                  * Hardware must be ready to receive high level protocols.
 198                  * BTW:
 199                  * reddite ergo quae sunt Caesaris Caesari
 200                  * et quae sunt Dei Deo!
 201                  */
 202                 *outbuf = __constant_cpu_to_le32(0);
 203                 retval = 0;
 204                 break;
 205
 206         /* mandatory */
 207         case OID_GEN_MEDIA_SUPPORTED:
 208                 debug("%s: OID_GEN_MEDIA_SUPPORTED\n", __func__);
 209                 *outbuf = cpu_to_le32(params->medium);
 210                 retval = 0;
 211                 break;
 212
 213         /* mandatory */
 214         case OID_GEN_MEDIA_IN_USE:
 215                 debug("%s: OID_GEN_MEDIA_IN_USE\n", __func__);
 216                 /* one medium, one transport... (maybe you do it better) */
 217                 *outbuf = cpu_to_le32(params->medium);
 218                 retval = 0;
 219                 break;
 220
 221         /* mandatory */
 222         case OID_GEN_MAXIMUM_FRAME_SIZE:
 223                 debug("%s: OID_GEN_MAXIMUM_FRAME_SIZE\n", __func__);
 224                 if (params->dev) {
 225                         *outbuf = cpu_to_le32(params->mtu);
 226                         retval = 0;
 227                 }
 228                 break;
 229
 230         /* mandatory */
 231         case OID_GEN_LINK_SPEED:
 232 #if defined(DEBUG) && defined(DEBUG_VERBOSE)
 233                 debug("%s: OID_GEN_LINK_SPEED\n", __func__);
 234 #endif
 235                 if (params->media_state == NDIS_MEDIA_STATE_DISCONNECTED)
 236                         *outbuf = __constant_cpu_to_le32(0);
 237                 else
 238                         *outbuf = cpu_to_le32(params->speed);
 239                 retval = 0;
 240                 break;
 241
 242         /* mandatory */
 243         case OID_GEN_TRANSMIT_BLOCK_SIZE:
 244                 debug("%s: OID_GEN_TRANSMIT_BLOCK_SIZE\n", __func__);
 245                 if (params->dev) {
 246                         *outbuf = cpu_to_le32(params->mtu);
 247                         retval = 0;
 248                 }
 249                 break;
 250
 251         /* mandatory */
 252         case OID_GEN_RECEIVE_BLOCK_SIZE:
 253                 debug("%s: OID_GEN_RECEIVE_BLOCK_SIZE\n", __func__);
 254                 if (params->dev) {
 255                         *outbuf = cpu_to_le32(params->mtu);
 256                         retval = 0;
 257                 }
 258                 break;
 259
 260         /* mandatory */
 261         case OID_GEN_VENDOR_ID:
 262                 debug("%s: OID_GEN_VENDOR_ID\n", __func__);
 263                 *outbuf = cpu_to_le32(params->vendorID);
 264                 retval = 0;
 265                 break;
 266
 267         /* mandatory */
 268         case OID_GEN_VENDOR_DESCRIPTION:
 269                 debug("%s: OID_GEN_VENDOR_DESCRIPTION\n", __func__);
 270                 length = strlen(params->vendorDescr);
 271                 memcpy(outbuf, params->vendorDescr, length);
 272                 retval = 0;
 273                 break;
 274
 275         case OID_GEN_VENDOR_DRIVER_VERSION:
 276                 debug("%s: OID_GEN_VENDOR_DRIVER_VERSION\n", __func__);
 277                 /* Created as LE */
 278                 *outbuf = rndis_driver_version;
 279                 retval = 0;
 280                 break;
 281
 282         /* mandatory */
 283         case OID_GEN_CURRENT_PACKET_FILTER:
 284                 debug("%s: OID_GEN_CURRENT_PACKET_FILTER\n", __func__);
 285                 *outbuf = cpu_to_le32(*params->filter);
 286                 retval = 0;
 287                 break;
 288
 289         /* mandatory */
 290         case OID_GEN_MAXIMUM_TOTAL_SIZE:
 291                 debug("%s: OID_GEN_MAXIMUM_TOTAL_SIZE\n", __func__);
 292                 *outbuf = __constant_cpu_to_le32(RNDIS_MAX_TOTAL_SIZE);
 293                 retval = 0;
 294                 break;
 295
 296         /* mandatory */
 297         case OID_GEN_MEDIA_CONNECT_STATUS:
 298 #if defined(DEBUG) && defined(DEBUG_VERBOSE)
 299                 debug("%s: OID_GEN_MEDIA_CONNECT_STATUS\n", __func__);
 300 #endif
 301                 *outbuf = cpu_to_le32(params->media_state);
 302                 retval = 0;
 303                 break;
 304
 305         case OID_GEN_PHYSICAL_MEDIUM:
 306                 debug("%s: OID_GEN_PHYSICAL_MEDIUM\n", __func__);
 307                 *outbuf = __constant_cpu_to_le32(0);
 308                 retval = 0;
 309                 break;
 310
 311         /*
 312          * The RNDIS specification is incomplete/wrong.   Some versions
 313          * of MS-Windows expect OIDs that aren't specified there.  Other
 314          * versions emit undefined RNDIS messages. DOCUMENT ALL THESE!
 315          */
 316         case OID_GEN_MAC_OPTIONS:               /* from WinME */
 317                 debug("%s: OID_GEN_MAC_OPTIONS\n", __func__);
 318                 *outbuf = __constant_cpu_to_le32(
 319                                   NDIS_MAC_OPTION_RECEIVE_SERIALIZED
 320                                 | NDIS_MAC_OPTION_FULL_DUPLEX);
 321                 retval = 0;
 322                 break;
 323
 324         /* statistics OIDs (table 4-2) */
 325
 326         /* mandatory */
 327         case OID_GEN_XMIT_OK:
 328 #if defined(DEBUG) && defined(DEBUG_VERBOSE)
 329                 debug("%s: OID_GEN_XMIT_OK\n", __func__);
 330 #endif
 331                 if (params->stats) {
 332                         *outbuf = cpu_to_le32(
 333                                         params->stats->tx_packets -
 334                                         params->stats->tx_errors -
 335                                         params->stats->tx_dropped);
 336                         retval = 0;
 337                 }
 338                 break;
 339
 340         /* mandatory */
 341         case OID_GEN_RCV_OK:
 342 #if defined(DEBUG) && defined(DEBUG_VERBOSE)
 343                 debug("%s: OID_GEN_RCV_OK\n", __func__);
 344 #endif
 345                 if (params->stats) {
 346                         *outbuf = cpu_to_le32(
 347                                         params->stats->rx_packets -
 348                                         params->stats->rx_errors -
 349                                         params->stats->rx_dropped);
 350                         retval = 0;
 351                 }
 352                 break;
 353
 354         /* mandatory */
 355         case OID_GEN_XMIT_ERROR:
 356 #if defined(DEBUG) && defined(DEBUG_VERBOSE)
 357                 debug("%s: OID_GEN_XMIT_ERROR\n", __func__);
 358 #endif
 359                 if (params->stats) {
 360                         *outbuf = cpu_to_le32(params->stats->tx_errors);
 361                         retval = 0;
 362                 }
 363                 break;
 364
 365         /* mandatory */
 366         case OID_GEN_RCV_ERROR:
 367 #if defined(DEBUG) && defined(DEBUG_VERBOSE)
 368                 debug("%s: OID_GEN_RCV_ERROR\n", __func__);
 369 #endif
 370                 if (params->stats) {
 371                         *outbuf = cpu_to_le32(params->stats->rx_errors);
 372                         retval = 0;
 373                 }
 374                 break;
 375
 376         /* mandatory */
 377         case OID_GEN_RCV_NO_BUFFER:
 378                 debug("%s: OID_GEN_RCV_NO_BUFFER\n", __func__);
 379                 if (params->stats) {
 380                         *outbuf = cpu_to_le32(params->stats->rx_dropped);
 381                         retval = 0;
 382                 }
 383                 break;
 384
 385 #ifdef  RNDIS_OPTIONAL_STATS
 386         case OID_GEN_DIRECTED_BYTES_XMIT:
 387                 debug("%s: OID_GEN_DIRECTED_BYTES_XMIT\n", __func__);
 388                 /*
 389                  * Aunt Tilly's size of shoes
 390                  * minus antarctica count of penguins
 391                  * divided by weight of Alpha Centauri
 392                  */
 393                 if (params->stats) {
 394                         *outbuf = cpu_to_le32(
 395                                         (params->stats->tx_packets -
 396                                          params->stats->tx_errors -
 397                                          params->stats->tx_dropped)
 398                                         * 123);
 399                         retval = 0;
 400                 }
 401                 break;
 402
 403         case OID_GEN_DIRECTED_FRAMES_XMIT:
 404                 debug("%s: OID_GEN_DIRECTED_FRAMES_XMIT\n", __func__);
 405                 /* dito */
 406                 if (params->stats) {
 407                         *outbuf = cpu_to_le32(
 408                                         (params->stats->tx_packets -
 409                                          params->stats->tx_errors -
 410                                          params->stats->tx_dropped)
 411                                         / 123);
 412                         retval = 0;
 413                 }
 414                 break;
 415
 416         case OID_GEN_MULTICAST_BYTES_XMIT:
 417                 debug("%s: OID_GEN_MULTICAST_BYTES_XMIT\n", __func__);
 418                 if (params->stats) {
 419                         *outbuf = cpu_to_le32(params->stats->multicast * 1234);
 420                         retval = 0;
 421                 }
 422                 break;
 423
 424         case OID_GEN_MULTICAST_FRAMES_XMIT:
 425                 debug("%s: OID_GEN_MULTICAST_FRAMES_XMIT\n", __func__);
 426                 if (params->stats) {
 427                         *outbuf = cpu_to_le32(params->stats->multicast);
 428                         retval = 0;
 429                 }
 430                 break;
 431
 432         case OID_GEN_BROADCAST_BYTES_XMIT:
 433                 debug("%s: OID_GEN_BROADCAST_BYTES_XMIT\n", __func__);
 434                 if (params->stats) {
 435                         *outbuf = cpu_to_le32(params->stats->tx_packets/42*255);
 436                         retval = 0;
 437                 }
 438                 break;
 439
 440         case OID_GEN_BROADCAST_FRAMES_XMIT:
 441                 debug("%s: OID_GEN_BROADCAST_FRAMES_XMIT\n", __func__);
 442                 if (params->stats) {
 443                         *outbuf = cpu_to_le32(params->stats->tx_packets / 42);
 444                         retval = 0;
 445                 }
 446                 break;
 447
 448         case OID_GEN_DIRECTED_BYTES_RCV:
 449                 debug("%s: OID_GEN_DIRECTED_BYTES_RCV\n", __func__);
 450                 *outbuf = __constant_cpu_to_le32(0);
 451                 retval = 0;
 452                 break;
 453
 454         case OID_GEN_DIRECTED_FRAMES_RCV:
 455                 debug("%s: OID_GEN_DIRECTED_FRAMES_RCV\n", __func__);
 456                 *outbuf = __constant_cpu_to_le32(0);
 457                 retval = 0;
 458                 break;
 459
 460         case OID_GEN_MULTICAST_BYTES_RCV:
 461                 debug("%s: OID_GEN_MULTICAST_BYTES_RCV\n", __func__);
 462                 if (params->stats) {
 463                         *outbuf = cpu_to_le32(params->stats->multicast * 1111);
 464                         retval = 0;
 465                 }
 466                 break;
 467
 468         case OID_GEN_MULTICAST_FRAMES_RCV:
 469                 debug("%s: OID_GEN_MULTICAST_FRAMES_RCV\n", __func__);
 470                 if (params->stats) {
 471                         *outbuf = cpu_to_le32(params->stats->multicast);
 472                         retval = 0;
 473                 }
 474                 break;
 475
 476         case OID_GEN_BROADCAST_BYTES_RCV:
 477                 debug("%s: OID_GEN_BROADCAST_BYTES_RCV\n", __func__);
 478                 if (params->stats) {
 479                         *outbuf = cpu_to_le32(params->stats->rx_packets/42*255);
 480                         retval = 0;
 481                 }
 482                 break;
 483
 484         case OID_GEN_BROADCAST_FRAMES_RCV:
 485                 debug("%s: OID_GEN_BROADCAST_FRAMES_RCV\n", __func__);
 486                 if (params->stats) {
 487                         *outbuf = cpu_to_le32(params->stats->rx_packets / 42);
 488                         retval = 0;
 489                 }
 490                 break;
 491
 492         case OID_GEN_RCV_CRC_ERROR:
 493                 debug("%s: OID_GEN_RCV_CRC_ERROR\n", __func__);
 494                 if (params->stats) {
 495                         *outbuf = cpu_to_le32(params->stats->rx_crc_errors);
 496                         retval = 0;
 497                 }
 498                 break;
 499
 500         case OID_GEN_TRANSMIT_QUEUE_LENGTH:
 501                 debug("%s: OID_GEN_TRANSMIT_QUEUE_LENGTH\n", __func__);
 502                 *outbuf = __constant_cpu_to_le32(0);
 503                 retval = 0;
 504                 break;
 505 #endif  /* RNDIS_OPTIONAL_STATS */
 506
 507         /* ieee802.3 OIDs (table 4-3) */
 508
 509         /* mandatory */
 510         case OID_802_3_PERMANENT_ADDRESS:
 511                 debug("%s: OID_802_3_PERMANENT_ADDRESS\n", __func__);
 512                 if (params->dev) {
 513                         length = ETH_ALEN;
 514                         memcpy(outbuf, params->host_mac, length);
 515                         retval = 0;
 516                 }
 517                 break;
 518
 519         /* mandatory */
 520         case OID_802_3_CURRENT_ADDRESS:
 521                 debug("%s: OID_802_3_CURRENT_ADDRESS\n", __func__);
 522                 if (params->dev) {
 523                         length = ETH_ALEN;
 524                         memcpy(outbuf, params->host_mac, length);
 525                         retval = 0;
 526                 }
 527                 break;
 528
 529         /* mandatory */
 530         case OID_802_3_MULTICAST_LIST:
 531                 debug("%s: OID_802_3_MULTICAST_LIST\n", __func__);
 532                 /* Multicast base address only */
 533                 *outbuf = __constant_cpu_to_le32(0xE0000000);
 534                 retval = 0;
 535                 break;
 536
 537         /* mandatory */
 538         case OID_802_3_MAXIMUM_LIST_SIZE:
 539                 debug("%s: OID_802_3_MAXIMUM_LIST_SIZE\n", __func__);
 540                 /* Multicast base address only */
 541                 *outbuf = __constant_cpu_to_le32(1);
 542                 retval = 0;
 543                 break;
 544
 545         case OID_802_3_MAC_OPTIONS:
 546                 debug("%s: OID_802_3_MAC_OPTIONS\n", __func__);
 547                 break;
 548
 549         /* ieee802.3 statistics OIDs (table 4-4) */
 550
 551         /* mandatory */
 552         case OID_802_3_RCV_ERROR_ALIGNMENT:
 553                 debug("%s: OID_802_3_RCV_ERROR_ALIGNMENT\n", __func__);
 554                 if (params->stats) {
 555                         *outbuf = cpu_to_le32(params->stats->rx_frame_errors);
 556                         retval = 0;
 557                 }
 558                 break;
 559
 560         /* mandatory */
 561         case OID_802_3_XMIT_ONE_COLLISION:
 562                 debug("%s: OID_802_3_XMIT_ONE_COLLISION\n", __func__);
 563                 *outbuf = __constant_cpu_to_le32(0);
 564                 retval = 0;
 565                 break;
 566
 567         /* mandatory */
 568         case OID_802_3_XMIT_MORE_COLLISIONS:
 569                 debug("%s: OID_802_3_XMIT_MORE_COLLISIONS\n", __func__);
 570                 *outbuf = __constant_cpu_to_le32(0);
 571                 retval = 0;
 572                 break;
 573
 574 #ifdef  RNDIS_OPTIONAL_STATS
 575         case OID_802_3_XMIT_DEFERRED:
 576                 debug("%s: OID_802_3_XMIT_DEFERRED\n", __func__);
 577                 /* TODO */
 578                 break;
 579
 580         case OID_802_3_XMIT_MAX_COLLISIONS:
 581                 debug("%s: OID_802_3_XMIT_MAX_COLLISIONS\n", __func__);
 582                 /* TODO */
 583                 break;
 584
 585         case OID_802_3_RCV_OVERRUN:
 586                 debug("%s: OID_802_3_RCV_OVERRUN\n", __func__);
 587                 /* TODO */
 588                 break;
 589
 590         case OID_802_3_XMIT_UNDERRUN:
 591                 debug("%s: OID_802_3_XMIT_UNDERRUN\n", __func__);
 592                 /* TODO */
 593                 break;
 594
 595         case OID_802_3_XMIT_HEARTBEAT_FAILURE:
 596                 debug("%s: OID_802_3_XMIT_HEARTBEAT_FAILURE\n", __func__);
 597                 /* TODO */
 598                 break;
 599
 600         case OID_802_3_XMIT_TIMES_CRS_LOST:
 601                 debug("%s: OID_802_3_XMIT_TIMES_CRS_LOST\n", __func__);
 602                 /* TODO */
 603                 break;
 604
 605         case OID_802_3_XMIT_LATE_COLLISIONS:
 606                 debug("%s: OID_802_3_XMIT_LATE_COLLISIONS\n", __func__);
 607                 /* TODO */
 608                 break;
 609 #endif  /* RNDIS_OPTIONAL_STATS */
 610
 611 #ifdef  RNDIS_PM
 612         /* power management OIDs (table 4-5) */
 613         case OID_PNP_CAPABILITIES:
 614                 debug("%s: OID_PNP_CAPABILITIES\n", __func__);
 615
 616                 /* for now, no wakeup capabilities */
 617                 length = sizeof(struct NDIS_PNP_CAPABILITIES);
 618                 memset(outbuf, 0, length);
 619                 retval = 0;
 620                 break;
 621         case OID_PNP_QUERY_POWER:
 622                 debug("%s: OID_PNP_QUERY_POWER D%d\n", __func__,
 623                                 get_unaligned_le32(buf) - 1);
 624                 /*
 625                  * only suspend is a real power state, and
 626                  * it can't be entered by OID_PNP_SET_POWER...
 627                  */
 628                 length = 0;
 629                 retval = 0;
 630                 break;
 631 #endif
 632
 633         default:
 634                 debug("%s: query unknown OID 0x%08X\n", __func__, OID);
 635         }
 636         if (retval < 0)
 637                 length = 0;
 638
 639         resp->InformationBufferLength = cpu_to_le32(length);
 640         r->length = length + sizeof *resp;
 641         resp->MessageLength = cpu_to_le32(r->length);
 642         return retval;
 643 }
 644
 645 static int gen_ndis_set_resp(u8 configNr, u32 OID, u8 *buf, u32 buf_len,
 646                                 rndis_resp_t *r)
 647 {
 648         rndis_set_cmplt_type            *resp;
 649         int                             retval = -ENOTSUPP;
 650         struct rndis_params             *params;
 651 #if (defined(DEBUG) && defined(DEBUG_VERBOSE)) || defined(RNDIS_PM)
 652         int                             i;
 653 #endif
 654
 655         if (!r)
 656                 return -ENOMEM;
 657         resp = (rndis_set_cmplt_type *) r->buf;
 658         if (!resp)
 659                 return -ENOMEM;
 660
 661 #if defined(DEBUG) && defined(DEBUG_VERBOSE)
 662         if (buf_len) {
 663                 debug("set OID %08x value, len %d:\n", OID, buf_len);
 664                 for (i = 0; i < buf_len; i += 16) {
 665                         debug("%03d: %08x %08x %08x %08x\n", i,
 666                                 get_unaligned_le32(&buf[i]),
 667                                 get_unaligned_le32(&buf[i + 4]),
 668                                 get_unaligned_le32(&buf[i + 8]),
 669                                 get_unaligned_le32(&buf[i + 12]));
 670                 }
 671         }
 672 #endif
 673
 674         params = &rndis_per_dev_params[configNr];
 675         switch (OID) {
 676         case OID_GEN_CURRENT_PACKET_FILTER:
 677
 678                 /*
 679                  * these NDIS_PACKET_TYPE_* bitflags are shared with
 680                  * cdc_filter; it's not RNDIS-specific
 681                  * NDIS_PACKET_TYPE_x == USB_CDC_PACKET_TYPE_x for x in:
 682                  *      PROMISCUOUS, DIRECTED,
 683                  *      MULTICAST, ALL_MULTICAST, BROADCAST
 684                  */
 685                 *params->filter = (u16) get_unaligned_le32(buf);
 686                 debug("%s: OID_GEN_CURRENT_PACKET_FILTER %08x\n",
 687                         __func__, *params->filter);
 688
 689                 /*
 690                  * this call has a significant side effect:  it's
 691                  * what makes the packet flow start and stop, like
 692                  * activating the CDC Ethernet altsetting.
 693                  */
 694 #ifdef  RNDIS_PM
 695 update_linkstate:
 696 #endif
 697                 retval = 0;
 698                 if (*params->filter)
 699                         params->state = RNDIS_DATA_INITIALIZED;
 700                 else
 701                         params->state = RNDIS_INITIALIZED;
 702                 break;
 703
 704         case OID_802_3_MULTICAST_LIST:
 705                 /* I think we can ignore this */
 706                 debug("%s: OID_802_3_MULTICAST_LIST\n", __func__);
 707                 retval = 0;
 708                 break;
 709 #if 0
 710         case OID_GEN_RNDIS_CONFIG_PARAMETER:
 711                 {
 712                 struct rndis_config_parameter   *param;
 713                 param = (struct rndis_config_parameter *) buf;
 714                 debug("%s: OID_GEN_RNDIS_CONFIG_PARAMETER '%*s'\n",
 715                         __func__,
 716                         min(cpu_to_le32(param->ParameterNameLength), 80),
 717                         buf + param->ParameterNameOffset);
 718                 retval = 0;
 719                 }
 720                 break;
 721 #endif
 722
 723 #ifdef  RNDIS_PM
 724         case OID_PNP_SET_POWER:
 725                 /*
 726                  * The only real power state is USB suspend, and RNDIS requests
 727                  * can't enter it; this one isn't really about power.  After
 728                  * resuming, Windows forces a reset, and then SET_POWER D0.
 729                  * FIXME ... then things go batty; Windows wedges itself.
 730                  */
 731                 i = get_unaligned_le32(buf);
 732                 debug("%s: OID_PNP_SET_POWER D%d\n", __func__, i - 1);
 733                 switch (i) {
 734                 case NdisDeviceStateD0:
 735                         *params->filter = params->saved_filter;
 736                         goto update_linkstate;
 737                 case NdisDeviceStateD3:
 738                 case NdisDeviceStateD2:
 739                 case NdisDeviceStateD1:
 740                         params->saved_filter = *params->filter;
 741                         retval = 0;
 742                         break;
 743                 }
 744                 break;
 745
 746 #ifdef  RNDIS_WAKEUP
 747         /*
 748          * no wakeup support advertised, so wakeup OIDs always fail:
 749          *  - OID_PNP_ENABLE_WAKE_UP
 750          *  - OID_PNP_{ADD,REMOVE}_WAKE_UP_PATTERN
 751          */
 752 #endif
 753
 754 #endif  /* RNDIS_PM */
 755
 756         default:
 757                 debug("%s: set unknown OID 0x%08X, size %d\n",
 758                         __func__, OID, buf_len);
 759         }
 760
 761         return retval;
 762 }
 763
 764 /*
 765  * Response Functions
 766  */
 767
 768 static int rndis_init_response(int configNr, rndis_init_msg_type *buf)
 769 {
 770         rndis_init_cmplt_type   *resp;
 771         rndis_resp_t            *r;
 772
 773         if (!rndis_per_dev_params[configNr].dev)
 774                 return -ENOTSUPP;
 775
 776         r = rndis_add_response(configNr, sizeof(rndis_init_cmplt_type));
 777         if (!r)
 778                 return -ENOMEM;
 779         resp = (rndis_init_cmplt_type *) r->buf;
 780
 781         resp->MessageType = __constant_cpu_to_le32(
 782                         REMOTE_NDIS_INITIALIZE_CMPLT);
 783         resp->MessageLength = __constant_cpu_to_le32(52);
 784         resp->RequestID = get_unaligned(&buf->RequestID); /* Still LE in msg buffer */
 785         resp->Status = __constant_cpu_to_le32(RNDIS_STATUS_SUCCESS);
 786         resp->MajorVersion = __constant_cpu_to_le32(RNDIS_MAJOR_VERSION);
 787         resp->MinorVersion = __constant_cpu_to_le32(RNDIS_MINOR_VERSION);
 788         resp->DeviceFlags = __constant_cpu_to_le32(RNDIS_DF_CONNECTIONLESS);
 789         resp->Medium = __constant_cpu_to_le32(RNDIS_MEDIUM_802_3);
 790         resp->MaxPacketsPerTransfer = __constant_cpu_to_le32(1);
 791         resp->MaxTransferSize = cpu_to_le32(
 792                   rndis_per_dev_params[configNr].mtu
 793                 + ETHER_HDR_SIZE
 794                 + sizeof(struct rndis_packet_msg_type)
 795                 + 22);
 796         resp->PacketAlignmentFactor = __constant_cpu_to_le32(0);
 797         resp->AFListOffset = __constant_cpu_to_le32(0);
 798         resp->AFListSize = __constant_cpu_to_le32(0);
 799
 800         if (rndis_per_dev_params[configNr].ack)
 801                 rndis_per_dev_params[configNr].ack(
 802                         rndis_per_dev_params[configNr].dev);
 803
 804         return 0;
 805 }
 806
 807 static int rndis_query_response(int configNr, rndis_query_msg_type *buf)
 808 {
 809         rndis_query_cmplt_type *resp;
 810         rndis_resp_t            *r;
 811
 812         debug("%s: OID = %08X\n", __func__, get_unaligned_le32(&buf->OID));
 813         if (!rndis_per_dev_params[configNr].dev)
 814                 return -ENOTSUPP;
 815
 816         /*
 817          * we need more memory:
 818          * gen_ndis_query_resp expects enough space for
 819          * rndis_query_cmplt_type followed by data.
 820          * oid_supported_list is the largest data reply
 821          */
 822         r = rndis_add_response(configNr,
 823                 sizeof(oid_supported_list) + sizeof(rndis_query_cmplt_type));
 824         if (!r)
 825                 return -ENOMEM;
 826         resp = (rndis_query_cmplt_type *) r->buf;
 827
 828         resp->MessageType = __constant_cpu_to_le32(REMOTE_NDIS_QUERY_CMPLT);
 829         resp->RequestID = get_unaligned(&buf->RequestID); /* Still LE in msg buffer */
 830
 831         if (gen_ndis_query_resp(configNr, get_unaligned_le32(&buf->OID),
 832                         get_unaligned_le32(&buf->InformationBufferOffset)
 833                                         + 8 + (u8 *) buf,
 834                         get_unaligned_le32(&buf->InformationBufferLength),
 835                         r)) {
 836                 /* OID not supported */
 837                 resp->Status = __constant_cpu_to_le32(
 838                                                 RNDIS_STATUS_NOT_SUPPORTED);
 839                 resp->MessageLength = __constant_cpu_to_le32(sizeof *resp);
 840                 resp->InformationBufferLength = __constant_cpu_to_le32(0);
 841                 resp->InformationBufferOffset = __constant_cpu_to_le32(0);
 842         } else
 843                 resp->Status = __constant_cpu_to_le32(RNDIS_STATUS_SUCCESS);
 844
 845         if (rndis_per_dev_params[configNr].ack)
 846                 rndis_per_dev_params[configNr].ack(
 847                         rndis_per_dev_params[configNr].dev);
 848         return 0;
 849 }
 850
 851 static int rndis_set_response(int configNr, rndis_set_msg_type *buf)
 852 {
 853         u32                     BufLength, BufOffset;
 854         rndis_set_cmplt_type    *resp;
 855         rndis_resp_t            *r;
 856
 857         r = rndis_add_response(configNr, sizeof(rndis_set_cmplt_type));
 858         if (!r)
 859                 return -ENOMEM;
 860         resp = (rndis_set_cmplt_type *) r->buf;
 861
 862         BufLength = get_unaligned_le32(&buf->InformationBufferLength);
 863         BufOffset = get_unaligned_le32(&buf->InformationBufferOffset);
 864
 865 #ifdef  VERBOSE
 866         debug("%s: Length: %d\n", __func__, BufLength);
 867         debug("%s: Offset: %d\n", __func__, BufOffset);
 868         debug("%s: InfoBuffer: ", __func__);
 869
 870         for (i = 0; i < BufLength; i++)
 871                 debug("%02x ", *(((u8 *) buf) + i + 8 + BufOffset));
 872
 873         debug("\n");
 874 #endif
 875
 876         resp->MessageType = __constant_cpu_to_le32(REMOTE_NDIS_SET_CMPLT);
 877         resp->MessageLength = __constant_cpu_to_le32(16);
 878         resp->RequestID = get_unaligned(&buf->RequestID); /* Still LE in msg buffer */
 879         if (gen_ndis_set_resp(configNr, get_unaligned_le32(&buf->OID),
 880                         ((u8 *) buf) + 8 + BufOffset, BufLength, r))
 881                 resp->Status = __constant_cpu_to_le32(
 882                                                 RNDIS_STATUS_NOT_SUPPORTED);
 883         else
 884                 resp->Status = __constant_cpu_to_le32(RNDIS_STATUS_SUCCESS);
 885
 886         if (rndis_per_dev_params[configNr].ack)
 887                 rndis_per_dev_params[configNr].ack(
 888                         rndis_per_dev_params[configNr].dev);
 889
 890         return 0;
 891 }
 892
 893 static int rndis_reset_response(int configNr, rndis_reset_msg_type *buf)
 894 {
 895         rndis_reset_cmplt_type  *resp;
 896         rndis_resp_t            *r;
 897
 898         r = rndis_add_response(configNr, sizeof(rndis_reset_cmplt_type));
 899         if (!r)
 900                 return -ENOMEM;
 901         resp = (rndis_reset_cmplt_type *) r->buf;
 902
 903         resp->MessageType = __constant_cpu_to_le32(REMOTE_NDIS_RESET_CMPLT);
 904         resp->MessageLength = __constant_cpu_to_le32(16);
 905         resp->Status = __constant_cpu_to_le32(RNDIS_STATUS_SUCCESS);
 906         /* resent information */
 907         resp->AddressingReset = __constant_cpu_to_le32(1);
 908
 909         if (rndis_per_dev_params[configNr].ack)
 910                 rndis_per_dev_params[configNr].ack(
 911                         rndis_per_dev_params[configNr].dev);
 912
 913         return 0;
 914 }
 915
 916 static int rndis_keepalive_response(int configNr,
 917                                         rndis_keepalive_msg_type *buf)
 918 {
 919         rndis_keepalive_cmplt_type      *resp;
 920         rndis_resp_t                    *r;
 921
 922         /* host "should" check only in RNDIS_DATA_INITIALIZED state */
 923
 924         r = rndis_add_response(configNr, sizeof(rndis_keepalive_cmplt_type));
 925         if (!r)
 926                 return -ENOMEM;
 927         resp = (rndis_keepalive_cmplt_type *) r->buf;
 928
 929         resp->MessageType = __constant_cpu_to_le32(
 930                         REMOTE_NDIS_KEEPALIVE_CMPLT);
 931         resp->MessageLength = __constant_cpu_to_le32(16);
 932         resp->RequestID = get_unaligned(&buf->RequestID); /* Still LE in msg buffer */
 933         resp->Status = __constant_cpu_to_le32(RNDIS_STATUS_SUCCESS);
 934
 935         if (rndis_per_dev_params[configNr].ack)
 936                 rndis_per_dev_params[configNr].ack(
 937                         rndis_per_dev_params[configNr].dev);
 938
 939         return 0;
 940 }
 941
 942
 943 /*
 944  * Device to Host Comunication
 945  */
 946 static int rndis_indicate_status_msg(int configNr, u32 status)
 947 {
 948         rndis_indicate_status_msg_type  *resp;
 949         rndis_resp_t                    *r;
 950
 951         if (rndis_per_dev_params[configNr].state == RNDIS_UNINITIALIZED)
 952                 return -ENOTSUPP;
 953
 954         r = rndis_add_response(configNr,
 955                                 sizeof(rndis_indicate_status_msg_type));
 956         if (!r)
 957                 return -ENOMEM;
 958         resp = (rndis_indicate_status_msg_type *) r->buf;
 959
 960         resp->MessageType = __constant_cpu_to_le32(
 961                         REMOTE_NDIS_INDICATE_STATUS_MSG);
 962         resp->MessageLength = __constant_cpu_to_le32(20);
 963         resp->Status = cpu_to_le32(status);
 964         resp->StatusBufferLength = __constant_cpu_to_le32(0);
 965         resp->StatusBufferOffset = __constant_cpu_to_le32(0);
 966
 967         if (rndis_per_dev_params[configNr].ack)
 968                 rndis_per_dev_params[configNr].ack(
 969                         rndis_per_dev_params[configNr].dev);
 970         return 0;
 971 }
 972
 973 int rndis_signal_connect(int configNr)
 974 {
 975         rndis_per_dev_params[configNr].media_state
 976                         = NDIS_MEDIA_STATE_CONNECTED;
 977         return rndis_indicate_status_msg(configNr,
 978                                           RNDIS_STATUS_MEDIA_CONNECT);
 979 }
 980
 981 int rndis_signal_disconnect(int configNr)
 982 {
 983         rndis_per_dev_params[configNr].media_state
 984                         = NDIS_MEDIA_STATE_DISCONNECTED;
 985
 986 #ifdef RNDIS_COMPLETE_SIGNAL_DISCONNECT
 987         return rndis_indicate_status_msg(configNr,
 988                                           RNDIS_STATUS_MEDIA_DISCONNECT);
 989 #else
 990         return 0;
 991 #endif
 992 }
 993
 994 void rndis_uninit(int configNr)
 995 {
 996         u8 *buf;
 997         u32 length;
 998
 999         if (configNr >= RNDIS_MAX_CONFIGS)
1000                 return;
1001         rndis_per_dev_params[configNr].used = 0;
1002         rndis_per_dev_params[configNr].state = RNDIS_UNINITIALIZED;
1003
1004         /* drain the response queue */
1005         while ((buf = rndis_get_next_response(configNr, &length)))
1006                 rndis_free_response(configNr, buf);
1007 }
1008
1009 void rndis_set_host_mac(int configNr, const u8 *addr)
1010 {
1011         rndis_per_dev_params[configNr].host_mac = addr;
1012 }
1013
1014 enum rndis_state rndis_get_state(int configNr)
1015 {
1016         if (configNr >= RNDIS_MAX_CONFIGS || configNr < 0)
1017                 return -ENOTSUPP;
1018         return rndis_per_dev_params[configNr].state;
1019 }
1020
1021 /*
1022  * Message Parser
1023  */
1024 int rndis_msg_parser(u8 configNr, u8 *buf)
1025 {
1026         u32                             MsgType, MsgLength;
1027         __le32                          *tmp;
1028         struct rndis_params             *params;
1029
1030         debug("%s: configNr = %d, %p\n", __func__, configNr, buf);
1031
1032         if (!buf)
1033                 return -ENOMEM;
1034
1035         tmp = (__le32 *) buf;
1036         MsgType   = get_unaligned_le32(tmp++);
1037         MsgLength = get_unaligned_le32(tmp++);
1038
1039         if (configNr >= RNDIS_MAX_CONFIGS)
1040                 return -ENOTSUPP;
1041         params = &rndis_per_dev_params[configNr];
1042
1043         /*
1044          * NOTE: RNDIS is *EXTREMELY* chatty ... Windows constantly polls for
1045          * rx/tx statistics and link status, in addition to KEEPALIVE traffic
1046          * and normal HC level polling to see if there's any IN traffic.
1047          */
1048
1049         /* For USB: responses may take up to 10 seconds */
1050         switch (MsgType) {
1051         case REMOTE_NDIS_INITIALIZE_MSG:
1052                 debug("%s: REMOTE_NDIS_INITIALIZE_MSG\n", __func__);
1053                 params->state = RNDIS_INITIALIZED;
1054                 return  rndis_init_response(configNr,
1055                                         (rndis_init_msg_type *) buf);
1056
1057         case REMOTE_NDIS_HALT_MSG:
1058                 debug("%s: REMOTE_NDIS_HALT_MSG\n", __func__);
1059                 params->state = RNDIS_UNINITIALIZED;
1060                 return 0;
1061
1062         case REMOTE_NDIS_QUERY_MSG:
1063                 return rndis_query_response(configNr,
1064                                         (rndis_query_msg_type *) buf);
1065
1066         case REMOTE_NDIS_SET_MSG:
1067                 return rndis_set_response(configNr,
1068                                         (rndis_set_msg_type *) buf);
1069
1070         case REMOTE_NDIS_RESET_MSG:
1071                 debug("%s: REMOTE_NDIS_RESET_MSG\n", __func__);
1072                 return rndis_reset_response(configNr,
1073                                         (rndis_reset_msg_type *) buf);
1074
1075         case REMOTE_NDIS_KEEPALIVE_MSG:
1076                 /* For USB: host does this every 5 seconds */
1077 #if defined(DEBUG) && defined(DEBUG_VERBOSE)
1078                 debug("%s: REMOTE_NDIS_KEEPALIVE_MSG\n", __func__);
1079 #endif
1080                 return rndis_keepalive_response(configNr,
1081                                         (rndis_keepalive_msg_type *) buf);
1082
1083         default:
1084                 /*
1085                  * At least Windows XP emits some undefined RNDIS messages.
1086                  * In one case those messages seemed to relate to the host
1087                  * suspending itself.
1088                  */
1089                 debug("%s: unknown RNDIS message 0x%08X len %d\n",
1090                         __func__ , MsgType, MsgLength);
1091                 {
1092                         unsigned i;
1093                         for (i = 0; i < MsgLength; i += 16) {
1094                                 debug("%03d: "
1095                                         " %02x %02x %02x %02x"
1096                                         " %02x %02x %02x %02x"
1097                                         " %02x %02x %02x %02x"
1098                                         " %02x %02x %02x %02x"
1099                                         "\n",
1100                                         i,
1101                                         buf[i], buf[i+1],
1102                                                 buf[i+2], buf[i+3],
1103                                         buf[i+4], buf[i+5],
1104                                                 buf[i+6], buf[i+7],
1105                                         buf[i+8], buf[i+9],
1106                                                 buf[i+10], buf[i+11],
1107                                         buf[i+12], buf[i+13],
1108                                                 buf[i+14], buf[i+15]);
1109                         }
1110                 }
1111                 break;
1112         }
1113
1114         return -ENOTSUPP;
1115 }
1116
1117 #ifndef CONFIG_DM_ETH
1118 int rndis_register(int (*rndis_control_ack)(struct eth_device *))
1119 #else
1120 int rndis_register(int (*rndis_control_ack)(struct udevice *))
1121 #endif
1122 {
1123         u8 i;
1124
1125         for (i = 0; i < RNDIS_MAX_CONFIGS; i++) {
1126                 if (!rndis_per_dev_params[i].used) {
1127                         rndis_per_dev_params[i].used = 1;
1128                         rndis_per_dev_params[i].ack = rndis_control_ack;
1129                         debug("%s: configNr = %d\n", __func__, i);
1130                         return i;
1131                 }
1132         }
1133         debug("%s failed\n", __func__);
1134
1135         return -1;
1136 }
1137
1138 void rndis_deregister(int configNr)
1139 {
1140         debug("%s: configNr = %d\n", __func__, configNr);
1141
1142         if (configNr >= RNDIS_MAX_CONFIGS)
1143                 return;
1144         rndis_per_dev_params[configNr].used = 0;
1145
1146         return;
1147 }
1148
1149 #ifndef CONFIG_DM_ETH
1150 int  rndis_set_param_dev(u8 configNr, struct eth_device *dev, int mtu,
1151                          struct net_device_stats *stats, u16 *cdc_filter)
1152 #else
1153 int  rndis_set_param_dev(u8 configNr, struct udevice *dev, int mtu,
1154                          struct net_device_stats *stats, u16 *cdc_filter)
1155 #endif
1156 {
1157         debug("%s: configNr = %d\n", __func__, configNr);
1158         if (!dev || !stats)
1159                 return -1;
1160         if (configNr >= RNDIS_MAX_CONFIGS)
1161                 return -1;
1162
1163         rndis_per_dev_params[configNr].dev = dev;
1164         rndis_per_dev_params[configNr].stats = stats;
1165         rndis_per_dev_params[configNr].mtu = mtu;
1166         rndis_per_dev_params[configNr].filter = cdc_filter;
1167
1168         return 0;
1169 }
1170
1171 int rndis_set_param_vendor(u8 configNr, u32 vendorID, const char *vendorDescr)
1172 {
1173         debug("%s: configNr = %d\n", __func__, configNr);
1174         if (!vendorDescr)
1175                 return -1;
1176         if (configNr >= RNDIS_MAX_CONFIGS)
1177                 return -1;
1178
1179         rndis_per_dev_params[configNr].vendorID = vendorID;
1180         rndis_per_dev_params[configNr].vendorDescr = vendorDescr;
1181
1182         return 0;
1183 }
1184
1185 int rndis_set_param_medium(u8 configNr, u32 medium, u32 speed)
1186 {
1187         debug("%s: configNr = %d, %u %u\n", __func__, configNr, medium, speed);
1188         if (configNr >= RNDIS_MAX_CONFIGS)
1189                 return -1;
1190
1191         rndis_per_dev_params[configNr].medium = medium;
1192         rndis_per_dev_params[configNr].speed = speed;
1193
1194         return 0;
1195 }
1196
1197 void rndis_add_hdr(void *buf, int length)
1198 {
1199         struct rndis_packet_msg_type    *header;
1200
1201         header = buf;
1202         memset(header, 0, sizeof *header);
1203         header->MessageType = __constant_cpu_to_le32(REMOTE_NDIS_PACKET_MSG);
1204         header->MessageLength = cpu_to_le32(length + sizeof *header);
1205         header->DataOffset = __constant_cpu_to_le32(36);
1206         header->DataLength = cpu_to_le32(length);
1207 }
1208
1209 void rndis_free_response(int configNr, u8 *buf)
1210 {
1211         rndis_resp_t            *r;
1212         struct list_head        *act, *tmp;
1213
1214         list_for_each_safe(act, tmp,
1215                         &(rndis_per_dev_params[configNr].resp_queue))
1216         {
1217                 r = list_entry(act, rndis_resp_t, list);
1218                 if (r && r->buf == buf) {
1219                         list_del(&r->list);
1220                         free(r);
1221                 }
1222         }
1223 }
1224
1225 u8 *rndis_get_next_response(int configNr, u32 *length)
1226 {
1227         rndis_resp_t            *r;
1228         struct list_head        *act, *tmp;
1229
1230         if (!length)
1231                 return NULL;
1232
1233         list_for_each_safe(act, tmp,
1234                         &(rndis_per_dev_params[configNr].resp_queue))
1235         {
1236                 r = list_entry(act, rndis_resp_t, list);
1237                 if (!r->send) {
1238                         r->send = 1;
1239                         *length = r->length;
1240                         return r->buf;
1241                 }
1242         }
1243
1244         return NULL;
1245 }
1246
1247 static rndis_resp_t *rndis_add_response(int configNr, u32 length)
1248 {
1249         rndis_resp_t    *r;
1250
1251         /* NOTE:  this gets copied into ether.c USB_BUFSIZ bytes ... */
1252         r = malloc(sizeof(rndis_resp_t) + length);
1253         if (!r)
1254                 return NULL;
1255
1256         r->buf = (u8 *) (r + 1);
1257         r->length = length;
1258         r->send = 0;
1259
1260         list_add_tail(&r->list,
1261                 &(rndis_per_dev_params[configNr].resp_queue));
1262         return r;
1263 }
1264
1265 int rndis_rm_hdr(void *buf, int length)
1266 {
1267         /* tmp points to a struct rndis_packet_msg_type */
1268         __le32          *tmp = buf;
1269         int             offs, len;
1270
1271         /* MessageType, MessageLength */
1272         if (__constant_cpu_to_le32(REMOTE_NDIS_PACKET_MSG)
1273                         != get_unaligned(tmp++))
1274                 return -EINVAL;
1275         tmp++;
1276
1277         /* DataOffset, DataLength */
1278         offs = get_unaligned_le32(tmp++) + 8 /* offset of DataOffset */;
1279         if (offs != sizeof(struct rndis_packet_msg_type))
1280                 debug("%s: unexpected DataOffset: %d\n", __func__, offs);
1281         if (offs >= length)
1282                 return -EOVERFLOW;
1283
1284         len = get_unaligned_le32(tmp++);
1285         if (len + sizeof(struct rndis_packet_msg_type) != length)
1286                 debug("%s: unexpected DataLength: %d, packet length=%d\n",
1287                                 __func__, len, length);
1288
1289         memmove(buf, buf + offs, len);
1290
1291         return offs;
1292 }
1293
1294 int rndis_init(void)
1295 {
1296         u8 i;
1297
1298         for (i = 0; i < RNDIS_MAX_CONFIGS; i++) {
1299                 rndis_per_dev_params[i].confignr = i;
1300                 rndis_per_dev_params[i].used = 0;
1301                 rndis_per_dev_params[i].state = RNDIS_UNINITIALIZED;
1302                 rndis_per_dev_params[i].media_state
1303                                 = NDIS_MEDIA_STATE_DISCONNECTED;
1304                 INIT_LIST_HEAD(&(rndis_per_dev_params[i].resp_queue));
1305         }
1306
1307         return 0;
1308 }
1309
1310 void rndis_exit(void)
1311 {
1312         /* Nothing to do */
1313 }