src/drivers/usb/acpi/intel_bluetooth.c

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2
   3 #include <acpi/acpigen.h>
   4 #include "chip.h"
   5
   6 /*
   7  * Intel Bluetooth DSM
   8  *
   9  * Check/Set Reset Delay (aa10f4e0-81ac-4233-abf6-3b2ac50e28d9)
  10  * Arg2 == 0:   Return a package with the following bit set
  11  * BIT(0)       Indicates whether the device supports other functions
  12  * BIT(1)       Check Bluetooth reset timing
  13  *
  14  * Arg2 == 1:   Set the reset delay based on Arg3
  15  *
  16  * Arg2 == 3:   Set the reset method based on Arg3 (Not supported by this driver)
  17  * WDISABLE2 (BT_RF_KILL_N)
  18  * VSEC (PCI Config Space)
  19  */
  20
  21 static void check_reset_delay(void *arg)
  22 {
  23         acpigen_write_if_lequal_op_int(ARG1_OP, 0);
  24         {
  25                 acpigen_write_return_singleton_buffer(0x03);
  26         }
  27         acpigen_write_else();
  28         {
  29                 acpigen_write_return_singleton_buffer(0x00);
  30         }
  31         acpigen_pop_len();
  32 }
  33
  34 static void set_reset_delay(void *arg)
  35 {
  36         acpigen_write_store_op_to_namestr(ARG3_OP, "RDLY");
  37 }
  38
  39 static void not_supported(void *arg)
  40 {
  41         acpigen_write_return_singleton_buffer(0x00);
  42 }
  43
  44 void (*reset_supported[])(void *) = { check_reset_delay, set_reset_delay };
  45 void (*reset_unsupported[])(void *) = { not_supported };
  46
  47 void acpi_device_intel_bt(unsigned int reset_gpio, unsigned int enable_gpio, bool audio_offload)
  48 {
  49 /*
  50  *      Name (RDLY, 0x69)
  51  */
  52         acpigen_write_name_integer("RDLY", 0x69);
  53
  54 /*
  55  *      Method (_DSM, 4, Serialized)
  56  *      {
  57  *              If ((Arg0 == ToUUID ("aa10f4e0-81ac-4233-abf6-3b2ac50e28d9")))
  58  *              {
  59  *                      If ((Arg2 == Zero))
  60  *                      {
  61  *                              If ((Arg1 == Zero))
  62  *                              {
  63  *                                      Return (Buffer (One)
  64  *                                      {
  65  *                                              0x03
  66  *                                      })
  67  *                              }
  68  *                              Else
  69  *                              {
  70  *                                      Return (Buffer (One)
  71  *                                      {
  72  *                                              0x00
  73  *                                      })
  74  *                              }
  75  *                      }
  76  *                      If ((Arg2 == One))
  77  *                      {
  78  *                              RDLY = Arg3
  79  *                      }
  80  *                      Return (Zero)
  81  *              }
  82  *              Else
  83  *              {
  84  *                      Return (Buffer (One)
  85  *                      {
  86  *                              0x00
  87  *                      })
  88  *              }
  89  *      }
  90  */
  91
  92         struct dsm_uuid uuid_callbacks[] = {
  93                 DSM_UUID("aa10f4e0-81ac-4233-abf6-3b2ac50e28d9",
  94                         reset_gpio ? reset_supported : reset_unsupported,
  95                         reset_gpio ? ARRAY_SIZE(reset_supported) : ARRAY_SIZE(reset_unsupported),
  96                         NULL),
  97         };
  98
  99         acpigen_write_dsm_uuid_arr(uuid_callbacks, ARRAY_SIZE(uuid_callbacks));
 100 /*
 101  *      PowerResource (BTRT, 0, 0)
 102  *      {
 103  *              Method (_STA, 0, NotSerialized)
 104  *              {
 105  *                      Return (\_SB.PCI0.GBTE())
 106  *              }
 107  *              Method (_ON, 0, NotSerialized)
 108  *              {
 109  *                      \_SB.PCI0.SBTE(1)
 110  *              }
 111  *              Method (_OFF, 0, NotSerialized)
 112  *              {
 113  *                      \_SB.PCI0.SBTE(0)
 114  *              }
 115  *              Method (_RST, 0, NotSerialized)
 116  *              {
 117  *                      Local0 = Acquire (\_SB.PCI0.CNMT, 1000)
 118  *                      If ((Local0 == Zero))
 119  *                      {
 120  *                              \_SB.PCI0.BTRK (Zero)
 121  *                              Sleep (RDLY)
 122  *                              \_SB.PCI0.BTRK (One)
 123  *                              Sleep (RDLY)
 124  *                              Release (\_SB.PCI0.CNMT)
 125                         }
 126  *              }
 127  *      }
 128  */
 129         acpigen_write_power_res("BTRT", 0, 0, NULL, 0);
 130         {
 131                 acpigen_write_method("_STA", 0);
 132                 {
 133                         if (enable_gpio) {
 134                                 acpigen_write_store();
 135                                 acpigen_emit_namestring("\\_SB.PCI0.GBTE");
 136                                 acpigen_emit_byte(LOCAL0_OP);
 137
 138                                 acpigen_write_return_op(LOCAL0_OP);
 139                         } else {
 140                                 acpigen_write_return_integer(1);
 141                         }
 142                 }
 143                 acpigen_pop_len();
 144
 145                 acpigen_write_method("_ON", 0);
 146                 {
 147                         if (enable_gpio) {
 148                                 acpigen_emit_namestring("\\_SB.PCI0.SBTE");
 149                                 acpigen_emit_byte(1);
 150                         }
 151                 }
 152                 acpigen_pop_len();
 153
 154                 acpigen_write_method("_OFF", 0);
 155                 {
 156                         if (enable_gpio) {
 157                                 acpigen_emit_namestring("\\_SB.PCI0.SBTE");
 158                                 acpigen_emit_byte(0);
 159                         }
 160                 }
 161                 acpigen_pop_len();
 162
 163                 acpigen_write_method("_RST", 0);
 164                 {
 165                         if (reset_gpio) {
 166                                 acpigen_write_store();
 167                                 acpigen_write_acquire("\\_SB.PCI0.CNMT", 1000);
 168                                 acpigen_emit_byte(LOCAL0_OP);
 169
 170                                 acpigen_write_if_lequal_op_int(LOCAL0_OP, 0);
 171                                 {
 172                                         acpigen_emit_namestring("\\_SB.PCI0.BTRK");
 173                                         acpigen_emit_byte(0);
 174
 175                                         acpigen_emit_ext_op(SLEEP_OP);
 176                                         acpigen_emit_namestring("RDLY");
 177
 178                                         acpigen_emit_namestring("\\_SB.PCI0.BTRK");
 179                                         acpigen_emit_byte(1);
 180
 181                                         acpigen_emit_ext_op(SLEEP_OP);
 182                                         acpigen_emit_namestring("RDLY");
 183
 184                                         acpigen_write_release("\\_SB.PCI0.CNMT");
 185                                 }
 186                                 acpigen_pop_len();
 187                         }
 188                 }
 189                 acpigen_pop_len();
 190         }
 191         acpigen_write_power_res_end();
 192
 193 /*
 194  *      Name (_PRR, Package (0x01)
 195  *      {
 196  *              BTRT
 197  *      })
 198  */
 199         acpigen_write_name("_PRR");
 200         {
 201                 acpigen_write_package(1);
 202                 acpigen_emit_namestring("BTRT");
 203         }
 204         acpigen_pop_len();
 205
 206 /*
 207  *      Name (_PR0, Package (0x01)
 208  *      {
 209  *              BTRT
 210  *      })
 211  */
 212         acpigen_write_name("_PR0");
 213         {
 214                 acpigen_write_package(1);
 215                 acpigen_emit_namestring("BTRT");
 216         }
 217         acpigen_pop_len();
 218
 219 /*
 220  *      Name (_PR3, Package (0x01)
 221  *      {
 222  *              BTRT
 223  *      })
 224  */
 225         acpigen_write_name("_PR3");
 226         {
 227                 acpigen_write_package(1);
 228                 acpigen_emit_namestring("BTRT");
 229         }
 230         acpigen_pop_len();
 231
 232 /*
 233  *      Method (AOLD, 0, Serialized)
 234  *      {
 235  *              Name (AODS, Package (0x03)
 236  *              {
 237  *                      Zero,
 238  *                      0x12,
 239  *                      Zero    // Audio Offload - 0: Disabled
 240  *                                                 1: Enabled
 241  *              })
 242  *              Return (AODS)
 243  *      }
 244  */
 245         acpigen_write_method_serialized("AOLD", 0);
 246         {
 247                 acpigen_write_name("AODS");
 248                 acpigen_write_package(3);
 249                 {
 250                         acpigen_write_integer(0);
 251                         acpigen_write_integer(0x12);
 252                         acpigen_write_integer(audio_offload);
 253                 }
 254                 acpigen_pop_len();
 255
 256                 acpigen_write_return_namestr("AODS");
 257         }
 258         acpigen_pop_len();
 259 }
 260
 261 void acpi_device_intel_bt_common(unsigned int enable_gpio, unsigned int reset_gpio)
 262 {
 263         acpigen_write_scope("\\_SB.PCI0");
 264 /*
 265  *      Mutex (CNMT, 0)
 266  */
 267         acpigen_write_mutex("CNMT", 0);
 268
 269 /*
 270  *      Method (SBTE, 1, Serialized)
 271  *      {
 272  *              If (Arg0 == 1)
 273  *              {
 274  *                      STXS(enable_gpio)
 275  *              } Else {
 276  *                      CTXS(enable_gpio)
 277  *              }
 278  *      }
 279  */
 280         acpigen_write_method_serialized("SBTE", 1);
 281         {
 282                 if (enable_gpio) {
 283                         acpigen_write_if_lequal_op_int(ARG0_OP, 1);
 284                         {
 285                                 acpigen_soc_set_tx_gpio(enable_gpio);
 286                         }
 287                         acpigen_write_else();
 288                         {
 289                                 acpigen_soc_clear_tx_gpio(enable_gpio);
 290                         }
 291                         acpigen_pop_len();
 292                 }
 293         }
 294         acpigen_pop_len();
 295
 296 /*
 297  *      Method (GBTE, 0, NotSerialized)
 298  *      {
 299  *              Return (GTXS (enable_gpio))
 300  *      }
 301  */
 302         acpigen_write_method("GBTE", 0);
 303         {
 304                 if (enable_gpio) {
 305                         acpigen_soc_get_tx_gpio(enable_gpio);
 306                         acpigen_write_return_op(LOCAL0_OP);
 307                 } else {
 308                         acpigen_write_return_integer(0);
 309                 }
 310         }
 311         acpigen_pop_len();
 312
 313 /*
 314  *      Method (BTRK, 1, Serialized)
 315  *      {
 316  *              If (Arg0 == 1)
 317  *              {
 318  *                      STXS (reset_gpio)
 319  *              } Else {
 320  *                      CTXS (reset_gpio)
 321  *              }
 322  *      }
 323  */
 324         acpigen_write_method_serialized("BTRK", 1);
 325         {
 326                 acpigen_write_if_lequal_op_int(ARG0_OP, 1);
 327                 {
 328                         acpigen_soc_set_tx_gpio(reset_gpio);
 329                 }
 330                 acpigen_write_else();
 331                 {
 332                         acpigen_soc_clear_tx_gpio(reset_gpio);
 333                 }
 334                 acpigen_pop_len();
 335         }
 336         acpigen_pop_len();
 337
 338 /*
 339  *      Method (GBTR, 0, NotSerialized)
 340  *      {
 341  *               Return (GTXS (reset_gpio))
 342  *      }
 343  */
 344         acpigen_write_method("GBTR", 0);
 345         {
 346                 if (reset_gpio) {
 347                         acpigen_soc_get_tx_gpio(reset_gpio);
 348                         acpigen_write_return_op(LOCAL0_OP);
 349                 } else {
 350                         acpigen_write_return_op(0);
 351                 }
 352         }
 353         acpigen_pop_len();
 354
 355         acpigen_pop_len();
 356 }