arch/arm/mach-omap2/hsmmc.c

   1 /*
   2  * linux/arch/arm/mach-omap2/hsmmc.c
   3  *
   4  * Copyright (C) 2007-2008 Texas Instruments
   5  * Copyright (C) 2008 Nokia Corporation
   6  * Author: Texas Instruments
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12 #include <linux/kernel.h>
  13 #include <linux/slab.h>
  14 #include <linux/string.h>
  15 #include <linux/delay.h>
  16 #include <linux/mmc/host.h>
  17 #include <linux/platform_data/hsmmc-omap.h>
  18
  19 #include "soc.h"
  20 #include "omap_device.h"
  21
  22 #include "hsmmc.h"
  23 #include "control.h"
  24
  25 #if IS_ENABLED(CONFIG_MMC_OMAP_HS)
  26
  27 static u16 control_pbias_offset;
  28 static u16 control_devconf1_offset;
  29
  30 #define HSMMC_NAME_LEN  9
  31
  32 static int __init omap_hsmmc_pdata_init(struct omap2_hsmmc_info *c,
  33                                         struct omap_hsmmc_platform_data *mmc)
  34 {
  35         char *hc_name;
  36
  37         hc_name = kzalloc(HSMMC_NAME_LEN + 1, GFP_KERNEL);
  38         if (!hc_name) {
  39                 kfree(hc_name);
  40                 return -ENOMEM;
  41         }
  42
  43         snprintf(hc_name, (HSMMC_NAME_LEN + 1), "mmc%islot%i", c->mmc, 1);
  44         mmc->name = hc_name;
  45         mmc->caps = c->caps;
  46         mmc->reg_offset = 0;
  47
  48         return 0;
  49 }
  50
  51 static int omap_hsmmc_done;
  52
  53 void omap_hsmmc_late_init(struct omap2_hsmmc_info *c)
  54 {
  55         struct platform_device *pdev;
  56         int res;
  57
  58         if (omap_hsmmc_done)
  59                 return;
  60
  61         omap_hsmmc_done = 1;
  62
  63         for (; c->mmc; c++) {
  64                 pdev = c->pdev;
  65                 if (!pdev)
  66                         continue;
  67                 res = omap_device_register(pdev);
  68                 if (res)
  69                         pr_err("Could not late init MMC\n");
  70         }
  71 }
  72
  73 #define MAX_OMAP_MMC_HWMOD_NAME_LEN             16
  74
  75 static void __init omap_hsmmc_init_one(struct omap2_hsmmc_info *hsmmcinfo,
  76                                         int ctrl_nr)
  77 {
  78         struct omap_hwmod *oh;
  79         struct omap_hwmod *ohs[1];
  80         struct omap_device *od;
  81         struct platform_device *pdev;
  82         char oh_name[MAX_OMAP_MMC_HWMOD_NAME_LEN];
  83         struct omap_hsmmc_platform_data *mmc_data;
  84         struct omap_hsmmc_dev_attr *mmc_dev_attr;
  85         char *name;
  86         int res;
  87
  88         mmc_data = kzalloc(sizeof(*mmc_data), GFP_KERNEL);
  89         if (!mmc_data)
  90                 return;
  91
  92         res = omap_hsmmc_pdata_init(hsmmcinfo, mmc_data);
  93         if (res < 0)
  94                 goto free_mmc;
  95
  96         name = "omap_hsmmc";
  97         res = snprintf(oh_name, MAX_OMAP_MMC_HWMOD_NAME_LEN,
  98                      "mmc%d", ctrl_nr);
  99         WARN(res >= MAX_OMAP_MMC_HWMOD_NAME_LEN,
 100              "String buffer overflow in MMC%d device setup\n", ctrl_nr);
 101
 102         oh = omap_hwmod_lookup(oh_name);
 103         if (!oh) {
 104                 pr_err("Could not look up %s\n", oh_name);
 105                 goto free_name;
 106         }
 107         ohs[0] = oh;
 108         if (oh->dev_attr != NULL) {
 109                 mmc_dev_attr = oh->dev_attr;
 110                 mmc_data->controller_flags = mmc_dev_attr->flags;
 111         }
 112
 113         pdev = platform_device_alloc(name, ctrl_nr - 1);
 114         if (!pdev) {
 115                 pr_err("Could not allocate pdev for %s\n", name);
 116                 goto free_name;
 117         }
 118         dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
 119
 120         od = omap_device_alloc(pdev, ohs, 1);
 121         if (IS_ERR(od)) {
 122                 pr_err("Could not allocate od for %s\n", name);
 123                 goto put_pdev;
 124         }
 125
 126         res = platform_device_add_data(pdev, mmc_data,
 127                               sizeof(struct omap_hsmmc_platform_data));
 128         if (res) {
 129                 pr_err("Could not add pdata for %s\n", name);
 130                 goto put_pdev;
 131         }
 132
 133         hsmmcinfo->pdev = pdev;
 134
 135         res = omap_device_register(pdev);
 136         if (res) {
 137                 pr_err("Could not register od for %s\n", name);
 138                 goto free_od;
 139         }
 140
 141         goto free_mmc;
 142
 143 free_od:
 144         omap_device_delete(od);
 145
 146 put_pdev:
 147         platform_device_put(pdev);
 148
 149 free_name:
 150         kfree(mmc_data->name);
 151
 152 free_mmc:
 153         kfree(mmc_data);
 154 }
 155
 156 void __init omap_hsmmc_init(struct omap2_hsmmc_info *controllers)
 157 {
 158         if (omap_hsmmc_done)
 159                 return;
 160
 161         omap_hsmmc_done = 1;
 162
 163         if (cpu_is_omap2430()) {
 164                 control_pbias_offset = OMAP243X_CONTROL_PBIAS_LITE;
 165                 control_devconf1_offset = OMAP243X_CONTROL_DEVCONF1;
 166         } else {
 167                 control_pbias_offset = OMAP343X_CONTROL_PBIAS_LITE;
 168                 control_devconf1_offset = OMAP343X_CONTROL_DEVCONF1;
 169         }
 170
 171         for (; controllers->mmc; controllers++)
 172                 omap_hsmmc_init_one(controllers, controllers->mmc);
 173
 174 }
 175
 176 #endif