blob: d3cfe26beeaa6bcc771a085f1e3f41d641af4c19 [file] [log] [blame]
Alexey Korolevc6826472008-12-16 18:20:03 +00001/*
2 * LPDDR flash memory device operations. This module provides read, write,
3 * erase, lock/unlock support for LPDDR flash memories
4 * (C) 2008 Korolev Alexey <akorolev@infradead.org>
5 * (C) 2008 Vasiliy Leonenko <vasiliy.leonenko@gmail.com>
Lucas De Marchi25985ed2011-03-30 22:57:33 -03006 * Many thanks to Roman Borisov for initial enabling
Alexey Korolevc6826472008-12-16 18:20:03 +00007 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21 * 02110-1301, USA.
22 * TODO:
23 * Implement VPP management
24 * Implement XIP support
25 * Implement OTP support
26 */
27#include <linux/mtd/pfow.h>
28#include <linux/mtd/qinfo.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090029#include <linux/slab.h>
Paul Gortmakera0e5cc52011-07-03 15:17:31 -040030#include <linux/module.h>
Alexey Korolevc6826472008-12-16 18:20:03 +000031
32static int lpddr_read(struct mtd_info *mtd, loff_t adr, size_t len,
33 size_t *retlen, u_char *buf);
34static int lpddr_write_buffers(struct mtd_info *mtd, loff_t to,
35 size_t len, size_t *retlen, const u_char *buf);
36static int lpddr_writev(struct mtd_info *mtd, const struct kvec *vecs,
37 unsigned long count, loff_t to, size_t *retlen);
38static int lpddr_erase(struct mtd_info *mtd, struct erase_info *instr);
39static int lpddr_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
40static int lpddr_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
41static int lpddr_point(struct mtd_info *mtd, loff_t adr, size_t len,
42 size_t *retlen, void **mtdbuf, resource_size_t *phys);
Artem Bityutskiy5e4e6e32012-02-03 13:20:43 +020043static int lpddr_unpoint(struct mtd_info *mtd, loff_t adr, size_t len);
Alexey Korolevc6826472008-12-16 18:20:03 +000044static int get_chip(struct map_info *map, struct flchip *chip, int mode);
45static int chip_ready(struct map_info *map, struct flchip *chip, int mode);
46static void put_chip(struct map_info *map, struct flchip *chip);
47
48struct mtd_info *lpddr_cmdset(struct map_info *map)
49{
50 struct lpddr_private *lpddr = map->fldrv_priv;
51 struct flchip_shared *shared;
52 struct flchip *chip;
53 struct mtd_info *mtd;
54 int numchips;
55 int i, j;
56
57 mtd = kzalloc(sizeof(*mtd), GFP_KERNEL);
58 if (!mtd) {
59 printk(KERN_ERR "Failed to allocate memory for MTD device\n");
60 return NULL;
61 }
62 mtd->priv = map;
63 mtd->type = MTD_NORFLASH;
64
65 /* Fill in the default mtd operations */
Artem Bityutskiy3c3c10b2012-01-30 14:58:32 +020066 mtd->_read = lpddr_read;
Alexey Korolevc6826472008-12-16 18:20:03 +000067 mtd->type = MTD_NORFLASH;
68 mtd->flags = MTD_CAP_NORFLASH;
69 mtd->flags &= ~MTD_BIT_WRITEABLE;
Artem Bityutskiy3c3c10b2012-01-30 14:58:32 +020070 mtd->_erase = lpddr_erase;
71 mtd->_write = lpddr_write_buffers;
72 mtd->_writev = lpddr_writev;
73 mtd->_lock = lpddr_lock;
74 mtd->_unlock = lpddr_unlock;
Alexey Korolevc6826472008-12-16 18:20:03 +000075 if (map_is_linear(map)) {
Artem Bityutskiy3c3c10b2012-01-30 14:58:32 +020076 mtd->_point = lpddr_point;
77 mtd->_unpoint = lpddr_unpoint;
Alexey Korolevc6826472008-12-16 18:20:03 +000078 }
Alexey Korolevc6826472008-12-16 18:20:03 +000079 mtd->size = 1 << lpddr->qinfo->DevSizeShift;
80 mtd->erasesize = 1 << lpddr->qinfo->UniformBlockSizeShift;
81 mtd->writesize = 1 << lpddr->qinfo->BufSizeShift;
82
83 shared = kmalloc(sizeof(struct flchip_shared) * lpddr->numchips,
84 GFP_KERNEL);
85 if (!shared) {
86 kfree(lpddr);
87 kfree(mtd);
88 return NULL;
89 }
90
91 chip = &lpddr->chips[0];
92 numchips = lpddr->numchips / lpddr->qinfo->HWPartsNum;
93 for (i = 0; i < numchips; i++) {
94 shared[i].writing = shared[i].erasing = NULL;
Stefani Seibold8ae66412010-08-05 09:19:26 +020095 mutex_init(&shared[i].lock);
Alexey Korolevc6826472008-12-16 18:20:03 +000096 for (j = 0; j < lpddr->qinfo->HWPartsNum; j++) {
97 *chip = lpddr->chips[i];
98 chip->start += j << lpddr->chipshift;
99 chip->oldstate = chip->state = FL_READY;
100 chip->priv = &shared[i];
101 /* those should be reset too since
102 they create memory references. */
103 init_waitqueue_head(&chip->wq);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200104 mutex_init(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000105 chip++;
106 }
107 }
108
109 return mtd;
110}
111EXPORT_SYMBOL(lpddr_cmdset);
112
113static int wait_for_ready(struct map_info *map, struct flchip *chip,
114 unsigned int chip_op_time)
115{
116 unsigned int timeo, reset_timeo, sleep_time;
117 unsigned int dsr;
118 flstate_t chip_state = chip->state;
119 int ret = 0;
120
121 /* set our timeout to 8 times the expected delay */
122 timeo = chip_op_time * 8;
123 if (!timeo)
124 timeo = 500000;
125 reset_timeo = timeo;
126 sleep_time = chip_op_time / 2;
127
128 for (;;) {
129 dsr = CMDVAL(map_read(map, map->pfow_base + PFOW_DSR));
130 if (dsr & DSR_READY_STATUS)
131 break;
132 if (!timeo) {
133 printk(KERN_ERR "%s: Flash timeout error state %d \n",
134 map->name, chip_state);
135 ret = -ETIME;
136 break;
137 }
138
139 /* OK Still waiting. Drop the lock, wait a while and retry. */
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200140 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000141 if (sleep_time >= 1000000/HZ) {
142 /*
143 * Half of the normal delay still remaining
144 * can be performed with a sleeping delay instead
145 * of busy waiting.
146 */
147 msleep(sleep_time/1000);
148 timeo -= sleep_time;
149 sleep_time = 1000000/HZ;
150 } else {
151 udelay(1);
152 cond_resched();
153 timeo--;
154 }
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200155 mutex_lock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000156
157 while (chip->state != chip_state) {
158 /* Someone's suspended the operation: sleep */
159 DECLARE_WAITQUEUE(wait, current);
160 set_current_state(TASK_UNINTERRUPTIBLE);
161 add_wait_queue(&chip->wq, &wait);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200162 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000163 schedule();
164 remove_wait_queue(&chip->wq, &wait);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200165 mutex_lock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000166 }
167 if (chip->erase_suspended || chip->write_suspended) {
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300168 /* Suspend has occurred while sleep: reset timeout */
Alexey Korolevc6826472008-12-16 18:20:03 +0000169 timeo = reset_timeo;
170 chip->erase_suspended = chip->write_suspended = 0;
171 }
172 }
173 /* check status for errors */
174 if (dsr & DSR_ERR) {
175 /* Clear DSR*/
176 map_write(map, CMD(~(DSR_ERR)), map->pfow_base + PFOW_DSR);
177 printk(KERN_WARNING"%s: Bad status on wait: 0x%x \n",
178 map->name, dsr);
179 print_drs_error(dsr);
180 ret = -EIO;
181 }
182 chip->state = FL_READY;
183 return ret;
184}
185
186static int get_chip(struct map_info *map, struct flchip *chip, int mode)
187{
188 int ret;
189 DECLARE_WAITQUEUE(wait, current);
190
191 retry:
192 if (chip->priv && (mode == FL_WRITING || mode == FL_ERASING)
193 && chip->state != FL_SYNCING) {
194 /*
195 * OK. We have possibility for contension on the write/erase
196 * operations which are global to the real chip and not per
197 * partition. So let's fight it over in the partition which
198 * currently has authority on the operation.
199 *
200 * The rules are as follows:
201 *
202 * - any write operation must own shared->writing.
203 *
204 * - any erase operation must own _both_ shared->writing and
205 * shared->erasing.
206 *
207 * - contension arbitration is handled in the owner's context.
208 *
209 * The 'shared' struct can be read and/or written only when
210 * its lock is taken.
211 */
212 struct flchip_shared *shared = chip->priv;
213 struct flchip *contender;
Stefani Seibold8ae66412010-08-05 09:19:26 +0200214 mutex_lock(&shared->lock);
Alexey Korolevc6826472008-12-16 18:20:03 +0000215 contender = shared->writing;
216 if (contender && contender != chip) {
217 /*
218 * The engine to perform desired operation on this
219 * partition is already in use by someone else.
220 * Let's fight over it in the context of the chip
221 * currently using it. If it is possible to suspend,
222 * that other partition will do just that, otherwise
223 * it'll happily send us to sleep. In any case, when
224 * get_chip returns success we're clear to go ahead.
225 */
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200226 ret = mutex_trylock(&contender->mutex);
Stefani Seibold8ae66412010-08-05 09:19:26 +0200227 mutex_unlock(&shared->lock);
Alexey Korolevc6826472008-12-16 18:20:03 +0000228 if (!ret)
229 goto retry;
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200230 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000231 ret = chip_ready(map, contender, mode);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200232 mutex_lock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000233
234 if (ret == -EAGAIN) {
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200235 mutex_unlock(&contender->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000236 goto retry;
237 }
238 if (ret) {
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200239 mutex_unlock(&contender->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000240 return ret;
241 }
Stefani Seibold8ae66412010-08-05 09:19:26 +0200242 mutex_lock(&shared->lock);
Alexey Korolevc6826472008-12-16 18:20:03 +0000243
244 /* We should not own chip if it is already in FL_SYNCING
245 * state. Put contender and retry. */
246 if (chip->state == FL_SYNCING) {
247 put_chip(map, contender);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200248 mutex_unlock(&contender->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000249 goto retry;
250 }
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200251 mutex_unlock(&contender->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000252 }
253
254 /* Check if we have suspended erase on this chip.
255 Must sleep in such a case. */
256 if (mode == FL_ERASING && shared->erasing
257 && shared->erasing->oldstate == FL_ERASING) {
Stefani Seibold8ae66412010-08-05 09:19:26 +0200258 mutex_unlock(&shared->lock);
Alexey Korolevc6826472008-12-16 18:20:03 +0000259 set_current_state(TASK_UNINTERRUPTIBLE);
260 add_wait_queue(&chip->wq, &wait);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200261 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000262 schedule();
263 remove_wait_queue(&chip->wq, &wait);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200264 mutex_lock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000265 goto retry;
266 }
267
268 /* We now own it */
269 shared->writing = chip;
270 if (mode == FL_ERASING)
271 shared->erasing = chip;
Stefani Seibold8ae66412010-08-05 09:19:26 +0200272 mutex_unlock(&shared->lock);
Alexey Korolevc6826472008-12-16 18:20:03 +0000273 }
274
275 ret = chip_ready(map, chip, mode);
276 if (ret == -EAGAIN)
277 goto retry;
278
279 return ret;
280}
281
282static int chip_ready(struct map_info *map, struct flchip *chip, int mode)
283{
284 struct lpddr_private *lpddr = map->fldrv_priv;
285 int ret = 0;
286 DECLARE_WAITQUEUE(wait, current);
287
288 /* Prevent setting state FL_SYNCING for chip in suspended state. */
289 if (FL_SYNCING == mode && FL_READY != chip->oldstate)
290 goto sleep;
291
292 switch (chip->state) {
293 case FL_READY:
294 case FL_JEDEC_QUERY:
295 return 0;
296
297 case FL_ERASING:
298 if (!lpddr->qinfo->SuspEraseSupp ||
299 !(mode == FL_READY || mode == FL_POINT))
300 goto sleep;
301
302 map_write(map, CMD(LPDDR_SUSPEND),
303 map->pfow_base + PFOW_PROGRAM_ERASE_SUSPEND);
304 chip->oldstate = FL_ERASING;
305 chip->state = FL_ERASE_SUSPENDING;
306 ret = wait_for_ready(map, chip, 0);
307 if (ret) {
308 /* Oops. something got wrong. */
309 /* Resume and pretend we weren't here. */
Tadashi Abe100f2342011-05-19 15:58:15 +0900310 put_chip(map, chip);
Alexey Korolevc6826472008-12-16 18:20:03 +0000311 printk(KERN_ERR "%s: suspend operation failed."
312 "State may be wrong \n", map->name);
313 return -EIO;
314 }
315 chip->erase_suspended = 1;
316 chip->state = FL_READY;
317 return 0;
318 /* Erase suspend */
319 case FL_POINT:
320 /* Only if there's no operation suspended... */
321 if (mode == FL_READY && chip->oldstate == FL_READY)
322 return 0;
323
324 default:
325sleep:
326 set_current_state(TASK_UNINTERRUPTIBLE);
327 add_wait_queue(&chip->wq, &wait);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200328 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000329 schedule();
330 remove_wait_queue(&chip->wq, &wait);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200331 mutex_lock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000332 return -EAGAIN;
333 }
334}
335
336static void put_chip(struct map_info *map, struct flchip *chip)
337{
338 if (chip->priv) {
339 struct flchip_shared *shared = chip->priv;
Stefani Seibold8ae66412010-08-05 09:19:26 +0200340 mutex_lock(&shared->lock);
Alexey Korolevc6826472008-12-16 18:20:03 +0000341 if (shared->writing == chip && chip->oldstate == FL_READY) {
342 /* We own the ability to write, but we're done */
343 shared->writing = shared->erasing;
344 if (shared->writing && shared->writing != chip) {
345 /* give back the ownership */
346 struct flchip *loaner = shared->writing;
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200347 mutex_lock(&loaner->mutex);
Stefani Seibold8ae66412010-08-05 09:19:26 +0200348 mutex_unlock(&shared->lock);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200349 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000350 put_chip(map, loaner);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200351 mutex_lock(&chip->mutex);
352 mutex_unlock(&loaner->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000353 wake_up(&chip->wq);
354 return;
355 }
356 shared->erasing = NULL;
357 shared->writing = NULL;
358 } else if (shared->erasing == chip && shared->writing != chip) {
359 /*
360 * We own the ability to erase without the ability
361 * to write, which means the erase was suspended
362 * and some other partition is currently writing.
363 * Don't let the switch below mess things up since
364 * we don't have ownership to resume anything.
365 */
Stefani Seibold8ae66412010-08-05 09:19:26 +0200366 mutex_unlock(&shared->lock);
Alexey Korolevc6826472008-12-16 18:20:03 +0000367 wake_up(&chip->wq);
368 return;
369 }
Stefani Seibold8ae66412010-08-05 09:19:26 +0200370 mutex_unlock(&shared->lock);
Alexey Korolevc6826472008-12-16 18:20:03 +0000371 }
372
373 switch (chip->oldstate) {
374 case FL_ERASING:
Alexey Korolevc6826472008-12-16 18:20:03 +0000375 map_write(map, CMD(LPDDR_RESUME),
376 map->pfow_base + PFOW_COMMAND_CODE);
377 map_write(map, CMD(LPDDR_START_EXECUTION),
378 map->pfow_base + PFOW_COMMAND_EXECUTE);
379 chip->oldstate = FL_READY;
380 chip->state = FL_ERASING;
381 break;
382 case FL_READY:
383 break;
384 default:
385 printk(KERN_ERR "%s: put_chip() called with oldstate %d!\n",
386 map->name, chip->oldstate);
387 }
388 wake_up(&chip->wq);
389}
390
391int do_write_buffer(struct map_info *map, struct flchip *chip,
392 unsigned long adr, const struct kvec **pvec,
393 unsigned long *pvec_seek, int len)
394{
395 struct lpddr_private *lpddr = map->fldrv_priv;
396 map_word datum;
397 int ret, wbufsize, word_gap, words;
398 const struct kvec *vec;
399 unsigned long vec_seek;
400 unsigned long prog_buf_ofs;
401
402 wbufsize = 1 << lpddr->qinfo->BufSizeShift;
403
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200404 mutex_lock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000405 ret = get_chip(map, chip, FL_WRITING);
406 if (ret) {
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200407 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000408 return ret;
409 }
410 /* Figure out the number of words to write */
411 word_gap = (-adr & (map_bankwidth(map)-1));
412 words = (len - word_gap + map_bankwidth(map) - 1) / map_bankwidth(map);
413 if (!word_gap) {
414 words--;
415 } else {
416 word_gap = map_bankwidth(map) - word_gap;
417 adr -= word_gap;
418 datum = map_word_ff(map);
419 }
420 /* Write data */
421 /* Get the program buffer offset from PFOW register data first*/
422 prog_buf_ofs = map->pfow_base + CMDVAL(map_read(map,
423 map->pfow_base + PFOW_PROGRAM_BUFFER_OFFSET));
424 vec = *pvec;
425 vec_seek = *pvec_seek;
426 do {
427 int n = map_bankwidth(map) - word_gap;
428
429 if (n > vec->iov_len - vec_seek)
430 n = vec->iov_len - vec_seek;
431 if (n > len)
432 n = len;
433
434 if (!word_gap && (len < map_bankwidth(map)))
435 datum = map_word_ff(map);
436
437 datum = map_word_load_partial(map, datum,
438 vec->iov_base + vec_seek, word_gap, n);
439
440 len -= n;
441 word_gap += n;
442 if (!len || word_gap == map_bankwidth(map)) {
443 map_write(map, datum, prog_buf_ofs);
444 prog_buf_ofs += map_bankwidth(map);
445 word_gap = 0;
446 }
447
448 vec_seek += n;
449 if (vec_seek == vec->iov_len) {
450 vec++;
451 vec_seek = 0;
452 }
453 } while (len);
454 *pvec = vec;
455 *pvec_seek = vec_seek;
456
457 /* GO GO GO */
458 send_pfow_command(map, LPDDR_BUFF_PROGRAM, adr, wbufsize, NULL);
459 chip->state = FL_WRITING;
460 ret = wait_for_ready(map, chip, (1<<lpddr->qinfo->ProgBufferTime));
461 if (ret) {
462 printk(KERN_WARNING"%s Buffer program error: %d at %lx; \n",
463 map->name, ret, adr);
464 goto out;
465 }
466
467 out: put_chip(map, chip);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200468 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000469 return ret;
470}
471
472int do_erase_oneblock(struct mtd_info *mtd, loff_t adr)
473{
474 struct map_info *map = mtd->priv;
475 struct lpddr_private *lpddr = map->fldrv_priv;
476 int chipnum = adr >> lpddr->chipshift;
477 struct flchip *chip = &lpddr->chips[chipnum];
478 int ret;
479
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200480 mutex_lock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000481 ret = get_chip(map, chip, FL_ERASING);
482 if (ret) {
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200483 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000484 return ret;
485 }
486 send_pfow_command(map, LPDDR_BLOCK_ERASE, adr, 0, NULL);
487 chip->state = FL_ERASING;
488 ret = wait_for_ready(map, chip, (1<<lpddr->qinfo->BlockEraseTime)*1000);
489 if (ret) {
490 printk(KERN_WARNING"%s Erase block error %d at : %llx\n",
491 map->name, ret, adr);
492 goto out;
493 }
494 out: put_chip(map, chip);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200495 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000496 return ret;
497}
498
499static int lpddr_read(struct mtd_info *mtd, loff_t adr, size_t len,
500 size_t *retlen, u_char *buf)
501{
502 struct map_info *map = mtd->priv;
503 struct lpddr_private *lpddr = map->fldrv_priv;
504 int chipnum = adr >> lpddr->chipshift;
505 struct flchip *chip = &lpddr->chips[chipnum];
506 int ret = 0;
507
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200508 mutex_lock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000509 ret = get_chip(map, chip, FL_READY);
510 if (ret) {
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200511 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000512 return ret;
513 }
514
515 map_copy_from(map, buf, adr, len);
516 *retlen = len;
517
518 put_chip(map, chip);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200519 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000520 return ret;
521}
522
523static int lpddr_point(struct mtd_info *mtd, loff_t adr, size_t len,
524 size_t *retlen, void **mtdbuf, resource_size_t *phys)
525{
526 struct map_info *map = mtd->priv;
527 struct lpddr_private *lpddr = map->fldrv_priv;
528 int chipnum = adr >> lpddr->chipshift;
529 unsigned long ofs, last_end = 0;
530 struct flchip *chip = &lpddr->chips[chipnum];
531 int ret = 0;
532
Artem Bityutskiy5def4892012-02-03 16:23:52 +0200533 if (!map->virt)
Alexey Korolevc6826472008-12-16 18:20:03 +0000534 return -EINVAL;
535
536 /* ofs: offset within the first chip that the first read should start */
537 ofs = adr - (chipnum << lpddr->chipshift);
Alexey Korolevc6826472008-12-16 18:20:03 +0000538 *mtdbuf = (void *)map->virt + chip->start + ofs;
Alexey Korolevc6826472008-12-16 18:20:03 +0000539
540 while (len) {
541 unsigned long thislen;
542
543 if (chipnum >= lpddr->numchips)
544 break;
545
546 /* We cannot point across chips that are virtually disjoint */
547 if (!last_end)
548 last_end = chip->start;
549 else if (chip->start != last_end)
550 break;
551
552 if ((len + ofs - 1) >> lpddr->chipshift)
553 thislen = (1<<lpddr->chipshift) - ofs;
554 else
555 thislen = len;
556 /* get the chip */
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200557 mutex_lock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000558 ret = get_chip(map, chip, FL_POINT);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200559 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000560 if (ret)
561 break;
562
563 chip->state = FL_POINT;
564 chip->ref_point_counter++;
565 *retlen += thislen;
566 len -= thislen;
567
568 ofs = 0;
569 last_end += 1 << lpddr->chipshift;
570 chipnum++;
571 chip = &lpddr->chips[chipnum];
572 }
573 return 0;
574}
575
Artem Bityutskiy5e4e6e32012-02-03 13:20:43 +0200576static int lpddr_unpoint (struct mtd_info *mtd, loff_t adr, size_t len)
Alexey Korolevc6826472008-12-16 18:20:03 +0000577{
578 struct map_info *map = mtd->priv;
579 struct lpddr_private *lpddr = map->fldrv_priv;
Artem Bityutskiy5e4e6e32012-02-03 13:20:43 +0200580 int chipnum = adr >> lpddr->chipshift, err = 0;
Alexey Korolevc6826472008-12-16 18:20:03 +0000581 unsigned long ofs;
582
583 /* ofs: offset within the first chip that the first read should start */
584 ofs = adr - (chipnum << lpddr->chipshift);
585
586 while (len) {
587 unsigned long thislen;
588 struct flchip *chip;
589
590 chip = &lpddr->chips[chipnum];
591 if (chipnum >= lpddr->numchips)
592 break;
593
594 if ((len + ofs - 1) >> lpddr->chipshift)
595 thislen = (1<<lpddr->chipshift) - ofs;
596 else
597 thislen = len;
598
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200599 mutex_lock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000600 if (chip->state == FL_POINT) {
601 chip->ref_point_counter--;
602 if (chip->ref_point_counter == 0)
603 chip->state = FL_READY;
Artem Bityutskiy5e4e6e32012-02-03 13:20:43 +0200604 } else {
Alexey Korolevc6826472008-12-16 18:20:03 +0000605 printk(KERN_WARNING "%s: Warning: unpoint called on non"
606 "pointed region\n", map->name);
Artem Bityutskiy5e4e6e32012-02-03 13:20:43 +0200607 err = -EINVAL;
608 }
Alexey Korolevc6826472008-12-16 18:20:03 +0000609
610 put_chip(map, chip);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200611 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000612
613 len -= thislen;
614 ofs = 0;
615 chipnum++;
616 }
Artem Bityutskiy5e4e6e32012-02-03 13:20:43 +0200617
618 return err;
Alexey Korolevc6826472008-12-16 18:20:03 +0000619}
620
621static int lpddr_write_buffers(struct mtd_info *mtd, loff_t to, size_t len,
622 size_t *retlen, const u_char *buf)
623{
624 struct kvec vec;
625
626 vec.iov_base = (void *) buf;
627 vec.iov_len = len;
628
629 return lpddr_writev(mtd, &vec, 1, to, retlen);
630}
631
632
633static int lpddr_writev(struct mtd_info *mtd, const struct kvec *vecs,
634 unsigned long count, loff_t to, size_t *retlen)
635{
636 struct map_info *map = mtd->priv;
637 struct lpddr_private *lpddr = map->fldrv_priv;
638 int ret = 0;
639 int chipnum;
640 unsigned long ofs, vec_seek, i;
641 int wbufsize = 1 << lpddr->qinfo->BufSizeShift;
Alexey Korolevc6826472008-12-16 18:20:03 +0000642 size_t len = 0;
643
644 for (i = 0; i < count; i++)
645 len += vecs[i].iov_len;
646
Alexey Korolevc6826472008-12-16 18:20:03 +0000647 if (!len)
648 return 0;
649
650 chipnum = to >> lpddr->chipshift;
651
652 ofs = to;
653 vec_seek = 0;
654
655 do {
656 /* We must not cross write block boundaries */
657 int size = wbufsize - (ofs & (wbufsize-1));
658
659 if (size > len)
660 size = len;
661
662 ret = do_write_buffer(map, &lpddr->chips[chipnum],
663 ofs, &vecs, &vec_seek, size);
664 if (ret)
665 return ret;
666
667 ofs += size;
668 (*retlen) += size;
669 len -= size;
670
671 /* Be nice and reschedule with the chip in a usable
672 * state for other processes */
673 cond_resched();
674
675 } while (len);
676
677 return 0;
678}
679
680static int lpddr_erase(struct mtd_info *mtd, struct erase_info *instr)
681{
682 unsigned long ofs, len;
683 int ret;
684 struct map_info *map = mtd->priv;
685 struct lpddr_private *lpddr = map->fldrv_priv;
686 int size = 1 << lpddr->qinfo->UniformBlockSizeShift;
687
688 ofs = instr->addr;
689 len = instr->len;
690
Alexey Korolevc6826472008-12-16 18:20:03 +0000691 while (len > 0) {
692 ret = do_erase_oneblock(mtd, ofs);
693 if (ret)
694 return ret;
695 ofs += size;
696 len -= size;
697 }
698 instr->state = MTD_ERASE_DONE;
699 mtd_erase_callback(instr);
700
701 return 0;
702}
703
704#define DO_XXLOCK_LOCK 1
705#define DO_XXLOCK_UNLOCK 2
706int do_xxlock(struct mtd_info *mtd, loff_t adr, uint32_t len, int thunk)
707{
708 int ret = 0;
709 struct map_info *map = mtd->priv;
710 struct lpddr_private *lpddr = map->fldrv_priv;
711 int chipnum = adr >> lpddr->chipshift;
712 struct flchip *chip = &lpddr->chips[chipnum];
713
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200714 mutex_lock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000715 ret = get_chip(map, chip, FL_LOCKING);
716 if (ret) {
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200717 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000718 return ret;
719 }
720
721 if (thunk == DO_XXLOCK_LOCK) {
722 send_pfow_command(map, LPDDR_LOCK_BLOCK, adr, adr + len, NULL);
723 chip->state = FL_LOCKING;
724 } else if (thunk == DO_XXLOCK_UNLOCK) {
725 send_pfow_command(map, LPDDR_UNLOCK_BLOCK, adr, adr + len, NULL);
726 chip->state = FL_UNLOCKING;
727 } else
728 BUG();
729
730 ret = wait_for_ready(map, chip, 1);
731 if (ret) {
732 printk(KERN_ERR "%s: block unlock error status %d \n",
733 map->name, ret);
734 goto out;
735 }
736out: put_chip(map, chip);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200737 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000738 return ret;
739}
740
741static int lpddr_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
742{
743 return do_xxlock(mtd, ofs, len, DO_XXLOCK_LOCK);
744}
745
746static int lpddr_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
747{
748 return do_xxlock(mtd, ofs, len, DO_XXLOCK_UNLOCK);
749}
750
751int word_program(struct map_info *map, loff_t adr, uint32_t curval)
752{
753 int ret;
754 struct lpddr_private *lpddr = map->fldrv_priv;
755 int chipnum = adr >> lpddr->chipshift;
756 struct flchip *chip = &lpddr->chips[chipnum];
757
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200758 mutex_lock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000759 ret = get_chip(map, chip, FL_WRITING);
760 if (ret) {
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200761 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000762 return ret;
763 }
764
765 send_pfow_command(map, LPDDR_WORD_PROGRAM, adr, 0x00, (map_word *)&curval);
766
767 ret = wait_for_ready(map, chip, (1<<lpddr->qinfo->SingleWordProgTime));
768 if (ret) {
769 printk(KERN_WARNING"%s word_program error at: %llx; val: %x\n",
770 map->name, adr, curval);
771 goto out;
772 }
773
774out: put_chip(map, chip);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200775 mutex_unlock(&chip->mutex);
Alexey Korolevc6826472008-12-16 18:20:03 +0000776 return ret;
777}
778
779MODULE_LICENSE("GPL");
780MODULE_AUTHOR("Alexey Korolev <akorolev@infradead.org>");
781MODULE_DESCRIPTION("MTD driver for LPDDR flash chips");