~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/arm/mach-omap2/board-n8x0.c

Version: ~ [ linux-5.3 ] ~ [ linux-5.2.15 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.73 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.144 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.193 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.193 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.73 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * linux/arch/arm/mach-omap2/board-n8x0.c
  3  *
  4  * Copyright (C) 2005-2009 Nokia Corporation
  5  * Author: Juha Yrjola <juha.yrjola@nokia.com>
  6  *
  7  * Modified from mach-omap2/board-generic.c
  8  *
  9  * This program is free software; you can redistribute it and/or modify
 10  * it under the terms of the GNU General Public License version 2 as
 11  * published by the Free Software Foundation.
 12  */
 13 
 14 #include <linux/clk.h>
 15 #include <linux/delay.h>
 16 #include <linux/gpio.h>
 17 #include <linux/init.h>
 18 #include <linux/io.h>
 19 #include <linux/irq.h>
 20 #include <linux/stddef.h>
 21 #include <linux/i2c.h>
 22 #include <linux/spi/spi.h>
 23 #include <linux/usb/musb.h>
 24 #include <linux/mmc/host.h>
 25 #include <linux/platform_data/spi-omap2-mcspi.h>
 26 #include <linux/platform_data/mmc-omap.h>
 27 #include <linux/mfd/menelaus.h>
 28 #include <sound/tlv320aic3x.h>
 29 
 30 #include <asm/mach/arch.h>
 31 #include <asm/mach-types.h>
 32 
 33 #include "common.h"
 34 #include "mmc.h"
 35 #include "soc.h"
 36 #include "common-board-devices.h"
 37 
 38 #define TUSB6010_ASYNC_CS       1
 39 #define TUSB6010_SYNC_CS        4
 40 #define TUSB6010_GPIO_INT       58
 41 #define TUSB6010_GPIO_ENABLE    0
 42 #define TUSB6010_DMACHAN        0x3f
 43 
 44 #define NOKIA_N810_WIMAX        (1 << 2)
 45 #define NOKIA_N810              (1 << 1)
 46 #define NOKIA_N800              (1 << 0)
 47 
 48 static u32 board_caps;
 49 
 50 #define board_is_n800()         (board_caps & NOKIA_N800)
 51 #define board_is_n810()         (board_caps & NOKIA_N810)
 52 #define board_is_n810_wimax()   (board_caps & NOKIA_N810_WIMAX)
 53 
 54 static void board_check_revision(void)
 55 {
 56         if (of_have_populated_dt()) {
 57                 if (of_machine_is_compatible("nokia,n800"))
 58                         board_caps = NOKIA_N800;
 59                 else if (of_machine_is_compatible("nokia,n810"))
 60                         board_caps = NOKIA_N810;
 61                 else if (of_machine_is_compatible("nokia,n810-wimax"))
 62                         board_caps = NOKIA_N810_WIMAX;
 63         }
 64 
 65         if (!board_caps)
 66                 pr_err("Unknown board\n");
 67 }
 68 
 69 #if IS_ENABLED(CONFIG_USB_MUSB_TUSB6010)
 70 /*
 71  * Enable or disable power to TUSB6010. When enabling, turn on 3.3 V and
 72  * 1.5 V voltage regulators of PM companion chip. Companion chip will then
 73  * provide then PGOOD signal to TUSB6010 which will release it from reset.
 74  */
 75 static int tusb_set_power(int state)
 76 {
 77         int i, retval = 0;
 78 
 79         if (state) {
 80                 gpio_set_value(TUSB6010_GPIO_ENABLE, 1);
 81                 msleep(1);
 82 
 83                 /* Wait until TUSB6010 pulls INT pin down */
 84                 i = 100;
 85                 while (i && gpio_get_value(TUSB6010_GPIO_INT)) {
 86                         msleep(1);
 87                         i--;
 88                 }
 89 
 90                 if (!i) {
 91                         printk(KERN_ERR "tusb: powerup failed\n");
 92                         retval = -ENODEV;
 93                 }
 94         } else {
 95                 gpio_set_value(TUSB6010_GPIO_ENABLE, 0);
 96                 msleep(10);
 97         }
 98 
 99         return retval;
100 }
101 
102 static struct musb_hdrc_config musb_config = {
103         .multipoint     = 1,
104         .dyn_fifo       = 1,
105         .num_eps        = 16,
106         .ram_bits       = 12,
107 };
108 
109 static struct musb_hdrc_platform_data tusb_data = {
110         .mode           = MUSB_OTG,
111         .set_power      = tusb_set_power,
112         .min_power      = 25,   /* x2 = 50 mA drawn from VBUS as peripheral */
113         .power          = 100,  /* Max 100 mA VBUS for host mode */
114         .config         = &musb_config,
115 };
116 
117 static void __init n8x0_usb_init(void)
118 {
119         int ret = 0;
120         static char     announce[] __initdata = KERN_INFO "TUSB 6010\n";
121 
122         /* PM companion chip power control pin */
123         ret = gpio_request_one(TUSB6010_GPIO_ENABLE, GPIOF_OUT_INIT_LOW,
124                                "TUSB6010 enable");
125         if (ret != 0) {
126                 printk(KERN_ERR "Could not get TUSB power GPIO%i\n",
127                        TUSB6010_GPIO_ENABLE);
128                 return;
129         }
130         tusb_set_power(0);
131 
132         ret = tusb6010_setup_interface(&tusb_data, TUSB6010_REFCLK_19, 2,
133                                         TUSB6010_ASYNC_CS, TUSB6010_SYNC_CS,
134                                         TUSB6010_GPIO_INT, TUSB6010_DMACHAN);
135         if (ret != 0)
136                 goto err;
137 
138         printk(announce);
139 
140         return;
141 
142 err:
143         gpio_free(TUSB6010_GPIO_ENABLE);
144 }
145 #else
146 
147 static void __init n8x0_usb_init(void) {}
148 
149 #endif /*CONFIG_USB_MUSB_TUSB6010 */
150 
151 
152 static struct omap2_mcspi_device_config p54spi_mcspi_config = {
153         .turbo_mode     = 0,
154 };
155 
156 static struct spi_board_info n800_spi_board_info[] __initdata = {
157         {
158                 .modalias       = "p54spi",
159                 .bus_num        = 2,
160                 .chip_select    = 0,
161                 .max_speed_hz   = 48000000,
162                 .controller_data = &p54spi_mcspi_config,
163         },
164 };
165 
166 #if defined(CONFIG_MENELAUS) && IS_ENABLED(CONFIG_MMC_OMAP)
167 
168 /*
169  * On both N800 and N810, only the first of the two MMC controllers is in use.
170  * The two MMC slots are multiplexed via Menelaus companion chip over I2C.
171  * On N800, both slots are powered via Menelaus. On N810, only one of the
172  * slots is powered via Menelaus. The N810 EMMC is powered via GPIO.
173  *
174  * VMMC                         slot 1 on both N800 and N810
175  * VDCDC3_APE and VMCS2_APE     slot 2 on N800
176  * GPIO23 and GPIO9             slot 2 EMMC on N810
177  *
178  */
179 #define N8X0_SLOT_SWITCH_GPIO   96
180 #define N810_EMMC_VSD_GPIO      23
181 #define N810_EMMC_VIO_GPIO      9
182 
183 static int slot1_cover_open;
184 static int slot2_cover_open;
185 static struct device *mmc_device;
186 
187 static int n8x0_mmc_switch_slot(struct device *dev, int slot)
188 {
189 #ifdef CONFIG_MMC_DEBUG
190         dev_dbg(dev, "Choose slot %d\n", slot + 1);
191 #endif
192         gpio_set_value(N8X0_SLOT_SWITCH_GPIO, slot);
193         return 0;
194 }
195 
196 static int n8x0_mmc_set_power_menelaus(struct device *dev, int slot,
197                                         int power_on, int vdd)
198 {
199         int mV;
200 
201 #ifdef CONFIG_MMC_DEBUG
202         dev_dbg(dev, "Set slot %d power: %s (vdd %d)\n", slot + 1,
203                 power_on ? "on" : "off", vdd);
204 #endif
205         if (slot == 0) {
206                 if (!power_on)
207                         return menelaus_set_vmmc(0);
208                 switch (1 << vdd) {
209                 case MMC_VDD_33_34:
210                 case MMC_VDD_32_33:
211                 case MMC_VDD_31_32:
212                         mV = 3100;
213                         break;
214                 case MMC_VDD_30_31:
215                         mV = 3000;
216                         break;
217                 case MMC_VDD_28_29:
218                         mV = 2800;
219                         break;
220                 case MMC_VDD_165_195:
221                         mV = 1850;
222                         break;
223                 default:
224                         BUG();
225                 }
226                 return menelaus_set_vmmc(mV);
227         } else {
228                 if (!power_on)
229                         return menelaus_set_vdcdc(3, 0);
230                 switch (1 << vdd) {
231                 case MMC_VDD_33_34:
232                 case MMC_VDD_32_33:
233                         mV = 3300;
234                         break;
235                 case MMC_VDD_30_31:
236                 case MMC_VDD_29_30:
237                         mV = 3000;
238                         break;
239                 case MMC_VDD_28_29:
240                 case MMC_VDD_27_28:
241                         mV = 2800;
242                         break;
243                 case MMC_VDD_24_25:
244                 case MMC_VDD_23_24:
245                         mV = 2400;
246                         break;
247                 case MMC_VDD_22_23:
248                 case MMC_VDD_21_22:
249                         mV = 2200;
250                         break;
251                 case MMC_VDD_20_21:
252                         mV = 2000;
253                         break;
254                 case MMC_VDD_165_195:
255                         mV = 1800;
256                         break;
257                 default:
258                         BUG();
259                 }
260                 return menelaus_set_vdcdc(3, mV);
261         }
262         return 0;
263 }
264 
265 static void n810_set_power_emmc(struct device *dev,
266                                          int power_on)
267 {
268         dev_dbg(dev, "Set EMMC power %s\n", power_on ? "on" : "off");
269 
270         if (power_on) {
271                 gpio_set_value(N810_EMMC_VSD_GPIO, 1);
272                 msleep(1);
273                 gpio_set_value(N810_EMMC_VIO_GPIO, 1);
274                 msleep(1);
275         } else {
276                 gpio_set_value(N810_EMMC_VIO_GPIO, 0);
277                 msleep(50);
278                 gpio_set_value(N810_EMMC_VSD_GPIO, 0);
279                 msleep(50);
280         }
281 }
282 
283 static int n8x0_mmc_set_power(struct device *dev, int slot, int power_on,
284                               int vdd)
285 {
286         if (board_is_n800() || slot == 0)
287                 return n8x0_mmc_set_power_menelaus(dev, slot, power_on, vdd);
288 
289         n810_set_power_emmc(dev, power_on);
290 
291         return 0;
292 }
293 
294 static int n8x0_mmc_set_bus_mode(struct device *dev, int slot, int bus_mode)
295 {
296         int r;
297 
298         dev_dbg(dev, "Set slot %d bus mode %s\n", slot + 1,
299                 bus_mode == MMC_BUSMODE_OPENDRAIN ? "open-drain" : "push-pull");
300         BUG_ON(slot != 0 && slot != 1);
301         slot++;
302         switch (bus_mode) {
303         case MMC_BUSMODE_OPENDRAIN:
304                 r = menelaus_set_mmc_opendrain(slot, 1);
305                 break;
306         case MMC_BUSMODE_PUSHPULL:
307                 r = menelaus_set_mmc_opendrain(slot, 0);
308                 break;
309         default:
310                 BUG();
311         }
312         if (r != 0 && printk_ratelimit())
313                 dev_err(dev, "MMC: unable to set bus mode for slot %d\n",
314                         slot);
315         return r;
316 }
317 
318 static int n8x0_mmc_get_cover_state(struct device *dev, int slot)
319 {
320         slot++;
321         BUG_ON(slot != 1 && slot != 2);
322         if (slot == 1)
323                 return slot1_cover_open;
324         else
325                 return slot2_cover_open;
326 }
327 
328 static void n8x0_mmc_callback(void *data, u8 card_mask)
329 {
330         int bit, *openp, index;
331 
332         if (board_is_n800()) {
333                 bit = 1 << 1;
334                 openp = &slot2_cover_open;
335                 index = 1;
336         } else {
337                 bit = 1;
338                 openp = &slot1_cover_open;
339                 index = 0;
340         }
341 
342         if (card_mask & bit)
343                 *openp = 1;
344         else
345                 *openp = 0;
346 
347 #ifdef CONFIG_MMC_OMAP
348         omap_mmc_notify_cover_event(mmc_device, index, *openp);
349 #else
350         pr_warn("MMC: notify cover event not available\n");
351 #endif
352 }
353 
354 static int n8x0_mmc_late_init(struct device *dev)
355 {
356         int r, bit, *openp;
357         int vs2sel;
358 
359         mmc_device = dev;
360 
361         r = menelaus_set_slot_sel(1);
362         if (r < 0)
363                 return r;
364 
365         if (board_is_n800())
366                 vs2sel = 0;
367         else
368                 vs2sel = 2;
369 
370         r = menelaus_set_mmc_slot(2, 0, vs2sel, 1);
371         if (r < 0)
372                 return r;
373 
374         n8x0_mmc_set_power(dev, 0, MMC_POWER_ON, 16); /* MMC_VDD_28_29 */
375         n8x0_mmc_set_power(dev, 1, MMC_POWER_ON, 16);
376 
377         r = menelaus_set_mmc_slot(1, 1, 0, 1);
378         if (r < 0)
379                 return r;
380         r = menelaus_set_mmc_slot(2, 1, vs2sel, 1);
381         if (r < 0)
382                 return r;
383 
384         r = menelaus_get_slot_pin_states();
385         if (r < 0)
386                 return r;
387 
388         if (board_is_n800()) {
389                 bit = 1 << 1;
390                 openp = &slot2_cover_open;
391         } else {
392                 bit = 1;
393                 openp = &slot1_cover_open;
394                 slot2_cover_open = 0;
395         }
396 
397         /* All slot pin bits seem to be inversed until first switch change */
398         if (r == 0xf || r == (0xf & ~bit))
399                 r = ~r;
400 
401         if (r & bit)
402                 *openp = 1;
403         else
404                 *openp = 0;
405 
406         r = menelaus_register_mmc_callback(n8x0_mmc_callback, NULL);
407 
408         return r;
409 }
410 
411 static void n8x0_mmc_shutdown(struct device *dev)
412 {
413         int vs2sel;
414 
415         if (board_is_n800())
416                 vs2sel = 0;
417         else
418                 vs2sel = 2;
419 
420         menelaus_set_mmc_slot(1, 0, 0, 0);
421         menelaus_set_mmc_slot(2, 0, vs2sel, 0);
422 }
423 
424 static void n8x0_mmc_cleanup(struct device *dev)
425 {
426         menelaus_unregister_mmc_callback();
427 
428         gpio_free(N8X0_SLOT_SWITCH_GPIO);
429 
430         if (board_is_n810()) {
431                 gpio_free(N810_EMMC_VSD_GPIO);
432                 gpio_free(N810_EMMC_VIO_GPIO);
433         }
434 }
435 
436 /*
437  * MMC controller1 has two slots that are multiplexed via I2C.
438  * MMC controller2 is not in use.
439  */
440 static struct omap_mmc_platform_data mmc1_data = {
441         .nr_slots                       = 0,
442         .switch_slot                    = n8x0_mmc_switch_slot,
443         .init                           = n8x0_mmc_late_init,
444         .cleanup                        = n8x0_mmc_cleanup,
445         .shutdown                       = n8x0_mmc_shutdown,
446         .max_freq                       = 24000000,
447         .slots[0] = {
448                 .wires                  = 4,
449                 .set_power              = n8x0_mmc_set_power,
450                 .set_bus_mode           = n8x0_mmc_set_bus_mode,
451                 .get_cover_state        = n8x0_mmc_get_cover_state,
452                 .ocr_mask               = MMC_VDD_165_195 | MMC_VDD_30_31 |
453                                                 MMC_VDD_32_33   | MMC_VDD_33_34,
454                 .name                   = "internal",
455         },
456         .slots[1] = {
457                 .set_power              = n8x0_mmc_set_power,
458                 .set_bus_mode           = n8x0_mmc_set_bus_mode,
459                 .get_cover_state        = n8x0_mmc_get_cover_state,
460                 .ocr_mask               = MMC_VDD_165_195 | MMC_VDD_20_21 |
461                                                 MMC_VDD_21_22 | MMC_VDD_22_23 |
462                                                 MMC_VDD_23_24 | MMC_VDD_24_25 |
463                                                 MMC_VDD_27_28 | MMC_VDD_28_29 |
464                                                 MMC_VDD_29_30 | MMC_VDD_30_31 |
465                                                 MMC_VDD_32_33 | MMC_VDD_33_34,
466                 .name                   = "external",
467         },
468 };
469 
470 static struct omap_mmc_platform_data *mmc_data[OMAP24XX_NR_MMC];
471 
472 static struct gpio n810_emmc_gpios[] __initdata = {
473         { N810_EMMC_VSD_GPIO, GPIOF_OUT_INIT_LOW,  "MMC slot 2 Vddf" },
474         { N810_EMMC_VIO_GPIO, GPIOF_OUT_INIT_LOW,  "MMC slot 2 Vdd"  },
475 };
476 
477 static void __init n8x0_mmc_init(void)
478 {
479         int err;
480 
481         if (board_is_n810()) {
482                 mmc1_data.slots[0].name = "external";
483 
484                 /*
485                  * Some Samsung Movinand chips do not like open-ended
486                  * multi-block reads and fall to braind-dead state
487                  * while doing so. Reducing the number of blocks in
488                  * the transfer or delays in clock disable do not help
489                  */
490                 mmc1_data.slots[1].name = "internal";
491                 mmc1_data.slots[1].ban_openended = 1;
492         }
493 
494         err = gpio_request_one(N8X0_SLOT_SWITCH_GPIO, GPIOF_OUT_INIT_LOW,
495                                "MMC slot switch");
496         if (err)
497                 return;
498 
499         if (board_is_n810()) {
500                 err = gpio_request_array(n810_emmc_gpios,
501                                          ARRAY_SIZE(n810_emmc_gpios));
502                 if (err) {
503                         gpio_free(N8X0_SLOT_SWITCH_GPIO);
504                         return;
505                 }
506         }
507 
508         mmc1_data.nr_slots = 2;
509         mmc_data[0] = &mmc1_data;
510 }
511 #else
512 static struct omap_mmc_platform_data mmc1_data;
513 void __init n8x0_mmc_init(void)
514 {
515 }
516 #endif  /* CONFIG_MMC_OMAP */
517 
518 #ifdef CONFIG_MENELAUS
519 
520 static int n8x0_auto_sleep_regulators(void)
521 {
522         u32 val;
523         int ret;
524 
525         val = EN_VPLL_SLEEP | EN_VMMC_SLEEP    \
526                 | EN_VAUX_SLEEP | EN_VIO_SLEEP \
527                 | EN_VMEM_SLEEP | EN_DC3_SLEEP \
528                 | EN_VC_SLEEP | EN_DC2_SLEEP;
529 
530         ret = menelaus_set_regulator_sleep(1, val);
531         if (ret < 0) {
532                 pr_err("Could not set regulators to sleep on menelaus: %u\n",
533                        ret);
534                 return ret;
535         }
536         return 0;
537 }
538 
539 static int n8x0_auto_voltage_scale(void)
540 {
541         int ret;
542 
543         ret = menelaus_set_vcore_hw(1400, 1050);
544         if (ret < 0) {
545                 pr_err("Could not set VCORE voltage on menelaus: %u\n", ret);
546                 return ret;
547         }
548         return 0;
549 }
550 
551 static int n8x0_menelaus_late_init(struct device *dev)
552 {
553         int ret;
554 
555         ret = n8x0_auto_voltage_scale();
556         if (ret < 0)
557                 return ret;
558         ret = n8x0_auto_sleep_regulators();
559         if (ret < 0)
560                 return ret;
561         return 0;
562 }
563 
564 #else
565 static int n8x0_menelaus_late_init(struct device *dev)
566 {
567         return 0;
568 }
569 #endif
570 
571 struct menelaus_platform_data n8x0_menelaus_platform_data __initdata = {
572         .late_init = n8x0_menelaus_late_init,
573 };
574 
575 struct aic3x_pdata n810_aic33_data __initdata = {
576         .gpio_reset = 118,
577 };
578 
579 static int __init n8x0_late_initcall(void)
580 {
581         if (!board_caps)
582                 return -ENODEV;
583 
584         n8x0_mmc_init();
585         n8x0_usb_init();
586 
587         return 0;
588 }
589 omap_late_initcall(n8x0_late_initcall);
590 
591 /*
592  * Legacy init pdata init for n8x0. Note that we want to follow the
593  * I2C bus numbering starting at 0 for device tree like other omaps.
594  */
595 void * __init n8x0_legacy_init(void)
596 {
597         board_check_revision();
598         spi_register_board_info(n800_spi_board_info,
599                                 ARRAY_SIZE(n800_spi_board_info));
600         return &mmc1_data;
601 }
602 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp