2013-02-26 12:34:45 +00:00
|
|
|
/*
|
|
|
|
* Universal Flash Storage Host controller Platform bus based glue driver
|
|
|
|
*
|
|
|
|
* This code is based on drivers/scsi/ufs/ufshcd-pltfrm.c
|
|
|
|
* Copyright (C) 2011-2013 Samsung India Software Operations
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Santosh Yaraganavi <santosh.sy@samsung.com>
|
|
|
|
* Vinayak Holikatti <h.vinayak@samsung.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
* See the COPYING file in the top-level directory or visit
|
|
|
|
* <http://www.gnu.org/licenses/gpl-2.0.html>
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* This program is provided "AS IS" and "WITH ALL FAULTS" and
|
|
|
|
* without warranty of any kind. You are solely responsible for
|
|
|
|
* determining the appropriateness of using and distributing
|
|
|
|
* the program and assume all risks associated with your exercise
|
|
|
|
* of rights with respect to the program, including but not limited
|
|
|
|
* to infringement of third party rights, the risks and costs of
|
|
|
|
* program errors, damage to or loss of data, programs or equipment,
|
|
|
|
* and unavailability or interruption of operations. Under no
|
|
|
|
* circumstances will the contributor of this Program be liable for
|
|
|
|
* any damages of any kind arising from your use or distribution of
|
|
|
|
* this program.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/platform_device.h>
|
2013-07-29 19:06:00 +00:00
|
|
|
#include <linux/pm_runtime.h>
|
2014-09-25 12:32:21 +00:00
|
|
|
#include <linux/of.h>
|
2013-02-26 12:34:45 +00:00
|
|
|
|
2013-06-27 04:31:54 +00:00
|
|
|
#include "ufshcd.h"
|
2015-10-28 11:15:49 +00:00
|
|
|
#include "ufshcd-pltfrm.h"
|
2019-03-16 05:04:41 +00:00
|
|
|
#include "unipro.h"
|
2014-09-25 12:32:21 +00:00
|
|
|
|
2016-03-10 15:37:05 +00:00
|
|
|
#define UFSHCD_DEFAULT_LANES_PER_DIRECTION 2
|
|
|
|
|
2014-09-25 12:32:23 +00:00
|
|
|
static int ufshcd_parse_clock_info(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
int cnt;
|
|
|
|
int i;
|
|
|
|
struct device *dev = hba->dev;
|
|
|
|
struct device_node *np = dev->of_node;
|
|
|
|
char *name;
|
|
|
|
u32 *clkfreq = NULL;
|
|
|
|
struct ufs_clk_info *clki;
|
2014-09-25 12:32:33 +00:00
|
|
|
int len = 0;
|
|
|
|
size_t sz = 0;
|
2014-09-25 12:32:23 +00:00
|
|
|
|
|
|
|
if (!np)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
cnt = of_property_count_strings(np, "clock-names");
|
|
|
|
if (!cnt || (cnt == -EINVAL)) {
|
|
|
|
dev_info(dev, "%s: Unable to find clocks, assuming enabled\n",
|
|
|
|
__func__);
|
|
|
|
} else if (cnt < 0) {
|
|
|
|
dev_err(dev, "%s: count clock strings failed, err %d\n",
|
|
|
|
__func__, cnt);
|
|
|
|
ret = cnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cnt <= 0)
|
|
|
|
goto out;
|
|
|
|
|
2014-09-25 12:32:33 +00:00
|
|
|
if (!of_get_property(np, "freq-table-hz", &len)) {
|
|
|
|
dev_info(dev, "freq-table-hz property not specified\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (len <= 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
sz = len / sizeof(*clkfreq);
|
|
|
|
if (sz != 2 * cnt) {
|
|
|
|
dev_err(dev, "%s len mismatch\n", "freq-table-hz");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
treewide: devm_kzalloc() -> devm_kcalloc()
The devm_kzalloc() function has a 2-factor argument form, devm_kcalloc().
This patch replaces cases of:
devm_kzalloc(handle, a * b, gfp)
with:
devm_kcalloc(handle, a * b, gfp)
as well as handling cases of:
devm_kzalloc(handle, a * b * c, gfp)
with:
devm_kzalloc(handle, array3_size(a, b, c), gfp)
as it's slightly less ugly than:
devm_kcalloc(handle, array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
devm_kzalloc(handle, 4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
Some manual whitespace fixes were needed in this patch, as Coccinelle
really liked to write "=devm_kcalloc..." instead of "= devm_kcalloc...".
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
expression HANDLE;
type TYPE;
expression THING, E;
@@
(
devm_kzalloc(HANDLE,
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
devm_kzalloc(HANDLE,
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression HANDLE;
expression COUNT;
typedef u8;
typedef __u8;
@@
(
devm_kzalloc(HANDLE,
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(char) * COUNT
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
expression HANDLE;
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
expression HANDLE;
identifier SIZE, COUNT;
@@
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression HANDLE;
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
devm_kzalloc(HANDLE,
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression HANDLE;
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
expression HANDLE;
identifier STRIDE, SIZE, COUNT;
@@
(
devm_kzalloc(HANDLE,
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression HANDLE;
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
devm_kzalloc(HANDLE, C1 * C2 * C3, ...)
|
devm_kzalloc(HANDLE,
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
devm_kzalloc(HANDLE,
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
devm_kzalloc(HANDLE,
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
devm_kzalloc(HANDLE,
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression HANDLE;
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
devm_kzalloc(HANDLE, sizeof(THING) * C2, ...)
|
devm_kzalloc(HANDLE, sizeof(TYPE) * C2, ...)
|
devm_kzalloc(HANDLE, C1 * C2 * C3, ...)
|
devm_kzalloc(HANDLE, C1 * C2, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- (E1) * E2
+ E1, E2
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- (E1) * (E2)
+ E1, E2
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 21:07:58 +00:00
|
|
|
clkfreq = devm_kcalloc(dev, sz, sizeof(*clkfreq),
|
|
|
|
GFP_KERNEL);
|
2014-09-25 12:32:23 +00:00
|
|
|
if (!clkfreq) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:33 +00:00
|
|
|
ret = of_property_read_u32_array(np, "freq-table-hz",
|
|
|
|
clkfreq, sz);
|
2014-09-25 12:32:23 +00:00
|
|
|
if (ret && (ret != -EINVAL)) {
|
2014-09-25 12:32:33 +00:00
|
|
|
dev_err(dev, "%s: error reading array %d\n",
|
|
|
|
"freq-table-hz", ret);
|
2014-10-23 10:25:17 +00:00
|
|
|
return ret;
|
2014-09-25 12:32:23 +00:00
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:33 +00:00
|
|
|
for (i = 0; i < sz; i += 2) {
|
2014-09-25 12:32:23 +00:00
|
|
|
ret = of_property_read_string_index(np,
|
2014-09-25 12:32:33 +00:00
|
|
|
"clock-names", i/2, (const char **)&name);
|
2014-09-25 12:32:23 +00:00
|
|
|
if (ret)
|
2014-10-23 10:25:17 +00:00
|
|
|
goto out;
|
2014-09-25 12:32:23 +00:00
|
|
|
|
|
|
|
clki = devm_kzalloc(dev, sizeof(*clki), GFP_KERNEL);
|
|
|
|
if (!clki) {
|
|
|
|
ret = -ENOMEM;
|
2014-10-23 10:25:17 +00:00
|
|
|
goto out;
|
2014-09-25 12:32:23 +00:00
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:33 +00:00
|
|
|
clki->min_freq = clkfreq[i];
|
|
|
|
clki->max_freq = clkfreq[i+1];
|
2014-09-25 12:32:23 +00:00
|
|
|
clki->name = kstrdup(name, GFP_KERNEL);
|
2014-09-25 12:32:33 +00:00
|
|
|
dev_dbg(dev, "%s: min %u max %u name %s\n", "freq-table-hz",
|
|
|
|
clki->min_freq, clki->max_freq, clki->name);
|
2014-09-25 12:32:23 +00:00
|
|
|
list_add_tail(&clki->list, &hba->clk_list_head);
|
|
|
|
}
|
2014-09-25 12:32:33 +00:00
|
|
|
out:
|
2014-09-25 12:32:23 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:22 +00:00
|
|
|
#define MAX_PROP_SIZE 32
|
|
|
|
static int ufshcd_populate_vreg(struct device *dev, const char *name,
|
|
|
|
struct ufs_vreg **out_vreg)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
char prop_name[MAX_PROP_SIZE];
|
|
|
|
struct ufs_vreg *vreg = NULL;
|
|
|
|
struct device_node *np = dev->of_node;
|
|
|
|
|
|
|
|
if (!np) {
|
|
|
|
dev_err(dev, "%s: non DT initialization\n", __func__);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
snprintf(prop_name, MAX_PROP_SIZE, "%s-supply", name);
|
|
|
|
if (!of_parse_phandle(np, prop_name, 0)) {
|
|
|
|
dev_info(dev, "%s: Unable to find %s regulator, assuming enabled\n",
|
|
|
|
__func__, prop_name);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
vreg = devm_kzalloc(dev, sizeof(*vreg), GFP_KERNEL);
|
2014-10-23 10:25:15 +00:00
|
|
|
if (!vreg)
|
|
|
|
return -ENOMEM;
|
2014-09-25 12:32:22 +00:00
|
|
|
|
|
|
|
vreg->name = kstrdup(name, GFP_KERNEL);
|
|
|
|
|
|
|
|
snprintf(prop_name, MAX_PROP_SIZE, "%s-max-microamp", name);
|
scsi: ufs: Change "<name>-max-microamp" to non-mandatory property
In dt-bindings for ufs, "<name>-max-microamp" property indicates current
limit and is mandatory if "<name>-fixed-regulator" is not defined on a
specified regulator.
However, in some platforms, regulators without "<name>-fixed-regulator"
property may not need to define their current limit because they may want
to define voltage range only for proper voltage switching in different
power modes, especially for vcc, vccq or vccq2.
Currently missing "<name>-max-microamp" property in device tree will lead
initialization to fail, thus such limitation shall be resolved to tolerate
this kind of regulators.
After resolving this, regulators without "<name>-max-microamp" property
will have undefined "max current" value, i.e., zero value in "max_uA" field
in struct ufs_vreg. Because we do bypass current switching operation (by
regulator_set_load) in case of undefined current limit, this patch shall be
safe.
Signed-off-by: Stanley Chu <stanley.chu@mediatek.com>
Reviewed-by: Avri Altman <avri.altman@wdc.com>
Acked-by: Alim Akhtar <alim.akhtar@samsung.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-28 09:16:26 +00:00
|
|
|
if (of_property_read_u32(np, prop_name, &vreg->max_uA)) {
|
|
|
|
dev_info(dev, "%s: unable to find %s\n", __func__, prop_name);
|
|
|
|
vreg->max_uA = 0;
|
2014-09-25 12:32:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(name, "vcc")) {
|
|
|
|
if (of_property_read_bool(np, "vcc-supply-1p8")) {
|
|
|
|
vreg->min_uV = UFS_VREG_VCC_1P8_MIN_UV;
|
|
|
|
vreg->max_uV = UFS_VREG_VCC_1P8_MAX_UV;
|
|
|
|
} else {
|
|
|
|
vreg->min_uV = UFS_VREG_VCC_MIN_UV;
|
|
|
|
vreg->max_uV = UFS_VREG_VCC_MAX_UV;
|
|
|
|
}
|
|
|
|
} else if (!strcmp(name, "vccq")) {
|
|
|
|
vreg->min_uV = UFS_VREG_VCCQ_MIN_UV;
|
|
|
|
vreg->max_uV = UFS_VREG_VCCQ_MAX_UV;
|
|
|
|
} else if (!strcmp(name, "vccq2")) {
|
|
|
|
vreg->min_uV = UFS_VREG_VCCQ2_MIN_UV;
|
|
|
|
vreg->max_uV = UFS_VREG_VCCQ2_MAX_UV;
|
|
|
|
}
|
|
|
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (!ret)
|
|
|
|
*out_vreg = vreg;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_parse_regulator_info - get regulator info from device tree
|
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
|
|
|
* Get regulator info from device tree for vcc, vccq, vccq2 power supplies.
|
|
|
|
* If any of the supplies are not defined it is assumed that they are always-on
|
|
|
|
* and hence return zero. If the property is defined but parsing is failed
|
|
|
|
* then return corresponding error.
|
|
|
|
*/
|
|
|
|
static int ufshcd_parse_regulator_info(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct device *dev = hba->dev;
|
|
|
|
struct ufs_vreg_info *info = &hba->vreg_info;
|
|
|
|
|
2014-09-25 12:32:24 +00:00
|
|
|
err = ufshcd_populate_vreg(dev, "vdd-hba", &info->vdd_hba);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
2014-09-25 12:32:22 +00:00
|
|
|
err = ufshcd_populate_vreg(dev, "vcc", &info->vcc);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
err = ufshcd_populate_vreg(dev, "vccq", &info->vccq);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
err = ufshcd_populate_vreg(dev, "vccq2", &info->vccq2);
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-02-26 12:34:45 +00:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
/**
|
|
|
|
* ufshcd_pltfrm_suspend - suspend power management function
|
|
|
|
* @dev: pointer to device handle
|
|
|
|
*
|
2014-09-25 12:32:30 +00:00
|
|
|
* Returns 0 if successful
|
|
|
|
* Returns non-zero otherwise
|
2013-02-26 12:34:45 +00:00
|
|
|
*/
|
2015-10-28 11:15:49 +00:00
|
|
|
int ufshcd_pltfrm_suspend(struct device *dev)
|
2013-02-26 12:34:45 +00:00
|
|
|
{
|
2014-09-25 12:32:30 +00:00
|
|
|
return ufshcd_system_suspend(dev_get_drvdata(dev));
|
2013-02-26 12:34:45 +00:00
|
|
|
}
|
2015-10-28 11:15:49 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_pltfrm_suspend);
|
2013-02-26 12:34:45 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_pltfrm_resume - resume power management function
|
|
|
|
* @dev: pointer to device handle
|
|
|
|
*
|
2014-09-25 12:32:30 +00:00
|
|
|
* Returns 0 if successful
|
|
|
|
* Returns non-zero otherwise
|
2013-02-26 12:34:45 +00:00
|
|
|
*/
|
2015-10-28 11:15:49 +00:00
|
|
|
int ufshcd_pltfrm_resume(struct device *dev)
|
2013-02-26 12:34:45 +00:00
|
|
|
{
|
2014-09-25 12:32:30 +00:00
|
|
|
return ufshcd_system_resume(dev_get_drvdata(dev));
|
2013-02-26 12:34:45 +00:00
|
|
|
}
|
2015-10-28 11:15:49 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_pltfrm_resume);
|
2013-02-26 12:34:45 +00:00
|
|
|
|
2015-10-28 11:15:49 +00:00
|
|
|
int ufshcd_pltfrm_runtime_suspend(struct device *dev)
|
2013-07-29 19:06:00 +00:00
|
|
|
{
|
2014-09-25 12:32:30 +00:00
|
|
|
return ufshcd_runtime_suspend(dev_get_drvdata(dev));
|
2013-07-29 19:06:00 +00:00
|
|
|
}
|
2015-10-28 11:15:49 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_pltfrm_runtime_suspend);
|
|
|
|
|
|
|
|
int ufshcd_pltfrm_runtime_resume(struct device *dev)
|
2013-07-29 19:06:00 +00:00
|
|
|
{
|
2014-09-25 12:32:30 +00:00
|
|
|
return ufshcd_runtime_resume(dev_get_drvdata(dev));
|
2013-07-29 19:06:00 +00:00
|
|
|
}
|
2015-10-28 11:15:49 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_pltfrm_runtime_resume);
|
|
|
|
|
|
|
|
int ufshcd_pltfrm_runtime_idle(struct device *dev)
|
2013-07-29 19:06:00 +00:00
|
|
|
{
|
2014-09-25 12:32:30 +00:00
|
|
|
return ufshcd_runtime_idle(dev_get_drvdata(dev));
|
2013-07-29 19:06:00 +00:00
|
|
|
}
|
2015-10-28 11:15:49 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_pltfrm_runtime_idle);
|
|
|
|
|
2014-12-14 22:13:55 +00:00
|
|
|
#endif /* CONFIG_PM */
|
2013-07-29 19:06:00 +00:00
|
|
|
|
2015-10-28 11:15:49 +00:00
|
|
|
void ufshcd_pltfrm_shutdown(struct platform_device *pdev)
|
2014-09-25 12:32:30 +00:00
|
|
|
{
|
|
|
|
ufshcd_shutdown((struct ufs_hba *)platform_get_drvdata(pdev));
|
|
|
|
}
|
2015-10-28 11:15:49 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_pltfrm_shutdown);
|
2014-09-25 12:32:30 +00:00
|
|
|
|
2016-03-10 15:37:05 +00:00
|
|
|
static void ufshcd_init_lanes_per_dir(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
struct device *dev = hba->dev;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = of_property_read_u32(dev->of_node, "lanes-per-direction",
|
|
|
|
&hba->lanes_per_direction);
|
|
|
|
if (ret) {
|
|
|
|
dev_dbg(hba->dev,
|
|
|
|
"%s: failed to read lanes-per-direction, ret=%d\n",
|
|
|
|
__func__, ret);
|
|
|
|
hba->lanes_per_direction = UFSHCD_DEFAULT_LANES_PER_DIRECTION;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-16 05:04:41 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_get_pwr_dev_param - get finally agreed attributes for
|
|
|
|
* power mode change
|
|
|
|
* @pltfrm_param: pointer to platform parameters
|
|
|
|
* @dev_max: pointer to device attributes
|
|
|
|
* @agreed_pwr: returned agreed attributes
|
|
|
|
*
|
|
|
|
* Returns 0 on success, non-zero value on failure
|
|
|
|
*/
|
|
|
|
int ufshcd_get_pwr_dev_param(struct ufs_dev_params *pltfrm_param,
|
|
|
|
struct ufs_pa_layer_attr *dev_max,
|
|
|
|
struct ufs_pa_layer_attr *agreed_pwr)
|
|
|
|
{
|
|
|
|
int min_pltfrm_gear;
|
|
|
|
int min_dev_gear;
|
|
|
|
bool is_dev_sup_hs = false;
|
|
|
|
bool is_pltfrm_max_hs = false;
|
|
|
|
|
|
|
|
if (dev_max->pwr_rx == FAST_MODE)
|
|
|
|
is_dev_sup_hs = true;
|
|
|
|
|
|
|
|
if (pltfrm_param->desired_working_mode == UFS_HS_MODE) {
|
|
|
|
is_pltfrm_max_hs = true;
|
|
|
|
min_pltfrm_gear = min_t(u32, pltfrm_param->hs_rx_gear,
|
|
|
|
pltfrm_param->hs_tx_gear);
|
|
|
|
} else {
|
|
|
|
min_pltfrm_gear = min_t(u32, pltfrm_param->pwm_rx_gear,
|
|
|
|
pltfrm_param->pwm_tx_gear);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* device doesn't support HS but
|
|
|
|
* pltfrm_param->desired_working_mode is HS,
|
|
|
|
* thus device and pltfrm_param don't agree
|
|
|
|
*/
|
|
|
|
if (!is_dev_sup_hs && is_pltfrm_max_hs) {
|
|
|
|
pr_info("%s: device doesn't support HS\n",
|
|
|
|
__func__);
|
|
|
|
return -ENOTSUPP;
|
|
|
|
} else if (is_dev_sup_hs && is_pltfrm_max_hs) {
|
|
|
|
/*
|
|
|
|
* since device supports HS, it supports FAST_MODE.
|
|
|
|
* since pltfrm_param->desired_working_mode is also HS
|
|
|
|
* then final decision (FAST/FASTAUTO) is done according
|
|
|
|
* to pltfrm_params as it is the restricting factor
|
|
|
|
*/
|
|
|
|
agreed_pwr->pwr_rx = pltfrm_param->rx_pwr_hs;
|
|
|
|
agreed_pwr->pwr_tx = agreed_pwr->pwr_rx;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* here pltfrm_param->desired_working_mode is PWM.
|
|
|
|
* it doesn't matter whether device supports HS or PWM,
|
|
|
|
* in both cases pltfrm_param->desired_working_mode will
|
|
|
|
* determine the mode
|
|
|
|
*/
|
|
|
|
agreed_pwr->pwr_rx = pltfrm_param->rx_pwr_pwm;
|
|
|
|
agreed_pwr->pwr_tx = agreed_pwr->pwr_rx;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* we would like tx to work in the minimum number of lanes
|
|
|
|
* between device capability and vendor preferences.
|
|
|
|
* the same decision will be made for rx
|
|
|
|
*/
|
|
|
|
agreed_pwr->lane_tx = min_t(u32, dev_max->lane_tx,
|
|
|
|
pltfrm_param->tx_lanes);
|
|
|
|
agreed_pwr->lane_rx = min_t(u32, dev_max->lane_rx,
|
|
|
|
pltfrm_param->rx_lanes);
|
|
|
|
|
|
|
|
/* device maximum gear is the minimum between device rx and tx gears */
|
|
|
|
min_dev_gear = min_t(u32, dev_max->gear_rx, dev_max->gear_tx);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if both device capabilities and vendor pre-defined preferences are
|
|
|
|
* both HS or both PWM then set the minimum gear to be the chosen
|
|
|
|
* working gear.
|
|
|
|
* if one is PWM and one is HS then the one that is PWM get to decide
|
|
|
|
* what is the gear, as it is the one that also decided previously what
|
|
|
|
* pwr the device will be configured to.
|
|
|
|
*/
|
|
|
|
if ((is_dev_sup_hs && is_pltfrm_max_hs) ||
|
|
|
|
(!is_dev_sup_hs && !is_pltfrm_max_hs)) {
|
|
|
|
agreed_pwr->gear_rx =
|
|
|
|
min_t(u32, min_dev_gear, min_pltfrm_gear);
|
|
|
|
} else if (!is_dev_sup_hs) {
|
|
|
|
agreed_pwr->gear_rx = min_dev_gear;
|
|
|
|
} else {
|
|
|
|
agreed_pwr->gear_rx = min_pltfrm_gear;
|
|
|
|
}
|
|
|
|
agreed_pwr->gear_tx = agreed_pwr->gear_rx;
|
|
|
|
|
|
|
|
agreed_pwr->hs_rate = pltfrm_param->hs_rate;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_get_pwr_dev_param);
|
|
|
|
|
2013-02-26 12:34:45 +00:00
|
|
|
/**
|
2015-10-28 11:15:49 +00:00
|
|
|
* ufshcd_pltfrm_init - probe routine of the driver
|
2013-02-26 12:34:45 +00:00
|
|
|
* @pdev: pointer to Platform device handle
|
2015-10-28 11:15:49 +00:00
|
|
|
* @vops: pointer to variant ops
|
2013-02-26 12:34:45 +00:00
|
|
|
*
|
|
|
|
* Returns 0 on success, non-zero value on failure
|
|
|
|
*/
|
2015-10-28 11:15:49 +00:00
|
|
|
int ufshcd_pltfrm_init(struct platform_device *pdev,
|
2019-03-04 19:39:11 +00:00
|
|
|
const struct ufs_hba_variant_ops *vops)
|
2013-02-26 12:34:45 +00:00
|
|
|
{
|
|
|
|
struct ufs_hba *hba;
|
|
|
|
void __iomem *mmio_base;
|
2013-06-27 04:31:54 +00:00
|
|
|
int irq, err;
|
2013-02-26 12:34:45 +00:00
|
|
|
struct device *dev = &pdev->dev;
|
|
|
|
|
2019-09-04 13:03:48 +00:00
|
|
|
mmio_base = devm_platform_ioremap_resource(pdev, 0);
|
2017-03-14 12:19:36 +00:00
|
|
|
if (IS_ERR(mmio_base)) {
|
|
|
|
err = PTR_ERR(mmio_base);
|
2013-06-27 04:31:54 +00:00
|
|
|
goto out;
|
2013-02-26 12:34:45 +00:00
|
|
|
}
|
|
|
|
|
2013-06-27 04:31:54 +00:00
|
|
|
irq = platform_get_irq(pdev, 0);
|
|
|
|
if (irq < 0) {
|
|
|
|
dev_err(dev, "IRQ resource not available\n");
|
2013-02-26 12:34:45 +00:00
|
|
|
err = -ENODEV;
|
2013-06-27 04:31:54 +00:00
|
|
|
goto out;
|
2013-02-26 12:34:45 +00:00
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:21 +00:00
|
|
|
err = ufshcd_alloc_host(dev, &hba);
|
|
|
|
if (err) {
|
|
|
|
dev_err(&pdev->dev, "Allocation failed\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-10-28 11:15:49 +00:00
|
|
|
hba->vops = vops;
|
2014-09-25 12:32:21 +00:00
|
|
|
|
2014-09-25 12:32:23 +00:00
|
|
|
err = ufshcd_parse_clock_info(hba);
|
|
|
|
if (err) {
|
|
|
|
dev_err(&pdev->dev, "%s: clock parse failed %d\n",
|
|
|
|
__func__, err);
|
2015-10-28 11:15:49 +00:00
|
|
|
goto dealloc_host;
|
2014-09-25 12:32:23 +00:00
|
|
|
}
|
2014-09-25 12:32:22 +00:00
|
|
|
err = ufshcd_parse_regulator_info(hba);
|
|
|
|
if (err) {
|
|
|
|
dev_err(&pdev->dev, "%s: regulator init failed %d\n",
|
|
|
|
__func__, err);
|
2015-10-28 11:15:49 +00:00
|
|
|
goto dealloc_host;
|
2014-09-25 12:32:22 +00:00
|
|
|
}
|
|
|
|
|
2016-03-10 15:37:05 +00:00
|
|
|
ufshcd_init_lanes_per_dir(hba);
|
|
|
|
|
2014-09-25 12:32:21 +00:00
|
|
|
err = ufshcd_init(hba, mmio_base, irq);
|
2013-02-26 12:34:45 +00:00
|
|
|
if (err) {
|
2015-11-28 16:33:56 +00:00
|
|
|
dev_err(dev, "Initialization failed\n");
|
2019-06-12 15:19:05 +00:00
|
|
|
goto dealloc_host;
|
2013-02-26 12:34:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
platform_set_drvdata(pdev, hba);
|
|
|
|
|
2019-06-12 15:19:05 +00:00
|
|
|
pm_runtime_set_active(&pdev->dev);
|
|
|
|
pm_runtime_enable(&pdev->dev);
|
|
|
|
|
2013-07-29 19:06:00 +00:00
|
|
|
return 0;
|
|
|
|
|
2015-10-28 11:15:49 +00:00
|
|
|
dealloc_host:
|
|
|
|
ufshcd_dealloc_host(hba);
|
2013-06-27 04:31:54 +00:00
|
|
|
out:
|
2013-02-26 12:34:45 +00:00
|
|
|
return err;
|
|
|
|
}
|
2015-10-28 11:15:49 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_pltfrm_init);
|
2013-02-26 12:34:45 +00:00
|
|
|
|
|
|
|
MODULE_AUTHOR("Santosh Yaragnavi <santosh.sy@samsung.com>");
|
|
|
|
MODULE_AUTHOR("Vinayak Holikatti <h.vinayak@samsung.com>");
|
2016-05-11 11:21:25 +00:00
|
|
|
MODULE_DESCRIPTION("UFS host controller Platform bus based glue driver");
|
2013-02-26 12:34:45 +00:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_VERSION(UFSHCD_DRIVER_VERSION);
|