Loading...
1/*
2 * Generic ULPI USB transceiver support
3 *
4 * Copyright (C) 2009 Daniel Mack <daniel@caiaq.de>
5 *
6 * Based on sources from
7 *
8 * Sascha Hauer <s.hauer@pengutronix.de>
9 * Freescale Semiconductors
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26#include <linux/kernel.h>
27#include <linux/slab.h>
28#include <linux/usb.h>
29#include <linux/usb/otg.h>
30#include <linux/usb/ulpi.h>
31
32
33struct ulpi_info {
34 unsigned int id;
35 char *name;
36};
37
38#define ULPI_ID(vendor, product) (((vendor) << 16) | (product))
39#define ULPI_INFO(_id, _name) \
40 { \
41 .id = (_id), \
42 .name = (_name), \
43 }
44
45/* ULPI hardcoded IDs, used for probing */
46static struct ulpi_info ulpi_ids[] = {
47 ULPI_INFO(ULPI_ID(0x04cc, 0x1504), "NXP ISP1504"),
48 ULPI_INFO(ULPI_ID(0x0424, 0x0006), "SMSC USB331x"),
49};
50
51static int ulpi_set_otg_flags(struct otg_transceiver *otg)
52{
53 unsigned int flags = ULPI_OTG_CTRL_DP_PULLDOWN |
54 ULPI_OTG_CTRL_DM_PULLDOWN;
55
56 if (otg->flags & ULPI_OTG_ID_PULLUP)
57 flags |= ULPI_OTG_CTRL_ID_PULLUP;
58
59 /*
60 * ULPI Specification rev.1.1 default
61 * for Dp/DmPulldown is enabled.
62 */
63 if (otg->flags & ULPI_OTG_DP_PULLDOWN_DIS)
64 flags &= ~ULPI_OTG_CTRL_DP_PULLDOWN;
65
66 if (otg->flags & ULPI_OTG_DM_PULLDOWN_DIS)
67 flags &= ~ULPI_OTG_CTRL_DM_PULLDOWN;
68
69 if (otg->flags & ULPI_OTG_EXTVBUSIND)
70 flags |= ULPI_OTG_CTRL_EXTVBUSIND;
71
72 return otg_io_write(otg, flags, ULPI_OTG_CTRL);
73}
74
75static int ulpi_set_fc_flags(struct otg_transceiver *otg)
76{
77 unsigned int flags = 0;
78
79 /*
80 * ULPI Specification rev.1.1 default
81 * for XcvrSelect is Full Speed.
82 */
83 if (otg->flags & ULPI_FC_HS)
84 flags |= ULPI_FUNC_CTRL_HIGH_SPEED;
85 else if (otg->flags & ULPI_FC_LS)
86 flags |= ULPI_FUNC_CTRL_LOW_SPEED;
87 else if (otg->flags & ULPI_FC_FS4LS)
88 flags |= ULPI_FUNC_CTRL_FS4LS;
89 else
90 flags |= ULPI_FUNC_CTRL_FULL_SPEED;
91
92 if (otg->flags & ULPI_FC_TERMSEL)
93 flags |= ULPI_FUNC_CTRL_TERMSELECT;
94
95 /*
96 * ULPI Specification rev.1.1 default
97 * for OpMode is Normal Operation.
98 */
99 if (otg->flags & ULPI_FC_OP_NODRV)
100 flags |= ULPI_FUNC_CTRL_OPMODE_NONDRIVING;
101 else if (otg->flags & ULPI_FC_OP_DIS_NRZI)
102 flags |= ULPI_FUNC_CTRL_OPMODE_DISABLE_NRZI;
103 else if (otg->flags & ULPI_FC_OP_NSYNC_NEOP)
104 flags |= ULPI_FUNC_CTRL_OPMODE_NOSYNC_NOEOP;
105 else
106 flags |= ULPI_FUNC_CTRL_OPMODE_NORMAL;
107
108 /*
109 * ULPI Specification rev.1.1 default
110 * for SuspendM is Powered.
111 */
112 flags |= ULPI_FUNC_CTRL_SUSPENDM;
113
114 return otg_io_write(otg, flags, ULPI_FUNC_CTRL);
115}
116
117static int ulpi_set_ic_flags(struct otg_transceiver *otg)
118{
119 unsigned int flags = 0;
120
121 if (otg->flags & ULPI_IC_AUTORESUME)
122 flags |= ULPI_IFC_CTRL_AUTORESUME;
123
124 if (otg->flags & ULPI_IC_EXTVBUS_INDINV)
125 flags |= ULPI_IFC_CTRL_EXTERNAL_VBUS;
126
127 if (otg->flags & ULPI_IC_IND_PASSTHRU)
128 flags |= ULPI_IFC_CTRL_PASSTHRU;
129
130 if (otg->flags & ULPI_IC_PROTECT_DIS)
131 flags |= ULPI_IFC_CTRL_PROTECT_IFC_DISABLE;
132
133 return otg_io_write(otg, flags, ULPI_IFC_CTRL);
134}
135
136static int ulpi_set_flags(struct otg_transceiver *otg)
137{
138 int ret;
139
140 ret = ulpi_set_otg_flags(otg);
141 if (ret)
142 return ret;
143
144 ret = ulpi_set_ic_flags(otg);
145 if (ret)
146 return ret;
147
148 return ulpi_set_fc_flags(otg);
149}
150
151static int ulpi_check_integrity(struct otg_transceiver *otg)
152{
153 int ret, i;
154 unsigned int val = 0x55;
155
156 for (i = 0; i < 2; i++) {
157 ret = otg_io_write(otg, val, ULPI_SCRATCH);
158 if (ret < 0)
159 return ret;
160
161 ret = otg_io_read(otg, ULPI_SCRATCH);
162 if (ret < 0)
163 return ret;
164
165 if (ret != val) {
166 pr_err("ULPI integrity check: failed!");
167 return -ENODEV;
168 }
169 val = val << 1;
170 }
171
172 pr_info("ULPI integrity check: passed.\n");
173
174 return 0;
175}
176
177static int ulpi_init(struct otg_transceiver *otg)
178{
179 int i, vid, pid, ret;
180 u32 ulpi_id = 0;
181
182 for (i = 0; i < 4; i++) {
183 ret = otg_io_read(otg, ULPI_PRODUCT_ID_HIGH - i);
184 if (ret < 0)
185 return ret;
186 ulpi_id = (ulpi_id << 8) | ret;
187 }
188 vid = ulpi_id & 0xffff;
189 pid = ulpi_id >> 16;
190
191 pr_info("ULPI transceiver vendor/product ID 0x%04x/0x%04x\n", vid, pid);
192
193 for (i = 0; i < ARRAY_SIZE(ulpi_ids); i++) {
194 if (ulpi_ids[i].id == ULPI_ID(vid, pid)) {
195 pr_info("Found %s ULPI transceiver.\n",
196 ulpi_ids[i].name);
197 break;
198 }
199 }
200
201 ret = ulpi_check_integrity(otg);
202 if (ret)
203 return ret;
204
205 return ulpi_set_flags(otg);
206}
207
208static int ulpi_set_host(struct otg_transceiver *otg, struct usb_bus *host)
209{
210 unsigned int flags = otg_io_read(otg, ULPI_IFC_CTRL);
211
212 if (!host) {
213 otg->host = NULL;
214 return 0;
215 }
216
217 otg->host = host;
218
219 flags &= ~(ULPI_IFC_CTRL_6_PIN_SERIAL_MODE |
220 ULPI_IFC_CTRL_3_PIN_SERIAL_MODE |
221 ULPI_IFC_CTRL_CARKITMODE);
222
223 if (otg->flags & ULPI_IC_6PIN_SERIAL)
224 flags |= ULPI_IFC_CTRL_6_PIN_SERIAL_MODE;
225 else if (otg->flags & ULPI_IC_3PIN_SERIAL)
226 flags |= ULPI_IFC_CTRL_3_PIN_SERIAL_MODE;
227 else if (otg->flags & ULPI_IC_CARKIT)
228 flags |= ULPI_IFC_CTRL_CARKITMODE;
229
230 return otg_io_write(otg, flags, ULPI_IFC_CTRL);
231}
232
233static int ulpi_set_vbus(struct otg_transceiver *otg, bool on)
234{
235 unsigned int flags = otg_io_read(otg, ULPI_OTG_CTRL);
236
237 flags &= ~(ULPI_OTG_CTRL_DRVVBUS | ULPI_OTG_CTRL_DRVVBUS_EXT);
238
239 if (on) {
240 if (otg->flags & ULPI_OTG_DRVVBUS)
241 flags |= ULPI_OTG_CTRL_DRVVBUS;
242
243 if (otg->flags & ULPI_OTG_DRVVBUS_EXT)
244 flags |= ULPI_OTG_CTRL_DRVVBUS_EXT;
245 }
246
247 return otg_io_write(otg, flags, ULPI_OTG_CTRL);
248}
249
250struct otg_transceiver *
251otg_ulpi_create(struct otg_io_access_ops *ops,
252 unsigned int flags)
253{
254 struct otg_transceiver *otg;
255
256 otg = kzalloc(sizeof(*otg), GFP_KERNEL);
257 if (!otg)
258 return NULL;
259
260 otg->label = "ULPI";
261 otg->flags = flags;
262 otg->io_ops = ops;
263 otg->init = ulpi_init;
264 otg->set_host = ulpi_set_host;
265 otg->set_vbus = ulpi_set_vbus;
266
267 return otg;
268}
269EXPORT_SYMBOL_GPL(otg_ulpi_create);
270
1/*
2 * Generic ULPI USB transceiver support
3 *
4 * Copyright (C) 2009 Daniel Mack <daniel@caiaq.de>
5 *
6 * Based on sources from
7 *
8 * Sascha Hauer <s.hauer@pengutronix.de>
9 * Freescale Semiconductors
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26#include <linux/kernel.h>
27#include <linux/slab.h>
28#include <linux/export.h>
29#include <linux/usb.h>
30#include <linux/usb/otg.h>
31#include <linux/usb/ulpi.h>
32
33
34struct ulpi_info {
35 unsigned int id;
36 char *name;
37};
38
39#define ULPI_ID(vendor, product) (((vendor) << 16) | (product))
40#define ULPI_INFO(_id, _name) \
41 { \
42 .id = (_id), \
43 .name = (_name), \
44 }
45
46/* ULPI hardcoded IDs, used for probing */
47static struct ulpi_info ulpi_ids[] = {
48 ULPI_INFO(ULPI_ID(0x04cc, 0x1504), "NXP ISP1504"),
49 ULPI_INFO(ULPI_ID(0x0424, 0x0006), "SMSC USB331x"),
50};
51
52static int ulpi_set_otg_flags(struct usb_phy *phy)
53{
54 unsigned int flags = ULPI_OTG_CTRL_DP_PULLDOWN |
55 ULPI_OTG_CTRL_DM_PULLDOWN;
56
57 if (phy->flags & ULPI_OTG_ID_PULLUP)
58 flags |= ULPI_OTG_CTRL_ID_PULLUP;
59
60 /*
61 * ULPI Specification rev.1.1 default
62 * for Dp/DmPulldown is enabled.
63 */
64 if (phy->flags & ULPI_OTG_DP_PULLDOWN_DIS)
65 flags &= ~ULPI_OTG_CTRL_DP_PULLDOWN;
66
67 if (phy->flags & ULPI_OTG_DM_PULLDOWN_DIS)
68 flags &= ~ULPI_OTG_CTRL_DM_PULLDOWN;
69
70 if (phy->flags & ULPI_OTG_EXTVBUSIND)
71 flags |= ULPI_OTG_CTRL_EXTVBUSIND;
72
73 return usb_phy_io_write(phy, flags, ULPI_OTG_CTRL);
74}
75
76static int ulpi_set_fc_flags(struct usb_phy *phy)
77{
78 unsigned int flags = 0;
79
80 /*
81 * ULPI Specification rev.1.1 default
82 * for XcvrSelect is Full Speed.
83 */
84 if (phy->flags & ULPI_FC_HS)
85 flags |= ULPI_FUNC_CTRL_HIGH_SPEED;
86 else if (phy->flags & ULPI_FC_LS)
87 flags |= ULPI_FUNC_CTRL_LOW_SPEED;
88 else if (phy->flags & ULPI_FC_FS4LS)
89 flags |= ULPI_FUNC_CTRL_FS4LS;
90 else
91 flags |= ULPI_FUNC_CTRL_FULL_SPEED;
92
93 if (phy->flags & ULPI_FC_TERMSEL)
94 flags |= ULPI_FUNC_CTRL_TERMSELECT;
95
96 /*
97 * ULPI Specification rev.1.1 default
98 * for OpMode is Normal Operation.
99 */
100 if (phy->flags & ULPI_FC_OP_NODRV)
101 flags |= ULPI_FUNC_CTRL_OPMODE_NONDRIVING;
102 else if (phy->flags & ULPI_FC_OP_DIS_NRZI)
103 flags |= ULPI_FUNC_CTRL_OPMODE_DISABLE_NRZI;
104 else if (phy->flags & ULPI_FC_OP_NSYNC_NEOP)
105 flags |= ULPI_FUNC_CTRL_OPMODE_NOSYNC_NOEOP;
106 else
107 flags |= ULPI_FUNC_CTRL_OPMODE_NORMAL;
108
109 /*
110 * ULPI Specification rev.1.1 default
111 * for SuspendM is Powered.
112 */
113 flags |= ULPI_FUNC_CTRL_SUSPENDM;
114
115 return usb_phy_io_write(phy, flags, ULPI_FUNC_CTRL);
116}
117
118static int ulpi_set_ic_flags(struct usb_phy *phy)
119{
120 unsigned int flags = 0;
121
122 if (phy->flags & ULPI_IC_AUTORESUME)
123 flags |= ULPI_IFC_CTRL_AUTORESUME;
124
125 if (phy->flags & ULPI_IC_EXTVBUS_INDINV)
126 flags |= ULPI_IFC_CTRL_EXTERNAL_VBUS;
127
128 if (phy->flags & ULPI_IC_IND_PASSTHRU)
129 flags |= ULPI_IFC_CTRL_PASSTHRU;
130
131 if (phy->flags & ULPI_IC_PROTECT_DIS)
132 flags |= ULPI_IFC_CTRL_PROTECT_IFC_DISABLE;
133
134 return usb_phy_io_write(phy, flags, ULPI_IFC_CTRL);
135}
136
137static int ulpi_set_flags(struct usb_phy *phy)
138{
139 int ret;
140
141 ret = ulpi_set_otg_flags(phy);
142 if (ret)
143 return ret;
144
145 ret = ulpi_set_ic_flags(phy);
146 if (ret)
147 return ret;
148
149 return ulpi_set_fc_flags(phy);
150}
151
152static int ulpi_check_integrity(struct usb_phy *phy)
153{
154 int ret, i;
155 unsigned int val = 0x55;
156
157 for (i = 0; i < 2; i++) {
158 ret = usb_phy_io_write(phy, val, ULPI_SCRATCH);
159 if (ret < 0)
160 return ret;
161
162 ret = usb_phy_io_read(phy, ULPI_SCRATCH);
163 if (ret < 0)
164 return ret;
165
166 if (ret != val) {
167 pr_err("ULPI integrity check: failed!");
168 return -ENODEV;
169 }
170 val = val << 1;
171 }
172
173 pr_info("ULPI integrity check: passed.\n");
174
175 return 0;
176}
177
178static int ulpi_init(struct usb_phy *phy)
179{
180 int i, vid, pid, ret;
181 u32 ulpi_id = 0;
182
183 for (i = 0; i < 4; i++) {
184 ret = usb_phy_io_read(phy, ULPI_PRODUCT_ID_HIGH - i);
185 if (ret < 0)
186 return ret;
187 ulpi_id = (ulpi_id << 8) | ret;
188 }
189 vid = ulpi_id & 0xffff;
190 pid = ulpi_id >> 16;
191
192 pr_info("ULPI transceiver vendor/product ID 0x%04x/0x%04x\n", vid, pid);
193
194 for (i = 0; i < ARRAY_SIZE(ulpi_ids); i++) {
195 if (ulpi_ids[i].id == ULPI_ID(vid, pid)) {
196 pr_info("Found %s ULPI transceiver.\n",
197 ulpi_ids[i].name);
198 break;
199 }
200 }
201
202 ret = ulpi_check_integrity(phy);
203 if (ret)
204 return ret;
205
206 return ulpi_set_flags(phy);
207}
208
209static int ulpi_set_host(struct usb_otg *otg, struct usb_bus *host)
210{
211 struct usb_phy *phy = otg->phy;
212 unsigned int flags = usb_phy_io_read(phy, ULPI_IFC_CTRL);
213
214 if (!host) {
215 otg->host = NULL;
216 return 0;
217 }
218
219 otg->host = host;
220
221 flags &= ~(ULPI_IFC_CTRL_6_PIN_SERIAL_MODE |
222 ULPI_IFC_CTRL_3_PIN_SERIAL_MODE |
223 ULPI_IFC_CTRL_CARKITMODE);
224
225 if (phy->flags & ULPI_IC_6PIN_SERIAL)
226 flags |= ULPI_IFC_CTRL_6_PIN_SERIAL_MODE;
227 else if (phy->flags & ULPI_IC_3PIN_SERIAL)
228 flags |= ULPI_IFC_CTRL_3_PIN_SERIAL_MODE;
229 else if (phy->flags & ULPI_IC_CARKIT)
230 flags |= ULPI_IFC_CTRL_CARKITMODE;
231
232 return usb_phy_io_write(phy, flags, ULPI_IFC_CTRL);
233}
234
235static int ulpi_set_vbus(struct usb_otg *otg, bool on)
236{
237 struct usb_phy *phy = otg->phy;
238 unsigned int flags = usb_phy_io_read(phy, ULPI_OTG_CTRL);
239
240 flags &= ~(ULPI_OTG_CTRL_DRVVBUS | ULPI_OTG_CTRL_DRVVBUS_EXT);
241
242 if (on) {
243 if (phy->flags & ULPI_OTG_DRVVBUS)
244 flags |= ULPI_OTG_CTRL_DRVVBUS;
245
246 if (phy->flags & ULPI_OTG_DRVVBUS_EXT)
247 flags |= ULPI_OTG_CTRL_DRVVBUS_EXT;
248 }
249
250 return usb_phy_io_write(phy, flags, ULPI_OTG_CTRL);
251}
252
253struct usb_phy *
254otg_ulpi_create(struct usb_phy_io_ops *ops,
255 unsigned int flags)
256{
257 struct usb_phy *phy;
258 struct usb_otg *otg;
259
260 phy = kzalloc(sizeof(*phy), GFP_KERNEL);
261 if (!phy)
262 return NULL;
263
264 otg = kzalloc(sizeof(*otg), GFP_KERNEL);
265 if (!otg) {
266 kfree(phy);
267 return NULL;
268 }
269
270 phy->label = "ULPI";
271 phy->flags = flags;
272 phy->io_ops = ops;
273 phy->otg = otg;
274 phy->init = ulpi_init;
275
276 otg->phy = phy;
277 otg->set_host = ulpi_set_host;
278 otg->set_vbus = ulpi_set_vbus;
279
280 return phy;
281}
282EXPORT_SYMBOL_GPL(otg_ulpi_create);
283