1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Probing flash chips with QINFO records. |
4 | * (C) 2008 Korolev Alexey <akorolev@infradead.org> |
5 | * (C) 2008 Vasiliy Leonenko <vasiliy.leonenko@gmail.com> |
6 | */ |
7 | #include <linux/module.h> |
8 | #include <linux/types.h> |
9 | #include <linux/kernel.h> |
10 | #include <linux/init.h> |
11 | #include <linux/errno.h> |
12 | #include <linux/slab.h> |
13 | #include <linux/interrupt.h> |
14 | |
15 | #include <linux/mtd/xip.h> |
16 | #include <linux/mtd/map.h> |
17 | #include <linux/mtd/pfow.h> |
18 | #include <linux/mtd/qinfo.h> |
19 | |
20 | static int lpddr_chip_setup(struct map_info *map, struct lpddr_private *lpddr); |
21 | struct mtd_info *lpddr_probe(struct map_info *map); |
22 | static struct lpddr_private *lpddr_probe_chip(struct map_info *map); |
23 | static int lpddr_pfow_present(struct map_info *map, |
24 | struct lpddr_private *lpddr); |
25 | |
26 | static struct qinfo_query_info qinfo_array[] = { |
27 | /* General device info */ |
28 | {0, 0, "DevSizeShift" , "Device size 2^n bytes" }, |
29 | {0, 3, "BufSizeShift" , "Program buffer size 2^n bytes" }, |
30 | /* Erase block information */ |
31 | {1, 1, "TotalBlocksNum" , "Total number of blocks" }, |
32 | {1, 2, "UniformBlockSizeShift" , "Uniform block size 2^n bytes" }, |
33 | /* Partition information */ |
34 | {2, 1, "HWPartsNum" , "Number of hardware partitions" }, |
35 | /* Optional features */ |
36 | {5, 1, "SuspEraseSupp" , "Suspend erase supported" }, |
37 | /* Operation typical time */ |
38 | {10, 0, "SingleWordProgTime" , "Single word program 2^n u-sec" }, |
39 | {10, 1, "ProgBufferTime" , "Program buffer write 2^n u-sec" }, |
40 | {10, 2, "BlockEraseTime" , "Block erase 2^n m-sec" }, |
41 | {10, 3, "FullChipEraseTime" , "Full chip erase 2^n m-sec" }, |
42 | }; |
43 | |
44 | static long lpddr_get_qinforec_pos(struct map_info *map, char *id_str) |
45 | { |
46 | int qinfo_lines = ARRAY_SIZE(qinfo_array); |
47 | int i; |
48 | int bankwidth = map_bankwidth(map) * 8; |
49 | int major, minor; |
50 | |
51 | for (i = 0; i < qinfo_lines; i++) { |
52 | if (strcmp(id_str, qinfo_array[i].id_str) == 0) { |
53 | major = qinfo_array[i].major & ((1 << bankwidth) - 1); |
54 | minor = qinfo_array[i].minor & ((1 << bankwidth) - 1); |
55 | return minor | (major << bankwidth); |
56 | } |
57 | } |
58 | printk(KERN_ERR"%s qinfo id string is wrong! \n" , map->name); |
59 | BUG(); |
60 | return -1; |
61 | } |
62 | |
63 | static uint16_t lpddr_info_query(struct map_info *map, char *id_str) |
64 | { |
65 | unsigned int dsr, val; |
66 | int bits_per_chip = map_bankwidth(map) * 8; |
67 | unsigned long adr = lpddr_get_qinforec_pos(map, id_str); |
68 | int attempts = 20; |
69 | |
70 | /* Write a request for the PFOW record */ |
71 | map_write(map, CMD(LPDDR_INFO_QUERY), |
72 | map->pfow_base + PFOW_COMMAND_CODE); |
73 | map_write(map, CMD(adr & ((1 << bits_per_chip) - 1)), |
74 | map->pfow_base + PFOW_COMMAND_ADDRESS_L); |
75 | map_write(map, CMD(adr >> bits_per_chip), |
76 | map->pfow_base + PFOW_COMMAND_ADDRESS_H); |
77 | map_write(map, CMD(LPDDR_START_EXECUTION), |
78 | map->pfow_base + PFOW_COMMAND_EXECUTE); |
79 | |
80 | while ((attempts--) > 0) { |
81 | dsr = CMDVAL(map_read(map, map->pfow_base + PFOW_DSR)); |
82 | if (dsr & DSR_READY_STATUS) |
83 | break; |
84 | udelay(10); |
85 | } |
86 | |
87 | val = CMDVAL(map_read(map, map->pfow_base + PFOW_COMMAND_DATA)); |
88 | return val; |
89 | } |
90 | |
91 | static int lpddr_pfow_present(struct map_info *map, struct lpddr_private *lpddr) |
92 | { |
93 | map_word pfow_val[4]; |
94 | |
95 | /* Check identification string */ |
96 | pfow_val[0] = map_read(map, map->pfow_base + PFOW_QUERY_STRING_P); |
97 | pfow_val[1] = map_read(map, map->pfow_base + PFOW_QUERY_STRING_F); |
98 | pfow_val[2] = map_read(map, map->pfow_base + PFOW_QUERY_STRING_O); |
99 | pfow_val[3] = map_read(map, map->pfow_base + PFOW_QUERY_STRING_W); |
100 | |
101 | if (!map_word_equal(map, CMD('P'), pfow_val[0])) |
102 | goto out; |
103 | |
104 | if (!map_word_equal(map, CMD('F'), pfow_val[1])) |
105 | goto out; |
106 | |
107 | if (!map_word_equal(map, CMD('O'), pfow_val[2])) |
108 | goto out; |
109 | |
110 | if (!map_word_equal(map, CMD('W'), pfow_val[3])) |
111 | goto out; |
112 | |
113 | return 1; /* "PFOW" is found */ |
114 | out: |
115 | printk(KERN_WARNING"%s: PFOW string at 0x%lx is not found \n" , |
116 | map->name, map->pfow_base); |
117 | return 0; |
118 | } |
119 | |
120 | static int lpddr_chip_setup(struct map_info *map, struct lpddr_private *lpddr) |
121 | { |
122 | |
123 | lpddr->qinfo = kzalloc(size: sizeof(struct qinfo_chip), GFP_KERNEL); |
124 | if (!lpddr->qinfo) |
125 | return 0; |
126 | |
127 | /* Get the ManuID */ |
128 | lpddr->ManufactId = CMDVAL(map_read(map, map->pfow_base + PFOW_MANUFACTURER_ID)); |
129 | /* Get the DeviceID */ |
130 | lpddr->DevId = CMDVAL(map_read(map, map->pfow_base + PFOW_DEVICE_ID)); |
131 | /* read parameters from chip qinfo table */ |
132 | lpddr->qinfo->DevSizeShift = lpddr_info_query(map, id_str: "DevSizeShift" ); |
133 | lpddr->qinfo->TotalBlocksNum = lpddr_info_query(map, id_str: "TotalBlocksNum" ); |
134 | lpddr->qinfo->BufSizeShift = lpddr_info_query(map, id_str: "BufSizeShift" ); |
135 | lpddr->qinfo->HWPartsNum = lpddr_info_query(map, id_str: "HWPartsNum" ); |
136 | lpddr->qinfo->UniformBlockSizeShift = |
137 | lpddr_info_query(map, id_str: "UniformBlockSizeShift" ); |
138 | lpddr->qinfo->SuspEraseSupp = lpddr_info_query(map, id_str: "SuspEraseSupp" ); |
139 | lpddr->qinfo->SingleWordProgTime = |
140 | lpddr_info_query(map, id_str: "SingleWordProgTime" ); |
141 | lpddr->qinfo->ProgBufferTime = lpddr_info_query(map, id_str: "ProgBufferTime" ); |
142 | lpddr->qinfo->BlockEraseTime = lpddr_info_query(map, id_str: "BlockEraseTime" ); |
143 | return 1; |
144 | } |
145 | static struct lpddr_private *lpddr_probe_chip(struct map_info *map) |
146 | { |
147 | struct lpddr_private lpddr; |
148 | struct lpddr_private *retlpddr; |
149 | int numvirtchips; |
150 | |
151 | |
152 | if ((map->pfow_base + 0x1000) >= map->size) { |
153 | printk(KERN_NOTICE"%s Probe at base (0x%08lx) past the end of" |
154 | "the map(0x%08lx)\n" , map->name, |
155 | (unsigned long)map->pfow_base, map->size - 1); |
156 | return NULL; |
157 | } |
158 | memset(&lpddr, 0, sizeof(struct lpddr_private)); |
159 | if (!lpddr_pfow_present(map, lpddr: &lpddr)) |
160 | return NULL; |
161 | |
162 | if (!lpddr_chip_setup(map, lpddr: &lpddr)) |
163 | return NULL; |
164 | |
165 | /* Ok so we found a chip */ |
166 | lpddr.chipshift = lpddr.qinfo->DevSizeShift; |
167 | lpddr.numchips = 1; |
168 | |
169 | numvirtchips = lpddr.numchips * lpddr.qinfo->HWPartsNum; |
170 | retlpddr = kzalloc(struct_size(retlpddr, chips, numvirtchips), |
171 | GFP_KERNEL); |
172 | if (!retlpddr) |
173 | return NULL; |
174 | |
175 | memcpy(retlpddr, &lpddr, sizeof(struct lpddr_private)); |
176 | |
177 | retlpddr->numchips = numvirtchips; |
178 | retlpddr->chipshift = retlpddr->qinfo->DevSizeShift - |
179 | __ffs(retlpddr->qinfo->HWPartsNum); |
180 | |
181 | return retlpddr; |
182 | } |
183 | |
184 | struct mtd_info *lpddr_probe(struct map_info *map) |
185 | { |
186 | struct mtd_info *mtd = NULL; |
187 | struct lpddr_private *lpddr; |
188 | |
189 | /* First probe the map to see if we havecan open PFOW here */ |
190 | lpddr = lpddr_probe_chip(map); |
191 | if (!lpddr) |
192 | return NULL; |
193 | |
194 | map->fldrv_priv = lpddr; |
195 | mtd = lpddr_cmdset(map); |
196 | if (mtd) { |
197 | if (mtd->size > map->size) { |
198 | printk(KERN_WARNING "Reducing visibility of %ldKiB chip" |
199 | "to %ldKiB\n" , (unsigned long)mtd->size >> 10, |
200 | (unsigned long)map->size >> 10); |
201 | mtd->size = map->size; |
202 | } |
203 | return mtd; |
204 | } |
205 | |
206 | kfree(objp: lpddr->qinfo); |
207 | kfree(objp: lpddr); |
208 | map->fldrv_priv = NULL; |
209 | return NULL; |
210 | } |
211 | |
212 | static struct mtd_chip_driver lpddr_chipdrv = { |
213 | .probe = lpddr_probe, |
214 | .name = "qinfo_probe" , |
215 | .module = THIS_MODULE |
216 | }; |
217 | |
218 | static int __init lpddr_probe_init(void) |
219 | { |
220 | register_mtd_chip_driver(&lpddr_chipdrv); |
221 | return 0; |
222 | } |
223 | |
224 | static void __exit lpddr_probe_exit(void) |
225 | { |
226 | unregister_mtd_chip_driver(&lpddr_chipdrv); |
227 | } |
228 | |
229 | module_init(lpddr_probe_init); |
230 | module_exit(lpddr_probe_exit); |
231 | |
232 | MODULE_LICENSE("GPL" ); |
233 | MODULE_AUTHOR("Vasiliy Leonenko <vasiliy.leonenko@gmail.com>" ); |
234 | MODULE_DESCRIPTION("Driver to probe qinfo flash chips" ); |
235 | |
236 | |