Commit | Line | Data |
---|---|---|
6fa3eb70 S |
1 | /* system header files */ |
2 | #include <linux/kernel.h> | |
3 | #include <linux/mm.h> | |
4 | #include <linux/interrupt.h> | |
5 | #include <linux/init.h> | |
6 | #include <linux/module.h> | |
7 | #include <linux/device.h> | |
8 | #include <linux/delay.h> | |
9 | #include <linux/pm.h> | |
10 | #include <linux/mutex.h> | |
11 | #include <linux/uaccess.h> | |
12 | #include <linux/syscalls.h> | |
13 | #include <linux/mtd/nand.h> | |
14 | ||
15 | #include <asm/irq.h> | |
16 | #include <asm/io.h> | |
17 | #include <asm/mach-types.h> | |
18 | #include <asm/mach/arch.h> | |
19 | #include <asm/mach/irq.h> | |
20 | #include <asm/mach/map.h> | |
21 | #include <asm/mach/time.h> | |
22 | #include <asm/setup.h> | |
23 | ||
24 | #include <mach/system.h> | |
25 | #include <mach/board.h> | |
26 | #include <mach/hardware.h> | |
27 | #include <mach/mt_gpio.h> | |
28 | #include <mach/mt_bt.h> | |
29 | #include <mach/eint.h> | |
30 | #include <mach/mtk_rtc.h> | |
31 | #include <mach/mt_typedefs.h> | |
32 | // Fix-me: marked for early porting | |
33 | #include <cust_gpio_usage.h> | |
34 | #include <cust_eint.h> | |
35 | #include <mach/upmu_hw.h> | |
36 | #include "board-custom.h" | |
37 | #if defined(CONFIG_MTK_COMBO) || defined(CONFIG_MTK_COMBO_MODULE) | |
38 | #include <mach/mtk_wcn_cmb_stub.h> | |
39 | ||
40 | #endif | |
41 | ||
42 | #if defined(CONFIG_MTK_WCN_CMB_SDIO_SLOT) | |
43 | ||
44 | static sdio_irq_handler_t mtk_wcn_cmb_sdio_eirq_handler = NULL; | |
45 | int mtk_wcn_sdio_irq_flag_set (int falg); | |
46 | static atomic_t sdio_irq_enable_flag; | |
47 | static pm_callback_t mtk_wcn_cmb_sdio_pm_cb = NULL; | |
48 | static void *mtk_wcn_cmb_sdio_pm_data = NULL; | |
49 | static void *mtk_wcn_cmb_sdio_eirq_data = NULL; | |
50 | //static pm_message_t mt_wifi_pm_state = { .event = PM_EVENT_HIBERNATE }; | |
51 | //static int mt_wifi_pm_late_cb = 0; | |
52 | ||
53 | const static u32 mtk_wcn_cmb_sdio_eint_pin = GPIO_WIFI_EINT_PIN; | |
54 | const static u32 mtk_wcn_cmb_sdio_eint_num = CUST_EINT_WIFI_NUM; | |
55 | const static u32 mtk_wcn_cmb_sdio_eint_m_eint = GPIO_WIFI_EINT_PIN_M_EINT; | |
56 | const static u32 mtk_wcn_cmb_sdio_eint_m_gpio = GPIO_WIFI_EINT_PIN_M_GPIO; | |
57 | ||
58 | ||
59 | #if (CONFIG_MTK_WCN_CMB_SDIO_SLOT == 0) | |
60 | static unsigned char combo_port_pwr_map[4] = {0x0, 0xFF, 0xFF, 0xFF}; | |
61 | /* | |
62 | index: port number of combo chip (1:SDIO1, 2:SDIO2, no SDIO0) | |
63 | value: slot power status of (0:off, 1:on, 0xFF:invalid) | |
64 | */ | |
65 | #elif (CONFIG_MTK_WCN_CMB_SDIO_SLOT == 1) | |
66 | static unsigned char combo_port_pwr_map[4] = {0xFF, 0x0, 0xFF, 0xFF}; | |
67 | /* | |
68 | index: port number of combo chip (1:SDIO1, 2:SDIO2, no SDIO0) | |
69 | value: slot power status of (0:off, 1:on, 0xFF:invalid) | |
70 | */ | |
71 | #elif (CONFIG_MTK_WCN_CMB_SDIO_SLOT == 2) | |
72 | static unsigned char combo_port_pwr_map[4] = {0xFF, 0xFF, 0x0, 0xFF}; | |
73 | /* | |
74 | index: port number of combo chip (1:SDIO1, 2:SDIO2, no SDIO0) | |
75 | value: slot power status of (0:off, 1:on, 0xFF:invalid) | |
76 | */ | |
77 | ||
78 | #elif (CONFIG_MTK_WCN_CMB_SDIO_SLOT == 3) | |
79 | static unsigned char combo_port_pwr_map[4] = {0xFF, 0xFF, 0xFF, 0x0}; | |
80 | /* | |
81 | index: port number of combo chip (1:SDIO1, 2:SDIO2, no SDIO0) | |
82 | value: slot power status of (0:off, 1:on, 0xFF:invalid) | |
83 | */ | |
84 | ||
85 | #else | |
86 | #error "unsupported CONFIG_MTK_WCN_CMB_SDIO_SLOT" CONFIG_MTK_WCN_CMB_SDIO_SLOT | |
87 | #endif | |
88 | ||
89 | #else | |
90 | #if 0 | |
91 | static sdio_irq_handler_t mt_wifi_irq_handler = NULL; | |
92 | static pm_message_t mt_wifi_pm_state = { .event = PM_EVENT_HIBERNATE }; | |
93 | static pm_callback_t mt_wifi_pm_cb = NULL; | |
94 | static void *mt_wifi_pm_data = NULL; | |
95 | static void *mt_wifi_irq_data = NULL; | |
96 | static int mt_wifi_pm_late_cb = 0; | |
97 | #endif | |
98 | /* temp solution to avoid compile error */ | |
99 | ||
100 | #ifndef CUST_EINT_WIFI_NUM | |
101 | #define CUST_EINT_WIFI_NUM 0 | |
102 | #endif | |
103 | ||
104 | #ifndef CUST_EINT_WIFI_TYPE | |
105 | #define CUST_EINT_WIFI_TYPE 0 | |
106 | #endif | |
107 | ||
108 | #endif | |
109 | /*=======================================================================*/ | |
110 | /* Board Specific Devices Power Management */ | |
111 | /*=======================================================================*/ | |
112 | extern kal_bool pmic_chrdet_status(void); | |
113 | extern U32 pmic_config_interface (U32 RegNum, U32 val, U32 MASK, U32 SHIFT); | |
114 | extern U32 pmic_read_interface (U32 RegNum, U32 *val, U32 MASK, U32 SHIFT); | |
115 | ||
116 | void mt_power_off(void) | |
117 | { | |
118 | #ifdef CONFIG_MTK_PMIC_MT6397 | |
119 | int ret_val=0; | |
120 | int reg_val=0; | |
121 | #endif | |
122 | ||
123 | printk("mt_power_off\n"); | |
124 | ||
125 | #ifdef CONFIG_MTK_PMIC_MT6397 | |
126 | //Enable CA15 by default for different PMIC behavior | |
127 | pmic_config_interface(VCA15_CON7, 0x1, PMIC_VCA15_EN_MASK, PMIC_VCA15_EN_SHIFT); | |
128 | pmic_config_interface(VSRMCA15_CON7, 0x1, PMIC_VSRMCA15_EN_MASK, PMIC_VSRMCA15_EN_SHIFT); | |
129 | udelay(200); | |
130 | ||
131 | ret_val=pmic_read_interface(VCA15_CON7, ®_val, 0xFFFF, 0); | |
132 | printk("Reg[0x%x]=0x%x\n", VCA15_CON7, reg_val); | |
133 | ret_val=pmic_read_interface(VSRMCA15_CON7, ®_val, 0xFFFF, 0); | |
134 | printk("Reg[0x%x]=0x%x\n", VSRMCA15_CON7, reg_val); | |
135 | #endif | |
136 | /* pull PWRBB low */ | |
137 | rtc_bbpu_power_down(); | |
138 | ||
139 | while (1) { | |
140 | #if defined(CONFIG_POWER_EXT) | |
141 | //EVB | |
142 | printk("EVB without charger\n"); | |
143 | #else | |
144 | //Phone | |
145 | printk("Phone with charger\n"); | |
146 | if (pmic_chrdet_status() == KAL_TRUE) | |
147 | arch_reset(0, "power_off_with_charger"); | |
148 | #endif | |
149 | } | |
150 | } | |
151 | ||
152 | /*=======================================================================*/ | |
153 | /* Board Specific Devices */ | |
154 | /*=======================================================================*/ | |
155 | /*GPS driver*/ | |
156 | /*FIXME: remove mt3326 notation */ | |
157 | struct mt3326_gps_hardware mt3326_gps_hw = { | |
158 | .ext_power_on = NULL, | |
159 | .ext_power_off = NULL, | |
160 | }; | |
161 | ||
162 | /*=======================================================================*/ | |
163 | /* Board Specific Devices Init */ | |
164 | /*=======================================================================*/ | |
165 | #ifdef MTK_BT_SUPPORT | |
166 | void mt_bt_power_on(void) | |
167 | { | |
168 | printk(KERN_INFO "+mt_bt_power_on\n"); | |
169 | ||
170 | #if defined(CONFIG_MTK_COMBO) || defined(CONFIG_MTK_COMBO_MODULE) | |
171 | /* combo chip product */ | |
172 | /* | |
173 | * Ignore rfkill0/state call. Controll BT power on/off through device /dev/stpbt. | |
174 | */ | |
175 | #else | |
176 | /* standalone product */ | |
177 | #endif | |
178 | ||
179 | printk(KERN_INFO "-mt_bt_power_on\n"); | |
180 | } | |
181 | EXPORT_SYMBOL(mt_bt_power_on); | |
182 | ||
183 | void mt_bt_power_off(void) | |
184 | { | |
185 | printk(KERN_INFO "+mt_bt_power_off\n"); | |
186 | ||
187 | #if defined(CONFIG_MTK_COMBO) || defined(CONFIG_MTK_COMBO_MODULE) | |
188 | /* combo chip product */ | |
189 | /* | |
190 | * Ignore rfkill0/state call. Controll BT power on/off through device /dev/stpbt. | |
191 | */ | |
192 | #else | |
193 | /* standalone product */ | |
194 | #endif | |
195 | ||
196 | printk(KERN_INFO "-mt_bt_power_off\n"); | |
197 | } | |
198 | EXPORT_SYMBOL(mt_bt_power_off); | |
199 | ||
200 | int mt_bt_suspend(pm_message_t state) | |
201 | { | |
202 | printk(KERN_INFO "+mt_bt_suspend\n"); | |
203 | printk(KERN_INFO "-mt_bt_suspend\n"); | |
204 | return MT_BT_OK; | |
205 | } | |
206 | ||
207 | int mt_bt_resume(pm_message_t state) | |
208 | { | |
209 | printk(KERN_INFO "+mt_bt_resume\n"); | |
210 | printk(KERN_INFO "-mt_bt_resume\n"); | |
211 | return MT_BT_OK; | |
212 | } | |
213 | #endif | |
214 | ||
215 | ||
216 | ||
217 | #if defined(CONFIG_MTK_WCN_CMB_SDIO_SLOT) | |
218 | static void mtk_wcn_cmb_sdio_enable_eirq(void) | |
219 | { | |
220 | mt_eint_unmask(mtk_wcn_cmb_sdio_eint_num);/* CUST_EINT_WIFI_NUM */ | |
221 | } | |
222 | ||
223 | static void mtk_wcn_cmb_sdio_disable_eirq(void) | |
224 | { | |
225 | mt_eint_mask(mtk_wcn_cmb_sdio_eint_num); /* CUST_EINT_WIFI_NUM */ | |
226 | } | |
227 | ||
228 | static void mtk_wcn_cmb_sdio_eirq_handler_stub(void) | |
229 | { | |
230 | if ((NULL != mtk_wcn_cmb_sdio_eirq_handler) && (0 != atomic_read(&sdio_irq_enable_flag))) { | |
231 | mtk_wcn_cmb_sdio_eirq_handler(mtk_wcn_cmb_sdio_eirq_data); | |
232 | } | |
233 | } | |
234 | ||
235 | static void mtk_wcn_cmb_sdio_request_eirq(sdio_irq_handler_t irq_handler, void *data) | |
236 | { | |
237 | mtk_wcn_sdio_irq_flag_set (0); | |
238 | mtk_wcn_cmb_sdio_eirq_data = data; | |
239 | mtk_wcn_cmb_sdio_eirq_handler = irq_handler; | |
240 | #if CUST_EINT_WIFI_DEBOUNCE_EN | |
241 | mt_eint_set_hw_debounce(mtk_wcn_cmb_sdio_eint_num, CUST_EINT_WIFI_DEBOUNCE_CN); /*CUST_EINT_WIFI_NUM */ | |
242 | #endif | |
243 | mt_set_gpio_pull_enable(mtk_wcn_cmb_sdio_eint_pin, GPIO_PULL_ENABLE); | |
244 | mt_set_gpio_pull_select(mtk_wcn_cmb_sdio_eint_pin, GPIO_PULL_UP); | |
245 | mt_eint_registration(mtk_wcn_cmb_sdio_eint_num/*CUST_EINT_WIFI_NUM */, | |
246 | CUST_EINT_WIFI_TYPE, | |
247 | mtk_wcn_cmb_sdio_eirq_handler_stub, | |
248 | 0); | |
249 | mt_eint_mask(mtk_wcn_cmb_sdio_eint_num);/*CUST_EINT_WIFI_NUM */ | |
250 | ||
251 | } | |
252 | ||
253 | static void mtk_wcn_cmb_sdio_register_pm(pm_callback_t pm_cb, void *data) | |
254 | { | |
255 | printk( KERN_INFO "mtk_wcn_cmb_sdio_register_pm (0x%p, 0x%p)\n", pm_cb, data); | |
256 | /* register pm change callback */ | |
257 | mtk_wcn_cmb_sdio_pm_cb = pm_cb; | |
258 | mtk_wcn_cmb_sdio_pm_data = data; | |
259 | } | |
260 | ||
261 | static void mtk_wcn_cmb_sdio_on (int sdio_port_num) { | |
262 | pm_message_t state = { .event = PM_EVENT_USER_RESUME }; | |
263 | ||
264 | printk(KERN_INFO "mtk_wcn_cmb_sdio_on (%d) \n", sdio_port_num); | |
265 | ||
266 | /* 1. disable sdio eirq */ | |
267 | mtk_wcn_cmb_sdio_disable_eirq(); | |
268 | mt_set_gpio_pull_enable(mtk_wcn_cmb_sdio_eint_pin, GPIO_PULL_DISABLE); /* GPIO_WIFI_EINT_PIN */ | |
269 | mt_set_gpio_mode(mtk_wcn_cmb_sdio_eint_pin, mtk_wcn_cmb_sdio_eint_m_eint); /* EINT mode */ | |
270 | ||
271 | /* 2. call sd callback */ | |
272 | if (mtk_wcn_cmb_sdio_pm_cb) { | |
273 | //printk(KERN_INFO "mtk_wcn_cmb_sdio_pm_cb(PM_EVENT_USER_RESUME, 0x%p, 0x%p) \n", mtk_wcn_cmb_sdio_pm_cb, mtk_wcn_cmb_sdio_pm_data); | |
274 | mtk_wcn_cmb_sdio_pm_cb(state, mtk_wcn_cmb_sdio_pm_data); | |
275 | } | |
276 | else { | |
277 | printk(KERN_WARNING "mtk_wcn_cmb_sdio_on no sd callback!!\n"); | |
278 | } | |
279 | } | |
280 | ||
281 | static void mtk_wcn_cmb_sdio_off (int sdio_port_num) { | |
282 | pm_message_t state = { .event = PM_EVENT_USER_SUSPEND }; | |
283 | ||
284 | printk(KERN_INFO "mtk_wcn_cmb_sdio_off (%d) \n", sdio_port_num); | |
285 | ||
286 | /* 1. call sd callback */ | |
287 | if (mtk_wcn_cmb_sdio_pm_cb) { | |
288 | //printk(KERN_INFO "mtk_wcn_cmb_sdio_off(PM_EVENT_USER_SUSPEND, 0x%p, 0x%p) \n", mtk_wcn_cmb_sdio_pm_cb, mtk_wcn_cmb_sdio_pm_data); | |
289 | mtk_wcn_cmb_sdio_pm_cb(state, mtk_wcn_cmb_sdio_pm_data); | |
290 | } | |
291 | else { | |
292 | printk(KERN_WARNING "mtk_wcn_cmb_sdio_off no sd callback!!\n"); | |
293 | } | |
294 | ||
295 | /* 2. disable sdio eirq */ | |
296 | mtk_wcn_cmb_sdio_disable_eirq(); | |
297 | /*printk(KERN_INFO "[mt6620] set WIFI_EINT input pull down\n");*/ | |
298 | mt_set_gpio_mode(mtk_wcn_cmb_sdio_eint_pin, mtk_wcn_cmb_sdio_eint_m_gpio); /* GPIO mode */ | |
299 | mt_set_gpio_dir(mtk_wcn_cmb_sdio_eint_pin, GPIO_DIR_IN); | |
300 | mt_set_gpio_pull_select(mtk_wcn_cmb_sdio_eint_pin, GPIO_PULL_UP); | |
301 | mt_set_gpio_pull_enable(mtk_wcn_cmb_sdio_eint_pin, GPIO_PULL_ENABLE); | |
302 | } | |
303 | ||
304 | int board_sdio_ctrl (unsigned int sdio_port_num, unsigned int on) { | |
305 | #if defined(CONFIG_MTK_WCN_CMB_SDIO_SLOT) | |
306 | sdio_port_num = CONFIG_MTK_WCN_CMB_SDIO_SLOT; | |
307 | printk(KERN_WARNING "mt_combo_sdio_ctrl: force set sdio port to (%d)\n", sdio_port_num); | |
308 | #endif | |
309 | if ((sdio_port_num >= 4) || (combo_port_pwr_map[sdio_port_num] == 0xFF) ) { | |
310 | /* invalid sdio port number or slot mapping */ | |
311 | printk(KERN_WARNING "mt_mtk_wcn_cmb_sdio_ctrl invalid port(%d, %d)\n", sdio_port_num, combo_port_pwr_map[sdio_port_num]); | |
312 | return -1; | |
313 | } | |
314 | /*printk(KERN_INFO "mt_mtk_wcn_cmb_sdio_ctrl (%d, %d)\n", sdio_port_num, on);*/ | |
315 | ||
316 | if (!combo_port_pwr_map[sdio_port_num] && on) { | |
317 | printk(KERN_INFO "board_sdio_ctrl force off before on\n"); | |
318 | mtk_wcn_cmb_sdio_off(sdio_port_num); | |
319 | combo_port_pwr_map[sdio_port_num] = 0; | |
320 | /* off -> on */ | |
321 | mtk_wcn_cmb_sdio_on(sdio_port_num); | |
322 | combo_port_pwr_map[sdio_port_num] = 1; | |
323 | } | |
324 | else if (combo_port_pwr_map[sdio_port_num] && !on) { | |
325 | /* on -> off */ | |
326 | mtk_wcn_cmb_sdio_off(sdio_port_num); | |
327 | combo_port_pwr_map[sdio_port_num] = 0; | |
328 | } | |
329 | else { | |
330 | return -2; | |
331 | } | |
332 | return 0; | |
333 | } | |
334 | EXPORT_SYMBOL(board_sdio_ctrl); | |
335 | int mtk_wcn_sdio_irq_flag_set (int flag) | |
336 | { | |
337 | ||
338 | if (0 != flag) | |
339 | { | |
340 | atomic_set(&sdio_irq_enable_flag, 1); | |
341 | } | |
342 | else | |
343 | { | |
344 | atomic_set(&sdio_irq_enable_flag, 0); | |
345 | } | |
346 | printk(KERN_INFO "sdio_irq_enable_flag:%d\n", atomic_read(&sdio_irq_enable_flag)); | |
347 | ||
348 | return atomic_read(&sdio_irq_enable_flag); | |
349 | } | |
350 | EXPORT_SYMBOL(mtk_wcn_sdio_irq_flag_set); | |
351 | ||
352 | #endif | |
353 | #if defined(CONFIG_WLAN) | |
354 | #if !defined(CONFIG_MTK_WCN_CMB_SDIO_SLOT) | |
355 | #if 0 | |
356 | static void mt_wifi_enable_irq(void) | |
357 | { | |
358 | mt_eint_unmask(CUST_EINT_WIFI_NUM); | |
359 | } | |
360 | ||
361 | static void mt_wifi_disable_irq(void) | |
362 | { | |
363 | mt_eint_mask(CUST_EINT_WIFI_NUM); | |
364 | } | |
365 | ||
366 | static void mt_wifi_eirq_handler(void) | |
367 | { | |
368 | if (mt_wifi_irq_handler) { | |
369 | mt_wifi_irq_handler(mt_wifi_irq_data); | |
370 | } | |
371 | } | |
372 | ||
373 | static void mt_wifi_request_irq(sdio_irq_handler_t irq_handler, void *data) | |
374 | { | |
375 | #if CUST_EINT_WIFI_SENSITIVE | |
376 | mt_eint_set_sens(CUST_EINT_WIFI_NUM, CUST_EINT_WIFI_SENSITIVE); | |
377 | #endif | |
378 | ||
379 | #if CUST_EINT_WIFI_DEBOUNCE_EN | |
380 | mt_eint_set_hw_debounce(CUST_EINT_WIFI_NUM, CUST_EINT_WIFI_DEBOUNCE_CN); | |
381 | #endif | |
382 | mt_eint_registration(CUST_EINT_WIFI_NUM, | |
383 | CUST_EINT_WIFI_TYPE, | |
384 | mt_wifi_eirq_handler, | |
385 | 0); | |
386 | mt_eint_mask(CUST_EINT_WIFI_NUM); | |
387 | ||
388 | mt_wifi_irq_handler = irq_handler; | |
389 | mt_wifi_irq_data = data; | |
390 | } | |
391 | ||
392 | static void mt_wifi_register_pm(pm_callback_t pm_cb, void *data) | |
393 | { | |
394 | /* register pm change callback */ | |
395 | mt_wifi_pm_cb = pm_cb; | |
396 | mt_wifi_pm_data = data; | |
397 | } | |
398 | #endif | |
399 | ||
400 | #endif /* end of !defined(CONFIG_MTK_WCN_CMB_SDIO_SLOT) */ | |
401 | ||
402 | int mt_wifi_resume(pm_message_t state) | |
403 | { | |
404 | int evt = state.event; | |
405 | ||
406 | if (evt != PM_EVENT_USER_RESUME && evt != PM_EVENT_RESUME) { | |
407 | return -1; | |
408 | } | |
409 | ||
410 | /*printk(KERN_INFO "[WIFI] %s Resume\n", evt == PM_EVENT_RESUME ? "PM":"USR");*/ | |
411 | ||
412 | #if defined(CONFIG_MTK_COMBO) || defined(CONFIG_MTK_COMBO_MODULE) | |
413 | /* combo chip product: notify combo driver to turn on Wi-Fi */ | |
414 | ||
415 | ||
416 | #endif | |
417 | ||
418 | return 0; | |
419 | } | |
420 | ||
421 | int mt_wifi_suspend(pm_message_t state) | |
422 | { | |
423 | int evt = state.event; | |
424 | #if defined(CONFIG_MTK_WCN_CMB_SDIO_SLOT) | |
425 | static int is_1st_suspend_from_boot = 1; | |
426 | #endif | |
427 | ||
428 | if (evt != PM_EVENT_USER_SUSPEND && evt != PM_EVENT_SUSPEND) { | |
429 | return -1; | |
430 | } | |
431 | ||
432 | #if defined(CONFIG_MTK_COMBO) || defined(CONFIG_MTK_COMBO_MODULE) | |
433 | #if defined(CONFIG_MTK_WCN_CMB_SDIO_SLOT) | |
434 | /* combo chip product: notify combo driver to turn on Wi-Fi */ | |
435 | if (is_1st_suspend_from_boot) { | |
436 | pm_message_t state = { .event = PM_EVENT_USER_SUSPEND }; | |
437 | ||
438 | if (mtk_wcn_cmb_sdio_pm_cb) { | |
439 | is_1st_suspend_from_boot = 0; | |
440 | /* *** IMPORTANT DEPENDENDY*** | |
441 | RFKILL: set wifi and bt suspend by default in probe() | |
442 | MT6573-SD: sd host is added to MMC stack and suspend is ZERO by default | |
443 | (which means NOT suspended). | |
444 | ||
445 | When boot up, RFKILL will set wifi off and this function gets | |
446 | called. In order to successfully resume wifi at 1st time, pm_cb here | |
447 | shall be called once to let MT6573-SD do sd host suspend and remove | |
448 | sd host from MMC. Then wifi can be turned on successfully. | |
449 | ||
450 | Boot->SD host added to MMC (suspend=0)->RFKILL set wifi off | |
451 | ->SD host removed from MMC (suspend=1)->RFKILL set wifi on | |
452 | */ | |
453 | printk(KERN_INFO "1st mt_wifi_suspend (PM_EVENT_USER_SUSPEND) \n"); | |
454 | (*mtk_wcn_cmb_sdio_pm_cb)(state, mtk_wcn_cmb_sdio_pm_data); | |
455 | } | |
456 | else { | |
457 | printk(KERN_WARNING "1st mt_wifi_suspend but no sd callback!!\n"); | |
458 | } | |
459 | } | |
460 | else { | |
461 | /* combo chip product, notify combo driver */ | |
462 | } | |
463 | #endif | |
464 | ||
465 | #else | |
466 | #endif | |
467 | return 0; | |
468 | } | |
469 | ||
470 | void mt_wifi_power_on(void) | |
471 | { | |
472 | pm_message_t state = { .event = PM_EVENT_USER_RESUME }; | |
473 | ||
474 | (void)mt_wifi_resume(state); | |
475 | } | |
476 | EXPORT_SYMBOL(mt_wifi_power_on); | |
477 | ||
478 | void mt_wifi_power_off(void) | |
479 | { | |
480 | pm_message_t state = { .event = PM_EVENT_USER_SUSPEND }; | |
481 | ||
482 | (void)mt_wifi_suspend(state); | |
483 | } | |
484 | EXPORT_SYMBOL(mt_wifi_power_off); | |
485 | ||
486 | #endif /* end of defined(CONFIG_WLAN) */ | |
487 | ||
488 | /* Board Specific Devices */ | |
489 | /*=======================================================================*/ | |
490 | ||
491 | /*=======================================================================*/ | |
492 | /* Board Specific Devices Init */ | |
493 | /*=======================================================================*/ | |
494 | ||
495 | /*=======================================================================*/ | |
496 | /* Board Devices Capability */ | |
497 | /*=======================================================================*/ | |
498 | #define MSDC_SDCARD_FLAG (MSDC_SYS_SUSPEND | MSDC_WP_PIN_EN | MSDC_CD_PIN_EN | MSDC_REMOVABLE | MSDC_HIGHSPEED) | |
499 | #define MSDC_SDIO_FLAG (MSDC_EXT_SDIO_IRQ | MSDC_HIGHSPEED) | |
500 | ||
501 | #if defined(CFG_DEV_MSDC0) | |
502 | #if defined(CONFIG_MTK_WCN_CMB_SDIO_SLOT) && (CONFIG_MTK_WCN_CMB_SDIO_SLOT == 0) | |
503 | struct msdc_hw msdc0_hw = { | |
504 | .clk_src = MSDC_CLKSRC_200MHZ, | |
505 | .cmd_edge = MSDC_SMPL_FALLING, | |
506 | .rdata_edge = MSDC_SMPL_FALLING, | |
507 | .wdata_edge = MSDC_SMPL_FALLING, | |
508 | .clk_drv = 0, | |
509 | .cmd_drv = 0, | |
510 | .dat_drv = 0, | |
511 | .data_pins = 4, | |
512 | .data_offset = 0, | |
513 | //MT6620 use External IRQ, wifi uses high speed. here wifi manage his own suspend and resume, does not support hot plug | |
514 | .flags = MSDC_SDIO_FLAG,//MSDC_SYS_SUSPEND | MSDC_WP_PIN_EN | MSDC_CD_PIN_EN | MSDC_REMOVABLE,(this flag is for SD card) | |
515 | .dat0rddly = 0, | |
516 | .dat1rddly = 0, | |
517 | .dat2rddly = 0, | |
518 | .dat3rddly = 0, | |
519 | .dat4rddly = 0, | |
520 | .dat5rddly = 0, | |
521 | .dat6rddly = 0, | |
522 | .dat7rddly = 0, | |
523 | .datwrddly = 0, | |
524 | .cmdrrddly = 0, | |
525 | .cmdrddly = 0, | |
526 | .host_function = MSDC_SDIO, | |
527 | .boot = 0, | |
528 | .request_sdio_eirq = mtk_wcn_cmb_sdio_request_eirq, | |
529 | .enable_sdio_eirq = mtk_wcn_cmb_sdio_enable_eirq, | |
530 | .disable_sdio_eirq = mtk_wcn_cmb_sdio_disable_eirq, | |
531 | .register_pm = mtk_wcn_cmb_sdio_register_pm, | |
532 | }; | |
533 | #else | |
534 | struct msdc_hw msdc0_hw = { | |
535 | .clk_src = MSDC_CLKSRC_200MHZ, | |
536 | .cmd_edge = MSDC_SMPL_FALLING, | |
537 | .rdata_edge = MSDC_SMPL_FALLING, | |
538 | .wdata_edge = MSDC_SMPL_FALLING, | |
539 | .clk_drv = 4, | |
540 | .cmd_drv = 2, | |
541 | .dat_drv = 2, | |
542 | .data_pins = 8, | |
543 | .data_offset = 0, | |
544 | .flags = MSDC_SYS_SUSPEND | MSDC_HIGHSPEED | MSDC_UHS1 | MSDC_DDR, | |
545 | .dat0rddly = 0, | |
546 | .dat1rddly = 0, | |
547 | .dat2rddly = 0, | |
548 | .dat3rddly = 0, | |
549 | .dat4rddly = 0, | |
550 | .dat5rddly = 0, | |
551 | .dat6rddly = 0, | |
552 | .dat7rddly = 0, | |
553 | .datwrddly = 0, | |
554 | .cmdrrddly = 0, | |
555 | .cmdrddly = 0, | |
556 | .host_function = MSDC_EMMC, | |
557 | .boot = MSDC_BOOT_EN, | |
558 | }; | |
559 | #endif | |
560 | #endif | |
561 | #if defined(CFG_DEV_MSDC1) | |
562 | #if defined(CONFIG_MTK_WCN_CMB_SDIO_SLOT) && (CONFIG_MTK_WCN_CMB_SDIO_SLOT == 1) | |
563 | struct msdc_hw msdc1_hw = { | |
564 | .clk_src = MSDC_CLKSRC_200MHZ, | |
565 | .cmd_edge = MSDC_SMPL_FALLING, | |
566 | .rdata_edge = MSDC_SMPL_FALLING, | |
567 | .wdata_edge = MSDC_SMPL_FALLING, | |
568 | .clk_drv = 4, | |
569 | .cmd_drv = 3, | |
570 | .dat_drv = 3, | |
571 | .clk_drv_sd_18 = 4, /* sdr104 mode */ | |
572 | .cmd_drv_sd_18 = 4, | |
573 | .dat_drv_sd_18 = 4, | |
574 | .clk_drv_sd_18_sdr50 = 4, /* sdr50 mode */ | |
575 | .cmd_drv_sd_18_sdr50 = 4, | |
576 | .dat_drv_sd_18_sdr50 = 4, | |
577 | .clk_drv_sd_18_ddr50 = 4, /* ddr50 mode */ | |
578 | .cmd_drv_sd_18_ddr50 = 4, | |
579 | .dat_drv_sd_18_ddr50 = 4, | |
580 | .data_pins = 4, | |
581 | .data_offset = 0, | |
582 | .flags = MSDC_SDIO_FLAG, | |
583 | .dat0rddly = 0, | |
584 | .dat1rddly = 0, | |
585 | .dat2rddly = 0, | |
586 | .dat3rddly = 0, | |
587 | .dat4rddly = 0, | |
588 | .dat5rddly = 0, | |
589 | .dat6rddly = 0, | |
590 | .dat7rddly = 0, | |
591 | .datwrddly = 0, | |
592 | .cmdrrddly = 0, | |
593 | .cmdrddly = 0, | |
594 | .host_function = MSDC_SDIO, | |
595 | .boot = 0, | |
596 | .cd_level = MSDC_CD_LOW, | |
597 | }; | |
598 | ||
599 | ||
600 | #else | |
601 | ||
602 | struct msdc_hw msdc1_hw = { | |
603 | .clk_src = MSDC_CLKSRC_200MHZ, | |
604 | .cmd_edge = MSDC_SMPL_FALLING, | |
605 | .rdata_edge = MSDC_SMPL_FALLING, | |
606 | .wdata_edge = MSDC_SMPL_FALLING, | |
607 | .clk_drv = 6, | |
608 | .cmd_drv = 6, | |
609 | .dat_drv = 6, | |
610 | .clk_drv_sd_18 = 3, /* sdr104 mode */ | |
611 | .cmd_drv_sd_18 = 3, | |
612 | .dat_drv_sd_18 = 2, | |
613 | .clk_drv_sd_18_sdr50 = 3, /* sdr50 mode */ | |
614 | .cmd_drv_sd_18_sdr50 = 3, | |
615 | .dat_drv_sd_18_sdr50 = 2, | |
616 | .clk_drv_sd_18_ddr50 = 3, /* ddr50 mode */ | |
617 | .cmd_drv_sd_18_ddr50 = 3, | |
618 | .dat_drv_sd_18_ddr50 = 2, | |
619 | .data_pins = 4, | |
620 | .data_offset = 0, | |
621 | #ifdef CUST_EINT_MSDC1_INS_NUM | |
622 | .flags = MSDC_SYS_SUSPEND | MSDC_WP_PIN_EN | MSDC_CD_PIN_EN | MSDC_REMOVABLE | MSDC_HIGHSPEED | MSDC_UHS1 |MSDC_DDR |MSDC_SD_NEED_POWER, | |
623 | ||
624 | #else | |
625 | .flags = MSDC_SYS_SUSPEND | MSDC_WP_PIN_EN | MSDC_HIGHSPEED | MSDC_UHS1 |MSDC_DDR, | |
626 | #endif | |
627 | .dat0rddly = 0, | |
628 | .dat1rddly = 0, | |
629 | .dat2rddly = 0, | |
630 | .dat3rddly = 0, | |
631 | .dat4rddly = 0, | |
632 | .dat5rddly = 0, | |
633 | .dat6rddly = 0, | |
634 | .dat7rddly = 0, | |
635 | .datwrddly = 0, | |
636 | .cmdrrddly = 0, | |
637 | .cmdrddly = 0, | |
638 | .host_function = MSDC_SD, | |
639 | .boot = 0, | |
640 | .cd_level = MSDC_CD_LOW, | |
641 | }; | |
642 | #endif | |
643 | #endif | |
644 | #if defined(CFG_DEV_MSDC2) | |
645 | #if defined(CONFIG_MTK_WCN_CMB_SDIO_SLOT) && (CONFIG_MTK_WCN_CMB_SDIO_SLOT == 2) | |
646 | /* MSDC2 settings for MT66xx combo connectivity chip */ | |
647 | struct msdc_hw msdc2_hw = { | |
648 | .clk_src = MSDC_CLKSRC_200MHZ, | |
649 | .cmd_edge = MSDC_SMPL_FALLING, | |
650 | .rdata_edge = MSDC_SMPL_FALLING, | |
651 | .wdata_edge = MSDC_SMPL_FALLING, | |
652 | .clk_drv = 0, | |
653 | .cmd_drv = 0, | |
654 | .dat_drv = 0, | |
655 | .data_pins = 4, | |
656 | .data_offset = 0, | |
657 | //MT6620 use External IRQ, wifi uses high speed. here wifi manage his own suspend and resume, does not support hot plug | |
658 | .flags = MSDC_SDIO_FLAG,//MSDC_SYS_SUSPEND | MSDC_WP_PIN_EN | MSDC_CD_PIN_EN | MSDC_REMOVABLE, | |
659 | .dat0rddly = 0, | |
660 | .dat1rddly = 0, | |
661 | .dat2rddly = 0, | |
662 | .dat3rddly = 0, | |
663 | .dat4rddly = 0, | |
664 | .dat5rddly = 0, | |
665 | .dat6rddly = 0, | |
666 | .dat7rddly = 0, | |
667 | .datwrddly = 0, | |
668 | .cmdrrddly = 0, | |
669 | .cmdrddly = 0, | |
670 | .host_function = MSDC_SDIO, | |
671 | .boot = 0, | |
672 | .request_sdio_eirq = mtk_wcn_cmb_sdio_request_eirq, | |
673 | .enable_sdio_eirq = mtk_wcn_cmb_sdio_enable_eirq, | |
674 | .disable_sdio_eirq = mtk_wcn_cmb_sdio_disable_eirq, | |
675 | .register_pm = mtk_wcn_cmb_sdio_register_pm, | |
676 | }; | |
677 | #else | |
678 | ||
679 | #if 0 | |
680 | struct msdc_hw msdc2_hw = { | |
681 | .clk_src = MSDC_CLKSRC_200MHZ, | |
682 | .cmd_edge = MSDC_SMPL_FALLING, | |
683 | .rdata_edge = MSDC_SMPL_FALLING, | |
684 | .wdata_edge = MSDC_SMPL_FALLING, | |
685 | .clk_drv = 3, | |
686 | .cmd_drv = 2, | |
687 | .dat_drv = 2, | |
688 | .clk_drv_sd_18 = 4, | |
689 | .cmd_drv_sd_18 = 3, | |
690 | .dat_drv_sd_18 = 3, | |
691 | .data_pins = 4, | |
692 | .data_offset = 0, | |
693 | .flags = MSDC_SYS_SUSPEND | MSDC_WP_PIN_EN | MSDC_CD_PIN_EN | MSDC_REMOVABLE | MSDC_HIGHSPEED, | |
694 | .dat0rddly = 0, | |
695 | .dat1rddly = 0, | |
696 | .dat2rddly = 0, | |
697 | .dat3rddly = 0, | |
698 | .dat4rddly = 0, | |
699 | .dat5rddly = 0, | |
700 | .dat6rddly = 0, | |
701 | .dat7rddly = 0, | |
702 | .datwrddly = 0, | |
703 | .cmdrrddly = 0, | |
704 | .cmdrddly = 0, | |
705 | .host_function = MSDC_SD, | |
706 | .boot = 0, | |
707 | .cd_level = MSDC_CD_LOW, | |
708 | }; | |
709 | #endif | |
710 | #endif | |
711 | #endif | |
712 | #if defined(CFG_DEV_MSDC3) | |
713 | #if defined(CONFIG_MTK_WCN_CMB_SDIO_SLOT) && (CONFIG_MTK_WCN_CMB_SDIO_SLOT == 3) | |
714 | /* MSDC3 settings for MT66xx combo connectivity chip */ | |
715 | struct msdc_hw msdc3_hw = { | |
716 | .clk_src = MSDC_CLKSRC_200MHZ, | |
717 | .cmd_edge = MSDC_SMPL_FALLING, | |
718 | .rdata_edge = MSDC_SMPL_FALLING, | |
719 | .wdata_edge = MSDC_SMPL_FALLING, | |
720 | .clk_drv = 0, | |
721 | .cmd_drv = 0, | |
722 | .dat_drv = 0, | |
723 | .data_pins = 4, | |
724 | .data_offset = 0, | |
725 | //MT6620 use External IRQ, wifi uses high speed. here wifi manage his own suspend and resume, does not support hot plug | |
726 | .flags = MSDC_SDIO_FLAG,//MSDC_SYS_SUSPEND | MSDC_WP_PIN_EN | MSDC_CD_PIN_EN | MSDC_REMOVABLE, | |
727 | .dat0rddly = 0, | |
728 | .dat1rddly = 0, | |
729 | .dat2rddly = 0, | |
730 | .dat3rddly = 0, | |
731 | .dat4rddly = 0, | |
732 | .dat5rddly = 0, | |
733 | .dat6rddly = 0, | |
734 | .dat7rddly = 0, | |
735 | .datwrddly = 0, | |
736 | .cmdrrddly = 0, | |
737 | .cmdrddly = 0, | |
738 | .host_function = MSDC_SDIO, | |
739 | .boot = 0, | |
740 | .request_sdio_eirq = mtk_wcn_cmb_sdio_request_eirq, | |
741 | .enable_sdio_eirq = mtk_wcn_cmb_sdio_enable_eirq, | |
742 | .disable_sdio_eirq = mtk_wcn_cmb_sdio_disable_eirq, | |
743 | .register_pm = mtk_wcn_cmb_sdio_register_pm, | |
744 | }; | |
745 | #if 0 | |
746 | ||
747 | struct msdc_hw msdc3_hw = { | |
748 | .clk_src = 1, | |
749 | .cmd_edge = MSDC_SMPL_FALLING, | |
750 | .data_edge = MSDC_SMPL_FALLING, | |
751 | .clk_drv = 4, | |
752 | .cmd_drv = 4, | |
753 | .dat_drv = 4, | |
754 | .data_pins = 4, | |
755 | .data_offset = 0, | |
756 | .flags = MSDC_SDCARD_FLAG, | |
757 | .dat0rddly = 0, | |
758 | .dat1rddly = 0, | |
759 | .dat2rddly = 0, | |
760 | .dat3rddly = 0, | |
761 | .dat4rddly = 0, | |
762 | .dat5rddly = 0, | |
763 | .dat6rddly = 0, | |
764 | .dat7rddly = 0, | |
765 | .datwrddly = 0, | |
766 | .cmdrrddly = 0, | |
767 | .cmdrddly = 0, | |
768 | }; | |
769 | #endif | |
770 | #endif | |
771 | #endif | |
772 | #if defined(CFG_DEV_MSDC4) | |
773 | #if defined(CONFIG_MTK_WCN_CMB_SDIO_SLOT) && (CONFIG_MTK_WCN_CMB_SDIO_SLOT == 4) | |
774 | struct msdc_hw msdc4_hw = { | |
775 | .clk_src = MSDC_CLKSRC_200MHZ, | |
776 | .cmd_edge = MSDC_SMPL_FALLING, | |
777 | .rdata_edge = MSDC_SMPL_FALLING, | |
778 | .wdata_edge = MSDC_SMPL_FALLING, | |
779 | .clk_drv = 0, | |
780 | .cmd_drv = 0, | |
781 | .dat_drv = 0, | |
782 | .data_pins = 4, | |
783 | .data_offset = 0, | |
784 | //MT6620 use External IRQ, wifi uses high speed. here wifi manage his own suspend and resume, does not support hot plug | |
785 | .flags = MSDC_SDIO_FLAG,//MSDC_SYS_SUSPEND | MSDC_WP_PIN_EN | MSDC_CD_PIN_EN | MSDC_REMOVABLE,(this flag is for SD card) | |
786 | .dat0rddly = 0, | |
787 | .dat1rddly = 0, | |
788 | .dat2rddly = 0, | |
789 | .dat3rddly = 0, | |
790 | .dat4rddly = 0, | |
791 | .dat5rddly = 0, | |
792 | .dat6rddly = 0, | |
793 | .dat7rddly = 0, | |
794 | .datwrddly = 0, | |
795 | .cmdrrddly = 0, | |
796 | .cmdrddly = 0, | |
797 | .host_function = MSDC_SDIO, | |
798 | .boot = 0, | |
799 | .request_sdio_eirq = mtk_wcn_cmb_sdio_request_eirq, | |
800 | .enable_sdio_eirq = mtk_wcn_cmb_sdio_enable_eirq, | |
801 | .disable_sdio_eirq = mtk_wcn_cmb_sdio_disable_eirq, | |
802 | .register_pm = mtk_wcn_cmb_sdio_register_pm, | |
803 | }; | |
804 | #else | |
805 | struct msdc_hw msdc4_hw = { | |
806 | .clk_src = MSDC_CLKSRC_200MHZ, | |
807 | .cmd_edge = MSDC_SMPL_FALLING, | |
808 | .rdata_edge = MSDC_SMPL_FALLING, | |
809 | .wdata_edge = MSDC_SMPL_FALLING, | |
810 | .clk_drv = 1, | |
811 | .cmd_drv = 0, | |
812 | .dat_drv = 0, | |
813 | .data_pins = 8, | |
814 | .data_offset = 0, | |
815 | .flags = MSDC_SYS_SUSPEND | MSDC_HIGHSPEED | MSDC_UHS1 |MSDC_DDR, | |
816 | .dat0rddly = 0, | |
817 | .dat1rddly = 0, | |
818 | .dat2rddly = 0, | |
819 | .dat3rddly = 0, | |
820 | .dat4rddly = 0, | |
821 | .dat5rddly = 0, | |
822 | .dat6rddly = 0, | |
823 | .dat7rddly = 0, | |
824 | .datwrddly = 0, | |
825 | .cmdrrddly = 0, | |
826 | .cmdrddly = 0, | |
827 | .host_function = MSDC_EMMC, | |
828 | .boot = MSDC_BOOT_EN, | |
829 | }; | |
830 | #endif | |
831 | #endif | |
832 | ||
833 | /* MT6575 NAND Driver */ | |
834 | #if defined(CONFIG_MTK_MTD_NAND) | |
835 | struct mtk_nand_host_hw mtk_nand_hw = { | |
836 | .nfi_bus_width = 8, | |
837 | .nfi_access_timing = NFI_DEFAULT_ACCESS_TIMING, | |
838 | .nfi_cs_num = NFI_CS_NUM, | |
839 | .nand_sec_size = 512, | |
840 | .nand_sec_shift = 9, | |
841 | .nand_ecc_size = 2048, | |
842 | .nand_ecc_bytes = 32, | |
843 | .nand_ecc_mode = NAND_ECC_HW, | |
844 | }; | |
845 | #endif |