1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * JZ47xx ECC common code
4  *
5  * Copyright (c) 2015 Imagination Technologies
6  * Author: Alex Smith <alex.smith@imgtec.com>
7  */
8 
9 #include <linux/clk.h>
10 #include <linux/init.h>
11 #include <linux/module.h>
12 #include <linux/of_platform.h>
13 #include <linux/platform_device.h>
14 
15 #include "ingenic_ecc.h"
16 
17 /**
18  * ingenic_ecc_calculate() - calculate ECC for a data buffer
19  * @ecc: ECC device.
20  * @params: ECC parameters.
21  * @buf: input buffer with raw data.
22  * @ecc_code: output buffer with ECC.
23  *
24  * Return: 0 on success, -ETIMEDOUT if timed out while waiting for ECC
25  * controller.
26  */
27 int ingenic_ecc_calculate(struct ingenic_ecc *ecc,
28 			  struct ingenic_ecc_params *params,
29 			  const u8 *buf, u8 *ecc_code)
30 {
31 	return ecc->ops->calculate(ecc, params, buf, ecc_code);
32 }
33 
34 /**
35  * ingenic_ecc_correct() - detect and correct bit errors
36  * @ecc: ECC device.
37  * @params: ECC parameters.
38  * @buf: raw data read from the chip.
39  * @ecc_code: ECC read from the chip.
40  *
41  * Given the raw data and the ECC read from the NAND device, detects and
42  * corrects errors in the data.
43  *
44  * Return: the number of bit errors corrected, -EBADMSG if there are too many
45  * errors to correct or -ETIMEDOUT if we timed out waiting for the controller.
46  */
47 int ingenic_ecc_correct(struct ingenic_ecc *ecc,
48 			struct ingenic_ecc_params *params,
49 			u8 *buf, u8 *ecc_code)
50 {
51 	return ecc->ops->correct(ecc, params, buf, ecc_code);
52 }
53 
54 /**
55  * ingenic_ecc_get() - get the ECC controller device
56  * @np: ECC device tree node.
57  *
58  * Gets the ECC controller device from the specified device tree node. The
59  * device must be released with ingenic_ecc_release() when it is no longer being
60  * used.
61  *
62  * Return: a pointer to ingenic_ecc, errors are encoded into the pointer.
63  * PTR_ERR(-EPROBE_DEFER) if the device hasn't been initialised yet.
64  */
65 static struct ingenic_ecc *ingenic_ecc_get(struct device_node *np)
66 {
67 	struct platform_device *pdev;
68 	struct ingenic_ecc *ecc;
69 
70 	pdev = of_find_device_by_node(np);
71 	if (!pdev)
72 		return ERR_PTR(-EPROBE_DEFER);
73 
74 	if (!platform_get_drvdata(pdev)) {
75 		put_device(&pdev->dev);
76 		return ERR_PTR(-EPROBE_DEFER);
77 	}
78 
79 	ecc = platform_get_drvdata(pdev);
80 	clk_prepare_enable(ecc->clk);
81 
82 	return ecc;
83 }
84 
85 /**
86  * of_ingenic_ecc_get() - get the ECC controller from a DT node
87  * @of_node: the node that contains an ecc-engine property.
88  *
89  * Get the ecc-engine property from the given device tree
90  * node and pass it to ingenic_ecc_get to do the work.
91  *
92  * Return: a pointer to ingenic_ecc, errors are encoded into the pointer.
93  * PTR_ERR(-EPROBE_DEFER) if the device hasn't been initialised yet.
94  */
95 struct ingenic_ecc *of_ingenic_ecc_get(struct device_node *of_node)
96 {
97 	struct ingenic_ecc *ecc = NULL;
98 	struct device_node *np;
99 
100 	np = of_parse_phandle(of_node, "ecc-engine", 0);
101 
102 	/*
103 	 * If the ecc-engine property is not found, check for the deprecated
104 	 * ingenic,bch-controller property
105 	 */
106 	if (!np)
107 		np = of_parse_phandle(of_node, "ingenic,bch-controller", 0);
108 
109 	if (np) {
110 		ecc = ingenic_ecc_get(np);
111 		of_node_put(np);
112 	}
113 	return ecc;
114 }
115 
116 /**
117  * ingenic_ecc_release() - release the ECC controller device
118  * @ecc: ECC device.
119  */
120 void ingenic_ecc_release(struct ingenic_ecc *ecc)
121 {
122 	clk_disable_unprepare(ecc->clk);
123 	put_device(ecc->dev);
124 }
125 
126 int ingenic_ecc_probe(struct platform_device *pdev)
127 {
128 	struct device *dev = &pdev->dev;
129 	struct ingenic_ecc *ecc;
130 
131 	ecc = devm_kzalloc(dev, sizeof(*ecc), GFP_KERNEL);
132 	if (!ecc)
133 		return -ENOMEM;
134 
135 	ecc->ops = device_get_match_data(dev);
136 	if (!ecc->ops)
137 		return -EINVAL;
138 
139 	ecc->base = devm_platform_ioremap_resource(pdev, 0);
140 	if (IS_ERR(ecc->base))
141 		return PTR_ERR(ecc->base);
142 
143 	ecc->ops->disable(ecc);
144 
145 	ecc->clk = devm_clk_get(dev, NULL);
146 	if (IS_ERR(ecc->clk)) {
147 		dev_err(dev, "failed to get clock: %ld\n", PTR_ERR(ecc->clk));
148 		return PTR_ERR(ecc->clk);
149 	}
150 
151 	mutex_init(&ecc->lock);
152 
153 	ecc->dev = dev;
154 	platform_set_drvdata(pdev, ecc);
155 
156 	return 0;
157 }
158 EXPORT_SYMBOL(ingenic_ecc_probe);
159