pinctrl-sx150x.c (6489677f86c330404ae47703bf59d30ec4c46de9) pinctrl-sx150x.c (d977a876c655f176d9faf87fe55148ca2676d3fb)
1/*
2 * Copyright (c) 2016, BayLibre, SAS. All rights reserved.
3 * Author: Neil Armstrong <narmstrong@baylibre.com>
4 *
5 * Copyright (c) 2010, Code Aurora Forum. All rights reserved.
6 *
7 * Driver for Semtech SX150X I2C GPIO Expanders
8 *

--- 329 unchanged lines hidden (view full) ---

338 int ret;
339
340 switch (mode) {
341 case LINE_MODE_PUSH_PULL:
342 if (pctl->data->model != SX150X_789 ||
343 sx150x_pin_is_oscio(pctl, offset))
344 return 0;
345
1/*
2 * Copyright (c) 2016, BayLibre, SAS. All rights reserved.
3 * Author: Neil Armstrong <narmstrong@baylibre.com>
4 *
5 * Copyright (c) 2010, Code Aurora Forum. All rights reserved.
6 *
7 * Driver for Semtech SX150X I2C GPIO Expanders
8 *

--- 329 unchanged lines hidden (view full) ---

338 int ret;
339
340 switch (mode) {
341 case LINE_MODE_PUSH_PULL:
342 if (pctl->data->model != SX150X_789 ||
343 sx150x_pin_is_oscio(pctl, offset))
344 return 0;
345
346 mutex_lock(&pctl->lock);
347 ret = regmap_write_bits(pctl->regmap,
348 pctl->data->pri.x789.reg_drain,
349 BIT(offset), 0);
346 ret = regmap_write_bits(pctl->regmap,
347 pctl->data->pri.x789.reg_drain,
348 BIT(offset), 0);
350 mutex_unlock(&pctl->lock);
351 if (ret < 0)
352 return ret;
353 break;
354
355 case LINE_MODE_OPEN_DRAIN:
356 if (pctl->data->model != SX150X_789 ||
357 sx150x_pin_is_oscio(pctl, offset))
358 return -ENOTSUPP;
359
349 break;
350
351 case LINE_MODE_OPEN_DRAIN:
352 if (pctl->data->model != SX150X_789 ||
353 sx150x_pin_is_oscio(pctl, offset))
354 return -ENOTSUPP;
355
360 mutex_lock(&pctl->lock);
361 ret = regmap_write_bits(pctl->regmap,
362 pctl->data->pri.x789.reg_drain,
363 BIT(offset), BIT(offset));
356 ret = regmap_write_bits(pctl->regmap,
357 pctl->data->pri.x789.reg_drain,
358 BIT(offset), BIT(offset));
364 mutex_unlock(&pctl->lock);
365 if (ret < 0)
366 return ret;
367 break;
359 break;
368
369 default:
360 default:
370 return -ENOTSUPP;
361 ret = -ENOTSUPP;
362 break;
371 }
372
363 }
364
373 return 0;
365 return ret;
374}
375
376static int __sx150x_gpio_set(struct sx150x_pinctrl *pctl, unsigned int offset,
377 int value)
378{
379 return regmap_write_bits(pctl->regmap, pctl->data->reg_data,
380 BIT(offset), value ? BIT(offset) : 0);
381}
382
383static void sx150x_gpio_set(struct gpio_chip *chip, unsigned int offset,
384 int value)
385{
386 struct sx150x_pinctrl *pctl = gpiochip_get_data(chip);
387
366}
367
368static int __sx150x_gpio_set(struct sx150x_pinctrl *pctl, unsigned int offset,
369 int value)
370{
371 return regmap_write_bits(pctl->regmap, pctl->data->reg_data,
372 BIT(offset), value ? BIT(offset) : 0);
373}
374
375static void sx150x_gpio_set(struct gpio_chip *chip, unsigned int offset,
376 int value)
377{
378 struct sx150x_pinctrl *pctl = gpiochip_get_data(chip);
379
388 if (sx150x_pin_is_oscio(pctl, offset)) {
389 mutex_lock(&pctl->lock);
380 if (sx150x_pin_is_oscio(pctl, offset))
390 regmap_write(pctl->regmap,
391 pctl->data->pri.x789.reg_clock,
392 (value ? 0x1f : 0x10));
381 regmap_write(pctl->regmap,
382 pctl->data->pri.x789.reg_clock,
383 (value ? 0x1f : 0x10));
393 mutex_unlock(&pctl->lock);
394 } else {
395 mutex_lock(&pctl->lock);
384 else
396 __sx150x_gpio_set(pctl, offset, value);
385 __sx150x_gpio_set(pctl, offset, value);
397 mutex_unlock(&pctl->lock);
398 }
386
399}
400
401static int sx150x_gpio_direction_input(struct gpio_chip *chip,
402 unsigned int offset)
403{
404 struct sx150x_pinctrl *pctl = gpiochip_get_data(chip);
387}
388
389static int sx150x_gpio_direction_input(struct gpio_chip *chip,
390 unsigned int offset)
391{
392 struct sx150x_pinctrl *pctl = gpiochip_get_data(chip);
405 int ret;
406
407 if (sx150x_pin_is_oscio(pctl, offset))
408 return -EINVAL;
409
393
394 if (sx150x_pin_is_oscio(pctl, offset))
395 return -EINVAL;
396
410 mutex_lock(&pctl->lock);
411 ret = regmap_write_bits(pctl->regmap,
412 pctl->data->reg_dir,
413 BIT(offset), BIT(offset));
414 mutex_unlock(&pctl->lock);
415
416 return ret;
397 return regmap_write_bits(pctl->regmap,
398 pctl->data->reg_dir,
399 BIT(offset), BIT(offset));
417}
418
419static int sx150x_gpio_direction_output(struct gpio_chip *chip,
420 unsigned int offset, int value)
421{
422 struct sx150x_pinctrl *pctl = gpiochip_get_data(chip);
400}
401
402static int sx150x_gpio_direction_output(struct gpio_chip *chip,
403 unsigned int offset, int value)
404{
405 struct sx150x_pinctrl *pctl = gpiochip_get_data(chip);
423 int status;
406 int ret;
424
425 if (sx150x_pin_is_oscio(pctl, offset)) {
426 sx150x_gpio_set(chip, offset, value);
427 return 0;
428 }
429
407
408 if (sx150x_pin_is_oscio(pctl, offset)) {
409 sx150x_gpio_set(chip, offset, value);
410 return 0;
411 }
412
430 mutex_lock(&pctl->lock);
431 status = __sx150x_gpio_set(pctl, offset, value);
432 if (status >= 0)
433 status = regmap_write_bits(pctl->regmap,
434 pctl->data->reg_dir,
435 BIT(offset), 0);
436 mutex_unlock(&pctl->lock);
413 ret = __sx150x_gpio_set(pctl, offset, value);
414 if (ret < 0)
415 return ret;
437
416
438 return status;
417 return regmap_write_bits(pctl->regmap,
418 pctl->data->reg_dir,
419 BIT(offset), 0);
439}
440
441static void sx150x_irq_mask(struct irq_data *d)
442{
443 struct sx150x_pinctrl *pctl =
444 gpiochip_get_data(irq_data_get_irq_chip_data(d));
445 unsigned int n = d->hwirq;
446

--- 84 unchanged lines hidden (view full) ---

531 int ret;
532 u32 arg;
533 unsigned int data;
534
535 if (sx150x_pin_is_oscio(pctl, pin)) {
536 switch (param) {
537 case PIN_CONFIG_DRIVE_PUSH_PULL:
538 case PIN_CONFIG_OUTPUT:
420}
421
422static void sx150x_irq_mask(struct irq_data *d)
423{
424 struct sx150x_pinctrl *pctl =
425 gpiochip_get_data(irq_data_get_irq_chip_data(d));
426 unsigned int n = d->hwirq;
427

--- 84 unchanged lines hidden (view full) ---

512 int ret;
513 u32 arg;
514 unsigned int data;
515
516 if (sx150x_pin_is_oscio(pctl, pin)) {
517 switch (param) {
518 case PIN_CONFIG_DRIVE_PUSH_PULL:
519 case PIN_CONFIG_OUTPUT:
539 mutex_lock(&pctl->lock);
540 ret = regmap_read(pctl->regmap,
541 pctl->data->pri.x789.reg_clock,
542 &data);
520 ret = regmap_read(pctl->regmap,
521 pctl->data->pri.x789.reg_clock,
522 &data);
543 mutex_unlock(&pctl->lock);
544
545 if (ret < 0)
546 return ret;
547
548 if (param == PIN_CONFIG_DRIVE_PUSH_PULL)
549 arg = (data & 0x1f) ? 1 : 0;
550 else {
551 if ((data & 0x1f) == 0x1f)
552 arg = 1;

--- 8 unchanged lines hidden (view full) ---

561 return -ENOTSUPP;
562 }
563
564 goto out;
565 }
566
567 switch (param) {
568 case PIN_CONFIG_BIAS_PULL_DOWN:
523 if (ret < 0)
524 return ret;
525
526 if (param == PIN_CONFIG_DRIVE_PUSH_PULL)
527 arg = (data & 0x1f) ? 1 : 0;
528 else {
529 if ((data & 0x1f) == 0x1f)
530 arg = 1;

--- 8 unchanged lines hidden (view full) ---

539 return -ENOTSUPP;
540 }
541
542 goto out;
543 }
544
545 switch (param) {
546 case PIN_CONFIG_BIAS_PULL_DOWN:
569 mutex_lock(&pctl->lock);
570 ret = regmap_read(pctl->regmap,
571 pctl->data->reg_pulldn,
572 &data);
573 data &= BIT(pin);
547 ret = regmap_read(pctl->regmap,
548 pctl->data->reg_pulldn,
549 &data);
550 data &= BIT(pin);
574 mutex_unlock(&pctl->lock);
575
576 if (ret < 0)
577 return ret;
578
579 if (!ret)
580 return -EINVAL;
581
582 arg = 1;
583 break;
584
585 case PIN_CONFIG_BIAS_PULL_UP:
551
552 if (ret < 0)
553 return ret;
554
555 if (!ret)
556 return -EINVAL;
557
558 arg = 1;
559 break;
560
561 case PIN_CONFIG_BIAS_PULL_UP:
586 mutex_lock(&pctl->lock);
587 ret = regmap_read(pctl->regmap,
588 pctl->data->reg_pullup,
589 &data);
590 data &= BIT(pin);
562 ret = regmap_read(pctl->regmap,
563 pctl->data->reg_pullup,
564 &data);
565 data &= BIT(pin);
591 mutex_unlock(&pctl->lock);
592
593 if (ret < 0)
594 return ret;
595
596 if (!ret)
597 return -EINVAL;
598
599 arg = 1;
600 break;
601
602 case PIN_CONFIG_DRIVE_OPEN_DRAIN:
603 if (pctl->data->model != SX150X_789)
604 return -ENOTSUPP;
605
566
567 if (ret < 0)
568 return ret;
569
570 if (!ret)
571 return -EINVAL;
572
573 arg = 1;
574 break;
575
576 case PIN_CONFIG_DRIVE_OPEN_DRAIN:
577 if (pctl->data->model != SX150X_789)
578 return -ENOTSUPP;
579
606 mutex_lock(&pctl->lock);
607 ret = regmap_read(pctl->regmap,
608 pctl->data->pri.x789.reg_drain,
609 &data);
610 data &= BIT(pin);
580 ret = regmap_read(pctl->regmap,
581 pctl->data->pri.x789.reg_drain,
582 &data);
583 data &= BIT(pin);
611 mutex_unlock(&pctl->lock);
612
613 if (ret < 0)
614 return ret;
615
616 if (!data)
617 return -EINVAL;
618
619 arg = 1;
620 break;
621
622 case PIN_CONFIG_DRIVE_PUSH_PULL:
623 if (pctl->data->model != SX150X_789)
624 arg = true;
625 else {
584
585 if (ret < 0)
586 return ret;
587
588 if (!data)
589 return -EINVAL;
590
591 arg = 1;
592 break;
593
594 case PIN_CONFIG_DRIVE_PUSH_PULL:
595 if (pctl->data->model != SX150X_789)
596 arg = true;
597 else {
626 mutex_lock(&pctl->lock);
627 ret = regmap_read(pctl->regmap,
628 pctl->data->pri.x789.reg_drain,
629 &data);
630 data &= BIT(pin);
598 ret = regmap_read(pctl->regmap,
599 pctl->data->pri.x789.reg_drain,
600 &data);
601 data &= BIT(pin);
631 mutex_unlock(&pctl->lock);
632
633 if (ret < 0)
634 return ret;
635
636 if (data)
637 return -EINVAL;
638
639 arg = 1;

--- 48 unchanged lines hidden (view full) ---

688 continue;
689 } else
690 return -ENOTSUPP;
691 }
692
693 switch (param) {
694 case PIN_CONFIG_BIAS_PULL_PIN_DEFAULT:
695 case PIN_CONFIG_BIAS_DISABLE:
602
603 if (ret < 0)
604 return ret;
605
606 if (data)
607 return -EINVAL;
608
609 arg = 1;

--- 48 unchanged lines hidden (view full) ---

658 continue;
659 } else
660 return -ENOTSUPP;
661 }
662
663 switch (param) {
664 case PIN_CONFIG_BIAS_PULL_PIN_DEFAULT:
665 case PIN_CONFIG_BIAS_DISABLE:
696 mutex_lock(&pctl->lock);
697 ret = regmap_write_bits(pctl->regmap,
698 pctl->data->reg_pulldn,
699 BIT(pin), 0);
666 ret = regmap_write_bits(pctl->regmap,
667 pctl->data->reg_pulldn,
668 BIT(pin), 0);
700 mutex_unlock(&pctl->lock);
701 if (ret < 0)
702 return ret;
703
669 if (ret < 0)
670 return ret;
671
704 mutex_lock(&pctl->lock);
705 ret = regmap_write_bits(pctl->regmap,
706 pctl->data->reg_pullup,
707 BIT(pin), 0);
672 ret = regmap_write_bits(pctl->regmap,
673 pctl->data->reg_pullup,
674 BIT(pin), 0);
708 mutex_unlock(&pctl->lock);
709 if (ret < 0)
710 return ret;
711
712 break;
713
714 case PIN_CONFIG_BIAS_PULL_UP:
675 if (ret < 0)
676 return ret;
677
678 break;
679
680 case PIN_CONFIG_BIAS_PULL_UP:
715 mutex_lock(&pctl->lock);
716 ret = regmap_write_bits(pctl->regmap,
717 pctl->data->reg_pullup,
718 BIT(pin), BIT(pin));
681 ret = regmap_write_bits(pctl->regmap,
682 pctl->data->reg_pullup,
683 BIT(pin), BIT(pin));
719 mutex_unlock(&pctl->lock);
720 if (ret < 0)
721 return ret;
722
723 break;
724
725 case PIN_CONFIG_BIAS_PULL_DOWN:
684 if (ret < 0)
685 return ret;
686
687 break;
688
689 case PIN_CONFIG_BIAS_PULL_DOWN:
726 mutex_lock(&pctl->lock);
727 ret = regmap_write_bits(pctl->regmap,
728 pctl->data->reg_pulldn,
729 BIT(pin), BIT(pin));
690 ret = regmap_write_bits(pctl->regmap,
691 pctl->data->reg_pulldn,
692 BIT(pin), BIT(pin));
730 mutex_unlock(&pctl->lock);
731 if (ret < 0)
732 return ret;
733
734 break;
735
736 case PIN_CONFIG_DRIVE_OPEN_DRAIN:
737 ret = sx150x_gpio_set_single_ended(&pctl->gpio,
738 pin, LINE_MODE_OPEN_DRAIN);

--- 429 unchanged lines hidden --- 		693 if (ret < 0)
694 return ret;
695
696 break;
697
698 case PIN_CONFIG_DRIVE_OPEN_DRAIN:
699 ret = sx150x_gpio_set_single_ended(&pctl->gpio,
700 pin, LINE_MODE_OPEN_DRAIN);

--- 429 unchanged lines hidden ---