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