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