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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
|
/* SPDX-License-Identifier: GPL-2.0-only */
#define __SIMPLE_DEVICE__
#include <console/console.h>
#include <arch/io.h>
#include <device/pnp_ops.h>
#include <device/device.h>
#include <device/pnp.h>
#include <delay.h>
#include "dock.h"
#include <superio/nsc/pc87382/pc87382.h>
#include <southbridge/intel/i82801ix/i82801ix.h>
#include <ec/lenovo/h8/h8.h>
#include <ec/acpi/ec.h>
struct pin_config {
u8 port;
u8 mode;
};
static int poll_clk_stable(pnp_devfn_t dev, int timeout)
{
/* Enable 14.318MHz CLK on CLKIN */
pnp_write_config(dev, 0x29, 0xa0);
while(!(pnp_read_config(dev, 0x29) & 0x10) && timeout--)
udelay(1000);
if (!timeout)
return 1;
return 0;
}
static int gpio_init(pnp_devfn_t gpio, u16 gpio_base,
const struct pin_config pincfg[], int num_cfgs)
{
int i;
/* Enable GPIO LDN. */
pnp_set_logical_device(gpio);
pnp_set_iobase(gpio, PNP_IDX_IO0, gpio_base);
pnp_set_enable(gpio, 1);
for (i = 0; i < num_cfgs; i++) {
pnp_write_config(gpio, 0xf0, pincfg[i].port);
pnp_write_config(gpio, 0xf1, pincfg[i].mode);
pnp_write_config(gpio, 0xf2, 0x0);
}
return 0;
}
static const pnp_devfn_t l_dlpc = PNP_DEV(0x164e, PC87382_DOCK);
static const pnp_devfn_t l_gpio = PNP_DEV(0x164e, PC87382_GPIO);
static int pc87382_init(pnp_devfn_t dlpc, u16 dlpc_base)
{
/* Maximum 3300 LCLKs at 14.318MHz */
int timeout = 230;
/* Enable LPC bridge LDN. */
pnp_set_logical_device(dlpc);
pnp_set_iobase(dlpc, PNP_IDX_IO0, dlpc_base);
pnp_set_enable(dlpc, 1);
/* Reset docking state */
outb(0x00, dlpc_base);
outb(0x07, dlpc_base);
while (!(inb(dlpc_base) & 8) && timeout--)
udelay(1);
if (!timeout)
return 1;
return 0;
}
static void pc87382_close(pnp_devfn_t dlpc)
{
pnp_set_logical_device(dlpc);
/* Disconnect LPC bus */
u16 dlpc_base = pnp_read_iobase(dlpc, PNP_IDX_IO0);
if (dlpc_base) {
outb(0x00, dlpc_base);
pnp_set_enable(dlpc, 0);
}
}
static const struct pin_config local_gpio[] = {
{0x00, 3}, {0x01, 3}, {0x02, 0}, {0x03, 3},
{0x04, 4}, {0x20, 4}, {0x21, 4}, {0x23, 4},
};
/* Enable internal clock and configure GPIO LDN */
int pc87382_early(void)
{
/* Wake-up time is 33 msec (maximum). */
if (poll_clk_stable(l_gpio, 33) != 0)
return 1;
/* Set up GPIOs */
if (gpio_init(l_gpio, DLPC_GPIO_BASE,
local_gpio, ARRAY_SIZE(local_gpio)) != 0) {
return 1;
}
return 0;
}
static int pc87382_connect(void)
{
u8 reg;
reg = inb(DLPC_GPDO0);
reg |= D_PLTRST | D_LPCPD;
/* Deassert D_PLTRST# and D_LPCPD# */
outb(reg, DLPC_GPDO0);
if (pc87382_init(l_dlpc, DLPC_CONTROL) != 0)
return 1;
/* Assert D_PLTRST# */
reg &= ~D_PLTRST;
outb(reg, DLPC_GPDO0);
udelay(1000);
/* Deassert D_PLTRST# */
reg |= D_PLTRST;
outb(reg, DLPC_GPDO0);
mdelay(10);
return 0;
}
static void pc87382_disconnect(void)
{
pc87382_close(l_dlpc);
/* Assert D_PLTRST# and D_LPCPD# */
u8 reg = inb(DLPC_GPDO0);
reg &= ~(D_PLTRST | D_LPCPD);
outb(reg, DLPC_GPDO0);
}
/* Returns 3bit dock id */
static u8 dock_identify(void)
{
u8 id;
/* Make sure GPIO LDN is configured first ! */
id = (inb(DLPC_GPDI0) >> 4) & 1;
id |= (inb(DLPC_GPDI2) & 3) << 1;
return id;
}
/* Docking station side. */
#include <superio/nsc/pc87384/pc87384.h>
static const pnp_devfn_t r_gpio = PNP_DEV(SUPERIO_DEV, PC87384_GPIO);
static const pnp_devfn_t r_serial = PNP_DEV(SUPERIO_DEV, PC87384_SP1);
static const struct pin_config remote_gpio[] = {
{0x00, PC87384_GPIO_PIN_DEBOUNCE | PC87384_GPIO_PIN_PULLUP},
{0x01, PC87384_GPIO_PIN_TYPE_PUSH_PULL | PC87384_GPIO_PIN_OE},
{0x02, PC87384_GPIO_PIN_TYPE_PUSH_PULL | PC87384_GPIO_PIN_OE},
{0x03, PC87384_GPIO_PIN_DEBOUNCE | PC87384_GPIO_PIN_PULLUP},
{0x04, PC87384_GPIO_PIN_DEBOUNCE | PC87384_GPIO_PIN_PULLUP},
{0x05, PC87384_GPIO_PIN_DEBOUNCE | PC87384_GPIO_PIN_PULLUP},
{0x06, PC87384_GPIO_PIN_DEBOUNCE | PC87384_GPIO_PIN_PULLUP},
{0x07, PC87384_GPIO_PIN_DEBOUNCE | PC87384_GPIO_PIN_PULLUP},
};
static int pc87384_init(void)
{
if (poll_clk_stable(r_gpio, 1000) != 0)
return 1;
/* set GPIO pins to Serial/Parallel Port
* functions
*/
pnp_write_config(r_gpio, 0x22, 0xa9);
/* enable serial port */
if (CONFIG_TTYS0_BASE > 0) {
pnp_set_logical_device(r_serial);
pnp_set_iobase(r_serial, PNP_IDX_IO0, CONFIG_TTYS0_BASE);
pnp_set_enable(r_serial, 1);
}
if (gpio_init(r_gpio, DOCK_GPIO_BASE,
remote_gpio, ARRAY_SIZE(remote_gpio)) != 0)
return 1;
/* no GPIO events enabled for PORT0 */
outb(0x00, DOCK_GPIO_BASE + 0x02);
/* clear GPIO events on PORT0 */
outb(0xff, DOCK_GPIO_BASE + 0x03);
outb(0xff, DOCK_GPIO_BASE + 0x04);
/* no GPIO events enabled for PORT1 */
outb(0x00, DOCK_GPIO_BASE + 0x06);
/* clear GPIO events on PORT1*/
outb(0xff, DOCK_GPIO_BASE + 0x07);
outb(0x1f, DOCK_GPIO_BASE + 0x08);
outb(0xfd, DOCK_GPIO_BASE + 0x00);
return 0;
}
/* Mainboard */
void dock_connect(void)
{
const u8 id = dock_identify();
/* Dock type 2505 doesn't have serial, LPT port or LEDs */
if (id == DOCK_TYPE_NONE || id == DOCK_TYPE_2505)
return;
if (pc87382_connect() != 0 || pc87384_init() != 0) {
pc87382_disconnect();
return;
}
ec_write(H8_LED_CONTROL,
H8_LED_CONTROL_OFF | H8_LED_CONTROL_DOCK_LED1);
ec_write(H8_LED_CONTROL,
H8_LED_CONTROL_ON | H8_LED_CONTROL_DOCK_LED2);
}
void dock_disconnect(void)
{
pc87382_disconnect();
ec_write(H8_LED_CONTROL,
H8_LED_CONTROL_OFF | H8_LED_CONTROL_DOCK_LED1);
ec_write(H8_LED_CONTROL,
H8_LED_CONTROL_OFF | H8_LED_CONTROL_DOCK_LED2);
}
void dock_info(void)
{
const u8 id = dock_identify();
if (id != DOCK_TYPE_NONE)
printk(BIOS_DEBUG, "DOCK: is present: id=%d\n", id);
else
printk(BIOS_DEBUG, "DOCK: not connected\n");
}
|
