drivers/usb/gadget/rndis.c

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