drivers/gpu/drm/amd/display/dc/gpio/gpio_service.c

   1 /*
   2  * Copyright 2012-15 Advanced Micro Devices, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * Authors: AMD
  23  *
  24  */
  25
  26 /*
  27  * Pre-requisites: headers required by header of this unit
  28  */
  29
  30 #include "dm_services.h"
  31 #include "include/gpio_interface.h"
  32 #include "include/gpio_service_interface.h"
  33 #include "hw_translate.h"
  34 #include "hw_factory.h"
  35
  36 /*
  37  * Header of this unit
  38  */
  39
  40 #include "gpio_service.h"
  41
  42 /*
  43  * Post-requisites: headers required by this unit
  44  */
  45
  46 #include "hw_gpio.h"
  47
  48 /*
  49  * @brief
  50  * Public API.
  51  */
  52
  53 struct gpio_service *dal_gpio_service_create(
  54         enum dce_version dce_version,
  55         enum dce_environment dce_environment,
  56         struct dc_context *ctx)
  57 {
  58         struct gpio_service *service;
  59         uint32_t index_of_id;
  60
  61         service = kzalloc(sizeof(struct gpio_service), GFP_KERNEL);
  62
  63         if (!service) {
  64                 BREAK_TO_DEBUGGER();
  65                 return NULL;
  66         }
  67
  68         if (!dal_hw_translate_init(&service->translate, dce_version,
  69                         dce_environment)) {
  70                 BREAK_TO_DEBUGGER();
  71                 goto failure_1;
  72         }
  73
  74         if (!dal_hw_factory_init(&service->factory, dce_version,
  75                         dce_environment)) {
  76                 BREAK_TO_DEBUGGER();
  77                 goto failure_1;
  78         }
  79
  80         /* allocate and initialize busyness storage */
  81         {
  82                 index_of_id = 0;
  83                 service->ctx = ctx;
  84
  85                 do {
  86                         uint32_t number_of_bits =
  87                                 service->factory.number_of_pins[index_of_id];
  88                         uint32_t i = 0;
  89
  90                         if (number_of_bits)  {
  91                                 service->busyness[index_of_id] =
  92                                         kcalloc(number_of_bits, sizeof(char),
  93                                                 GFP_KERNEL);
  94
  95                                 if (!service->busyness[index_of_id]) {
  96                                         BREAK_TO_DEBUGGER();
  97                                         goto failure_2;
  98                                 }
  99
 100                                 do {
 101                                         service->busyness[index_of_id][i] = 0;
 102                                         ++i;
 103                                 } while (i < number_of_bits);
 104                         } else {
 105                                 service->busyness[index_of_id] = NULL;
 106                         }
 107
 108                         ++index_of_id;
 109                 } while (index_of_id < GPIO_ID_COUNT);
 110         }
 111
 112         return service;
 113
 114 failure_2:
 115         while (index_of_id) {
 116                 --index_of_id;
 117                 kfree(service->busyness[index_of_id]);
 118         }
 119
 120 failure_1:
 121         kfree(service);
 122
 123         return NULL;
 124 }
 125
 126 struct gpio *dal_gpio_service_create_irq(
 127         struct gpio_service *service,
 128         uint32_t offset,
 129         uint32_t mask)
 130 {
 131         enum gpio_id id;
 132         uint32_t en;
 133
 134         if (!service->translate.funcs->offset_to_id(offset, mask, &id, &en)) {
 135                 ASSERT_CRITICAL(false);
 136                 return NULL;
 137         }
 138
 139         return dal_gpio_create_irq(service, id, en);
 140 }
 141
 142 struct gpio *dal_gpio_service_create_generic_mux(
 143         struct gpio_service *service,
 144         uint32_t offset,
 145         uint32_t mask)
 146 {
 147         enum gpio_id id;
 148         uint32_t en;
 149         struct gpio *generic;
 150
 151         if (!service->translate.funcs->offset_to_id(offset, mask, &id, &en)) {
 152                 ASSERT_CRITICAL(false);
 153                 return NULL;
 154         }
 155
 156         generic = dal_gpio_create(
 157                 service, id, en, GPIO_PIN_OUTPUT_STATE_DEFAULT);
 158
 159         return generic;
 160 }
 161
 162 void dal_gpio_destroy_generic_mux(
 163         struct gpio **mux)
 164 {
 165         if (!mux || !*mux) {
 166                 ASSERT_CRITICAL(false);
 167                 return;
 168         }
 169
 170         dal_gpio_destroy(mux);
 171         kfree(*mux);
 172
 173         *mux = NULL;
 174 }
 175
 176 struct gpio_pin_info dal_gpio_get_generic_pin_info(
 177         struct gpio_service *service,
 178         enum gpio_id id,
 179         uint32_t en)
 180 {
 181         struct gpio_pin_info pin;
 182
 183         if (service->translate.funcs->id_to_offset) {
 184                 service->translate.funcs->id_to_offset(id, en, &pin);
 185         } else {
 186                 pin.mask = 0xFFFFFFFF;
 187                 pin.offset = 0xFFFFFFFF;
 188         }
 189
 190         return pin;
 191 }
 192
 193 void dal_gpio_service_destroy(
 194         struct gpio_service **ptr)
 195 {
 196         if (!ptr || !*ptr) {
 197                 BREAK_TO_DEBUGGER();
 198                 return;
 199         }
 200
 201         /* free business storage */
 202         {
 203                 uint32_t index_of_id = 0;
 204
 205                 do {
 206                         kfree((*ptr)->busyness[index_of_id]);
 207
 208                         ++index_of_id;
 209                 } while (index_of_id < GPIO_ID_COUNT);
 210         }
 211
 212         kfree(*ptr);
 213
 214         *ptr = NULL;
 215 }
 216
 217 enum gpio_result dal_mux_setup_config(
 218         struct gpio *mux,
 219         struct gpio_generic_mux_config *config)
 220 {
 221         struct gpio_config_data config_data;
 222
 223         if (!config)
 224                 return GPIO_RESULT_INVALID_DATA;
 225
 226         config_data.config.generic_mux = *config;
 227         config_data.type = GPIO_CONFIG_TYPE_GENERIC_MUX;
 228
 229         return dal_gpio_set_config(mux, &config_data);
 230 }
 231
 232 /*
 233  * @brief
 234  * Private API.
 235  */
 236
 237 static bool is_pin_busy(
 238         const struct gpio_service *service,
 239         enum gpio_id id,
 240         uint32_t en)
 241 {
 242         return service->busyness[id][en];
 243 }
 244
 245 static void set_pin_busy(
 246         struct gpio_service *service,
 247         enum gpio_id id,
 248         uint32_t en)
 249 {
 250         service->busyness[id][en] = true;
 251 }
 252
 253 static void set_pin_free(
 254         struct gpio_service *service,
 255         enum gpio_id id,
 256         uint32_t en)
 257 {
 258         service->busyness[id][en] = false;
 259 }
 260
 261 enum gpio_result dal_gpio_service_lock(
 262         struct gpio_service *service,
 263         enum gpio_id id,
 264         uint32_t en)
 265 {
 266         if (!service->busyness[id]) {
 267                 ASSERT_CRITICAL(false);
 268                 return GPIO_RESULT_OPEN_FAILED;
 269         }
 270
 271         set_pin_busy(service, id, en);
 272         return GPIO_RESULT_OK;
 273 }
 274
 275 enum gpio_result dal_gpio_service_unlock(
 276         struct gpio_service *service,
 277         enum gpio_id id,
 278         uint32_t en)
 279 {
 280         if (!service->busyness[id]) {
 281                 ASSERT_CRITICAL(false);
 282                 return GPIO_RESULT_OPEN_FAILED;
 283         }
 284
 285         set_pin_free(service, id, en);
 286         return GPIO_RESULT_OK;
 287 }
 288
 289 enum gpio_result dal_gpio_service_open(
 290         struct gpio *gpio)
 291 {
 292         struct gpio_service *service = gpio->service;
 293         enum gpio_id id = gpio->id;
 294         uint32_t en = gpio->en;
 295         enum gpio_mode mode = gpio->mode;
 296
 297         struct hw_gpio_pin **pin = &gpio->pin;
 298
 299
 300         if (!service->busyness[id]) {
 301                 ASSERT_CRITICAL(false);
 302                 return GPIO_RESULT_OPEN_FAILED;
 303         }
 304
 305         if (is_pin_busy(service, id, en)) {
 306                 ASSERT_CRITICAL(false);
 307                 return GPIO_RESULT_DEVICE_BUSY;
 308         }
 309
 310         switch (id) {
 311         case GPIO_ID_DDC_DATA:
 312                 *pin = service->factory.funcs->get_ddc_pin(gpio);
 313                 service->factory.funcs->define_ddc_registers(*pin, en);
 314         break;
 315         case GPIO_ID_DDC_CLOCK:
 316                 *pin = service->factory.funcs->get_ddc_pin(gpio);
 317                 service->factory.funcs->define_ddc_registers(*pin, en);
 318         break;
 319         case GPIO_ID_GENERIC:
 320                 *pin = service->factory.funcs->get_generic_pin(gpio);
 321                 service->factory.funcs->define_generic_registers(*pin, en);
 322         break;
 323         case GPIO_ID_HPD:
 324                 *pin = service->factory.funcs->get_hpd_pin(gpio);
 325                 service->factory.funcs->define_hpd_registers(*pin, en);
 326         break;
 327
 328         //TODO: gsl and sync support? create_sync and create_gsl are NULL
 329         case GPIO_ID_SYNC:
 330         case GPIO_ID_GSL:
 331         break;
 332         default:
 333                 ASSERT_CRITICAL(false);
 334                 return GPIO_RESULT_NON_SPECIFIC_ERROR;
 335         }
 336
 337         if (!*pin) {
 338                 ASSERT_CRITICAL(false);
 339                 return GPIO_RESULT_NON_SPECIFIC_ERROR;
 340         }
 341
 342         if (!(*pin)->funcs->open(*pin, mode)) {
 343                 ASSERT_CRITICAL(false);
 344                 dal_gpio_service_close(service, pin);
 345                 return GPIO_RESULT_OPEN_FAILED;
 346         }
 347
 348         set_pin_busy(service, id, en);
 349         return GPIO_RESULT_OK;
 350 }
 351
 352 void dal_gpio_service_close(
 353         struct gpio_service *service,
 354         struct hw_gpio_pin **ptr)
 355 {
 356         struct hw_gpio_pin *pin;
 357
 358         if (!ptr) {
 359                 ASSERT_CRITICAL(false);
 360                 return;
 361         }
 362
 363         pin = *ptr;
 364
 365         if (pin) {
 366                 set_pin_free(service, pin->id, pin->en);
 367
 368                 pin->funcs->close(pin);
 369
 370                 *ptr = NULL;
 371         }
 372 }
 373
 374 enum dc_irq_source dal_irq_get_source(
 375         const struct gpio *irq)
 376 {
 377         enum gpio_id id = dal_gpio_get_id(irq);
 378
 379         switch (id) {
 380         case GPIO_ID_HPD:
 381                 return (enum dc_irq_source)(DC_IRQ_SOURCE_HPD1 +
 382                         dal_gpio_get_enum(irq));
 383         case GPIO_ID_GPIO_PAD:
 384                 return (enum dc_irq_source)(DC_IRQ_SOURCE_GPIOPAD0 +
 385                         dal_gpio_get_enum(irq));
 386         default:
 387                 return DC_IRQ_SOURCE_INVALID;
 388         }
 389 }
 390
 391 enum dc_irq_source dal_irq_get_rx_source(
 392         const struct gpio *irq)
 393 {
 394         enum gpio_id id = dal_gpio_get_id(irq);
 395
 396         switch (id) {
 397         case GPIO_ID_HPD:
 398                 return (enum dc_irq_source)(DC_IRQ_SOURCE_HPD1RX +
 399                         dal_gpio_get_enum(irq));
 400         default:
 401                 return DC_IRQ_SOURCE_INVALID;
 402         }
 403 }
 404
 405 enum gpio_result dal_irq_setup_hpd_filter(
 406         struct gpio *irq,
 407         struct gpio_hpd_config *config)
 408 {
 409         struct gpio_config_data config_data;
 410
 411         if (!config)
 412                 return GPIO_RESULT_INVALID_DATA;
 413
 414         config_data.type = GPIO_CONFIG_TYPE_HPD;
 415         config_data.config.hpd = *config;
 416
 417         return dal_gpio_set_config(irq, &config_data);
 418 }
 419
 420 /*
 421  * @brief
 422  * Creation and destruction
 423  */
 424
 425 struct gpio *dal_gpio_create_irq(
 426         struct gpio_service *service,
 427         enum gpio_id id,
 428         uint32_t en)
 429 {
 430         struct gpio *irq;
 431
 432         switch (id) {
 433         case GPIO_ID_HPD:
 434         case GPIO_ID_GPIO_PAD:
 435         break;
 436         default:
 437                 id = GPIO_ID_HPD;
 438                 ASSERT_CRITICAL(false);
 439                 return NULL;
 440         }
 441
 442         irq = dal_gpio_create(
 443                 service, id, en, GPIO_PIN_OUTPUT_STATE_DEFAULT);
 444
 445         if (irq)
 446                 return irq;
 447
 448         ASSERT_CRITICAL(false);
 449         return NULL;
 450 }
 451
 452 void dal_gpio_destroy_irq(
 453         struct gpio **irq)
 454 {
 455         if (!irq || !*irq) {
 456                 ASSERT_CRITICAL(false);
 457                 return;
 458         }
 459
 460         dal_gpio_destroy(irq);
 461         kfree(*irq);
 462
 463         *irq = NULL;
 464 }
 465
 466 struct ddc *dal_gpio_create_ddc(
 467         struct gpio_service *service,
 468         uint32_t offset,
 469         uint32_t mask,
 470         struct gpio_ddc_hw_info *info)
 471 {
 472         enum gpio_id id;
 473         uint32_t en;
 474         struct ddc *ddc;
 475
 476         if (!service->translate.funcs->offset_to_id(offset, mask, &id, &en))
 477                 return NULL;
 478
 479         ddc = kzalloc(sizeof(struct ddc), GFP_KERNEL);
 480
 481         if (!ddc) {
 482                 BREAK_TO_DEBUGGER();
 483                 return NULL;
 484         }
 485
 486         ddc->pin_data = dal_gpio_create(
 487                 service, GPIO_ID_DDC_DATA, en, GPIO_PIN_OUTPUT_STATE_DEFAULT);
 488
 489         if (!ddc->pin_data) {
 490                 BREAK_TO_DEBUGGER();
 491                 goto failure_1;
 492         }
 493
 494         ddc->pin_clock = dal_gpio_create(
 495                 service, GPIO_ID_DDC_CLOCK, en, GPIO_PIN_OUTPUT_STATE_DEFAULT);
 496
 497         if (!ddc->pin_clock) {
 498                 BREAK_TO_DEBUGGER();
 499                 goto failure_2;
 500         }
 501
 502         ddc->hw_info = *info;
 503
 504         ddc->ctx = service->ctx;
 505
 506         return ddc;
 507
 508 failure_2:
 509         dal_gpio_destroy(&ddc->pin_data);
 510
 511 failure_1:
 512         kfree(ddc);
 513
 514         return NULL;
 515 }
 516
 517 void dal_gpio_destroy_ddc(
 518         struct ddc **ddc)
 519 {
 520         if (!ddc || !*ddc) {
 521                 BREAK_TO_DEBUGGER();
 522                 return;
 523         }
 524
 525         dal_ddc_close(*ddc);
 526         dal_gpio_destroy(&(*ddc)->pin_data);
 527         dal_gpio_destroy(&(*ddc)->pin_clock);
 528         kfree(*ddc);
 529
 530         *ddc = NULL;
 531 }
 532
 533 enum gpio_result dal_ddc_open(
 534         struct ddc *ddc,
 535         enum gpio_mode mode,
 536         enum gpio_ddc_config_type config_type)
 537 {
 538         enum gpio_result result;
 539
 540         struct gpio_config_data config_data;
 541         struct hw_gpio *hw_data;
 542         struct hw_gpio *hw_clock;
 543
 544         result = dal_gpio_open_ex(ddc->pin_data, mode);
 545
 546         if (result != GPIO_RESULT_OK) {
 547                 BREAK_TO_DEBUGGER();
 548                 return result;
 549         }
 550
 551         result = dal_gpio_open_ex(ddc->pin_clock, mode);
 552
 553         if (result != GPIO_RESULT_OK) {
 554                 BREAK_TO_DEBUGGER();
 555                 goto failure;
 556         }
 557
 558         /* DDC clock and data pins should belong
 559          * to the same DDC block id,
 560          * we use the data pin to set the pad mode. */
 561
 562         if (mode == GPIO_MODE_INPUT)
 563                 /* this is from detect_sink_type,
 564                  * we need extra delay there */
 565                 config_data.type = GPIO_CONFIG_TYPE_I2C_AUX_DUAL_MODE;
 566         else
 567                 config_data.type = GPIO_CONFIG_TYPE_DDC;
 568
 569         config_data.config.ddc.type = config_type;
 570
 571         hw_data = FROM_HW_GPIO_PIN(ddc->pin_data->pin);
 572         hw_clock = FROM_HW_GPIO_PIN(ddc->pin_clock->pin);
 573
 574         config_data.config.ddc.data_en_bit_present = hw_data->store.en != 0;
 575         config_data.config.ddc.clock_en_bit_present = hw_clock->store.en != 0;
 576
 577         result = dal_gpio_set_config(ddc->pin_data, &config_data);
 578
 579         if (result == GPIO_RESULT_OK)
 580                 return result;
 581
 582         BREAK_TO_DEBUGGER();
 583
 584         dal_gpio_close(ddc->pin_clock);
 585
 586 failure:
 587         dal_gpio_close(ddc->pin_data);
 588
 589         return result;
 590 }
 591
 592 enum gpio_result dal_ddc_change_mode(
 593         struct ddc *ddc,
 594         enum gpio_mode mode)
 595 {
 596         enum gpio_result result;
 597
 598         enum gpio_mode original_mode =
 599                 dal_gpio_get_mode(ddc->pin_data);
 600
 601         result = dal_gpio_change_mode(ddc->pin_data, mode);
 602
 603         /* [anaumov] DAL2 code returns GPIO_RESULT_NON_SPECIFIC_ERROR
 604          * in case of failures;
 605          * set_mode() is so that, in case of failure,
 606          * we must explicitly set original mode */
 607
 608         if (result != GPIO_RESULT_OK)
 609                 goto failure;
 610
 611         result = dal_gpio_change_mode(ddc->pin_clock, mode);
 612
 613         if (result == GPIO_RESULT_OK)
 614                 return result;
 615
 616         dal_gpio_change_mode(ddc->pin_clock, original_mode);
 617
 618 failure:
 619         dal_gpio_change_mode(ddc->pin_data, original_mode);
 620
 621         return result;
 622 }
 623
 624 enum gpio_ddc_line dal_ddc_get_line(
 625         const struct ddc *ddc)
 626 {
 627         return (enum gpio_ddc_line)dal_gpio_get_enum(ddc->pin_data);
 628 }
 629
 630 enum gpio_result dal_ddc_set_config(
 631         struct ddc *ddc,
 632         enum gpio_ddc_config_type config_type)
 633 {
 634         struct gpio_config_data config_data;
 635
 636         config_data.type = GPIO_CONFIG_TYPE_DDC;
 637
 638         config_data.config.ddc.type = config_type;
 639         config_data.config.ddc.data_en_bit_present = false;
 640         config_data.config.ddc.clock_en_bit_present = false;
 641
 642         return dal_gpio_set_config(ddc->pin_data, &config_data);
 643 }
 644
 645 void dal_ddc_close(
 646         struct ddc *ddc)
 647 {
 648         if (ddc != NULL) {
 649                 dal_gpio_close(ddc->pin_clock);
 650                 dal_gpio_close(ddc->pin_data);
 651         }
 652 }
 653