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