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
|
/*
* Copyright 2005-2007 Freescale Semiconductor, Inc. All Rights Reserved.
*/
/*
* The code contained herein is licensed under the GNU General Public
* License. You may obtain a copy of the GNU General Public License
* Version 2 or later at the following locations:
*
* http://www.opensource.org/licenses/gpl-license.html
* http://www.gnu.org/copyleft/gpl.html
*/
#include <linux/kernel.h>
#include <asm/arch/hardware.h>
#include <asm/arch/pmic_external.h>
#include <asm/arch/pmic_convity.h>
#include <asm/arch/arc_otg.h>
#include <linux/platform_device.h>
#include <linux/usb/fsl_xcvr.h>
#include <linux/delay.h>
#define ID_GND (1UL << 0) /*!< ID is grounded */
#define A_SESS_VLD (1UL << 1) /*!< Vbus greater than Session valid threshold */
#define B_SESS_VLD (1UL << 2) /*!< Vbus greater than B-Session Valid threshold */
#define VBUS_VLD (1UL << 3) /*!< Vbus greater than A-Device Vbus Valid threshold */
#define B_SESS_END (1UL << 4) /*!< Vbus less than B-Session end thresshold */
#define TRUE 1
#define FALSE 0
static inline void mc13783_set_host(void);
static inline void mc13783_set_peripheral(void);
PMIC_CONVITY_HANDLE pmic_handle = (PMIC_CONVITY_HANDLE) NULL;
extern void otg_set_serial_peripheral(void);
extern void otg_set_serial_host(void);
static void pmic_event_handler(const PMIC_CONVITY_EVENTS event)
{
if (event == USB_DETECT_MINI_B) {
otg_set_serial_peripheral();
}
if (event == USB_DETECT_MINI_A) {
otg_set_serial_host();
}
}
static int usb_pmic_mod_init(void)
{
PMIC_STATUS rs = PMIC_ERROR;
rs = pmic_convity_open(&pmic_handle, USB);
if (rs != PMIC_SUCCESS) {
printk(KERN_ERR "pmic_convity_open returned error %d\n", rs);
return rs;
}
rs = pmic_convity_set_callback(pmic_handle, pmic_event_handler,
USB_DETECT_MINI_A | USB_DETECT_MINI_B);
if (rs != PMIC_SUCCESS) {
printk(KERN_ERR
"pmic_convity_set_callback returned error %d\n", rs);
return rs;
}
return rs;
}
static void usb_pmic_mod_exit(void)
{
PMIC_STATUS rs;
pmic_convity_set_mode(pmic_handle, RS232_1);
pmic_convity_clear_callback(pmic_handle);
if (pmic_handle != (PMIC_CONVITY_HANDLE) NULL) {
rs = pmic_convity_close(pmic_handle);
if (rs != PMIC_SUCCESS) {
printk(KERN_ERR
"pmic_convity_close() returned error %d", rs);
} else {
pmic_handle = (PMIC_CONVITY_HANDLE) NULL;
}
}
}
static inline void mc13783_set_host(void)
{
PMIC_STATUS rs = PMIC_ERROR;
rs = pmic_convity_usb_otg_set_config(pmic_handle, USB_UDM_PD);
rs |= pmic_convity_usb_otg_set_config(pmic_handle, USB_UDP_PD);
rs |= pmic_convity_set_output(pmic_handle, TRUE, TRUE);
rs |=
pmic_convity_usb_otg_set_config(pmic_handle,
USB_VBUS_CURRENT_LIMIT_LOW_30MS);
#ifndef CONFIG_USB_OTG
rs |= pmic_convity_usb_otg_clear_config(pmic_handle, USB_OTG_SE0CONN);
rs |= pmic_convity_usb_otg_clear_config(pmic_handle, USB_PU);
#endif
if (rs != PMIC_SUCCESS) {
printk(KERN_ERR "mc13783_set_host failed\n");
}
}
static inline void mc13783_set_peripheral(void)
{
PMIC_STATUS rs = PMIC_ERROR;
rs = pmic_convity_usb_set_speed(pmic_handle, USB_FULL_SPEED);
#ifndef CONFIG_USB_OTG
rs |= pmic_convity_usb_otg_set_config(pmic_handle, USB_OTG_SE0CONN);
rs |= pmic_convity_usb_otg_set_config(pmic_handle, USB_PU);
#endif
if (rs != PMIC_SUCCESS) {
printk(KERN_ERR "mc13783_set_peripheral failed\n");
}
}
static struct fsl_xcvr_ops mc13783_ops_otg = {
.name = "mc13783",
.xcvr_type = PORTSC_PTS_SERIAL,
.set_host = mc13783_set_host,
.set_device = mc13783_set_peripheral,
};
extern void fsl_usb_xcvr_register(struct fsl_xcvr_ops *xcvr_ops);
int mc13783xc_init(void)
{
PMIC_STATUS rs = PMIC_ERROR;
#if defined(CONFIG_MXC_USB_SB3)
int xc_mode = USB_SINGLE_ENDED_BIDIR;
#elif defined(CONFIG_MXC_USB_SU6)
int xc_mode = USB_SINGLE_ENDED_UNIDIR;
#elif defined(CONFIG_MXC_USB_DB4)
int xc_mode = USB_DIFFERENTIAL_BIDIR;
#else
int xc_mode = USB_DIFFERENTIAL_UNIDIR;
#endif
rs = usb_pmic_mod_init();
if (rs != PMIC_SUCCESS) {
usb_pmic_mod_exit();
printk(KERN_ERR "usb_pmic_mod_init failed\n");
return rs;
}
rs = pmic_convity_usb_otg_set_config(pmic_handle, USB_OTG_SE0CONN);
rs |= pmic_convity_usb_set_xcvr(pmic_handle, xc_mode);
rs |= pmic_convity_usb_otg_set_config(pmic_handle, USB_PULL_OVERRIDE);
rs |= pmic_convity_usb_otg_clear_config(pmic_handle, USB_USBCNTRL);
rs |= pmic_convity_usb_otg_set_config(pmic_handle, USBXCVREN);
rs |= pmic_convity_usb_otg_clear_config(pmic_handle, USB_DP150K_PU);
rs |= pmic_convity_set_output(pmic_handle, FALSE, TRUE);
if (rs != PMIC_SUCCESS) {
printk(KERN_ERR "pmic configuration failed\n");
}
fsl_usb_xcvr_register(&mc13783_ops_otg);
#ifdef CONFIG_USB_OTG
mc13783_set_peripheral();
mc13783_set_host();
#endif
return rs;
}
extern void fsl_usb_xcvr_unregister(struct fsl_xcvr_ops *xcvr_ops);
void mc13783xc_uninit(void)
{
pmic_convity_usb_otg_set_config(pmic_handle, USB_PULL_OVERRIDE);
pmic_convity_usb_otg_clear_config(pmic_handle, USB_OTG_SE0CONN);
pmic_convity_usb_otg_set_config(pmic_handle, USB_USBCNTRL);
pmic_convity_usb_otg_clear_config(pmic_handle, USB_UDP_PD);
pmic_convity_usb_otg_clear_config(pmic_handle, USB_UDM_PD);
usb_pmic_mod_exit();
fsl_usb_xcvr_unregister(&mc13783_ops_otg);
}
module_init(mc13783xc_init);
module_exit(mc13783xc_uninit);
MODULE_AUTHOR("Freescale Semiconductor, Inc.");
MODULE_DESCRIPTION("mc13783xc");
MODULE_LICENSE("GPL");
|
