1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
/*
* Copyright (C) 2013 TangoTec Ltd.
* Author: Baruch Siach <baruch@tkos.co.il>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* Driver for the Xtensa LX4 GPIO32 Option
*
* Documentation: Xtensa LX4 Microprocessor Data Book, Section 2.22
*
* GPIO32 is a standard optional extension to the Xtensa architecture core that
* provides preconfigured output and input ports for intra SoC signaling. The
* GPIO32 option is implemented as 32bit Tensilica Instruction Extension (TIE)
* output state called EXPSTATE, and 32bit input wire called IMPWIRE. This
* driver treats input and output states as two distinct devices.
*
* Access to GPIO32 specific instructions is controlled by the CPENABLE
* (Coprocessor Enable Bits) register. By default Xtensa Linux startup code
* disables access to all coprocessors. This driver sets the CPENABLE bit
* corresponding to GPIO32 before any GPIO32 specific instruction, and restores
* CPENABLE state after that.
*
* This driver is currently incompatible with SMP. The GPIO32 extension is not
* guaranteed to be available in all cores. Moreover, each core controls a
* different set of IO wires. A theoretical SMP aware version of this driver
* would need to have a per core workqueue to do the actual GPIO manipulation.
*/
#include <linux/err.h>
#include <linux/module.h>
#include <linux/gpio.h>
#include <linux/bitops.h>
#include <linux/platform_device.h>
#include <asm/coprocessor.h> /* CPENABLE read/write macros */
#ifndef XCHAL_CP_ID_XTIOP
#error GPIO32 option is not enabled for your xtensa core variant
#endif
#if XCHAL_HAVE_CP
static inline unsigned long enable_cp(unsigned long *cpenable)
{
unsigned long flags;
local_irq_save(flags);
RSR_CPENABLE(*cpenable);
WSR_CPENABLE(*cpenable | BIT(XCHAL_CP_ID_XTIOP));
return flags;
}
static inline void disable_cp(unsigned long flags, unsigned long cpenable)
{
WSR_CPENABLE(cpenable);
local_irq_restore(flags);
}
#else
static inline unsigned long enable_cp(unsigned long *cpenable)
{
*cpenable = 0; /* avoid uninitialized value warning */
return 0;
}
static inline void disable_cp(unsigned long flags, unsigned long cpenable)
{
}
#endif /* XCHAL_HAVE_CP */
static int xtensa_impwire_get_direction(struct gpio_chip *gc, unsigned offset)
{
return 1; /* input only */
}
static int xtensa_impwire_get_value(struct gpio_chip *gc, unsigned offset)
{
unsigned long flags, saved_cpenable;
u32 impwire;
flags = enable_cp(&saved_cpenable);
__asm__ __volatile__("read_impwire %0" : "=a" (impwire));
disable_cp(flags, saved_cpenable);
return !!(impwire & BIT(offset));
}
static void xtensa_impwire_set_value(struct gpio_chip *gc, unsigned offset,
int value)
{
BUG(); /* output only; should never be called */
}
static int xtensa_expstate_get_direction(struct gpio_chip *gc, unsigned offset)
{
return 0; /* output only */
}
static int xtensa_expstate_get_value(struct gpio_chip *gc, unsigned offset)
{
unsigned long flags, saved_cpenable;
u32 expstate;
flags = enable_cp(&saved_cpenable);
__asm__ __volatile__("rur.expstate %0" : "=a" (expstate));
disable_cp(flags, saved_cpenable);
return !!(expstate & BIT(offset));
}
static void xtensa_expstate_set_value(struct gpio_chip *gc, unsigned offset,
int value)
{
unsigned long flags, saved_cpenable;
u32 mask = BIT(offset);
u32 val = value ? BIT(offset) : 0;
flags = enable_cp(&saved_cpenable);
__asm__ __volatile__("wrmsk_expstate %0, %1"
:: "a" (val), "a" (mask));
disable_cp(flags, saved_cpenable);
}
static struct gpio_chip impwire_chip = {
.label = "impwire",
.base = -1,
.ngpio = 32,
.get_direction = xtensa_impwire_get_direction,
.get = xtensa_impwire_get_value,
.set = xtensa_impwire_set_value,
};
static struct gpio_chip expstate_chip = {
.label = "expstate",
.base = -1,
.ngpio = 32,
.get_direction = xtensa_expstate_get_direction,
.get = xtensa_expstate_get_value,
.set = xtensa_expstate_set_value,
};
static int xtensa_gpio_probe(struct platform_device *pdev)
{
int ret;
ret = gpiochip_add_data(&impwire_chip, NULL);
if (ret)
return ret;
return gpiochip_add_data(&expstate_chip, NULL);
}
static struct platform_driver xtensa_gpio_driver = {
.driver = {
.name = "xtensa-gpio",
},
.probe = xtensa_gpio_probe,
};
static int __init xtensa_gpio_init(void)
{
struct platform_device *pdev;
pdev = platform_device_register_simple("xtensa-gpio", 0, NULL, 0);
if (IS_ERR(pdev))
return PTR_ERR(pdev);
return platform_driver_register(&xtensa_gpio_driver);
}
device_initcall(xtensa_gpio_init);
MODULE_AUTHOR("Baruch Siach <baruch@tkos.co.il>");
MODULE_DESCRIPTION("Xtensa LX4 GPIO32 driver");
MODULE_LICENSE("GPL");
|
