wifi/1.0/IWifiChip.hal

   1 /*
   2  * Copyright 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package android.hardware.wifi@1.0;
  18
  19 import IWifiChipEventCallback;
  20 import IWifiIface;
  21 import IWifiApIface;
  22 import IWifiNanIface;
  23 import IWifiP2pIface;
  24 import IWifiStaIface;
  25 import IWifiRttController;
  26
  27 /**
  28  * Interface that represents a chip that must be configured as a single unit.
  29  * The HAL/driver/firmware will be responsible for determining which phy is used
  30  * to perform operations like NAN, RTT, etc.
  31  */
  32 interface IWifiChip {
  33   /**
  34    * Set of interface types with the maximum number of interfaces that can have
  35    * one of the specified type for a given ChipIfaceCombination. See
  36    * ChipIfaceCombination for examples.
  37    */
  38   struct ChipIfaceCombinationLimit {
  39     vec<IfaceType> types; // Each IfaceType must occur at most once.
  40     uint32_t maxIfaces;
  41   };
  42
  43   /**
  44    * Set of interfaces that can operate concurrently when in a given mode. See
  45    * ChipMode below.
  46    *
  47    * For example:
  48    *   [{STA} <= 2]
  49    *       At most two STA interfaces are supported
  50    *       [], [STA], [STA+STA]
  51    *
  52    *   [{STA} <= 1, {NAN} <= 1, {AP} <= 1]
  53    *       Any combination of STA, NAN, AP
  54    *       [], [STA], [NAN], [AP], [STA+NAN], [STA+AP], [NAN+AP], [STA+NAN+AP]
  55    *
  56    *   [{STA} <= 1, {NAN,P2P} <= 1]
  57    *       Optionally a STA and either NAN or P2P
  58    *       [], [STA], [STA+NAN], [STA+P2P], [NAN], [P2P]
  59    *       Not included [NAN+P2P], [STA+NAN+P2P]
  60    *
  61    *   [{STA} <= 1, {STA,NAN} <= 1]
  62    *       Optionally a STA and either a second STA or a NAN
  63    *       [], [STA], [STA+NAN], [STA+STA], [NAN]
  64    *       Not included [STA+STA+NAN]
  65    */
  66   struct ChipIfaceCombination {
  67     vec<ChipIfaceCombinationLimit> limits;
  68   };
  69
  70   /**
  71    * A mode that the chip can be put in. A mode defines a set of constraints on
  72    * the interfaces that can exist while in that mode. Modes define a unit of
  73    * configuration where all interfaces must be torn down to switch to a
  74    * different mode. Some HALs may only have a single mode, but an example where
  75    * multiple modes would be required is if a chip has different firmwares with
  76    * different capabilities.
  77    *
  78    * When in a mode, it must be possible to perform any combination of creating
  79    * and removing interfaces as long as at least one of the
  80    * ChipIfaceCombinations is satisfied. This means that if a chip has two
  81    * available combinations, [{STA} <= 1] and [{AP} <= 1] then it is expected
  82    * that exactly one STA interface or one AP interface can be created, but it
  83    * is not expected that both a STA and AP interface could be created. If it
  84    * was then there would be a single available combination
  85    * [{STA} <=1, {AP} <= 1].
  86    *
  87    * When switching between two available combinations it is expected that
  88    * interfaces only supported by the initial combination must be removed until
  89    * the target combination is also satisfied. At that point new interfaces
  90    * satisfying only the target combination can be added (meaning the initial
  91    * combination limits will no longer satisfied). The addition of these new
  92    * interfaces must not impact the existence of interfaces that satisfy both
  93    * combinations.
  94    *
  95    * For example, a chip with available combinations:
  96    *     [{STA} <= 2, {NAN} <=1] and [{STA} <=1, {NAN} <= 1, {AP} <= 1}]
  97    * If the chip currently has 3 interfaces STA, STA and NAN and wants to add an
  98    * AP interface in place of one of the STAs then first one of the STA
  99    * interfaces must be removed and then the AP interface can be created after
 100    * the STA had been torn down. During this process the remaining STA and NAN
 101    * interfaces must not be removed/recreated.
 102    *
 103    * If a chip does not support this kind of reconfiguration in this mode then
 104    * the combinations must be separated into two separate modes. Before
 105    * switching modes all interfaces must be torn down, the mode switch must be
 106    * enacted and when it completes the new interfaces must be brought up.
 107    */
 108   struct ChipMode {
 109     /**
 110      * Id that can be used to put the chip in this mode.
 111      */
 112     ChipModeId id;
 113
 114     /**
 115      * A list of the possible interface combinations that the chip can have
 116      * while in this mode.
 117      */
 118     vec<ChipIfaceCombination> availableCombinations;
 119   };
 120
 121   /**
 122    * Information about the version of the driver and firmware running this chip.
 123    *
 124    * The information in these ASCII strings are vendor specific and does not
 125    * need to follow any particular format. It may be dumped as part of the bug
 126    * report.
 127    */
 128   struct ChipDebugInfo {
 129     string driverDescription;
 130     string firmwareDescription;
 131   };
 132
 133   /**
 134    * Capabilities exposed by this chip.
 135    */
 136   enum ChipCapabilityMask : uint32_t {
 137     /**
 138      * Memory dump of Firmware.
 139      */
 140     DEBUG_MEMORY_FIRMWARE_DUMP = 1 << 0,
 141     /**
 142      * Memory dump of Driver.
 143      */
 144     DEBUG_MEMORY_DRIVER_DUMP = 1 << 1,
 145     /**
 146      * Connectivity events reported via debug ring buffer.
 147      */
 148     DEBUG_RING_BUFFER_CONNECT_EVENT = 1 << 2,
 149     /**
 150      * Power events reported via debug ring buffer.
 151      */
 152     DEBUG_RING_BUFFER_POWER_EVENT = 1 << 3,
 153     /**
 154      * Wakelock events reported via debug ring buffer.
 155      */
 156     DEBUG_RING_BUFFER_WAKELOCK_EVENT = 1 << 4,
 157     /**
 158      * Vendor data reported via debug ring buffer.
 159      * This mostly contains firmware event logs.
 160      */
 161     DEBUG_RING_BUFFER_VENDOR_DATA = 1 << 5,
 162     /**
 163      * Host wake reasons stats collection.
 164      */
 165     DEBUG_HOST_WAKE_REASON_STATS = 1 << 6,
 166     /**
 167      * Error alerts.
 168      */
 169     DEBUG_ERROR_ALERTS = 1 << 7
 170   };
 171
 172   /**
 173    * Get the id assigned to this chip.
 174    *
 175    * @return status WifiStatus of the operation.
 176    *         Possible status codes:
 177    *         |WifiStatusCode.SUCCESS|,
 178    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
 179    * @return id Assigned chip Id.
 180    */
 181   getId() generates (WifiStatus status, ChipId id);
 182
 183   /**
 184    * Requests notifications of significant events on this chip. Multiple calls
 185    * to this must register multiple callbacks each of which must receive all
 186    * events.
 187    *
 188    * @param callback An instance of the |IWifiChipEventCallback| HIDL interface
 189    *        object.
 190    * @return status WifiStatus of the operation.
 191    *         Possible status codes:
 192    *         |WifiStatusCode.SUCCESS|,
 193    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
 194    */
 195   registerEventCallback(IWifiChipEventCallback callback) generates (WifiStatus status);
 196
 197   /**
 198    * Get the capabilities supported by this chip.
 199    *
 200    * @return status WifiStatus of the operation.
 201    *         Possible status codes:
 202    *         |WifiStatusCode.SUCCESS|,
 203    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 204    *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
 205    *         |WifiStatusCode.ERROR_UNKNOWN|
 206    * @return capabilities Bitset of |ChipCapabilityMask| values.
 207    */
 208   getCapabilities()
 209       generates (WifiStatus status, bitfield<ChipCapabilityMask> capabilities);
 210
 211   /**
 212    * Get the set of operation modes that the chip supports.
 213    *
 214    * @return status WifiStatus of the operation.
 215    *         Possible status codes:
 216    *         |WifiStatusCode.SUCCESS|,
 217    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
 218    * @return modes List of modes supported by the device.
 219    */
 220   getAvailableModes() generates (WifiStatus status, vec<ChipMode> modes);
 221
 222   /**
 223    * Reconfigure the Chip.
 224    * Any existing |IWifiIface| objects must be marked invalid after this call.
 225    * If this fails then the chips is now in an undefined state and
 226    * configureChip must be called again.
 227    * Must trigger |IWifiChipEventCallback.onChipReconfigured| on success.
 228    * Must trigger |IWifiEventCallback.onFailure| on failure.
 229    *
 230    * @param modeId The mode that the chip must switch to, corresponding to the
 231    *        id property of the target ChipMode.
 232    * @return status WifiStatus of the operation.
 233    *         Possible status codes:
 234    *         |WifiStatusCode.SUCCESS|,
 235    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 236    *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
 237    *         |WifiStatusCode.ERROR_UNKNOWN|
 238    */
 239   configureChip(ChipModeId modeId) generates (WifiStatus status);
 240
 241   /**
 242    * Get the current mode that the chip is in.
 243    *
 244    * @return modeId The mode that the chip is currently configured to,
 245    *         corresponding to the id property of the target ChipMode.
 246    * @return status WifiStatus of the operation.
 247    *         Possible status codes:
 248    *         |WifiStatusCode.SUCCESS|,
 249    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
 250    */
 251   getMode() generates (WifiStatus status, ChipModeId modeId);
 252
 253   /**
 254    * Request information about the chip.
 255    *
 256    * @return status WifiStatus of the operation.
 257    *         Possible status codes:
 258    *         |WifiStatusCode.SUCCESS|,
 259    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 260    *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
 261    *         |WifiStatusCode.ERROR_UNKNOWN|
 262    * @return chipDebugInfo Instance of |ChipDebugInfo|.
 263    */
 264   requestChipDebugInfo() generates (WifiStatus status, ChipDebugInfo chipDebugInfo);
 265
 266   /**
 267    * Request vendor debug info from the driver.
 268    *
 269    * @return status WifiStatus of the operation.
 270    *         Possible status codes:
 271    *         |WifiStatusCode.SUCCESS|,
 272    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 273    *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
 274    *         |WifiStatusCode.ERROR_UNKNOWN|
 275    * @param blob Vector of bytes retrieved from the driver.
 276    */
 277   requestDriverDebugDump() generates (WifiStatus status, vec<uint8_t> blob);
 278
 279   /**
 280    * Request vendor debug info from the firmware.
 281    *
 282    * @return status WifiStatus of the operation.
 283    *         Possible status codes:
 284    *         |WifiStatusCode.SUCCESS|,
 285    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 286    *         |WifiStatusCode.ERROR_NOT_AVAILABLE|,
 287    *         |WifiStatusCode.ERROR_UNKNOWN|
 288    * @param blob Vector of bytes retrieved from the driver.
 289    */
 290   requestFirmwareDebugDump() generates (WifiStatus status, vec<uint8_t> blob);
 291
 292   /**
 293    * Create an AP iface on the chip.
 294    *
 295    * Depending on the mode the chip is configured in, the interface creation
 296    * may fail (code: |ERROR_NOT_AVAILABLE|) if we've already reached the maximum
 297    * allowed (specified in |ChipIfaceCombination|) number of ifaces of the AP
 298    * type.
 299    *
 300    * @return status WifiStatus of the operation.
 301    *         Possible status codes:
 302    *         |WifiStatusCode.SUCCESS|,
 303    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 304    *         |WifiStatusCode.ERROR_NOT_SUPPORTED|
 305    * @return iface HIDL interface object representing the iface if
 306    *         successful, null otherwise.
 307    */
 308   createApIface() generates (WifiStatus status, IWifiApIface iface);
 309
 310   /**
 311    * List all the AP iface names configured on the chip.
 312    * The corresponding |IWifiApIface| object for any iface are
 313    * retrieved using |getApIface| method.
 314    *
 315    * @return status WifiStatus of the operation.
 316    *         Possible status codes:
 317    *         |WifiStatusCode.SUCCESS|,
 318    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
 319    * @return ifnames List of all AP iface names on the chip.
 320    */
 321   getApIfaceNames() generates (WifiStatus status, vec<string> ifnames);
 322
 323   /**
 324    * Gets a HIDL interface object for the AP Iface corresponding
 325    * to the provided ifname.
 326    *
 327    * @param ifname Name of the iface.
 328    * @return status WifiStatus of the operation.
 329    *         Possible status codes:
 330    *         |WifiStatusCode.SUCCESS|,
 331    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 332    *         |WifiStatusCode.ERROR_INVALID_ARGS|
 333    * @return iface HIDL interface object representing the iface if
 334    *         it exists, null otherwise.
 335    */
 336   getApIface(string ifname) generates (WifiStatus status, IWifiApIface iface);
 337
 338   /**
 339    * Removes the AP Iface with the provided ifname.
 340    * Any further calls on the corresponding |IWifiApIface| HIDL interface
 341    * object must fail.
 342    *
 343    * @param ifname Name of the iface.
 344    * @return status WifiStatus of the operation.
 345    *         Possible status codes:
 346    *         |WifiStatusCode.SUCCESS|,
 347    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 348    *         |WifiStatusCode.ERROR_INVALID_ARGS|
 349    */
 350   removeApIface(string ifname) generates (WifiStatus status);
 351
 352   /**
 353    * Create a NAN iface on the chip.
 354    *
 355    * Depending on the mode the chip is configured in, the interface creation
 356    * may fail (code: |ERROR_NOT_AVAILABLE|) if we've already reached the maximum
 357    * allowed (specified in |ChipIfaceCombination|) number of ifaces of the NAN
 358    * type.
 359    *
 360    * @return status WifiStatus of the operation.
 361    *         Possible status codes:
 362    *         |WifiStatusCode.SUCCESS|,
 363    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 364    *         |WifiStatusCode.ERROR_NOT_SUPPORTED|
 365    * @return iface HIDL interface object representing the iface if
 366    *         successful, null otherwise.
 367    */
 368   createNanIface() generates (WifiStatus status, IWifiNanIface iface);
 369
 370   /**
 371    * List all the NAN iface names configured on the chip.
 372    * The corresponding |IWifiNanIface| object for any iface are
 373    * retrieved using |getNanIface| method.
 374    *
 375    * @return status WifiStatus of the operation.
 376    *         Possible status codes:
 377    *         |WifiStatusCode.SUCCESS|,
 378    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
 379    * @return ifnames List of all NAN iface names on the chip.
 380    */
 381   getNanIfaceNames() generates (WifiStatus status, vec<string> ifnames);
 382
 383   /**
 384    * Gets a HIDL interface object for the NAN Iface corresponding
 385    * to the provided ifname.
 386    *
 387    * @param ifname Name of the iface.
 388    * @return status WifiStatus of the operation.
 389    *         Possible status codes:
 390    *         |WifiStatusCode.SUCCESS|,
 391    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 392    *         |WifiStatusCode.ERROR_INVALID_ARGS|
 393    * @return iface HIDL interface object representing the iface if
 394    *         it exists, null otherwise.
 395    */
 396   getNanIface(string ifname) generates (WifiStatus status, IWifiNanIface iface);
 397
 398   /**
 399    * Removes the NAN Iface with the provided ifname.
 400    * Any further calls on the corresponding |IWifiNanIface| HIDL interface
 401    * object must fail.
 402    *
 403    * @param ifname Name of the iface.
 404    * @return status WifiStatus of the operation.
 405    *         Possible status codes:
 406    *         |WifiStatusCode.SUCCESS|,
 407    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 408    *         |WifiStatusCode.ERROR_INVALID_ARGS|
 409    */
 410   removeNanIface(string ifname) generates (WifiStatus status);
 411
 412   /**
 413    * Create a P2P iface on the chip.
 414    *
 415    * Depending on the mode the chip is configured in, the interface creation
 416    * may fail (code: |ERROR_NOT_AVAILABLE|) if we've already reached the maximum
 417    * allowed (specified in |ChipIfaceCombination|) number of ifaces of the P2P
 418    * type.
 419    *
 420    * @return status WifiStatus of the operation.
 421    *         Possible status codes:
 422    *         |WifiStatusCode.SUCCESS|,
 423    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 424    *         |WifiStatusCode.ERROR_NOT_SUPPORTED|
 425    * @return iface HIDL interface object representing the iface if
 426    *         successful, null otherwise.
 427    */
 428   createP2pIface() generates (WifiStatus status, IWifiP2pIface iface);
 429
 430   /**
 431    * List all the P2P iface names configured on the chip.
 432    * The corresponding |IWifiP2pIface| object for any iface are
 433    * retrieved using |getP2pIface| method.
 434    *
 435    * @return status WifiStatus of the operation.
 436    *         Possible status codes:
 437    *         |WifiStatusCode.SUCCESS|,
 438    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
 439    * @return ifnames List of all P2P iface names on the chip.
 440    */
 441   getP2pIfaceNames() generates (WifiStatus status, vec<string> ifnames);
 442
 443   /**
 444    * Gets a HIDL interface object for the P2P Iface corresponding
 445    * to the provided ifname.
 446    *
 447    * @param ifname Name of the iface.
 448    * @return status WifiStatus of the operation.
 449    *         Possible status codes:
 450    *         |WifiStatusCode.SUCCESS|,
 451    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 452    *         |WifiStatusCode.ERROR_INVALID_ARGS|
 453    * @return iface HIDL interface object representing the iface if
 454    *         it exists, null otherwise.
 455    */
 456   getP2pIface(string ifname) generates (WifiStatus status, IWifiP2pIface iface);
 457
 458   /**
 459    * Removes the P2P Iface with the provided ifname.
 460    * Any further calls on the corresponding |IWifiP2pIface| HIDL interface
 461    * object must fail.
 462    *
 463    * @param ifname Name of the iface.
 464    * @return status WifiStatus of the operation.
 465    *         Possible status codes:
 466    *         |WifiStatusCode.SUCCESS|,
 467    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 468    *         |WifiStatusCode.ERROR_INVALID_ARGS|
 469    */
 470   removeP2pIface(string ifname) generates (WifiStatus status);
 471
 472   /**
 473    * Create an STA iface on the chip.
 474    *
 475    * Depending on the mode the chip is configured in, the interface creation
 476    * may fail (code: |ERROR_NOT_AVAILABLE|) if we've already reached the maximum
 477    * allowed (specified in |ChipIfaceCombination|) number of ifaces of the STA
 478    * type.
 479    *
 480    * @return status WifiStatus of the operation.
 481    *         Possible status codes:
 482    *         |WifiStatusCode.SUCCESS|,
 483    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 484    *         |WifiStatusCode.ERROR_NOT_SUPPORTED|
 485    * @return iface HIDL interface object representing the iface if
 486    *         successful, null otherwise.
 487    */
 488   createStaIface() generates (WifiStatus status, IWifiStaIface iface);
 489
 490   /**
 491    * List all the STA iface names configured on the chip.
 492    * The corresponding |IWifiStaIface| object for any iface are
 493    * retrieved using |getStaIface| method.
 494    *
 495    * @return status WifiStatus of the operation.
 496    *         Possible status codes:
 497    *         |WifiStatusCode.SUCCESS|,
 498    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
 499    * @return ifnames List of all STA iface names on the chip.
 500    */
 501   getStaIfaceNames() generates (WifiStatus status, vec<string> ifnames);
 502
 503   /**
 504    * Gets a HIDL interface object for the STA Iface corresponding
 505    * to the provided ifname.
 506    *
 507    * @param ifname Name of the iface.
 508    * @return status WifiStatus of the operation.
 509    *         Possible status codes:
 510    *         |WifiStatusCode.SUCCESS|,
 511    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 512    *         |WifiStatusCode.ERROR_INVALID_ARGS|
 513    * @return iface HIDL interface object representing the iface if
 514    *         it exists, null otherwise.
 515    */
 516   getStaIface(string ifname) generates (WifiStatus status, IWifiStaIface iface);
 517
 518   /**
 519    * Removes the STA Iface with the provided ifname.
 520    * Any further calls on the corresponding |IWifiStaIface| HIDL interface
 521    * object must fail.
 522    *
 523    * @param ifname Name of the iface.
 524    * @return status WifiStatus of the operation.
 525    *         Possible status codes:
 526    *         |WifiStatusCode.SUCCESS|,
 527    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 528    *         |WifiStatusCode.ERROR_INVALID_ARGS|
 529    */
 530   removeStaIface(string ifname) generates (WifiStatus status);
 531
 532   /**
 533    * Create a RTTController instance.
 534    *
 535    * RTT controller can be either:
 536    * a) Bound to a specific iface by passing in the corresponding |IWifiIface|
 537    * object in |iface| param, OR
 538    * b) Let the implementation decide the iface to use for RTT operations by
 539    * passing null in |iface| param.
 540    *
 541    * @param boundIface HIDL interface object representing the iface if
 542    *        the responder must be bound to a specific iface, null otherwise.
 543    * @return status WifiStatus of the operation.
 544    *         Possible status codes:
 545    *         |WifiStatusCode.SUCCESS|,
 546    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|
 547    */
 548   createRttController(IWifiIface boundIface)
 549       generates (WifiStatus status, IWifiRttController rtt);
 550
 551   /**
 552    * WiFi debug ring buffer life cycle is as follow:
 553    * - At initialization time, framework must call |getDebugRingBuffersStatus|.
 554    *   to obtain the names and list of supported ring buffers.
 555    *   The driver may expose several different rings each holding a different
 556    *   type of data (connection events, power events, etc).
 557    * - When WiFi operations start framework must call
 558    *   |startLoggingToDebugRingBuffer| to trigger log collection for a specific
 559    *   ring. The vebose level for each ring buffer can be specified in this API.
 560    * - During wifi operations, driver must periodically report per ring data to
 561    *   framework by invoking the
 562    *   |IWifiChipEventCallback.onDebugRingBufferDataAvailable| callback.
 563    * - When capturing a bug report, framework must indicate to driver that all
 564    *   the data has to be uploaded urgently by calling
 565    *   |forceDumpToDebugRingBuffer|.
 566    *
 567    * The data uploaded by driver must be stored by framework in separate files,
 568    * with one stream of file per ring. Framework must store the files in pcapng
 569    * format, allowing for easy merging and parsing with network analyzer tools.
 570    * TODO: Since we're not longer dumping out the raw data, storing in separate
 571    * pcapng files for parsing later must not work anymore.
 572    */
 573   /**
 574    * API to get the status of all ring buffers supported by driver.
 575    *
 576    * @return status WifiStatus of the operation.
 577    *         Possible status codes:
 578    *         |WifiStatusCode.SUCCESS|,
 579    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 580    *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
 581    *         |WifiStatusCode.NOT_AVAILABLE|,
 582    *         |WifiStatusCode.UNKNOWN|
 583    * @return ringBuffers Vector of |WifiDebugRingBufferStatus| corresponding to the
 584    *         status of each ring bufffer on the device.
 585    */
 586   getDebugRingBuffersStatus() generates (WifiStatus status,
 587                                          vec<WifiDebugRingBufferStatus> ringBuffers);
 588
 589   /**
 590    * API to trigger the debug data collection.
 591    *
 592    * @param ringName represent the name of the ring for which data collection
 593    *        shall start. This can be retrieved via the corresponding
 594    *        |WifiDebugRingBufferStatus|.
 595    * @parm maxIntervalInSec Maximum interval in seconds for driver to invoke
 596    *       |onDebugRingBufferData|, ignore if zero.
 597    * @parm minDataSizeInBytes: Minimum data size in buffer for driver to invoke
 598    *       |onDebugRingBufferData|, ignore if zero.
 599    * @return status WifiStatus of the operation.
 600    *         Possible status codes:
 601    *         |WifiStatusCode.SUCCESS|,
 602    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 603    *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
 604    *         |WifiStatusCode.NOT_AVAILABLE|,
 605    *         |WifiStatusCode.UNKNOWN|
 606    */
 607   startLoggingToDebugRingBuffer(string ringName,
 608                                 WifiDebugRingBufferVerboseLevel verboseLevel,
 609                                 uint32_t maxIntervalInSec,
 610                                 uint32_t minDataSizeInBytes)
 611       generates (WifiStatus status);
 612
 613   /**
 614    * API to force dump data into the corresponding ring buffer.
 615    * This is to be invoked during bugreport collection.
 616    *
 617    * @param ringName represent the name of the ring for which data collection
 618    *        shall be forced. This can be retrieved via the corresponding
 619    *        |WifiDebugRingBufferStatus|.
 620    * @return status WifiStatus of the operation.
 621    *         Possible status codes:
 622    *         |WifiStatusCode.SUCCESS|,
 623    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 624    *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
 625    *         |WifiStatusCode.ERROR_NOT_STARTED|,
 626    *         |WifiStatusCode.NOT_AVAILABLE|,
 627    *         |WifiStatusCode.UNKNOWN|
 628    */
 629   forceDumpToDebugRingBuffer(string ringName) generates (WifiStatus status);
 630
 631   /**
 632    * API to retrieve the wifi wake up reason stats for debugging.
 633    * The driver is expected to start maintaining these stats once the chip
 634    * is configured using |configureChip|. These stats must be reset whenever
 635    * the chip is reconfigured or the HAL is stopped.
 636    *
 637    * @return status WifiStatus of the operation.
 638    *         Possible status codes:
 639    *         |WifiStatusCode.SUCCESS|,
 640    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 641    *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
 642    *         |WifiStatusCode.NOT_AVAILABLE|,
 643    *         |WifiStatusCode.UNKNOWN|
 644    * @return stats Instance of |WifiDebugHostWakeReasonStats|.
 645    */
 646   getDebugHostWakeReasonStats()
 647       generates (WifiStatus status, WifiDebugHostWakeReasonStats stats);
 648
 649   /**
 650    * API to enable/disable alert notifications from the chip.
 651    * These alerts must be used to notify framework of any fatal error events
 652    * that the chip encounters via |IWifiChipEventCallback.onDebugErrorAlert| method.
 653    * Must fail if |ChipCapabilityMask.DEBUG_ERROR_ALERTS| is not set.
 654    *
 655    * @param enable true to enable, false to disable.
 656    * @return status WifiStatus of the operation.
 657    *         Possible status codes:
 658    *         |WifiStatusCode.SUCCESS|,
 659    *         |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
 660    *         |WifiStatusCode.ERROR_NOT_SUPPORTED|,
 661    *         |WifiStatusCode.NOT_AVAILABLE|,
 662    *         |WifiStatusCode.UNKNOWN|
 663    */
 664   enableDebugErrorAlerts(bool enable) generates (WifiStatus status);
 665 };