drivers/input/serio/i8042-acpipnpio.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 #ifndef _I8042_ACPIPNPIO_H
   3 #define _I8042_ACPIPNPIO_H
   4
   5 #include <linux/acpi.h>
   6
   7 #ifdef CONFIG_X86
   8 #include <asm/x86_init.h>
   9 #endif
  10
  11 /*
  12  * Names.
  13  */
  14
  15 #define I8042_KBD_PHYS_DESC "isa0060/serio0"
  16 #define I8042_AUX_PHYS_DESC "isa0060/serio1"
  17 #define I8042_MUX_PHYS_DESC "isa0060/serio%d"
  18
  19 /*
  20  * IRQs.
  21  */
  22
  23 #if defined(__ia64__)
  24 # define I8042_MAP_IRQ(x)       isa_irq_to_vector((x))
  25 #else
  26 # define I8042_MAP_IRQ(x)       (x)
  27 #endif
  28
  29 #define I8042_KBD_IRQ   i8042_kbd_irq
  30 #define I8042_AUX_IRQ   i8042_aux_irq
  31
  32 static int i8042_kbd_irq;
  33 static int i8042_aux_irq;
  34
  35 /*
  36  * Register numbers.
  37  */
  38
  39 #define I8042_COMMAND_REG       i8042_command_reg
  40 #define I8042_STATUS_REG        i8042_command_reg
  41 #define I8042_DATA_REG          i8042_data_reg
  42
  43 static int i8042_command_reg = 0x64;
  44 static int i8042_data_reg = 0x60;
  45
  46
  47 static inline int i8042_read_data(void)
  48 {
  49         return inb(I8042_DATA_REG);
  50 }
  51
  52 static inline int i8042_read_status(void)
  53 {
  54         return inb(I8042_STATUS_REG);
  55 }
  56
  57 static inline void i8042_write_data(int val)
  58 {
  59         outb(val, I8042_DATA_REG);
  60 }
  61
  62 static inline void i8042_write_command(int val)
  63 {
  64         outb(val, I8042_COMMAND_REG);
  65 }
  66
  67 #ifdef CONFIG_X86
  68
  69 #include <linux/dmi.h>
  70
  71 #define SERIO_QUIRK_NOKBD               BIT(0)
  72 #define SERIO_QUIRK_NOAUX               BIT(1)
  73 #define SERIO_QUIRK_NOMUX               BIT(2)
  74 #define SERIO_QUIRK_FORCEMUX            BIT(3)
  75 #define SERIO_QUIRK_UNLOCK              BIT(4)
  76 #define SERIO_QUIRK_PROBE_DEFER         BIT(5)
  77 #define SERIO_QUIRK_RESET_ALWAYS        BIT(6)
  78 #define SERIO_QUIRK_RESET_NEVER         BIT(7)
  79 #define SERIO_QUIRK_DIECT               BIT(8)
  80 #define SERIO_QUIRK_DUMBKBD             BIT(9)
  81 #define SERIO_QUIRK_NOLOOP              BIT(10)
  82 #define SERIO_QUIRK_NOTIMEOUT           BIT(11)
  83 #define SERIO_QUIRK_KBDRESET            BIT(12)
  84 #define SERIO_QUIRK_DRITEK              BIT(13)
  85 #define SERIO_QUIRK_NOPNP               BIT(14)
  86
  87 /* Quirk table for different mainboards. Options similar or identical to i8042
  88  * module parameters.
  89  * ORDERING IS IMPORTANT! The first match will be apllied and the rest ignored.
  90  * This allows entries to overwrite vendor wide quirks on a per device basis.
  91  * Where this is irrelevant, entries are sorted case sensitive by DMI_SYS_VENDOR
  92  * and/or DMI_BOARD_VENDOR to make it easier to avoid dublicate entries.
  93  */
  94 static const struct dmi_system_id i8042_dmi_quirk_table[] __initconst = {
  95         {
  96                 .matches = {
  97                         DMI_MATCH(DMI_SYS_VENDOR, "ALIENWARE"),
  98                         DMI_MATCH(DMI_PRODUCT_NAME, "Sentia"),
  99                 },
 100                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 101         },
 102         {
 103                 .matches = {
 104                         DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
 105                         DMI_MATCH(DMI_PRODUCT_NAME, "X750LN"),
 106                 },
 107                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 108         },
 109         {
 110                 /* Asus X450LCP */
 111                 .matches = {
 112                         DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
 113                         DMI_MATCH(DMI_PRODUCT_NAME, "X450LCP"),
 114                 },
 115                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_NEVER)
 116         },
 117         {
 118                 /* ASUS ZenBook UX425UA/QA */
 119                 .matches = {
 120                         DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
 121                         DMI_MATCH(DMI_PRODUCT_NAME, "ZenBook UX425"),
 122                 },
 123                 .driver_data = (void *)(SERIO_QUIRK_PROBE_DEFER | SERIO_QUIRK_RESET_NEVER)
 124         },
 125         {
 126                 /* ASUS ZenBook UM325UA/QA */
 127                 .matches = {
 128                         DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
 129                         DMI_MATCH(DMI_PRODUCT_NAME, "ZenBook UX325"),
 130                 },
 131                 .driver_data = (void *)(SERIO_QUIRK_PROBE_DEFER | SERIO_QUIRK_RESET_NEVER)
 132         },
 133         /*
 134          * On some Asus laptops, just running self tests cause problems.
 135          */
 136         {
 137                 .matches = {
 138                         DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
 139                         DMI_MATCH(DMI_CHASSIS_TYPE, "10"), /* Notebook */
 140                 },
 141                 .driver_data = (void *)(SERIO_QUIRK_RESET_NEVER)
 142         },
 143         {
 144                 .matches = {
 145                         DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
 146                         DMI_MATCH(DMI_CHASSIS_TYPE, "31"), /* Convertible Notebook */
 147                 },
 148                 .driver_data = (void *)(SERIO_QUIRK_RESET_NEVER)
 149         },
 150         {
 151                 /* ASUS P65UP5 - AUX LOOP command does not raise AUX IRQ */
 152                 .matches = {
 153                         DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
 154                         DMI_MATCH(DMI_BOARD_NAME, "P/I-P65UP5"),
 155                         DMI_MATCH(DMI_BOARD_VERSION, "REV 2.X"),
 156                 },
 157                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 158         },
 159         {
 160                 /* ASUS G1S */
 161                 .matches = {
 162                         DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc."),
 163                         DMI_MATCH(DMI_BOARD_NAME, "G1S"),
 164                         DMI_MATCH(DMI_BOARD_VERSION, "1.0"),
 165                 },
 166                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 167         },
 168         {
 169                 .matches = {
 170                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 171                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 1360"),
 172                 },
 173                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 174         },
 175         {
 176                 /* Acer Aspire 5710 */
 177                 .matches = {
 178                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 179                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5710"),
 180                 },
 181                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 182         },
 183         {
 184                 /* Acer Aspire 7738 */
 185                 .matches = {
 186                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 187                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 7738"),
 188                 },
 189                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 190         },
 191         {
 192                 /* Acer Aspire 5536 */
 193                 .matches = {
 194                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 195                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5536"),
 196                         DMI_MATCH(DMI_PRODUCT_VERSION, "0100"),
 197                 },
 198                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 199         },
 200         {
 201                 /*
 202                  * Acer Aspire 5738z
 203                  * Touchpad stops working in mux mode when dis- + re-enabled
 204                  * with the touchpad enable/disable toggle hotkey
 205                  */
 206                 .matches = {
 207                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 208                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5738"),
 209                 },
 210                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 211         },
 212         {
 213                 /* Acer Aspire One 150 */
 214                 .matches = {
 215                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 216                         DMI_MATCH(DMI_PRODUCT_NAME, "AOA150"),
 217                 },
 218                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 219         },
 220         {
 221                 /* Acer Aspire One 532h */
 222                 .matches = {
 223                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 224                         DMI_MATCH(DMI_PRODUCT_NAME, "AO532h"),
 225                 },
 226                 .driver_data = (void *)(SERIO_QUIRK_DRITEK)
 227         },
 228         {
 229                 .matches = {
 230                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 231                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire A114-31"),
 232                 },
 233                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 234         },
 235         {
 236                 .matches = {
 237                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 238                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire A314-31"),
 239                 },
 240                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 241         },
 242         {
 243                 .matches = {
 244                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 245                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire A315-31"),
 246                 },
 247                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 248         },
 249         {
 250                 .matches = {
 251                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 252                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire ES1-132"),
 253                 },
 254                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 255         },
 256         {
 257                 .matches = {
 258                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 259                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire ES1-332"),
 260                 },
 261                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 262         },
 263         {
 264                 .matches = {
 265                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 266                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire ES1-432"),
 267                 },
 268                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 269         },
 270         {
 271                 .matches = {
 272                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 273                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate Spin B118-RN"),
 274                 },
 275                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 276         },
 277         /*
 278          * Some Wistron based laptops need us to explicitly enable the 'Dritek
 279          * keyboard extension' to make their extra keys start generating scancodes.
 280          * Originally, this was just confined to older laptops, but a few Acer laptops
 281          * have turned up in 2007 that also need this again.
 282          */
 283         {
 284                 /* Acer Aspire 5100 */
 285                 .matches = {
 286                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 287                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5100"),
 288                 },
 289                 .driver_data = (void *)(SERIO_QUIRK_DRITEK)
 290         },
 291         {
 292                 /* Acer Aspire 5610 */
 293                 .matches = {
 294                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 295                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5610"),
 296                 },
 297                 .driver_data = (void *)(SERIO_QUIRK_DRITEK)
 298         },
 299         {
 300                 /* Acer Aspire 5630 */
 301                 .matches = {
 302                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 303                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5630"),
 304                 },
 305                 .driver_data = (void *)(SERIO_QUIRK_DRITEK)
 306         },
 307         {
 308                 /* Acer Aspire 5650 */
 309                 .matches = {
 310                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 311                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5650"),
 312                 },
 313                 .driver_data = (void *)(SERIO_QUIRK_DRITEK)
 314         },
 315         {
 316                 /* Acer Aspire 5680 */
 317                 .matches = {
 318                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 319                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5680"),
 320                 },
 321                 .driver_data = (void *)(SERIO_QUIRK_DRITEK)
 322         },
 323         {
 324                 /* Acer Aspire 5720 */
 325                 .matches = {
 326                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 327                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5720"),
 328                 },
 329                 .driver_data = (void *)(SERIO_QUIRK_DRITEK)
 330         },
 331         {
 332                 /* Acer Aspire 9110 */
 333                 .matches = {
 334                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 335                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 9110"),
 336                 },
 337                 .driver_data = (void *)(SERIO_QUIRK_DRITEK)
 338         },
 339         {
 340                 /* Acer TravelMate 660 */
 341                 .matches = {
 342                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 343                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 660"),
 344                 },
 345                 .driver_data = (void *)(SERIO_QUIRK_DRITEK)
 346         },
 347         {
 348                 /* Acer TravelMate 2490 */
 349                 .matches = {
 350                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 351                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2490"),
 352                 },
 353                 .driver_data = (void *)(SERIO_QUIRK_DRITEK)
 354         },
 355         {
 356                 /* Acer TravelMate 4280 */
 357                 .matches = {
 358                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 359                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 4280"),
 360                 },
 361                 .driver_data = (void *)(SERIO_QUIRK_DRITEK)
 362         },
 363         {
 364                 /* Amoi M636/A737 */
 365                 .matches = {
 366                         DMI_MATCH(DMI_SYS_VENDOR, "Amoi Electronics CO.,LTD."),
 367                         DMI_MATCH(DMI_PRODUCT_NAME, "M636/A737 platform"),
 368                 },
 369                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 370         },
 371         {
 372                 .matches = {
 373                         DMI_MATCH(DMI_SYS_VENDOR, "ByteSpeed LLC"),
 374                         DMI_MATCH(DMI_PRODUCT_NAME, "ByteSpeed Laptop C15B"),
 375                 },
 376                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 377         },
 378         {
 379                 /* Compal HEL80I */
 380                 .matches = {
 381                         DMI_MATCH(DMI_SYS_VENDOR, "COMPAL"),
 382                         DMI_MATCH(DMI_PRODUCT_NAME, "HEL80I"),
 383                 },
 384                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 385         },
 386         {
 387                 .matches = {
 388                         DMI_MATCH(DMI_SYS_VENDOR, "Compaq"),
 389                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant"),
 390                         DMI_MATCH(DMI_PRODUCT_VERSION, "8500"),
 391                 },
 392                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 393         },
 394         {
 395                 .matches = {
 396                         DMI_MATCH(DMI_SYS_VENDOR, "Compaq"),
 397                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant"),
 398                         DMI_MATCH(DMI_PRODUCT_VERSION, "DL760"),
 399                 },
 400                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 401         },
 402         {
 403                 /* Advent 4211 */
 404                 .matches = {
 405                         DMI_MATCH(DMI_SYS_VENDOR, "DIXONSXP"),
 406                         DMI_MATCH(DMI_PRODUCT_NAME, "Advent 4211"),
 407                 },
 408                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 409         },
 410         {
 411                 /* Dell Embedded Box PC 3000 */
 412                 .matches = {
 413                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 414                         DMI_MATCH(DMI_PRODUCT_NAME, "Embedded Box PC 3000"),
 415                 },
 416                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 417         },
 418         {
 419                 /* Dell XPS M1530 */
 420                 .matches = {
 421                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 422                         DMI_MATCH(DMI_PRODUCT_NAME, "XPS M1530"),
 423                 },
 424                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 425         },
 426         {
 427                 /* Dell Vostro 1510 */
 428                 .matches = {
 429                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 430                         DMI_MATCH(DMI_PRODUCT_NAME, "Vostro1510"),
 431                 },
 432                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 433         },
 434         {
 435                 /* Dell Vostro V13 */
 436                 .matches = {
 437                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 438                         DMI_MATCH(DMI_PRODUCT_NAME, "Vostro V13"),
 439                 },
 440                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_NOTIMEOUT)
 441         },
 442         {
 443                 /* Dell Vostro 1320 */
 444                 .matches = {
 445                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 446                         DMI_MATCH(DMI_PRODUCT_NAME, "Vostro 1320"),
 447                 },
 448                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 449         },
 450         {
 451                 /* Dell Vostro 1520 */
 452                 .matches = {
 453                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 454                         DMI_MATCH(DMI_PRODUCT_NAME, "Vostro 1520"),
 455                 },
 456                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 457         },
 458         {
 459                 /* Dell Vostro 1720 */
 460                 .matches = {
 461                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 462                         DMI_MATCH(DMI_PRODUCT_NAME, "Vostro 1720"),
 463                 },
 464                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 465         },
 466         {
 467                 /* Entroware Proteus */
 468                 .matches = {
 469                         DMI_MATCH(DMI_SYS_VENDOR, "Entroware"),
 470                         DMI_MATCH(DMI_PRODUCT_NAME, "Proteus"),
 471                         DMI_MATCH(DMI_PRODUCT_VERSION, "EL07R4"),
 472                 },
 473                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS)
 474         },
 475         /*
 476          * Some Fujitsu notebooks are having trouble with touchpads if
 477          * active multiplexing mode is activated. Luckily they don't have
 478          * external PS/2 ports so we can safely disable it.
 479          * ... apparently some Toshibas don't like MUX mode either and
 480          * die horrible death on reboot.
 481          */
 482         {
 483                 /* Fujitsu Lifebook P7010/P7010D */
 484                 .matches = {
 485                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
 486                         DMI_MATCH(DMI_PRODUCT_NAME, "P7010"),
 487                 },
 488                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 489         },
 490         {
 491                 /* Fujitsu Lifebook P5020D */
 492                 .matches = {
 493                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
 494                         DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook P Series"),
 495                 },
 496                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 497         },
 498         {
 499                 /* Fujitsu Lifebook S2000 */
 500                 .matches = {
 501                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
 502                         DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook S Series"),
 503                 },
 504                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 505         },
 506         {
 507                 /* Fujitsu Lifebook S6230 */
 508                 .matches = {
 509                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
 510                         DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook S6230"),
 511                 },
 512                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 513         },
 514         {
 515                 /* Fujitsu Lifebook T725 laptop */
 516                 .matches = {
 517                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
 518                         DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK T725"),
 519                 },
 520                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_NOTIMEOUT)
 521         },
 522         {
 523                 /* Fujitsu Lifebook U745 */
 524                 .matches = {
 525                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
 526                         DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK U745"),
 527                 },
 528                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 529         },
 530         {
 531                 /* Fujitsu T70H */
 532                 .matches = {
 533                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
 534                         DMI_MATCH(DMI_PRODUCT_NAME, "FMVLT70H"),
 535                 },
 536                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 537         },
 538         {
 539                 /* Fujitsu A544 laptop */
 540                 /* https://bugzilla.redhat.com/show_bug.cgi?id=1111138 */
 541                 .matches = {
 542                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
 543                         DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK A544"),
 544                 },
 545                 .driver_data = (void *)(SERIO_QUIRK_NOTIMEOUT)
 546         },
 547         {
 548                 /* Fujitsu AH544 laptop */
 549                 /* https://bugzilla.kernel.org/show_bug.cgi?id=69731 */
 550                 .matches = {
 551                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
 552                         DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK AH544"),
 553                 },
 554                 .driver_data = (void *)(SERIO_QUIRK_NOTIMEOUT)
 555         },
 556         {
 557                 /* Fujitsu U574 laptop */
 558                 /* https://bugzilla.kernel.org/show_bug.cgi?id=69731 */
 559                 .matches = {
 560                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
 561                         DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK U574"),
 562                 },
 563                 .driver_data = (void *)(SERIO_QUIRK_NOTIMEOUT)
 564         },
 565         {
 566                 /* Fujitsu UH554 laptop */
 567                 .matches = {
 568                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
 569                         DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK UH544"),
 570                 },
 571                 .driver_data = (void *)(SERIO_QUIRK_NOTIMEOUT)
 572         },
 573         {
 574                 /* Fujitsu Lifebook P7010 */
 575                 .matches = {
 576                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
 577                         DMI_MATCH(DMI_PRODUCT_NAME, "0000000000"),
 578                 },
 579                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 580         },
 581         {
 582                 /* Fujitsu-Siemens Lifebook T3010 */
 583                 .matches = {
 584                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
 585                         DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK T3010"),
 586                 },
 587                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 588         },
 589         {
 590                 /* Fujitsu-Siemens Lifebook E4010 */
 591                 .matches = {
 592                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
 593                         DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E4010"),
 594                 },
 595                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 596         },
 597         {
 598                 /* Fujitsu-Siemens Amilo Pro 2010 */
 599                 .matches = {
 600                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
 601                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pro V2010"),
 602                 },
 603                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 604         },
 605         {
 606                 /* Fujitsu-Siemens Amilo Pro 2030 */
 607                 .matches = {
 608                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
 609                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO PRO V2030"),
 610                 },
 611                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 612         },
 613         {
 614                 /* Fujitsu Lifebook A574/H */
 615                 .matches = {
 616                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
 617                         DMI_MATCH(DMI_PRODUCT_NAME, "FMVA0501PZ"),
 618                 },
 619                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 620         },
 621         {
 622                 /* Gigabyte M912 */
 623                 .matches = {
 624                         DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"),
 625                         DMI_MATCH(DMI_PRODUCT_NAME, "M912"),
 626                         DMI_MATCH(DMI_PRODUCT_VERSION, "01"),
 627                 },
 628                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 629         },
 630         {
 631                 /* Gigabyte Spring Peak - defines wrong chassis type */
 632                 .matches = {
 633                         DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"),
 634                         DMI_MATCH(DMI_PRODUCT_NAME, "Spring Peak"),
 635                 },
 636                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 637         },
 638         {
 639                 /* Gigabyte T1005 - defines wrong chassis type ("Other") */
 640                 .matches = {
 641                         DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"),
 642                         DMI_MATCH(DMI_PRODUCT_NAME, "T1005"),
 643                 },
 644                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 645         },
 646         {
 647                 /* Gigabyte T1005M/P - defines wrong chassis type ("Other") */
 648                 .matches = {
 649                         DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"),
 650                         DMI_MATCH(DMI_PRODUCT_NAME, "T1005M/P"),
 651                 },
 652                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 653         },
 654         /*
 655          * Some laptops need keyboard reset before probing for the trackpad to get
 656          * it detected, initialised & finally work.
 657          */
 658         {
 659                 /* Gigabyte P35 v2 - Elantech touchpad */
 660                 .matches = {
 661                         DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"),
 662                         DMI_MATCH(DMI_PRODUCT_NAME, "P35V2"),
 663                 },
 664                 .driver_data = (void *)(SERIO_QUIRK_KBDRESET)
 665         },
 666                 {
 667                 /* Aorus branded Gigabyte X3 Plus - Elantech touchpad */
 668                 .matches = {
 669                         DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"),
 670                         DMI_MATCH(DMI_PRODUCT_NAME, "X3"),
 671                 },
 672                 .driver_data = (void *)(SERIO_QUIRK_KBDRESET)
 673         },
 674         {
 675                 /* Gigabyte P34 - Elantech touchpad */
 676                 .matches = {
 677                         DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"),
 678                         DMI_MATCH(DMI_PRODUCT_NAME, "P34"),
 679                 },
 680                 .driver_data = (void *)(SERIO_QUIRK_KBDRESET)
 681         },
 682         {
 683                 /* Gigabyte P57 - Elantech touchpad */
 684                 .matches = {
 685                         DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"),
 686                         DMI_MATCH(DMI_PRODUCT_NAME, "P57"),
 687                 },
 688                 .driver_data = (void *)(SERIO_QUIRK_KBDRESET)
 689         },
 690         {
 691                 /* Gericom Bellagio */
 692                 .matches = {
 693                         DMI_MATCH(DMI_SYS_VENDOR, "Gericom"),
 694                         DMI_MATCH(DMI_PRODUCT_NAME, "N34AS6"),
 695                 },
 696                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 697         },
 698         {
 699                 /* Gigabyte M1022M netbook */
 700                 .matches = {
 701                         DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co.,Ltd."),
 702                         DMI_MATCH(DMI_BOARD_NAME, "M1022E"),
 703                         DMI_MATCH(DMI_BOARD_VERSION, "1.02"),
 704                 },
 705                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 706         },
 707         {
 708                 .matches = {
 709                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
 710                         DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion dv9700"),
 711                         DMI_MATCH(DMI_PRODUCT_VERSION, "Rev 1"),
 712                 },
 713                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 714         },
 715         {
 716                 /*
 717                  * HP Pavilion DV4017EA -
 718                  * errors on MUX ports are reported without raising AUXDATA
 719                  * causing "spurious NAK" messages.
 720                  */
 721                 .matches = {
 722                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
 723                         DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion dv4000 (EA032EA#ABF)"),
 724                 },
 725                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 726         },
 727         {
 728                 /*
 729                  * HP Pavilion ZT1000 -
 730                  * like DV4017EA does not raise AUXERR for errors on MUX ports.
 731                  */
 732                 .matches = {
 733                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
 734                         DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion Notebook PC"),
 735                         DMI_MATCH(DMI_PRODUCT_VERSION, "HP Pavilion Notebook ZT1000"),
 736                 },
 737                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 738         },
 739         {
 740                 /*
 741                  * HP Pavilion DV4270ca -
 742                  * like DV4017EA does not raise AUXERR for errors on MUX ports.
 743                  */
 744                 .matches = {
 745                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
 746                         DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion dv4000 (EH476UA#ABL)"),
 747                 },
 748                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 749         },
 750         {
 751                 /* Newer HP Pavilion dv4 models */
 752                 .matches = {
 753                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
 754                         DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion dv4 Notebook PC"),
 755                 },
 756                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_NOTIMEOUT)
 757         },
 758         {
 759                 /* IBM 2656 */
 760                 .matches = {
 761                         DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
 762                         DMI_MATCH(DMI_PRODUCT_NAME, "2656"),
 763                 },
 764                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 765         },
 766         {
 767                 /* Avatar AVIU-145A6 */
 768                 .matches = {
 769                         DMI_MATCH(DMI_SYS_VENDOR, "Intel"),
 770                         DMI_MATCH(DMI_PRODUCT_NAME, "IC4I"),
 771                 },
 772                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 773         },
 774         {
 775                 /* Intel MBO Desktop D845PESV */
 776                 .matches = {
 777                         DMI_MATCH(DMI_BOARD_VENDOR, "Intel Corporation"),
 778                         DMI_MATCH(DMI_BOARD_NAME, "D845PESV"),
 779                 },
 780                 .driver_data = (void *)(SERIO_QUIRK_NOPNP)
 781         },
 782         {
 783                 /*
 784                  * Intel NUC D54250WYK - does not have i8042 controller but
 785                  * declares PS/2 devices in DSDT.
 786                  */
 787                 .matches = {
 788                         DMI_MATCH(DMI_BOARD_VENDOR, "Intel Corporation"),
 789                         DMI_MATCH(DMI_BOARD_NAME, "D54250WYK"),
 790                 },
 791                 .driver_data = (void *)(SERIO_QUIRK_NOPNP)
 792         },
 793         {
 794                 /* Lenovo 3000 n100 */
 795                 .matches = {
 796                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 797                         DMI_MATCH(DMI_PRODUCT_NAME, "076804U"),
 798                 },
 799                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 800         },
 801         {
 802                 /* Lenovo XiaoXin Air 12 */
 803                 .matches = {
 804                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 805                         DMI_MATCH(DMI_PRODUCT_NAME, "80UN"),
 806                 },
 807                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 808         },
 809         {
 810                 /* Lenovo LaVie Z */
 811                 .matches = {
 812                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 813                         DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo LaVie Z"),
 814                 },
 815                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 816         },
 817         {
 818                 /* Lenovo Ideapad U455 */
 819                 .matches = {
 820                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 821                         DMI_MATCH(DMI_PRODUCT_NAME, "20046"),
 822                 },
 823                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 824         },
 825         {
 826                 /* Lenovo ThinkPad L460 */
 827                 .matches = {
 828                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 829                         DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad L460"),
 830                 },
 831                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 832         },
 833         {
 834                 /* Lenovo ThinkPad Twist S230u */
 835                 .matches = {
 836                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 837                         DMI_MATCH(DMI_PRODUCT_NAME, "33474HU"),
 838                 },
 839                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 840         },
 841         {
 842                 /* LG Electronics X110 */
 843                 .matches = {
 844                         DMI_MATCH(DMI_BOARD_VENDOR, "LG Electronics Inc."),
 845                         DMI_MATCH(DMI_BOARD_NAME, "X110"),
 846                 },
 847                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 848         },
 849         {
 850                 /* Medion Akoya Mini E1210 */
 851                 .matches = {
 852                         DMI_MATCH(DMI_SYS_VENDOR, "MEDION"),
 853                         DMI_MATCH(DMI_PRODUCT_NAME, "E1210"),
 854                 },
 855                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 856         },
 857         {
 858                 /* Medion Akoya E1222 */
 859                 .matches = {
 860                         DMI_MATCH(DMI_SYS_VENDOR, "MEDION"),
 861                         DMI_MATCH(DMI_PRODUCT_NAME, "E122X"),
 862                 },
 863                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
 864         },
 865         {
 866                 /* MSI Wind U-100 */
 867                 .matches = {
 868                         DMI_MATCH(DMI_BOARD_VENDOR, "MICRO-STAR INTERNATIONAL CO., LTD"),
 869                         DMI_MATCH(DMI_BOARD_NAME, "U-100"),
 870                 },
 871                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS | SERIO_QUIRK_NOPNP)
 872         },
 873         {
 874                 /*
 875                  * No data is coming from the touchscreen unless KBC
 876                  * is in legacy mode.
 877                  */
 878                 /* Panasonic CF-29 */
 879                 .matches = {
 880                         DMI_MATCH(DMI_SYS_VENDOR, "Matsushita"),
 881                         DMI_MATCH(DMI_PRODUCT_NAME, "CF-29"),
 882                 },
 883                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 884         },
 885         {
 886                 /* Medion Akoya E7225 */
 887                 .matches = {
 888                         DMI_MATCH(DMI_SYS_VENDOR, "Medion"),
 889                         DMI_MATCH(DMI_PRODUCT_NAME, "Akoya E7225"),
 890                         DMI_MATCH(DMI_PRODUCT_VERSION, "1.0"),
 891                 },
 892                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 893         },
 894         {
 895                 /* Microsoft Virtual Machine */
 896                 .matches = {
 897                         DMI_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"),
 898                         DMI_MATCH(DMI_PRODUCT_NAME, "Virtual Machine"),
 899                         DMI_MATCH(DMI_PRODUCT_VERSION, "VS2005R2"),
 900                 },
 901                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 902         },
 903         {
 904                 /* Medion MAM 2070 */
 905                 .matches = {
 906                         DMI_MATCH(DMI_SYS_VENDOR, "Notebook"),
 907                         DMI_MATCH(DMI_PRODUCT_NAME, "MAM 2070"),
 908                         DMI_MATCH(DMI_PRODUCT_VERSION, "5a"),
 909                 },
 910                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 911         },
 912         {
 913                 /* TUXEDO BU1406 */
 914                 .matches = {
 915                         DMI_MATCH(DMI_SYS_VENDOR, "Notebook"),
 916                         DMI_MATCH(DMI_PRODUCT_NAME, "N24_25BU"),
 917                 },
 918                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 919         },
 920         {
 921                 /* OQO Model 01 */
 922                 .matches = {
 923                         DMI_MATCH(DMI_SYS_VENDOR, "OQO"),
 924                         DMI_MATCH(DMI_PRODUCT_NAME, "ZEPTO"),
 925                         DMI_MATCH(DMI_PRODUCT_VERSION, "00"),
 926                 },
 927                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 928         },
 929         {
 930                 .matches = {
 931                         DMI_MATCH(DMI_SYS_VENDOR, "PEGATRON CORPORATION"),
 932                         DMI_MATCH(DMI_PRODUCT_NAME, "C15B"),
 933                 },
 934                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 935         },
 936         {
 937                 /* Acer Aspire 5 A515 */
 938                 .matches = {
 939                         DMI_MATCH(DMI_BOARD_VENDOR, "PK"),
 940                         DMI_MATCH(DMI_BOARD_NAME, "Grumpy_PK"),
 941                 },
 942                 .driver_data = (void *)(SERIO_QUIRK_NOPNP)
 943         },
 944         {
 945                 /* ULI EV4873 - AUX LOOP does not work properly */
 946                 .matches = {
 947                         DMI_MATCH(DMI_SYS_VENDOR, "ULI"),
 948                         DMI_MATCH(DMI_PRODUCT_NAME, "EV4873"),
 949                         DMI_MATCH(DMI_PRODUCT_VERSION, "5a"),
 950                 },
 951                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 952         },
 953         {
 954                 /*
 955                  * Arima-Rioworks HDAMB -
 956                  * AUX LOOP command does not raise AUX IRQ
 957                  */
 958                 .matches = {
 959                         DMI_MATCH(DMI_BOARD_VENDOR, "RIOWORKS"),
 960                         DMI_MATCH(DMI_BOARD_NAME, "HDAMB"),
 961                         DMI_MATCH(DMI_BOARD_VERSION, "Rev E"),
 962                 },
 963                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
 964         },
 965         {
 966                 /* Sharp Actius MM20 */
 967                 .matches = {
 968                         DMI_MATCH(DMI_SYS_VENDOR, "SHARP"),
 969                         DMI_MATCH(DMI_PRODUCT_NAME, "PC-MM20 Series"),
 970                 },
 971                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 972         },
 973         {
 974                 /*
 975                  * Sony Vaio FZ-240E -
 976                  * reset and GET ID commands issued via KBD port are
 977                  * sometimes being delivered to AUX3.
 978                  */
 979                 .matches = {
 980                         DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 981                         DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FZ240E"),
 982                 },
 983                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 984         },
 985         {
 986                 /*
 987                  * Most (all?) VAIOs do not have external PS/2 ports nor
 988                  * they implement active multiplexing properly, and
 989                  * MUX discovery usually messes up keyboard/touchpad.
 990                  */
 991                 .matches = {
 992                         DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 993                         DMI_MATCH(DMI_BOARD_NAME, "VAIO"),
 994                 },
 995                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
 996         },
 997         {
 998                 /* Sony Vaio FS-115b */
 999                 .matches = {
1000                         DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
1001                         DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FS115B"),
1002                 },
1003                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
1004         },
1005         {
1006                 /*
1007                  * Sony Vaio VGN-CS series require MUX or the touch sensor
1008                  * buttons will disturb touchpad operation
1009                  */
1010                 .matches = {
1011                         DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
1012                         DMI_MATCH(DMI_PRODUCT_NAME, "VGN-CS"),
1013                 },
1014                 .driver_data = (void *)(SERIO_QUIRK_FORCEMUX)
1015         },
1016         {
1017                 .matches = {
1018                         DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1019                         DMI_MATCH(DMI_PRODUCT_NAME, "Satellite P10"),
1020                 },
1021                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
1022         },
1023         {
1024                 .matches = {
1025                         DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1026                         DMI_MATCH(DMI_PRODUCT_NAME, "EQUIUM A110"),
1027                 },
1028                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
1029         },
1030         {
1031                 .matches = {
1032                         DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1033                         DMI_MATCH(DMI_PRODUCT_NAME, "SATELLITE C850D"),
1034                 },
1035                 .driver_data = (void *)(SERIO_QUIRK_NOMUX)
1036         },
1037         /*
1038          * A lot of modern Clevo barebones have touchpad and/or keyboard issues
1039          * after suspend fixable with nomux + reset + noloop + nopnp. Luckily,
1040          * none of them have an external PS/2 port so this can safely be set for
1041          * all of them. These two are based on a Clevo design, but have the
1042          * board_name changed.
1043          */
1044         {
1045                 .matches = {
1046                         DMI_MATCH(DMI_BOARD_VENDOR, "TUXEDO"),
1047                         DMI_MATCH(DMI_BOARD_NAME, "AURA1501"),
1048                 },
1049                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1050                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1051         },
1052         {
1053                 .matches = {
1054                         DMI_MATCH(DMI_BOARD_VENDOR, "TUXEDO"),
1055                         DMI_MATCH(DMI_BOARD_NAME, "EDUBOOK1502"),
1056                 },
1057                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1058                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1059         },
1060         {
1061                 /* Mivvy M310 */
1062                 .matches = {
1063                         DMI_MATCH(DMI_SYS_VENDOR, "VIOOO"),
1064                         DMI_MATCH(DMI_PRODUCT_NAME, "N10"),
1065                 },
1066                 .driver_data = (void *)(SERIO_QUIRK_RESET_ALWAYS)
1067         },
1068         /*
1069          * Some laptops need keyboard reset before probing for the trackpad to get
1070          * it detected, initialised & finally work.
1071          */
1072         {
1073                 /* Schenker XMG C504 - Elantech touchpad */
1074                 .matches = {
1075                         DMI_MATCH(DMI_SYS_VENDOR, "XMG"),
1076                         DMI_MATCH(DMI_PRODUCT_NAME, "C504"),
1077                 },
1078                 .driver_data = (void *)(SERIO_QUIRK_KBDRESET)
1079         },
1080         {
1081                 /* Blue FB5601 */
1082                 .matches = {
1083                         DMI_MATCH(DMI_SYS_VENDOR, "blue"),
1084                         DMI_MATCH(DMI_PRODUCT_NAME, "FB5601"),
1085                         DMI_MATCH(DMI_PRODUCT_VERSION, "M606"),
1086                 },
1087                 .driver_data = (void *)(SERIO_QUIRK_NOLOOP)
1088         },
1089         /*
1090          * A lot of modern Clevo barebones have touchpad and/or keyboard issues
1091          * after suspend fixable with nomux + reset + noloop + nopnp. Luckily,
1092          * none of them have an external PS/2 port so this can safely be set for
1093          * all of them.
1094          * Clevo barebones come with board_vendor and/or system_vendor set to
1095          * either the very generic string "Notebook" and/or a different value
1096          * for each individual reseller. The only somewhat universal way to
1097          * identify them is by board_name.
1098          */
1099         {
1100                 .matches = {
1101                         DMI_MATCH(DMI_BOARD_NAME, "LAPQC71A"),
1102                 },
1103                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1104                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1105         },
1106         {
1107                 .matches = {
1108                         DMI_MATCH(DMI_BOARD_NAME, "LAPQC71B"),
1109                 },
1110                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1111                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1112         },
1113         {
1114                 .matches = {
1115                         DMI_MATCH(DMI_BOARD_NAME, "N140CU"),
1116                 },
1117                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1118                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1119         },
1120         {
1121                 .matches = {
1122                         DMI_MATCH(DMI_BOARD_NAME, "N141CU"),
1123                 },
1124                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1125                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1126         },
1127         {
1128                 /*
1129                  * Setting SERIO_QUIRK_NOMUX or SERIO_QUIRK_RESET_ALWAYS makes
1130                  * the keyboard very laggy for ~5 seconds after boot and
1131                  * sometimes also after resume.
1132                  * However both are required for the keyboard to not fail
1133                  * completely sometimes after boot or resume.
1134                  */
1135                 .matches = {
1136                         DMI_MATCH(DMI_BOARD_NAME, "N150CU"),
1137                 },
1138                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1139                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1140         },
1141         {
1142                 .matches = {
1143                         DMI_MATCH(DMI_BOARD_NAME, "NH5xAx"),
1144                 },
1145                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1146                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1147         },
1148         {
1149                 /*
1150                  * Setting SERIO_QUIRK_NOMUX or SERIO_QUIRK_RESET_ALWAYS makes
1151                  * the keyboard very laggy for ~5 seconds after boot and
1152                  * sometimes also after resume.
1153                  * However both are required for the keyboard to not fail
1154                  * completely sometimes after boot or resume.
1155                  */
1156                 .matches = {
1157                         DMI_MATCH(DMI_BOARD_NAME, "NHxxRZQ"),
1158                 },
1159                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1160                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1161         },
1162         {
1163                 .matches = {
1164                         DMI_MATCH(DMI_BOARD_NAME, "NL5xRU"),
1165                 },
1166                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1167                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1168         },
1169         /*
1170          * At least one modern Clevo barebone has the touchpad connected both
1171          * via PS/2 and i2c interface. This causes a race condition between the
1172          * psmouse and i2c-hid driver. Since the full capability of the touchpad
1173          * is available via the i2c interface and the device has no external
1174          * PS/2 port, it is safe to just ignore all ps2 mouses here to avoid
1175          * this issue. The known affected device is the
1176          * TUXEDO InfinityBook S17 Gen6 / Clevo NS70MU which comes with one of
1177          * the two different dmi strings below. NS50MU is not a typo!
1178          */
1179         {
1180                 .matches = {
1181                         DMI_MATCH(DMI_BOARD_NAME, "NS50MU"),
1182                 },
1183                 .driver_data = (void *)(SERIO_QUIRK_NOAUX | SERIO_QUIRK_NOMUX |
1184                                         SERIO_QUIRK_RESET_ALWAYS | SERIO_QUIRK_NOLOOP |
1185                                         SERIO_QUIRK_NOPNP)
1186         },
1187         {
1188                 .matches = {
1189                         DMI_MATCH(DMI_BOARD_NAME, "NS50_70MU"),
1190                 },
1191                 .driver_data = (void *)(SERIO_QUIRK_NOAUX | SERIO_QUIRK_NOMUX |
1192                                         SERIO_QUIRK_RESET_ALWAYS | SERIO_QUIRK_NOLOOP |
1193                                         SERIO_QUIRK_NOPNP)
1194         },
1195         {
1196                 .matches = {
1197                         DMI_MATCH(DMI_BOARD_NAME, "NJ50_70CU"),
1198                 },
1199                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1200                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1201         },
1202         {
1203                 /*
1204                  * This is only a partial board_name and might be followed by
1205                  * another letter or number. DMI_MATCH however does do partial
1206                  * matching.
1207                  */
1208                 .matches = {
1209                         DMI_MATCH(DMI_PRODUCT_NAME, "P65xH"),
1210                 },
1211                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1212                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1213         },
1214         {
1215                 /* Clevo P650RS, 650RP6, Sager NP8152-S, and others */
1216                 .matches = {
1217                         DMI_MATCH(DMI_PRODUCT_NAME, "P65xRP"),
1218                 },
1219                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1220                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1221         },
1222         {
1223                 /*
1224                  * This is only a partial board_name and might be followed by
1225                  * another letter or number. DMI_MATCH however does do partial
1226                  * matching.
1227                  */
1228                 .matches = {
1229                         DMI_MATCH(DMI_PRODUCT_NAME, "P65_P67H"),
1230                 },
1231                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1232                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1233         },
1234         {
1235                 /*
1236                  * This is only a partial board_name and might be followed by
1237                  * another letter or number. DMI_MATCH however does do partial
1238                  * matching.
1239                  */
1240                 .matches = {
1241                         DMI_MATCH(DMI_PRODUCT_NAME, "P65_67RP"),
1242                 },
1243                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1244                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1245         },
1246         {
1247                 /*
1248                  * This is only a partial board_name and might be followed by
1249                  * another letter or number. DMI_MATCH however does do partial
1250                  * matching.
1251                  */
1252                 .matches = {
1253                         DMI_MATCH(DMI_PRODUCT_NAME, "P65_67RS"),
1254                 },
1255                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1256                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1257         },
1258         {
1259                 /*
1260                  * This is only a partial board_name and might be followed by
1261                  * another letter or number. DMI_MATCH however does do partial
1262                  * matching.
1263                  */
1264                 .matches = {
1265                         DMI_MATCH(DMI_PRODUCT_NAME, "P67xRP"),
1266                 },
1267                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1268                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1269         },
1270         {
1271                 .matches = {
1272                         DMI_MATCH(DMI_BOARD_NAME, "PB50_70DFx,DDx"),
1273                 },
1274                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1275                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1276         },
1277         {
1278                 .matches = {
1279                         DMI_MATCH(DMI_BOARD_NAME, "PCX0DX"),
1280                 },
1281                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1282                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1283         },
1284         /* See comment on TUXEDO InfinityBook S17 Gen6 / Clevo NS70MU above */
1285         {
1286                 .matches = {
1287                         DMI_MATCH(DMI_BOARD_NAME, "PD5x_7xPNP_PNR_PNN_PNT"),
1288                 },
1289                 .driver_data = (void *)(SERIO_QUIRK_NOAUX)
1290         },
1291         {
1292                 .matches = {
1293                         DMI_MATCH(DMI_BOARD_NAME, "X170SM"),
1294                 },
1295                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1296                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1297         },
1298         {
1299                 .matches = {
1300                         DMI_MATCH(DMI_BOARD_NAME, "X170KM-G"),
1301                 },
1302                 .driver_data = (void *)(SERIO_QUIRK_NOMUX | SERIO_QUIRK_RESET_ALWAYS |
1303                                         SERIO_QUIRK_NOLOOP | SERIO_QUIRK_NOPNP)
1304         },
1305         { }
1306 };
1307
1308 #ifdef CONFIG_PNP
1309 static const struct dmi_system_id i8042_dmi_laptop_table[] __initconst = {
1310         {
1311                 .matches = {
1312                         DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1313                 },
1314         },
1315         {
1316                 .matches = {
1317                         DMI_MATCH(DMI_CHASSIS_TYPE, "9"), /* Laptop */
1318                 },
1319         },
1320         {
1321                 .matches = {
1322                         DMI_MATCH(DMI_CHASSIS_TYPE, "10"), /* Notebook */
1323                 },
1324         },
1325         {
1326                 .matches = {
1327                         DMI_MATCH(DMI_CHASSIS_TYPE, "14"), /* Sub-Notebook */
1328                 },
1329         },
1330         { }
1331 };
1332 #endif
1333
1334 #endif /* CONFIG_X86 */
1335
1336 #ifdef CONFIG_PNP
1337 #include <linux/pnp.h>
1338
1339 static bool i8042_pnp_kbd_registered;
1340 static unsigned int i8042_pnp_kbd_devices;
1341 static bool i8042_pnp_aux_registered;
1342 static unsigned int i8042_pnp_aux_devices;
1343
1344 static int i8042_pnp_command_reg;
1345 static int i8042_pnp_data_reg;
1346 static int i8042_pnp_kbd_irq;
1347 static int i8042_pnp_aux_irq;
1348
1349 static char i8042_pnp_kbd_name[32];
1350 static char i8042_pnp_aux_name[32];
1351
1352 static void i8042_pnp_id_to_string(struct pnp_id *id, char *dst, int dst_size)
1353 {
1354         strscpy(dst, "PNP:", dst_size);
1355
1356         while (id) {
1357                 strlcat(dst, " ", dst_size);
1358                 strlcat(dst, id->id, dst_size);
1359                 id = id->next;
1360         }
1361 }
1362
1363 static int i8042_pnp_kbd_probe(struct pnp_dev *dev, const struct pnp_device_id *did)
1364 {
1365         if (pnp_port_valid(dev, 0) && pnp_port_len(dev, 0) == 1)
1366                 i8042_pnp_data_reg = pnp_port_start(dev,0);
1367
1368         if (pnp_port_valid(dev, 1) && pnp_port_len(dev, 1) == 1)
1369                 i8042_pnp_command_reg = pnp_port_start(dev, 1);
1370
1371         if (pnp_irq_valid(dev,0))
1372                 i8042_pnp_kbd_irq = pnp_irq(dev, 0);
1373
1374         strscpy(i8042_pnp_kbd_name, did->id, sizeof(i8042_pnp_kbd_name));
1375         if (strlen(pnp_dev_name(dev))) {
1376                 strlcat(i8042_pnp_kbd_name, ":", sizeof(i8042_pnp_kbd_name));
1377                 strlcat(i8042_pnp_kbd_name, pnp_dev_name(dev), sizeof(i8042_pnp_kbd_name));
1378         }
1379         i8042_pnp_id_to_string(dev->id, i8042_kbd_firmware_id,
1380                                sizeof(i8042_kbd_firmware_id));
1381         i8042_kbd_fwnode = dev_fwnode(&dev->dev);
1382
1383         /* Keyboard ports are always supposed to be wakeup-enabled */
1384         device_set_wakeup_enable(&dev->dev, true);
1385
1386         i8042_pnp_kbd_devices++;
1387         return 0;
1388 }
1389
1390 static int i8042_pnp_aux_probe(struct pnp_dev *dev, const struct pnp_device_id *did)
1391 {
1392         if (pnp_port_valid(dev, 0) && pnp_port_len(dev, 0) == 1)
1393                 i8042_pnp_data_reg = pnp_port_start(dev,0);
1394
1395         if (pnp_port_valid(dev, 1) && pnp_port_len(dev, 1) == 1)
1396                 i8042_pnp_command_reg = pnp_port_start(dev, 1);
1397
1398         if (pnp_irq_valid(dev, 0))
1399                 i8042_pnp_aux_irq = pnp_irq(dev, 0);
1400
1401         strscpy(i8042_pnp_aux_name, did->id, sizeof(i8042_pnp_aux_name));
1402         if (strlen(pnp_dev_name(dev))) {
1403                 strlcat(i8042_pnp_aux_name, ":", sizeof(i8042_pnp_aux_name));
1404                 strlcat(i8042_pnp_aux_name, pnp_dev_name(dev), sizeof(i8042_pnp_aux_name));
1405         }
1406         i8042_pnp_id_to_string(dev->id, i8042_aux_firmware_id,
1407                                sizeof(i8042_aux_firmware_id));
1408
1409         i8042_pnp_aux_devices++;
1410         return 0;
1411 }
1412
1413 static const struct pnp_device_id pnp_kbd_devids[] = {
1414         { .id = "PNP0300", .driver_data = 0 },
1415         { .id = "PNP0301", .driver_data = 0 },
1416         { .id = "PNP0302", .driver_data = 0 },
1417         { .id = "PNP0303", .driver_data = 0 },
1418         { .id = "PNP0304", .driver_data = 0 },
1419         { .id = "PNP0305", .driver_data = 0 },
1420         { .id = "PNP0306", .driver_data = 0 },
1421         { .id = "PNP0309", .driver_data = 0 },
1422         { .id = "PNP030a", .driver_data = 0 },
1423         { .id = "PNP030b", .driver_data = 0 },
1424         { .id = "PNP0320", .driver_data = 0 },
1425         { .id = "PNP0343", .driver_data = 0 },
1426         { .id = "PNP0344", .driver_data = 0 },
1427         { .id = "PNP0345", .driver_data = 0 },
1428         { .id = "CPQA0D7", .driver_data = 0 },
1429         { .id = "", },
1430 };
1431 MODULE_DEVICE_TABLE(pnp, pnp_kbd_devids);
1432
1433 static struct pnp_driver i8042_pnp_kbd_driver = {
1434         .name           = "i8042 kbd",
1435         .id_table       = pnp_kbd_devids,
1436         .probe          = i8042_pnp_kbd_probe,
1437         .driver         = {
1438                 .probe_type = PROBE_FORCE_SYNCHRONOUS,
1439                 .suppress_bind_attrs = true,
1440         },
1441 };
1442
1443 static const struct pnp_device_id pnp_aux_devids[] = {
1444         { .id = "AUI0200", .driver_data = 0 },
1445         { .id = "FJC6000", .driver_data = 0 },
1446         { .id = "FJC6001", .driver_data = 0 },
1447         { .id = "PNP0f03", .driver_data = 0 },
1448         { .id = "PNP0f0b", .driver_data = 0 },
1449         { .id = "PNP0f0e", .driver_data = 0 },
1450         { .id = "PNP0f12", .driver_data = 0 },
1451         { .id = "PNP0f13", .driver_data = 0 },
1452         { .id = "PNP0f19", .driver_data = 0 },
1453         { .id = "PNP0f1c", .driver_data = 0 },
1454         { .id = "SYN0801", .driver_data = 0 },
1455         { .id = "", },
1456 };
1457 MODULE_DEVICE_TABLE(pnp, pnp_aux_devids);
1458
1459 static struct pnp_driver i8042_pnp_aux_driver = {
1460         .name           = "i8042 aux",
1461         .id_table       = pnp_aux_devids,
1462         .probe          = i8042_pnp_aux_probe,
1463         .driver         = {
1464                 .probe_type = PROBE_FORCE_SYNCHRONOUS,
1465                 .suppress_bind_attrs = true,
1466         },
1467 };
1468
1469 static void i8042_pnp_exit(void)
1470 {
1471         if (i8042_pnp_kbd_registered) {
1472                 i8042_pnp_kbd_registered = false;
1473                 pnp_unregister_driver(&i8042_pnp_kbd_driver);
1474         }
1475
1476         if (i8042_pnp_aux_registered) {
1477                 i8042_pnp_aux_registered = false;
1478                 pnp_unregister_driver(&i8042_pnp_aux_driver);
1479         }
1480 }
1481
1482 static int __init i8042_pnp_init(void)
1483 {
1484         char kbd_irq_str[4] = { 0 }, aux_irq_str[4] = { 0 };
1485         bool pnp_data_busted = false;
1486         int err;
1487
1488         if (i8042_nopnp) {
1489                 pr_info("PNP detection disabled\n");
1490                 return 0;
1491         }
1492
1493         err = pnp_register_driver(&i8042_pnp_kbd_driver);
1494         if (!err)
1495                 i8042_pnp_kbd_registered = true;
1496
1497         err = pnp_register_driver(&i8042_pnp_aux_driver);
1498         if (!err)
1499                 i8042_pnp_aux_registered = true;
1500
1501         if (!i8042_pnp_kbd_devices && !i8042_pnp_aux_devices) {
1502                 i8042_pnp_exit();
1503 #if defined(__ia64__)
1504                 return -ENODEV;
1505 #else
1506                 pr_info("PNP: No PS/2 controller found.\n");
1507 #if defined(__loongarch__)
1508                 if (acpi_disabled == 0)
1509                         return -ENODEV;
1510 #else
1511                 if (x86_platform.legacy.i8042 !=
1512                                 X86_LEGACY_I8042_EXPECTED_PRESENT)
1513                         return -ENODEV;
1514 #endif
1515                 pr_info("Probing ports directly.\n");
1516                 return 0;
1517 #endif
1518         }
1519
1520         if (i8042_pnp_kbd_devices)
1521                 snprintf(kbd_irq_str, sizeof(kbd_irq_str),
1522                         "%d", i8042_pnp_kbd_irq);
1523         if (i8042_pnp_aux_devices)
1524                 snprintf(aux_irq_str, sizeof(aux_irq_str),
1525                         "%d", i8042_pnp_aux_irq);
1526
1527         pr_info("PNP: PS/2 Controller [%s%s%s] at %#x,%#x irq %s%s%s\n",
1528                 i8042_pnp_kbd_name, (i8042_pnp_kbd_devices && i8042_pnp_aux_devices) ? "," : "",
1529                 i8042_pnp_aux_name,
1530                 i8042_pnp_data_reg, i8042_pnp_command_reg,
1531                 kbd_irq_str, (i8042_pnp_kbd_devices && i8042_pnp_aux_devices) ? "," : "",
1532                 aux_irq_str);
1533
1534 #if defined(__ia64__)
1535         if (!i8042_pnp_kbd_devices)
1536                 i8042_nokbd = true;
1537         if (!i8042_pnp_aux_devices)
1538                 i8042_noaux = true;
1539 #endif
1540
1541         if (((i8042_pnp_data_reg & ~0xf) == (i8042_data_reg & ~0xf) &&
1542               i8042_pnp_data_reg != i8042_data_reg) ||
1543             !i8042_pnp_data_reg) {
1544                 pr_warn("PNP: PS/2 controller has invalid data port %#x; using default %#x\n",
1545                         i8042_pnp_data_reg, i8042_data_reg);
1546                 i8042_pnp_data_reg = i8042_data_reg;
1547                 pnp_data_busted = true;
1548         }
1549
1550         if (((i8042_pnp_command_reg & ~0xf) == (i8042_command_reg & ~0xf) &&
1551               i8042_pnp_command_reg != i8042_command_reg) ||
1552             !i8042_pnp_command_reg) {
1553                 pr_warn("PNP: PS/2 controller has invalid command port %#x; using default %#x\n",
1554                         i8042_pnp_command_reg, i8042_command_reg);
1555                 i8042_pnp_command_reg = i8042_command_reg;
1556                 pnp_data_busted = true;
1557         }
1558
1559         if (!i8042_nokbd && !i8042_pnp_kbd_irq) {
1560                 pr_warn("PNP: PS/2 controller doesn't have KBD irq; using default %d\n",
1561                         i8042_kbd_irq);
1562                 i8042_pnp_kbd_irq = i8042_kbd_irq;
1563                 pnp_data_busted = true;
1564         }
1565
1566         if (!i8042_noaux && !i8042_pnp_aux_irq) {
1567                 if (!pnp_data_busted && i8042_pnp_kbd_irq) {
1568                         pr_warn("PNP: PS/2 appears to have AUX port disabled, "
1569                                 "if this is incorrect please boot with i8042.nopnp\n");
1570                         i8042_noaux = true;
1571                 } else {
1572                         pr_warn("PNP: PS/2 controller doesn't have AUX irq; using default %d\n",
1573                                 i8042_aux_irq);
1574                         i8042_pnp_aux_irq = i8042_aux_irq;
1575                 }
1576         }
1577
1578         i8042_data_reg = i8042_pnp_data_reg;
1579         i8042_command_reg = i8042_pnp_command_reg;
1580         i8042_kbd_irq = i8042_pnp_kbd_irq;
1581         i8042_aux_irq = i8042_pnp_aux_irq;
1582
1583 #ifdef CONFIG_X86
1584         i8042_bypass_aux_irq_test = !pnp_data_busted &&
1585                                     dmi_check_system(i8042_dmi_laptop_table);
1586 #endif
1587
1588         return 0;
1589 }
1590
1591 #else  /* !CONFIG_PNP */
1592 static inline int i8042_pnp_init(void) { return 0; }
1593 static inline void i8042_pnp_exit(void) { }
1594 #endif /* CONFIG_PNP */
1595
1596
1597 #ifdef CONFIG_X86
1598 static void __init i8042_check_quirks(void)
1599 {
1600         const struct dmi_system_id *device_quirk_info;
1601         uintptr_t quirks;
1602
1603         device_quirk_info = dmi_first_match(i8042_dmi_quirk_table);
1604         if (!device_quirk_info)
1605                 return;
1606
1607         quirks = (uintptr_t)device_quirk_info->driver_data;
1608
1609         if (quirks & SERIO_QUIRK_NOKBD)
1610                 i8042_nokbd = true;
1611         if (quirks & SERIO_QUIRK_NOAUX)
1612                 i8042_noaux = true;
1613         if (quirks & SERIO_QUIRK_NOMUX)
1614                 i8042_nomux = true;
1615         if (quirks & SERIO_QUIRK_FORCEMUX)
1616                 i8042_nomux = false;
1617         if (quirks & SERIO_QUIRK_UNLOCK)
1618                 i8042_unlock = true;
1619         if (quirks & SERIO_QUIRK_PROBE_DEFER)
1620                 i8042_probe_defer = true;
1621         /* Honor module parameter when value is not default */
1622         if (i8042_reset == I8042_RESET_DEFAULT) {
1623                 if (quirks & SERIO_QUIRK_RESET_ALWAYS)
1624                         i8042_reset = I8042_RESET_ALWAYS;
1625                 if (quirks & SERIO_QUIRK_RESET_NEVER)
1626                         i8042_reset = I8042_RESET_NEVER;
1627         }
1628         if (quirks & SERIO_QUIRK_DIECT)
1629                 i8042_direct = true;
1630         if (quirks & SERIO_QUIRK_DUMBKBD)
1631                 i8042_dumbkbd = true;
1632         if (quirks & SERIO_QUIRK_NOLOOP)
1633                 i8042_noloop = true;
1634         if (quirks & SERIO_QUIRK_NOTIMEOUT)
1635                 i8042_notimeout = true;
1636         if (quirks & SERIO_QUIRK_KBDRESET)
1637                 i8042_kbdreset = true;
1638         if (quirks & SERIO_QUIRK_DRITEK)
1639                 i8042_dritek = true;
1640 #ifdef CONFIG_PNP
1641         if (quirks & SERIO_QUIRK_NOPNP)
1642                 i8042_nopnp = true;
1643 #endif
1644 }
1645 #else
1646 static inline void i8042_check_quirks(void) {}
1647 #endif
1648
1649 static int __init i8042_platform_init(void)
1650 {
1651         int retval;
1652
1653 #ifdef CONFIG_X86
1654         u8 a20_on = 0xdf;
1655         /* Just return if platform does not have i8042 controller */
1656         if (x86_platform.legacy.i8042 == X86_LEGACY_I8042_PLATFORM_ABSENT)
1657                 return -ENODEV;
1658 #endif
1659
1660 /*
1661  * On ix86 platforms touching the i8042 data register region can do really
1662  * bad things. Because of this the region is always reserved on ix86 boxes.
1663  *
1664  *      if (!request_region(I8042_DATA_REG, 16, "i8042"))
1665  *              return -EBUSY;
1666  */
1667
1668         i8042_kbd_irq = I8042_MAP_IRQ(1);
1669         i8042_aux_irq = I8042_MAP_IRQ(12);
1670
1671 #if defined(__ia64__)
1672         i8042_reset = I8042_RESET_ALWAYS;
1673 #endif
1674
1675         i8042_check_quirks();
1676
1677         pr_debug("Active quirks (empty means none):%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
1678                 i8042_nokbd ? " nokbd" : "",
1679                 i8042_noaux ? " noaux" : "",
1680                 i8042_nomux ? " nomux" : "",
1681                 i8042_unlock ? " unlock" : "",
1682                 i8042_probe_defer ? "probe_defer" : "",
1683                 i8042_reset == I8042_RESET_DEFAULT ?
1684                         "" : i8042_reset == I8042_RESET_ALWAYS ?
1685                                 " reset_always" : " reset_never",
1686                 i8042_direct ? " direct" : "",
1687                 i8042_dumbkbd ? " dumbkbd" : "",
1688                 i8042_noloop ? " noloop" : "",
1689                 i8042_notimeout ? " notimeout" : "",
1690                 i8042_kbdreset ? " kbdreset" : "",
1691 #ifdef CONFIG_X86
1692                 i8042_dritek ? " dritek" : "",
1693 #else
1694                 "",
1695 #endif
1696 #ifdef CONFIG_PNP
1697                 i8042_nopnp ? " nopnp" : "");
1698 #else
1699                 "");
1700 #endif
1701
1702         retval = i8042_pnp_init();
1703         if (retval)
1704                 return retval;
1705
1706 #ifdef CONFIG_X86
1707         /*
1708          * A20 was already enabled during early kernel init. But some buggy
1709          * BIOSes (in MSI Laptops) require A20 to be enabled using 8042 to
1710          * resume from S3. So we do it here and hope that nothing breaks.
1711          */
1712         i8042_command(&a20_on, 0x10d1);
1713         i8042_command(NULL, 0x00ff);    /* Null command for SMM firmware */
1714 #endif /* CONFIG_X86 */
1715
1716         return retval;
1717 }
1718
1719 static inline void i8042_platform_exit(void)
1720 {
1721         i8042_pnp_exit();
1722 }
1723
1724 #endif /* _I8042_ACPIPNPIO_H */