Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * LPDDR flash memory device operations. This module provides read, write,
4 * erase, lock/unlock support for LPDDR flash memories
5 * (C) 2008 Korolev Alexey <akorolev@infradead.org>
6 * (C) 2008 Vasiliy Leonenko <vasiliy.leonenko@gmail.com>
7 * Many thanks to Roman Borisov for initial enabling
8 *
9 * TODO:
10 * Implement VPP management
11 * Implement XIP support
12 * Implement OTP support
13 */
14#include <linux/mtd/pfow.h>
15#include <linux/mtd/qinfo.h>
16#include <linux/slab.h>
17#include <linux/module.h>
18
19static int lpddr_read(struct mtd_info *mtd, loff_t adr, size_t len,
20 size_t *retlen, u_char *buf);
21static int lpddr_write_buffers(struct mtd_info *mtd, loff_t to,
22 size_t len, size_t *retlen, const u_char *buf);
23static int lpddr_writev(struct mtd_info *mtd, const struct kvec *vecs,
24 unsigned long count, loff_t to, size_t *retlen);
25static int lpddr_erase(struct mtd_info *mtd, struct erase_info *instr);
26static int lpddr_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
27static int lpddr_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
28static int lpddr_point(struct mtd_info *mtd, loff_t adr, size_t len,
29 size_t *retlen, void **mtdbuf, resource_size_t *phys);
30static int lpddr_unpoint(struct mtd_info *mtd, loff_t adr, size_t len);
31static int get_chip(struct map_info *map, struct flchip *chip, int mode);
32static int chip_ready(struct map_info *map, struct flchip *chip, int mode);
33static void put_chip(struct map_info *map, struct flchip *chip);
34
35struct mtd_info *lpddr_cmdset(struct map_info *map)
36{
37 struct lpddr_private *lpddr = map->fldrv_priv;
38 struct flchip_shared *shared;
39 struct flchip *chip;
40 struct mtd_info *mtd;
41 int numchips;
42 int i, j;
43
44 mtd = kzalloc(sizeof(*mtd), GFP_KERNEL);
45 if (!mtd)
46 return NULL;
47 mtd->priv = map;
48 mtd->type = MTD_NORFLASH;
49
50 /* Fill in the default mtd operations */
51 mtd->_read = lpddr_read;
52 mtd->type = MTD_NORFLASH;
53 mtd->flags = MTD_CAP_NORFLASH;
54 mtd->flags &= ~MTD_BIT_WRITEABLE;
55 mtd->_erase = lpddr_erase;
56 mtd->_write = lpddr_write_buffers;
57 mtd->_writev = lpddr_writev;
58 mtd->_lock = lpddr_lock;
59 mtd->_unlock = lpddr_unlock;
60 if (map_is_linear(map)) {
61 mtd->_point = lpddr_point;
62 mtd->_unpoint = lpddr_unpoint;
63 }
64 mtd->size = 1 << lpddr->qinfo->DevSizeShift;
65 mtd->erasesize = 1 << lpddr->qinfo->UniformBlockSizeShift;
66 mtd->writesize = 1 << lpddr->qinfo->BufSizeShift;
67
68 shared = kmalloc_array(lpddr->numchips, sizeof(struct flchip_shared),
69 GFP_KERNEL);
70 if (!shared) {
71 kfree(mtd);
72 return NULL;
73 }
74
75 chip = &lpddr->chips[0];
76 numchips = lpddr->numchips / lpddr->qinfo->HWPartsNum;
77 for (i = 0; i < numchips; i++) {
78 shared[i].writing = shared[i].erasing = NULL;
79 mutex_init(&shared[i].lock);
80 for (j = 0; j < lpddr->qinfo->HWPartsNum; j++) {
81 *chip = lpddr->chips[i];
82 chip->start += j << lpddr->chipshift;
83 chip->oldstate = chip->state = FL_READY;
84 chip->priv = &shared[i];
85 /* those should be reset too since
86 they create memory references. */
87 init_waitqueue_head(&chip->wq);
88 mutex_init(&chip->mutex);
89 chip++;
90 }
91 }
92
93 return mtd;
94}
95EXPORT_SYMBOL(lpddr_cmdset);
96
97static int wait_for_ready(struct map_info *map, struct flchip *chip,
98 unsigned int chip_op_time)
99{
100 unsigned int timeo, reset_timeo, sleep_time;
101 unsigned int dsr;
102 flstate_t chip_state = chip->state;
103 int ret = 0;
104
105 /* set our timeout to 8 times the expected delay */
106 timeo = chip_op_time * 8;
107 if (!timeo)
108 timeo = 500000;
109 reset_timeo = timeo;
110 sleep_time = chip_op_time / 2;
111
112 for (;;) {
113 dsr = CMDVAL(map_read(map, map->pfow_base + PFOW_DSR));
114 if (dsr & DSR_READY_STATUS)
115 break;
116 if (!timeo) {
117 printk(KERN_ERR "%s: Flash timeout error state %d \n",
118 map->name, chip_state);
119 ret = -ETIME;
120 break;
121 }
122
123 /* OK Still waiting. Drop the lock, wait a while and retry. */
124 mutex_unlock(&chip->mutex);
125 if (sleep_time >= 1000000/HZ) {
126 /*
127 * Half of the normal delay still remaining
128 * can be performed with a sleeping delay instead
129 * of busy waiting.
130 */
131 msleep(sleep_time/1000);
132 timeo -= sleep_time;
133 sleep_time = 1000000/HZ;
134 } else {
135 udelay(1);
136 cond_resched();
137 timeo--;
138 }
139 mutex_lock(&chip->mutex);
140
141 while (chip->state != chip_state) {
142 /* Someone's suspended the operation: sleep */
143 DECLARE_WAITQUEUE(wait, current);
144 set_current_state(TASK_UNINTERRUPTIBLE);
145 add_wait_queue(&chip->wq, &wait);
146 mutex_unlock(&chip->mutex);
147 schedule();
148 remove_wait_queue(&chip->wq, &wait);
149 mutex_lock(&chip->mutex);
150 }
151 if (chip->erase_suspended || chip->write_suspended) {
152 /* Suspend has occurred while sleep: reset timeout */
153 timeo = reset_timeo;
154 chip->erase_suspended = chip->write_suspended = 0;
155 }
156 }
157 /* check status for errors */
158 if (dsr & DSR_ERR) {
159 /* Clear DSR*/
160 map_write(map, CMD(~(DSR_ERR)), map->pfow_base + PFOW_DSR);
161 printk(KERN_WARNING"%s: Bad status on wait: 0x%x \n",
162 map->name, dsr);
163 print_drs_error(dsr);
164 ret = -EIO;
165 }
166 chip->state = FL_READY;
167 return ret;
168}
169
170static int get_chip(struct map_info *map, struct flchip *chip, int mode)
171{
172 int ret;
173 DECLARE_WAITQUEUE(wait, current);
174
175 retry:
176 if (chip->priv && (mode == FL_WRITING || mode == FL_ERASING)
177 && chip->state != FL_SYNCING) {
178 /*
179 * OK. We have possibility for contension on the write/erase
180 * operations which are global to the real chip and not per
181 * partition. So let's fight it over in the partition which
182 * currently has authority on the operation.
183 *
184 * The rules are as follows:
185 *
186 * - any write operation must own shared->writing.
187 *
188 * - any erase operation must own _both_ shared->writing and
189 * shared->erasing.
190 *
191 * - contension arbitration is handled in the owner's context.
192 *
193 * The 'shared' struct can be read and/or written only when
194 * its lock is taken.
195 */
196 struct flchip_shared *shared = chip->priv;
197 struct flchip *contender;
198 mutex_lock(&shared->lock);
199 contender = shared->writing;
200 if (contender && contender != chip) {
201 /*
202 * The engine to perform desired operation on this
203 * partition is already in use by someone else.
204 * Let's fight over it in the context of the chip
205 * currently using it. If it is possible to suspend,
206 * that other partition will do just that, otherwise
207 * it'll happily send us to sleep. In any case, when
208 * get_chip returns success we're clear to go ahead.
209 */
210 ret = mutex_trylock(&contender->mutex);
211 mutex_unlock(&shared->lock);
212 if (!ret)
213 goto retry;
214 mutex_unlock(&chip->mutex);
215 ret = chip_ready(map, contender, mode);
216 mutex_lock(&chip->mutex);
217
218 if (ret == -EAGAIN) {
219 mutex_unlock(&contender->mutex);
220 goto retry;
221 }
222 if (ret) {
223 mutex_unlock(&contender->mutex);
224 return ret;
225 }
226 mutex_lock(&shared->lock);
227
228 /* We should not own chip if it is already in FL_SYNCING
229 * state. Put contender and retry. */
230 if (chip->state == FL_SYNCING) {
231 put_chip(map, contender);
232 mutex_unlock(&contender->mutex);
233 goto retry;
234 }
235 mutex_unlock(&contender->mutex);
236 }
237
238 /* Check if we have suspended erase on this chip.
239 Must sleep in such a case. */
240 if (mode == FL_ERASING && shared->erasing
241 && shared->erasing->oldstate == FL_ERASING) {
242 mutex_unlock(&shared->lock);
243 set_current_state(TASK_UNINTERRUPTIBLE);
244 add_wait_queue(&chip->wq, &wait);
245 mutex_unlock(&chip->mutex);
246 schedule();
247 remove_wait_queue(&chip->wq, &wait);
248 mutex_lock(&chip->mutex);
249 goto retry;
250 }
251
252 /* We now own it */
253 shared->writing = chip;
254 if (mode == FL_ERASING)
255 shared->erasing = chip;
256 mutex_unlock(&shared->lock);
257 }
258
259 ret = chip_ready(map, chip, mode);
260 if (ret == -EAGAIN)
261 goto retry;
262
263 return ret;
264}
265
266static int chip_ready(struct map_info *map, struct flchip *chip, int mode)
267{
268 struct lpddr_private *lpddr = map->fldrv_priv;
269 int ret = 0;
270 DECLARE_WAITQUEUE(wait, current);
271
272 /* Prevent setting state FL_SYNCING for chip in suspended state. */
273 if (FL_SYNCING == mode && FL_READY != chip->oldstate)
274 goto sleep;
275
276 switch (chip->state) {
277 case FL_READY:
278 case FL_JEDEC_QUERY:
279 return 0;
280
281 case FL_ERASING:
282 if (!lpddr->qinfo->SuspEraseSupp ||
283 !(mode == FL_READY || mode == FL_POINT))
284 goto sleep;
285
286 map_write(map, CMD(LPDDR_SUSPEND),
287 map->pfow_base + PFOW_PROGRAM_ERASE_SUSPEND);
288 chip->oldstate = FL_ERASING;
289 chip->state = FL_ERASE_SUSPENDING;
290 ret = wait_for_ready(map, chip, 0);
291 if (ret) {
292 /* Oops. something got wrong. */
293 /* Resume and pretend we weren't here. */
294 put_chip(map, chip);
295 printk(KERN_ERR "%s: suspend operation failed."
296 "State may be wrong \n", map->name);
297 return -EIO;
298 }
299 chip->erase_suspended = 1;
300 chip->state = FL_READY;
301 return 0;
302 /* Erase suspend */
303 case FL_POINT:
304 /* Only if there's no operation suspended... */
305 if (mode == FL_READY && chip->oldstate == FL_READY)
306 return 0;
307 fallthrough;
308 default:
309sleep:
310 set_current_state(TASK_UNINTERRUPTIBLE);
311 add_wait_queue(&chip->wq, &wait);
312 mutex_unlock(&chip->mutex);
313 schedule();
314 remove_wait_queue(&chip->wq, &wait);
315 mutex_lock(&chip->mutex);
316 return -EAGAIN;
317 }
318}
319
320static void put_chip(struct map_info *map, struct flchip *chip)
321{
322 if (chip->priv) {
323 struct flchip_shared *shared = chip->priv;
324 mutex_lock(&shared->lock);
325 if (shared->writing == chip && chip->oldstate == FL_READY) {
326 /* We own the ability to write, but we're done */
327 shared->writing = shared->erasing;
328 if (shared->writing && shared->writing != chip) {
329 /* give back the ownership */
330 struct flchip *loaner = shared->writing;
331 mutex_lock(&loaner->mutex);
332 mutex_unlock(&shared->lock);
333 mutex_unlock(&chip->mutex);
334 put_chip(map, loaner);
335 mutex_lock(&chip->mutex);
336 mutex_unlock(&loaner->mutex);
337 wake_up(&chip->wq);
338 return;
339 }
340 shared->erasing = NULL;
341 shared->writing = NULL;
342 } else if (shared->erasing == chip && shared->writing != chip) {
343 /*
344 * We own the ability to erase without the ability
345 * to write, which means the erase was suspended
346 * and some other partition is currently writing.
347 * Don't let the switch below mess things up since
348 * we don't have ownership to resume anything.
349 */
350 mutex_unlock(&shared->lock);
351 wake_up(&chip->wq);
352 return;
353 }
354 mutex_unlock(&shared->lock);
355 }
356
357 switch (chip->oldstate) {
358 case FL_ERASING:
359 map_write(map, CMD(LPDDR_RESUME),
360 map->pfow_base + PFOW_COMMAND_CODE);
361 map_write(map, CMD(LPDDR_START_EXECUTION),
362 map->pfow_base + PFOW_COMMAND_EXECUTE);
363 chip->oldstate = FL_READY;
364 chip->state = FL_ERASING;
365 break;
366 case FL_READY:
367 break;
368 default:
369 printk(KERN_ERR "%s: put_chip() called with oldstate %d!\n",
370 map->name, chip->oldstate);
371 }
372 wake_up(&chip->wq);
373}
374
375static int do_write_buffer(struct map_info *map, struct flchip *chip,
376 unsigned long adr, const struct kvec **pvec,
377 unsigned long *pvec_seek, int len)
378{
379 struct lpddr_private *lpddr = map->fldrv_priv;
380 map_word datum;
381 int ret, wbufsize, word_gap, words;
382 const struct kvec *vec;
383 unsigned long vec_seek;
384 unsigned long prog_buf_ofs;
385
386 wbufsize = 1 << lpddr->qinfo->BufSizeShift;
387
388 mutex_lock(&chip->mutex);
389 ret = get_chip(map, chip, FL_WRITING);
390 if (ret) {
391 mutex_unlock(&chip->mutex);
392 return ret;
393 }
394 /* Figure out the number of words to write */
395 word_gap = (-adr & (map_bankwidth(map)-1));
396 words = (len - word_gap + map_bankwidth(map) - 1) / map_bankwidth(map);
397 if (!word_gap) {
398 words--;
399 } else {
400 word_gap = map_bankwidth(map) - word_gap;
401 adr -= word_gap;
402 datum = map_word_ff(map);
403 }
404 /* Write data */
405 /* Get the program buffer offset from PFOW register data first*/
406 prog_buf_ofs = map->pfow_base + CMDVAL(map_read(map,
407 map->pfow_base + PFOW_PROGRAM_BUFFER_OFFSET));
408 vec = *pvec;
409 vec_seek = *pvec_seek;
410 do {
411 int n = map_bankwidth(map) - word_gap;
412
413 if (n > vec->iov_len - vec_seek)
414 n = vec->iov_len - vec_seek;
415 if (n > len)
416 n = len;
417
418 if (!word_gap && (len < map_bankwidth(map)))
419 datum = map_word_ff(map);
420
421 datum = map_word_load_partial(map, datum,
422 vec->iov_base + vec_seek, word_gap, n);
423
424 len -= n;
425 word_gap += n;
426 if (!len || word_gap == map_bankwidth(map)) {
427 map_write(map, datum, prog_buf_ofs);
428 prog_buf_ofs += map_bankwidth(map);
429 word_gap = 0;
430 }
431
432 vec_seek += n;
433 if (vec_seek == vec->iov_len) {
434 vec++;
435 vec_seek = 0;
436 }
437 } while (len);
438 *pvec = vec;
439 *pvec_seek = vec_seek;
440
441 /* GO GO GO */
442 send_pfow_command(map, LPDDR_BUFF_PROGRAM, adr, wbufsize, NULL);
443 chip->state = FL_WRITING;
444 ret = wait_for_ready(map, chip, (1<<lpddr->qinfo->ProgBufferTime));
445 if (ret) {
446 printk(KERN_WARNING"%s Buffer program error: %d at %lx; \n",
447 map->name, ret, adr);
448 goto out;
449 }
450
451 out: put_chip(map, chip);
452 mutex_unlock(&chip->mutex);
453 return ret;
454}
455
456static int do_erase_oneblock(struct mtd_info *mtd, loff_t adr)
457{
458 struct map_info *map = mtd->priv;
459 struct lpddr_private *lpddr = map->fldrv_priv;
460 int chipnum = adr >> lpddr->chipshift;
461 struct flchip *chip = &lpddr->chips[chipnum];
462 int ret;
463
464 mutex_lock(&chip->mutex);
465 ret = get_chip(map, chip, FL_ERASING);
466 if (ret) {
467 mutex_unlock(&chip->mutex);
468 return ret;
469 }
470 send_pfow_command(map, LPDDR_BLOCK_ERASE, adr, 0, NULL);
471 chip->state = FL_ERASING;
472 ret = wait_for_ready(map, chip, (1<<lpddr->qinfo->BlockEraseTime)*1000);
473 if (ret) {
474 printk(KERN_WARNING"%s Erase block error %d at : %llx\n",
475 map->name, ret, adr);
476 goto out;
477 }
478 out: put_chip(map, chip);
479 mutex_unlock(&chip->mutex);
480 return ret;
481}
482
483static int lpddr_read(struct mtd_info *mtd, loff_t adr, size_t len,
484 size_t *retlen, u_char *buf)
485{
486 struct map_info *map = mtd->priv;
487 struct lpddr_private *lpddr = map->fldrv_priv;
488 int chipnum = adr >> lpddr->chipshift;
489 struct flchip *chip = &lpddr->chips[chipnum];
490 int ret = 0;
491
492 mutex_lock(&chip->mutex);
493 ret = get_chip(map, chip, FL_READY);
494 if (ret) {
495 mutex_unlock(&chip->mutex);
496 return ret;
497 }
498
499 map_copy_from(map, buf, adr, len);
500 *retlen = len;
501
502 put_chip(map, chip);
503 mutex_unlock(&chip->mutex);
504 return ret;
505}
506
507static int lpddr_point(struct mtd_info *mtd, loff_t adr, size_t len,
508 size_t *retlen, void **mtdbuf, resource_size_t *phys)
509{
510 struct map_info *map = mtd->priv;
511 struct lpddr_private *lpddr = map->fldrv_priv;
512 int chipnum = adr >> lpddr->chipshift;
513 unsigned long ofs, last_end = 0;
514 struct flchip *chip = &lpddr->chips[chipnum];
515 int ret = 0;
516
517 if (!map->virt)
518 return -EINVAL;
519
520 /* ofs: offset within the first chip that the first read should start */
521 ofs = adr - (chipnum << lpddr->chipshift);
522 *mtdbuf = (void *)map->virt + chip->start + ofs;
523
524 while (len) {
525 unsigned long thislen;
526
527 if (chipnum >= lpddr->numchips)
528 break;
529
530 /* We cannot point across chips that are virtually disjoint */
531 if (!last_end)
532 last_end = chip->start;
533 else if (chip->start != last_end)
534 break;
535
536 if ((len + ofs - 1) >> lpddr->chipshift)
537 thislen = (1<<lpddr->chipshift) - ofs;
538 else
539 thislen = len;
540 /* get the chip */
541 mutex_lock(&chip->mutex);
542 ret = get_chip(map, chip, FL_POINT);
543 mutex_unlock(&chip->mutex);
544 if (ret)
545 break;
546
547 chip->state = FL_POINT;
548 chip->ref_point_counter++;
549 *retlen += thislen;
550 len -= thislen;
551
552 ofs = 0;
553 last_end += 1 << lpddr->chipshift;
554 chipnum++;
555 chip = &lpddr->chips[chipnum];
556 }
557 return 0;
558}
559
560static int lpddr_unpoint (struct mtd_info *mtd, loff_t adr, size_t len)
561{
562 struct map_info *map = mtd->priv;
563 struct lpddr_private *lpddr = map->fldrv_priv;
564 int chipnum = adr >> lpddr->chipshift, err = 0;
565 unsigned long ofs;
566
567 /* ofs: offset within the first chip that the first read should start */
568 ofs = adr - (chipnum << lpddr->chipshift);
569
570 while (len) {
571 unsigned long thislen;
572 struct flchip *chip;
573
574 chip = &lpddr->chips[chipnum];
575 if (chipnum >= lpddr->numchips)
576 break;
577
578 if ((len + ofs - 1) >> lpddr->chipshift)
579 thislen = (1<<lpddr->chipshift) - ofs;
580 else
581 thislen = len;
582
583 mutex_lock(&chip->mutex);
584 if (chip->state == FL_POINT) {
585 chip->ref_point_counter--;
586 if (chip->ref_point_counter == 0)
587 chip->state = FL_READY;
588 } else {
589 printk(KERN_WARNING "%s: Warning: unpoint called on non"
590 "pointed region\n", map->name);
591 err = -EINVAL;
592 }
593
594 put_chip(map, chip);
595 mutex_unlock(&chip->mutex);
596
597 len -= thislen;
598 ofs = 0;
599 chipnum++;
600 }
601
602 return err;
603}
604
605static int lpddr_write_buffers(struct mtd_info *mtd, loff_t to, size_t len,
606 size_t *retlen, const u_char *buf)
607{
608 struct kvec vec;
609
610 vec.iov_base = (void *) buf;
611 vec.iov_len = len;
612
613 return lpddr_writev(mtd, &vec, 1, to, retlen);
614}
615
616
617static int lpddr_writev(struct mtd_info *mtd, const struct kvec *vecs,
618 unsigned long count, loff_t to, size_t *retlen)
619{
620 struct map_info *map = mtd->priv;
621 struct lpddr_private *lpddr = map->fldrv_priv;
622 int ret = 0;
623 int chipnum;
624 unsigned long ofs, vec_seek, i;
625 int wbufsize = 1 << lpddr->qinfo->BufSizeShift;
626 size_t len = 0;
627
628 for (i = 0; i < count; i++)
629 len += vecs[i].iov_len;
630
631 if (!len)
632 return 0;
633
634 chipnum = to >> lpddr->chipshift;
635
636 ofs = to;
637 vec_seek = 0;
638
639 do {
640 /* We must not cross write block boundaries */
641 int size = wbufsize - (ofs & (wbufsize-1));
642
643 if (size > len)
644 size = len;
645
646 ret = do_write_buffer(map, &lpddr->chips[chipnum],
647 ofs, &vecs, &vec_seek, size);
648 if (ret)
649 return ret;
650
651 ofs += size;
652 (*retlen) += size;
653 len -= size;
654
655 /* Be nice and reschedule with the chip in a usable
656 * state for other processes */
657 cond_resched();
658
659 } while (len);
660
661 return 0;
662}
663
664static int lpddr_erase(struct mtd_info *mtd, struct erase_info *instr)
665{
666 unsigned long ofs, len;
667 int ret;
668 struct map_info *map = mtd->priv;
669 struct lpddr_private *lpddr = map->fldrv_priv;
670 int size = 1 << lpddr->qinfo->UniformBlockSizeShift;
671
672 ofs = instr->addr;
673 len = instr->len;
674
675 while (len > 0) {
676 ret = do_erase_oneblock(mtd, ofs);
677 if (ret)
678 return ret;
679 ofs += size;
680 len -= size;
681 }
682
683 return 0;
684}
685
686#define DO_XXLOCK_LOCK 1
687#define DO_XXLOCK_UNLOCK 2
688static int do_xxlock(struct mtd_info *mtd, loff_t adr, uint32_t len, int thunk)
689{
690 int ret = 0;
691 struct map_info *map = mtd->priv;
692 struct lpddr_private *lpddr = map->fldrv_priv;
693 int chipnum = adr >> lpddr->chipshift;
694 struct flchip *chip = &lpddr->chips[chipnum];
695
696 mutex_lock(&chip->mutex);
697 ret = get_chip(map, chip, FL_LOCKING);
698 if (ret) {
699 mutex_unlock(&chip->mutex);
700 return ret;
701 }
702
703 if (thunk == DO_XXLOCK_LOCK) {
704 send_pfow_command(map, LPDDR_LOCK_BLOCK, adr, adr + len, NULL);
705 chip->state = FL_LOCKING;
706 } else if (thunk == DO_XXLOCK_UNLOCK) {
707 send_pfow_command(map, LPDDR_UNLOCK_BLOCK, adr, adr + len, NULL);
708 chip->state = FL_UNLOCKING;
709 } else
710 BUG();
711
712 ret = wait_for_ready(map, chip, 1);
713 if (ret) {
714 printk(KERN_ERR "%s: block unlock error status %d \n",
715 map->name, ret);
716 goto out;
717 }
718out: put_chip(map, chip);
719 mutex_unlock(&chip->mutex);
720 return ret;
721}
722
723static int lpddr_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
724{
725 return do_xxlock(mtd, ofs, len, DO_XXLOCK_LOCK);
726}
727
728static int lpddr_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
729{
730 return do_xxlock(mtd, ofs, len, DO_XXLOCK_UNLOCK);
731}
732
733MODULE_LICENSE("GPL");
734MODULE_AUTHOR("Alexey Korolev <akorolev@infradead.org>");
735MODULE_DESCRIPTION("MTD driver for LPDDR flash chips");
1/*
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>
6 * Many thanks to Roman Borisov for initial enabling
7 *
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>
29#include <linux/slab.h>
30#include <linux/module.h>
31
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);
43static int lpddr_unpoint(struct mtd_info *mtd, loff_t adr, size_t len);
44static 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 return NULL;
60 mtd->priv = map;
61 mtd->type = MTD_NORFLASH;
62
63 /* Fill in the default mtd operations */
64 mtd->_read = lpddr_read;
65 mtd->type = MTD_NORFLASH;
66 mtd->flags = MTD_CAP_NORFLASH;
67 mtd->flags &= ~MTD_BIT_WRITEABLE;
68 mtd->_erase = lpddr_erase;
69 mtd->_write = lpddr_write_buffers;
70 mtd->_writev = lpddr_writev;
71 mtd->_lock = lpddr_lock;
72 mtd->_unlock = lpddr_unlock;
73 if (map_is_linear(map)) {
74 mtd->_point = lpddr_point;
75 mtd->_unpoint = lpddr_unpoint;
76 }
77 mtd->size = 1 << lpddr->qinfo->DevSizeShift;
78 mtd->erasesize = 1 << lpddr->qinfo->UniformBlockSizeShift;
79 mtd->writesize = 1 << lpddr->qinfo->BufSizeShift;
80
81 shared = kmalloc(sizeof(struct flchip_shared) * lpddr->numchips,
82 GFP_KERNEL);
83 if (!shared) {
84 kfree(lpddr);
85 kfree(mtd);
86 return NULL;
87 }
88
89 chip = &lpddr->chips[0];
90 numchips = lpddr->numchips / lpddr->qinfo->HWPartsNum;
91 for (i = 0; i < numchips; i++) {
92 shared[i].writing = shared[i].erasing = NULL;
93 mutex_init(&shared[i].lock);
94 for (j = 0; j < lpddr->qinfo->HWPartsNum; j++) {
95 *chip = lpddr->chips[i];
96 chip->start += j << lpddr->chipshift;
97 chip->oldstate = chip->state = FL_READY;
98 chip->priv = &shared[i];
99 /* those should be reset too since
100 they create memory references. */
101 init_waitqueue_head(&chip->wq);
102 mutex_init(&chip->mutex);
103 chip++;
104 }
105 }
106
107 return mtd;
108}
109EXPORT_SYMBOL(lpddr_cmdset);
110
111static int wait_for_ready(struct map_info *map, struct flchip *chip,
112 unsigned int chip_op_time)
113{
114 unsigned int timeo, reset_timeo, sleep_time;
115 unsigned int dsr;
116 flstate_t chip_state = chip->state;
117 int ret = 0;
118
119 /* set our timeout to 8 times the expected delay */
120 timeo = chip_op_time * 8;
121 if (!timeo)
122 timeo = 500000;
123 reset_timeo = timeo;
124 sleep_time = chip_op_time / 2;
125
126 for (;;) {
127 dsr = CMDVAL(map_read(map, map->pfow_base + PFOW_DSR));
128 if (dsr & DSR_READY_STATUS)
129 break;
130 if (!timeo) {
131 printk(KERN_ERR "%s: Flash timeout error state %d \n",
132 map->name, chip_state);
133 ret = -ETIME;
134 break;
135 }
136
137 /* OK Still waiting. Drop the lock, wait a while and retry. */
138 mutex_unlock(&chip->mutex);
139 if (sleep_time >= 1000000/HZ) {
140 /*
141 * Half of the normal delay still remaining
142 * can be performed with a sleeping delay instead
143 * of busy waiting.
144 */
145 msleep(sleep_time/1000);
146 timeo -= sleep_time;
147 sleep_time = 1000000/HZ;
148 } else {
149 udelay(1);
150 cond_resched();
151 timeo--;
152 }
153 mutex_lock(&chip->mutex);
154
155 while (chip->state != chip_state) {
156 /* Someone's suspended the operation: sleep */
157 DECLARE_WAITQUEUE(wait, current);
158 set_current_state(TASK_UNINTERRUPTIBLE);
159 add_wait_queue(&chip->wq, &wait);
160 mutex_unlock(&chip->mutex);
161 schedule();
162 remove_wait_queue(&chip->wq, &wait);
163 mutex_lock(&chip->mutex);
164 }
165 if (chip->erase_suspended || chip->write_suspended) {
166 /* Suspend has occurred while sleep: reset timeout */
167 timeo = reset_timeo;
168 chip->erase_suspended = chip->write_suspended = 0;
169 }
170 }
171 /* check status for errors */
172 if (dsr & DSR_ERR) {
173 /* Clear DSR*/
174 map_write(map, CMD(~(DSR_ERR)), map->pfow_base + PFOW_DSR);
175 printk(KERN_WARNING"%s: Bad status on wait: 0x%x \n",
176 map->name, dsr);
177 print_drs_error(dsr);
178 ret = -EIO;
179 }
180 chip->state = FL_READY;
181 return ret;
182}
183
184static int get_chip(struct map_info *map, struct flchip *chip, int mode)
185{
186 int ret;
187 DECLARE_WAITQUEUE(wait, current);
188
189 retry:
190 if (chip->priv && (mode == FL_WRITING || mode == FL_ERASING)
191 && chip->state != FL_SYNCING) {
192 /*
193 * OK. We have possibility for contension on the write/erase
194 * operations which are global to the real chip and not per
195 * partition. So let's fight it over in the partition which
196 * currently has authority on the operation.
197 *
198 * The rules are as follows:
199 *
200 * - any write operation must own shared->writing.
201 *
202 * - any erase operation must own _both_ shared->writing and
203 * shared->erasing.
204 *
205 * - contension arbitration is handled in the owner's context.
206 *
207 * The 'shared' struct can be read and/or written only when
208 * its lock is taken.
209 */
210 struct flchip_shared *shared = chip->priv;
211 struct flchip *contender;
212 mutex_lock(&shared->lock);
213 contender = shared->writing;
214 if (contender && contender != chip) {
215 /*
216 * The engine to perform desired operation on this
217 * partition is already in use by someone else.
218 * Let's fight over it in the context of the chip
219 * currently using it. If it is possible to suspend,
220 * that other partition will do just that, otherwise
221 * it'll happily send us to sleep. In any case, when
222 * get_chip returns success we're clear to go ahead.
223 */
224 ret = mutex_trylock(&contender->mutex);
225 mutex_unlock(&shared->lock);
226 if (!ret)
227 goto retry;
228 mutex_unlock(&chip->mutex);
229 ret = chip_ready(map, contender, mode);
230 mutex_lock(&chip->mutex);
231
232 if (ret == -EAGAIN) {
233 mutex_unlock(&contender->mutex);
234 goto retry;
235 }
236 if (ret) {
237 mutex_unlock(&contender->mutex);
238 return ret;
239 }
240 mutex_lock(&shared->lock);
241
242 /* We should not own chip if it is already in FL_SYNCING
243 * state. Put contender and retry. */
244 if (chip->state == FL_SYNCING) {
245 put_chip(map, contender);
246 mutex_unlock(&contender->mutex);
247 goto retry;
248 }
249 mutex_unlock(&contender->mutex);
250 }
251
252 /* Check if we have suspended erase on this chip.
253 Must sleep in such a case. */
254 if (mode == FL_ERASING && shared->erasing
255 && shared->erasing->oldstate == FL_ERASING) {
256 mutex_unlock(&shared->lock);
257 set_current_state(TASK_UNINTERRUPTIBLE);
258 add_wait_queue(&chip->wq, &wait);
259 mutex_unlock(&chip->mutex);
260 schedule();
261 remove_wait_queue(&chip->wq, &wait);
262 mutex_lock(&chip->mutex);
263 goto retry;
264 }
265
266 /* We now own it */
267 shared->writing = chip;
268 if (mode == FL_ERASING)
269 shared->erasing = chip;
270 mutex_unlock(&shared->lock);
271 }
272
273 ret = chip_ready(map, chip, mode);
274 if (ret == -EAGAIN)
275 goto retry;
276
277 return ret;
278}
279
280static int chip_ready(struct map_info *map, struct flchip *chip, int mode)
281{
282 struct lpddr_private *lpddr = map->fldrv_priv;
283 int ret = 0;
284 DECLARE_WAITQUEUE(wait, current);
285
286 /* Prevent setting state FL_SYNCING for chip in suspended state. */
287 if (FL_SYNCING == mode && FL_READY != chip->oldstate)
288 goto sleep;
289
290 switch (chip->state) {
291 case FL_READY:
292 case FL_JEDEC_QUERY:
293 return 0;
294
295 case FL_ERASING:
296 if (!lpddr->qinfo->SuspEraseSupp ||
297 !(mode == FL_READY || mode == FL_POINT))
298 goto sleep;
299
300 map_write(map, CMD(LPDDR_SUSPEND),
301 map->pfow_base + PFOW_PROGRAM_ERASE_SUSPEND);
302 chip->oldstate = FL_ERASING;
303 chip->state = FL_ERASE_SUSPENDING;
304 ret = wait_for_ready(map, chip, 0);
305 if (ret) {
306 /* Oops. something got wrong. */
307 /* Resume and pretend we weren't here. */
308 put_chip(map, chip);
309 printk(KERN_ERR "%s: suspend operation failed."
310 "State may be wrong \n", map->name);
311 return -EIO;
312 }
313 chip->erase_suspended = 1;
314 chip->state = FL_READY;
315 return 0;
316 /* Erase suspend */
317 case FL_POINT:
318 /* Only if there's no operation suspended... */
319 if (mode == FL_READY && chip->oldstate == FL_READY)
320 return 0;
321
322 default:
323sleep:
324 set_current_state(TASK_UNINTERRUPTIBLE);
325 add_wait_queue(&chip->wq, &wait);
326 mutex_unlock(&chip->mutex);
327 schedule();
328 remove_wait_queue(&chip->wq, &wait);
329 mutex_lock(&chip->mutex);
330 return -EAGAIN;
331 }
332}
333
334static void put_chip(struct map_info *map, struct flchip *chip)
335{
336 if (chip->priv) {
337 struct flchip_shared *shared = chip->priv;
338 mutex_lock(&shared->lock);
339 if (shared->writing == chip && chip->oldstate == FL_READY) {
340 /* We own the ability to write, but we're done */
341 shared->writing = shared->erasing;
342 if (shared->writing && shared->writing != chip) {
343 /* give back the ownership */
344 struct flchip *loaner = shared->writing;
345 mutex_lock(&loaner->mutex);
346 mutex_unlock(&shared->lock);
347 mutex_unlock(&chip->mutex);
348 put_chip(map, loaner);
349 mutex_lock(&chip->mutex);
350 mutex_unlock(&loaner->mutex);
351 wake_up(&chip->wq);
352 return;
353 }
354 shared->erasing = NULL;
355 shared->writing = NULL;
356 } else if (shared->erasing == chip && shared->writing != chip) {
357 /*
358 * We own the ability to erase without the ability
359 * to write, which means the erase was suspended
360 * and some other partition is currently writing.
361 * Don't let the switch below mess things up since
362 * we don't have ownership to resume anything.
363 */
364 mutex_unlock(&shared->lock);
365 wake_up(&chip->wq);
366 return;
367 }
368 mutex_unlock(&shared->lock);
369 }
370
371 switch (chip->oldstate) {
372 case FL_ERASING:
373 map_write(map, CMD(LPDDR_RESUME),
374 map->pfow_base + PFOW_COMMAND_CODE);
375 map_write(map, CMD(LPDDR_START_EXECUTION),
376 map->pfow_base + PFOW_COMMAND_EXECUTE);
377 chip->oldstate = FL_READY;
378 chip->state = FL_ERASING;
379 break;
380 case FL_READY:
381 break;
382 default:
383 printk(KERN_ERR "%s: put_chip() called with oldstate %d!\n",
384 map->name, chip->oldstate);
385 }
386 wake_up(&chip->wq);
387}
388
389static int do_write_buffer(struct map_info *map, struct flchip *chip,
390 unsigned long adr, const struct kvec **pvec,
391 unsigned long *pvec_seek, int len)
392{
393 struct lpddr_private *lpddr = map->fldrv_priv;
394 map_word datum;
395 int ret, wbufsize, word_gap, words;
396 const struct kvec *vec;
397 unsigned long vec_seek;
398 unsigned long prog_buf_ofs;
399
400 wbufsize = 1 << lpddr->qinfo->BufSizeShift;
401
402 mutex_lock(&chip->mutex);
403 ret = get_chip(map, chip, FL_WRITING);
404 if (ret) {
405 mutex_unlock(&chip->mutex);
406 return ret;
407 }
408 /* Figure out the number of words to write */
409 word_gap = (-adr & (map_bankwidth(map)-1));
410 words = (len - word_gap + map_bankwidth(map) - 1) / map_bankwidth(map);
411 if (!word_gap) {
412 words--;
413 } else {
414 word_gap = map_bankwidth(map) - word_gap;
415 adr -= word_gap;
416 datum = map_word_ff(map);
417 }
418 /* Write data */
419 /* Get the program buffer offset from PFOW register data first*/
420 prog_buf_ofs = map->pfow_base + CMDVAL(map_read(map,
421 map->pfow_base + PFOW_PROGRAM_BUFFER_OFFSET));
422 vec = *pvec;
423 vec_seek = *pvec_seek;
424 do {
425 int n = map_bankwidth(map) - word_gap;
426
427 if (n > vec->iov_len - vec_seek)
428 n = vec->iov_len - vec_seek;
429 if (n > len)
430 n = len;
431
432 if (!word_gap && (len < map_bankwidth(map)))
433 datum = map_word_ff(map);
434
435 datum = map_word_load_partial(map, datum,
436 vec->iov_base + vec_seek, word_gap, n);
437
438 len -= n;
439 word_gap += n;
440 if (!len || word_gap == map_bankwidth(map)) {
441 map_write(map, datum, prog_buf_ofs);
442 prog_buf_ofs += map_bankwidth(map);
443 word_gap = 0;
444 }
445
446 vec_seek += n;
447 if (vec_seek == vec->iov_len) {
448 vec++;
449 vec_seek = 0;
450 }
451 } while (len);
452 *pvec = vec;
453 *pvec_seek = vec_seek;
454
455 /* GO GO GO */
456 send_pfow_command(map, LPDDR_BUFF_PROGRAM, adr, wbufsize, NULL);
457 chip->state = FL_WRITING;
458 ret = wait_for_ready(map, chip, (1<<lpddr->qinfo->ProgBufferTime));
459 if (ret) {
460 printk(KERN_WARNING"%s Buffer program error: %d at %lx; \n",
461 map->name, ret, adr);
462 goto out;
463 }
464
465 out: put_chip(map, chip);
466 mutex_unlock(&chip->mutex);
467 return ret;
468}
469
470static int do_erase_oneblock(struct mtd_info *mtd, loff_t adr)
471{
472 struct map_info *map = mtd->priv;
473 struct lpddr_private *lpddr = map->fldrv_priv;
474 int chipnum = adr >> lpddr->chipshift;
475 struct flchip *chip = &lpddr->chips[chipnum];
476 int ret;
477
478 mutex_lock(&chip->mutex);
479 ret = get_chip(map, chip, FL_ERASING);
480 if (ret) {
481 mutex_unlock(&chip->mutex);
482 return ret;
483 }
484 send_pfow_command(map, LPDDR_BLOCK_ERASE, adr, 0, NULL);
485 chip->state = FL_ERASING;
486 ret = wait_for_ready(map, chip, (1<<lpddr->qinfo->BlockEraseTime)*1000);
487 if (ret) {
488 printk(KERN_WARNING"%s Erase block error %d at : %llx\n",
489 map->name, ret, adr);
490 goto out;
491 }
492 out: put_chip(map, chip);
493 mutex_unlock(&chip->mutex);
494 return ret;
495}
496
497static int lpddr_read(struct mtd_info *mtd, loff_t adr, size_t len,
498 size_t *retlen, u_char *buf)
499{
500 struct map_info *map = mtd->priv;
501 struct lpddr_private *lpddr = map->fldrv_priv;
502 int chipnum = adr >> lpddr->chipshift;
503 struct flchip *chip = &lpddr->chips[chipnum];
504 int ret = 0;
505
506 mutex_lock(&chip->mutex);
507 ret = get_chip(map, chip, FL_READY);
508 if (ret) {
509 mutex_unlock(&chip->mutex);
510 return ret;
511 }
512
513 map_copy_from(map, buf, adr, len);
514 *retlen = len;
515
516 put_chip(map, chip);
517 mutex_unlock(&chip->mutex);
518 return ret;
519}
520
521static int lpddr_point(struct mtd_info *mtd, loff_t adr, size_t len,
522 size_t *retlen, void **mtdbuf, resource_size_t *phys)
523{
524 struct map_info *map = mtd->priv;
525 struct lpddr_private *lpddr = map->fldrv_priv;
526 int chipnum = adr >> lpddr->chipshift;
527 unsigned long ofs, last_end = 0;
528 struct flchip *chip = &lpddr->chips[chipnum];
529 int ret = 0;
530
531 if (!map->virt)
532 return -EINVAL;
533
534 /* ofs: offset within the first chip that the first read should start */
535 ofs = adr - (chipnum << lpddr->chipshift);
536 *mtdbuf = (void *)map->virt + chip->start + ofs;
537
538 while (len) {
539 unsigned long thislen;
540
541 if (chipnum >= lpddr->numchips)
542 break;
543
544 /* We cannot point across chips that are virtually disjoint */
545 if (!last_end)
546 last_end = chip->start;
547 else if (chip->start != last_end)
548 break;
549
550 if ((len + ofs - 1) >> lpddr->chipshift)
551 thislen = (1<<lpddr->chipshift) - ofs;
552 else
553 thislen = len;
554 /* get the chip */
555 mutex_lock(&chip->mutex);
556 ret = get_chip(map, chip, FL_POINT);
557 mutex_unlock(&chip->mutex);
558 if (ret)
559 break;
560
561 chip->state = FL_POINT;
562 chip->ref_point_counter++;
563 *retlen += thislen;
564 len -= thislen;
565
566 ofs = 0;
567 last_end += 1 << lpddr->chipshift;
568 chipnum++;
569 chip = &lpddr->chips[chipnum];
570 }
571 return 0;
572}
573
574static int lpddr_unpoint (struct mtd_info *mtd, loff_t adr, size_t len)
575{
576 struct map_info *map = mtd->priv;
577 struct lpddr_private *lpddr = map->fldrv_priv;
578 int chipnum = adr >> lpddr->chipshift, err = 0;
579 unsigned long ofs;
580
581 /* ofs: offset within the first chip that the first read should start */
582 ofs = adr - (chipnum << lpddr->chipshift);
583
584 while (len) {
585 unsigned long thislen;
586 struct flchip *chip;
587
588 chip = &lpddr->chips[chipnum];
589 if (chipnum >= lpddr->numchips)
590 break;
591
592 if ((len + ofs - 1) >> lpddr->chipshift)
593 thislen = (1<<lpddr->chipshift) - ofs;
594 else
595 thislen = len;
596
597 mutex_lock(&chip->mutex);
598 if (chip->state == FL_POINT) {
599 chip->ref_point_counter--;
600 if (chip->ref_point_counter == 0)
601 chip->state = FL_READY;
602 } else {
603 printk(KERN_WARNING "%s: Warning: unpoint called on non"
604 "pointed region\n", map->name);
605 err = -EINVAL;
606 }
607
608 put_chip(map, chip);
609 mutex_unlock(&chip->mutex);
610
611 len -= thislen;
612 ofs = 0;
613 chipnum++;
614 }
615
616 return err;
617}
618
619static int lpddr_write_buffers(struct mtd_info *mtd, loff_t to, size_t len,
620 size_t *retlen, const u_char *buf)
621{
622 struct kvec vec;
623
624 vec.iov_base = (void *) buf;
625 vec.iov_len = len;
626
627 return lpddr_writev(mtd, &vec, 1, to, retlen);
628}
629
630
631static int lpddr_writev(struct mtd_info *mtd, const struct kvec *vecs,
632 unsigned long count, loff_t to, size_t *retlen)
633{
634 struct map_info *map = mtd->priv;
635 struct lpddr_private *lpddr = map->fldrv_priv;
636 int ret = 0;
637 int chipnum;
638 unsigned long ofs, vec_seek, i;
639 int wbufsize = 1 << lpddr->qinfo->BufSizeShift;
640 size_t len = 0;
641
642 for (i = 0; i < count; i++)
643 len += vecs[i].iov_len;
644
645 if (!len)
646 return 0;
647
648 chipnum = to >> lpddr->chipshift;
649
650 ofs = to;
651 vec_seek = 0;
652
653 do {
654 /* We must not cross write block boundaries */
655 int size = wbufsize - (ofs & (wbufsize-1));
656
657 if (size > len)
658 size = len;
659
660 ret = do_write_buffer(map, &lpddr->chips[chipnum],
661 ofs, &vecs, &vec_seek, size);
662 if (ret)
663 return ret;
664
665 ofs += size;
666 (*retlen) += size;
667 len -= size;
668
669 /* Be nice and reschedule with the chip in a usable
670 * state for other processes */
671 cond_resched();
672
673 } while (len);
674
675 return 0;
676}
677
678static int lpddr_erase(struct mtd_info *mtd, struct erase_info *instr)
679{
680 unsigned long ofs, len;
681 int ret;
682 struct map_info *map = mtd->priv;
683 struct lpddr_private *lpddr = map->fldrv_priv;
684 int size = 1 << lpddr->qinfo->UniformBlockSizeShift;
685
686 ofs = instr->addr;
687 len = instr->len;
688
689 while (len > 0) {
690 ret = do_erase_oneblock(mtd, ofs);
691 if (ret)
692 return ret;
693 ofs += size;
694 len -= size;
695 }
696 instr->state = MTD_ERASE_DONE;
697 mtd_erase_callback(instr);
698
699 return 0;
700}
701
702#define DO_XXLOCK_LOCK 1
703#define DO_XXLOCK_UNLOCK 2
704static int do_xxlock(struct mtd_info *mtd, loff_t adr, uint32_t len, int thunk)
705{
706 int ret = 0;
707 struct map_info *map = mtd->priv;
708 struct lpddr_private *lpddr = map->fldrv_priv;
709 int chipnum = adr >> lpddr->chipshift;
710 struct flchip *chip = &lpddr->chips[chipnum];
711
712 mutex_lock(&chip->mutex);
713 ret = get_chip(map, chip, FL_LOCKING);
714 if (ret) {
715 mutex_unlock(&chip->mutex);
716 return ret;
717 }
718
719 if (thunk == DO_XXLOCK_LOCK) {
720 send_pfow_command(map, LPDDR_LOCK_BLOCK, adr, adr + len, NULL);
721 chip->state = FL_LOCKING;
722 } else if (thunk == DO_XXLOCK_UNLOCK) {
723 send_pfow_command(map, LPDDR_UNLOCK_BLOCK, adr, adr + len, NULL);
724 chip->state = FL_UNLOCKING;
725 } else
726 BUG();
727
728 ret = wait_for_ready(map, chip, 1);
729 if (ret) {
730 printk(KERN_ERR "%s: block unlock error status %d \n",
731 map->name, ret);
732 goto out;
733 }
734out: put_chip(map, chip);
735 mutex_unlock(&chip->mutex);
736 return ret;
737}
738
739static int lpddr_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
740{
741 return do_xxlock(mtd, ofs, len, DO_XXLOCK_LOCK);
742}
743
744static int lpddr_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
745{
746 return do_xxlock(mtd, ofs, len, DO_XXLOCK_UNLOCK);
747}
748
749MODULE_LICENSE("GPL");
750MODULE_AUTHOR("Alexey Korolev <akorolev@infradead.org>");
751MODULE_DESCRIPTION("MTD driver for LPDDR flash chips");