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
19 static int lpddr_read(struct mtd_info *mtd, loff_t adr, size_t len,
20 size_t *retlen, u_char *buf);
21 static int lpddr_write_buffers(struct mtd_info *mtd, loff_t to,
22 size_t len, size_t *retlen, const u_char *buf);
23 static int lpddr_writev(struct mtd_info *mtd, const struct kvec *vecs,
24 unsigned long count, loff_t to, size_t *retlen);
25 static int lpddr_erase(struct mtd_info *mtd, struct erase_info *instr);
26 static int lpddr_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
27 static int lpddr_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
28 static int lpddr_point(struct mtd_info *mtd, loff_t adr, size_t len,
29 size_t *retlen, void **mtdbuf, resource_size_t *phys);
30 static int lpddr_unpoint(struct mtd_info *mtd, loff_t adr, size_t len);
31 static int get_chip(struct map_info *map, struct flchip *chip, int mode);
32 static int chip_ready(struct map_info *map, struct flchip *chip, int mode);
33 static void put_chip(struct map_info *map, struct flchip *chip);
34
lpddr_cmdset(struct map_info * map)35 struct 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 }
95 EXPORT_SYMBOL(lpddr_cmdset);
96
print_drs_error(unsigned int dsr)97 static 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
wait_for_ready(struct map_info * map,struct flchip * chip,unsigned int chip_op_time)125 static 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
get_chip(struct map_info * map,struct flchip * chip,int mode)198 static 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
chip_ready(struct map_info * map,struct flchip * chip,int mode)294 static 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:
337 sleep:
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
put_chip(struct map_info * map,struct flchip * chip)348 static 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
do_write_buffer(struct map_info * map,struct flchip * chip,unsigned long adr,const struct kvec ** pvec,unsigned long * pvec_seek,int len)403 static 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, words;
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 words = (len - word_gap + map_bankwidth(map) - 1) / map_bankwidth(map);
425 if (!word_gap) {
426 words--;
427 } else {
428 word_gap = map_bankwidth(map) - word_gap;
429 adr -= word_gap;
430 datum = map_word_ff(map);
431 }
432 /* Write data */
433 /* Get the program buffer offset from PFOW register data first*/
434 prog_buf_ofs = map->pfow_base + CMDVAL(map_read(map,
435 map->pfow_base + PFOW_PROGRAM_BUFFER_OFFSET));
436 vec = *pvec;
437 vec_seek = *pvec_seek;
438 do {
439 int n = map_bankwidth(map) - word_gap;
440
441 if (n > vec->iov_len - vec_seek)
442 n = vec->iov_len - vec_seek;
443 if (n > len)
444 n = len;
445
446 if (!word_gap && (len < map_bankwidth(map)))
447 datum = map_word_ff(map);
448
449 datum = map_word_load_partial(map, datum,
450 vec->iov_base + vec_seek, word_gap, n);
451
452 len -= n;
453 word_gap += n;
454 if (!len || word_gap == map_bankwidth(map)) {
455 map_write(map, datum, prog_buf_ofs);
456 prog_buf_ofs += map_bankwidth(map);
457 word_gap = 0;
458 }
459
460 vec_seek += n;
461 if (vec_seek == vec->iov_len) {
462 vec++;
463 vec_seek = 0;
464 }
465 } while (len);
466 *pvec = vec;
467 *pvec_seek = vec_seek;
468
469 /* GO GO GO */
470 send_pfow_command(map, LPDDR_BUFF_PROGRAM, adr, wbufsize, NULL);
471 chip->state = FL_WRITING;
472 ret = wait_for_ready(map, chip, (1<<lpddr->qinfo->ProgBufferTime));
473 if (ret) {
474 printk(KERN_WARNING"%s Buffer program error: %d at %lx; \n",
475 map->name, ret, adr);
476 goto out;
477 }
478
479 out: put_chip(map, chip);
480 mutex_unlock(&chip->mutex);
481 return ret;
482 }
483
do_erase_oneblock(struct mtd_info * mtd,loff_t adr)484 static int do_erase_oneblock(struct mtd_info *mtd, loff_t adr)
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;
491
492 mutex_lock(&chip->mutex);
493 ret = get_chip(map, chip, FL_ERASING);
494 if (ret) {
495 mutex_unlock(&chip->mutex);
496 return ret;
497 }
498 send_pfow_command(map, LPDDR_BLOCK_ERASE, adr, 0, NULL);
499 chip->state = FL_ERASING;
500 ret = wait_for_ready(map, chip, (1<<lpddr->qinfo->BlockEraseTime)*1000);
501 if (ret) {
502 printk(KERN_WARNING"%s Erase block error %d at : %llx\n",
503 map->name, ret, adr);
504 goto out;
505 }
506 out: put_chip(map, chip);
507 mutex_unlock(&chip->mutex);
508 return ret;
509 }
510
lpddr_read(struct mtd_info * mtd,loff_t adr,size_t len,size_t * retlen,u_char * buf)511 static int lpddr_read(struct mtd_info *mtd, loff_t adr, size_t len,
512 size_t *retlen, u_char *buf)
513 {
514 struct map_info *map = mtd->priv;
515 struct lpddr_private *lpddr = map->fldrv_priv;
516 int chipnum = adr >> lpddr->chipshift;
517 struct flchip *chip = &lpddr->chips[chipnum];
518 int ret = 0;
519
520 mutex_lock(&chip->mutex);
521 ret = get_chip(map, chip, FL_READY);
522 if (ret) {
523 mutex_unlock(&chip->mutex);
524 return ret;
525 }
526
527 map_copy_from(map, buf, adr, len);
528 *retlen = len;
529
530 put_chip(map, chip);
531 mutex_unlock(&chip->mutex);
532 return ret;
533 }
534
lpddr_point(struct mtd_info * mtd,loff_t adr,size_t len,size_t * retlen,void ** mtdbuf,resource_size_t * phys)535 static int lpddr_point(struct mtd_info *mtd, loff_t adr, size_t len,
536 size_t *retlen, void **mtdbuf, resource_size_t *phys)
537 {
538 struct map_info *map = mtd->priv;
539 struct lpddr_private *lpddr = map->fldrv_priv;
540 int chipnum = adr >> lpddr->chipshift;
541 unsigned long ofs, last_end = 0;
542 struct flchip *chip = &lpddr->chips[chipnum];
543 int ret = 0;
544
545 if (!map->virt)
546 return -EINVAL;
547
548 /* ofs: offset within the first chip that the first read should start */
549 ofs = adr - (chipnum << lpddr->chipshift);
550 *mtdbuf = (void *)map->virt + chip->start + ofs;
551
552 while (len) {
553 unsigned long thislen;
554
555 if (chipnum >= lpddr->numchips)
556 break;
557
558 /* We cannot point across chips that are virtually disjoint */
559 if (!last_end)
560 last_end = chip->start;
561 else if (chip->start != last_end)
562 break;
563
564 if ((len + ofs - 1) >> lpddr->chipshift)
565 thislen = (1<<lpddr->chipshift) - ofs;
566 else
567 thislen = len;
568 /* get the chip */
569 mutex_lock(&chip->mutex);
570 ret = get_chip(map, chip, FL_POINT);
571 mutex_unlock(&chip->mutex);
572 if (ret)
573 break;
574
575 chip->state = FL_POINT;
576 chip->ref_point_counter++;
577 *retlen += thislen;
578 len -= thislen;
579
580 ofs = 0;
581 last_end += 1 << lpddr->chipshift;
582 chipnum++;
583 chip = &lpddr->chips[chipnum];
584 }
585 return 0;
586 }
587
lpddr_unpoint(struct mtd_info * mtd,loff_t adr,size_t len)588 static int lpddr_unpoint (struct mtd_info *mtd, loff_t adr, size_t len)
589 {
590 struct map_info *map = mtd->priv;
591 struct lpddr_private *lpddr = map->fldrv_priv;
592 int chipnum = adr >> lpddr->chipshift, err = 0;
593 unsigned long ofs;
594
595 /* ofs: offset within the first chip that the first read should start */
596 ofs = adr - (chipnum << lpddr->chipshift);
597
598 while (len) {
599 unsigned long thislen;
600 struct flchip *chip;
601
602 chip = &lpddr->chips[chipnum];
603 if (chipnum >= lpddr->numchips)
604 break;
605
606 if ((len + ofs - 1) >> lpddr->chipshift)
607 thislen = (1<<lpddr->chipshift) - ofs;
608 else
609 thislen = len;
610
611 mutex_lock(&chip->mutex);
612 if (chip->state == FL_POINT) {
613 chip->ref_point_counter--;
614 if (chip->ref_point_counter == 0)
615 chip->state = FL_READY;
616 } else {
617 printk(KERN_WARNING "%s: Warning: unpoint called on non"
618 "pointed region\n", map->name);
619 err = -EINVAL;
620 }
621
622 put_chip(map, chip);
623 mutex_unlock(&chip->mutex);
624
625 len -= thislen;
626 ofs = 0;
627 chipnum++;
628 }
629
630 return err;
631 }
632
lpddr_write_buffers(struct mtd_info * mtd,loff_t to,size_t len,size_t * retlen,const u_char * buf)633 static int lpddr_write_buffers(struct mtd_info *mtd, loff_t to, size_t len,
634 size_t *retlen, const u_char *buf)
635 {
636 struct kvec vec;
637
638 vec.iov_base = (void *) buf;
639 vec.iov_len = len;
640
641 return lpddr_writev(mtd, &vec, 1, to, retlen);
642 }
643
644
lpddr_writev(struct mtd_info * mtd,const struct kvec * vecs,unsigned long count,loff_t to,size_t * retlen)645 static int lpddr_writev(struct mtd_info *mtd, const struct kvec *vecs,
646 unsigned long count, loff_t to, size_t *retlen)
647 {
648 struct map_info *map = mtd->priv;
649 struct lpddr_private *lpddr = map->fldrv_priv;
650 int ret = 0;
651 int chipnum;
652 unsigned long ofs, vec_seek, i;
653 int wbufsize = 1 << lpddr->qinfo->BufSizeShift;
654 size_t len = 0;
655
656 for (i = 0; i < count; i++)
657 len += vecs[i].iov_len;
658
659 if (!len)
660 return 0;
661
662 chipnum = to >> lpddr->chipshift;
663
664 ofs = to;
665 vec_seek = 0;
666
667 do {
668 /* We must not cross write block boundaries */
669 int size = wbufsize - (ofs & (wbufsize-1));
670
671 if (size > len)
672 size = len;
673
674 ret = do_write_buffer(map, &lpddr->chips[chipnum],
675 ofs, &vecs, &vec_seek, size);
676 if (ret)
677 return ret;
678
679 ofs += size;
680 (*retlen) += size;
681 len -= size;
682
683 /* Be nice and reschedule with the chip in a usable
684 * state for other processes */
685 cond_resched();
686
687 } while (len);
688
689 return 0;
690 }
691
lpddr_erase(struct mtd_info * mtd,struct erase_info * instr)692 static int lpddr_erase(struct mtd_info *mtd, struct erase_info *instr)
693 {
694 unsigned long ofs, len;
695 int ret;
696 struct map_info *map = mtd->priv;
697 struct lpddr_private *lpddr = map->fldrv_priv;
698 int size = 1 << lpddr->qinfo->UniformBlockSizeShift;
699
700 ofs = instr->addr;
701 len = instr->len;
702
703 while (len > 0) {
704 ret = do_erase_oneblock(mtd, ofs);
705 if (ret)
706 return ret;
707 ofs += size;
708 len -= size;
709 }
710
711 return 0;
712 }
713
714 #define DO_XXLOCK_LOCK 1
715 #define DO_XXLOCK_UNLOCK 2
do_xxlock(struct mtd_info * mtd,loff_t adr,uint32_t len,int thunk)716 static int do_xxlock(struct mtd_info *mtd, loff_t adr, uint32_t len, int thunk)
717 {
718 int ret = 0;
719 struct map_info *map = mtd->priv;
720 struct lpddr_private *lpddr = map->fldrv_priv;
721 int chipnum = adr >> lpddr->chipshift;
722 struct flchip *chip = &lpddr->chips[chipnum];
723
724 mutex_lock(&chip->mutex);
725 ret = get_chip(map, chip, FL_LOCKING);
726 if (ret) {
727 mutex_unlock(&chip->mutex);
728 return ret;
729 }
730
731 if (thunk == DO_XXLOCK_LOCK) {
732 send_pfow_command(map, LPDDR_LOCK_BLOCK, adr, adr + len, NULL);
733 chip->state = FL_LOCKING;
734 } else if (thunk == DO_XXLOCK_UNLOCK) {
735 send_pfow_command(map, LPDDR_UNLOCK_BLOCK, adr, adr + len, NULL);
736 chip->state = FL_UNLOCKING;
737 } else
738 BUG();
739
740 ret = wait_for_ready(map, chip, 1);
741 if (ret) {
742 printk(KERN_ERR "%s: block unlock error status %d \n",
743 map->name, ret);
744 goto out;
745 }
746 out: put_chip(map, chip);
747 mutex_unlock(&chip->mutex);
748 return ret;
749 }
750
lpddr_lock(struct mtd_info * mtd,loff_t ofs,uint64_t len)751 static int lpddr_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
752 {
753 return do_xxlock(mtd, ofs, len, DO_XXLOCK_LOCK);
754 }
755
lpddr_unlock(struct mtd_info * mtd,loff_t ofs,uint64_t len)756 static int lpddr_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
757 {
758 return do_xxlock(mtd, ofs, len, DO_XXLOCK_UNLOCK);
759 }
760
761 MODULE_LICENSE("GPL");
762 MODULE_AUTHOR("Alexey Korolev <akorolev@infradead.org>");
763 MODULE_DESCRIPTION("MTD driver for LPDDR flash chips");
764