Merge tag 'v3.3.7' into 3.3/master
[zen-stable.git] / drivers / mtd / lpddr / lpddr_cmds.c
blob536bbceaeaad559868acf633a6cd994412af3c4a
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
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.
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.
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
27 #include <linux/mtd/pfow.h>
28 #include <linux/mtd/qinfo.h>
29 #include <linux/slab.h>
30 #include <linux/module.h>
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 void 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);
48 struct mtd_info *lpddr_cmdset(struct map_info *map)
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;
57 mtd = kzalloc(sizeof(*mtd), GFP_KERNEL);
58 if (!mtd) {
59 printk(KERN_ERR "Failed to allocate memory for MTD device\n");
60 return NULL;
62 mtd->priv = map;
63 mtd->type = MTD_NORFLASH;
65 /* Fill in the default mtd operations */
66 mtd->read = lpddr_read;
67 mtd->type = MTD_NORFLASH;
68 mtd->flags = MTD_CAP_NORFLASH;
69 mtd->flags &= ~MTD_BIT_WRITEABLE;
70 mtd->erase = lpddr_erase;
71 mtd->write = lpddr_write_buffers;
72 mtd->writev = lpddr_writev;
73 mtd->lock = lpddr_lock;
74 mtd->unlock = lpddr_unlock;
75 if (map_is_linear(map)) {
76 mtd->point = lpddr_point;
77 mtd->unpoint = lpddr_unpoint;
79 mtd->size = 1 << lpddr->qinfo->DevSizeShift;
80 mtd->erasesize = 1 << lpddr->qinfo->UniformBlockSizeShift;
81 mtd->writesize = 1 << lpddr->qinfo->BufSizeShift;
83 shared = kmalloc(sizeof(struct flchip_shared) * lpddr->numchips,
84 GFP_KERNEL);
85 if (!shared) {
86 kfree(lpddr);
87 kfree(mtd);
88 return NULL;
91 chip = &lpddr->chips[0];
92 numchips = lpddr->numchips / lpddr->qinfo->HWPartsNum;
93 for (i = 0; i < numchips; i++) {
94 shared[i].writing = shared[i].erasing = NULL;
95 mutex_init(&shared[i].lock);
96 for (j = 0; j < lpddr->qinfo->HWPartsNum; j++) {
97 *chip = lpddr->chips[i];
98 chip->start += j << lpddr->chipshift;
99 chip->oldstate = chip->state = FL_READY;
100 chip->priv = &shared[i];
101 /* those should be reset too since
102 they create memory references. */
103 init_waitqueue_head(&chip->wq);
104 mutex_init(&chip->mutex);
105 chip++;
109 return mtd;
111 EXPORT_SYMBOL(lpddr_cmdset);
113 static int wait_for_ready(struct map_info *map, struct flchip *chip,
114 unsigned int chip_op_time)
116 unsigned int timeo, reset_timeo, sleep_time;
117 unsigned int dsr;
118 flstate_t chip_state = chip->state;
119 int ret = 0;
121 /* set our timeout to 8 times the expected delay */
122 timeo = chip_op_time * 8;
123 if (!timeo)
124 timeo = 500000;
125 reset_timeo = timeo;
126 sleep_time = chip_op_time / 2;
128 for (;;) {
129 dsr = CMDVAL(map_read(map, map->pfow_base + PFOW_DSR));
130 if (dsr & DSR_READY_STATUS)
131 break;
132 if (!timeo) {
133 printk(KERN_ERR "%s: Flash timeout error state %d \n",
134 map->name, chip_state);
135 ret = -ETIME;
136 break;
139 /* OK Still waiting. Drop the lock, wait a while and retry. */
140 mutex_unlock(&chip->mutex);
141 if (sleep_time >= 1000000/HZ) {
143 * Half of the normal delay still remaining
144 * can be performed with a sleeping delay instead
145 * of busy waiting.
147 msleep(sleep_time/1000);
148 timeo -= sleep_time;
149 sleep_time = 1000000/HZ;
150 } else {
151 udelay(1);
152 cond_resched();
153 timeo--;
155 mutex_lock(&chip->mutex);
157 while (chip->state != chip_state) {
158 /* Someone's suspended the operation: sleep */
159 DECLARE_WAITQUEUE(wait, current);
160 set_current_state(TASK_UNINTERRUPTIBLE);
161 add_wait_queue(&chip->wq, &wait);
162 mutex_unlock(&chip->mutex);
163 schedule();
164 remove_wait_queue(&chip->wq, &wait);
165 mutex_lock(&chip->mutex);
167 if (chip->erase_suspended || chip->write_suspended) {
168 /* Suspend has occurred while sleep: reset timeout */
169 timeo = reset_timeo;
170 chip->erase_suspended = chip->write_suspended = 0;
173 /* check status for errors */
174 if (dsr & DSR_ERR) {
175 /* Clear DSR*/
176 map_write(map, CMD(~(DSR_ERR)), map->pfow_base + PFOW_DSR);
177 printk(KERN_WARNING"%s: Bad status on wait: 0x%x \n",
178 map->name, dsr);
179 print_drs_error(dsr);
180 ret = -EIO;
182 chip->state = FL_READY;
183 return ret;
186 static int get_chip(struct map_info *map, struct flchip *chip, int mode)
188 int ret;
189 DECLARE_WAITQUEUE(wait, current);
191 retry:
192 if (chip->priv && (mode == FL_WRITING || mode == FL_ERASING)
193 && chip->state != FL_SYNCING) {
195 * OK. We have possibility for contension on the write/erase
196 * operations which are global to the real chip and not per
197 * partition. So let's fight it over in the partition which
198 * currently has authority on the operation.
200 * The rules are as follows:
202 * - any write operation must own shared->writing.
204 * - any erase operation must own _both_ shared->writing and
205 * shared->erasing.
207 * - contension arbitration is handled in the owner's context.
209 * The 'shared' struct can be read and/or written only when
210 * its lock is taken.
212 struct flchip_shared *shared = chip->priv;
213 struct flchip *contender;
214 mutex_lock(&shared->lock);
215 contender = shared->writing;
216 if (contender && contender != chip) {
218 * The engine to perform desired operation on this
219 * partition is already in use by someone else.
220 * Let's fight over it in the context of the chip
221 * currently using it. If it is possible to suspend,
222 * that other partition will do just that, otherwise
223 * it'll happily send us to sleep. In any case, when
224 * get_chip returns success we're clear to go ahead.
226 ret = mutex_trylock(&contender->mutex);
227 mutex_unlock(&shared->lock);
228 if (!ret)
229 goto retry;
230 mutex_unlock(&chip->mutex);
231 ret = chip_ready(map, contender, mode);
232 mutex_lock(&chip->mutex);
234 if (ret == -EAGAIN) {
235 mutex_unlock(&contender->mutex);
236 goto retry;
238 if (ret) {
239 mutex_unlock(&contender->mutex);
240 return ret;
242 mutex_lock(&shared->lock);
244 /* We should not own chip if it is already in FL_SYNCING
245 * state. Put contender and retry. */
246 if (chip->state == FL_SYNCING) {
247 put_chip(map, contender);
248 mutex_unlock(&contender->mutex);
249 goto retry;
251 mutex_unlock(&contender->mutex);
254 /* Check if we have suspended erase on this chip.
255 Must sleep in such a case. */
256 if (mode == FL_ERASING && shared->erasing
257 && shared->erasing->oldstate == FL_ERASING) {
258 mutex_unlock(&shared->lock);
259 set_current_state(TASK_UNINTERRUPTIBLE);
260 add_wait_queue(&chip->wq, &wait);
261 mutex_unlock(&chip->mutex);
262 schedule();
263 remove_wait_queue(&chip->wq, &wait);
264 mutex_lock(&chip->mutex);
265 goto retry;
268 /* We now own it */
269 shared->writing = chip;
270 if (mode == FL_ERASING)
271 shared->erasing = chip;
272 mutex_unlock(&shared->lock);
275 ret = chip_ready(map, chip, mode);
276 if (ret == -EAGAIN)
277 goto retry;
279 return ret;
282 static int chip_ready(struct map_info *map, struct flchip *chip, int mode)
284 struct lpddr_private *lpddr = map->fldrv_priv;
285 int ret = 0;
286 DECLARE_WAITQUEUE(wait, current);
288 /* Prevent setting state FL_SYNCING for chip in suspended state. */
289 if (FL_SYNCING == mode && FL_READY != chip->oldstate)
290 goto sleep;
292 switch (chip->state) {
293 case FL_READY:
294 case FL_JEDEC_QUERY:
295 return 0;
297 case FL_ERASING:
298 if (!lpddr->qinfo->SuspEraseSupp ||
299 !(mode == FL_READY || mode == FL_POINT))
300 goto sleep;
302 map_write(map, CMD(LPDDR_SUSPEND),
303 map->pfow_base + PFOW_PROGRAM_ERASE_SUSPEND);
304 chip->oldstate = FL_ERASING;
305 chip->state = FL_ERASE_SUSPENDING;
306 ret = wait_for_ready(map, chip, 0);
307 if (ret) {
308 /* Oops. something got wrong. */
309 /* Resume and pretend we weren't here. */
310 put_chip(map, chip);
311 printk(KERN_ERR "%s: suspend operation failed."
312 "State may be wrong \n", map->name);
313 return -EIO;
315 chip->erase_suspended = 1;
316 chip->state = FL_READY;
317 return 0;
318 /* Erase suspend */
319 case FL_POINT:
320 /* Only if there's no operation suspended... */
321 if (mode == FL_READY && chip->oldstate == FL_READY)
322 return 0;
324 default:
325 sleep:
326 set_current_state(TASK_UNINTERRUPTIBLE);
327 add_wait_queue(&chip->wq, &wait);
328 mutex_unlock(&chip->mutex);
329 schedule();
330 remove_wait_queue(&chip->wq, &wait);
331 mutex_lock(&chip->mutex);
332 return -EAGAIN;
336 static void put_chip(struct map_info *map, struct flchip *chip)
338 if (chip->priv) {
339 struct flchip_shared *shared = chip->priv;
340 mutex_lock(&shared->lock);
341 if (shared->writing == chip && chip->oldstate == FL_READY) {
342 /* We own the ability to write, but we're done */
343 shared->writing = shared->erasing;
344 if (shared->writing && shared->writing != chip) {
345 /* give back the ownership */
346 struct flchip *loaner = shared->writing;
347 mutex_lock(&loaner->mutex);
348 mutex_unlock(&shared->lock);
349 mutex_unlock(&chip->mutex);
350 put_chip(map, loaner);
351 mutex_lock(&chip->mutex);
352 mutex_unlock(&loaner->mutex);
353 wake_up(&chip->wq);
354 return;
356 shared->erasing = NULL;
357 shared->writing = NULL;
358 } else if (shared->erasing == chip && shared->writing != chip) {
360 * We own the ability to erase without the ability
361 * to write, which means the erase was suspended
362 * and some other partition is currently writing.
363 * Don't let the switch below mess things up since
364 * we don't have ownership to resume anything.
366 mutex_unlock(&shared->lock);
367 wake_up(&chip->wq);
368 return;
370 mutex_unlock(&shared->lock);
373 switch (chip->oldstate) {
374 case FL_ERASING:
375 map_write(map, CMD(LPDDR_RESUME),
376 map->pfow_base + PFOW_COMMAND_CODE);
377 map_write(map, CMD(LPDDR_START_EXECUTION),
378 map->pfow_base + PFOW_COMMAND_EXECUTE);
379 chip->oldstate = FL_READY;
380 chip->state = FL_ERASING;
381 break;
382 case FL_READY:
383 break;
384 default:
385 printk(KERN_ERR "%s: put_chip() called with oldstate %d!\n",
386 map->name, chip->oldstate);
388 wake_up(&chip->wq);
391 int do_write_buffer(struct map_info *map, struct flchip *chip,
392 unsigned long adr, const struct kvec **pvec,
393 unsigned long *pvec_seek, int len)
395 struct lpddr_private *lpddr = map->fldrv_priv;
396 map_word datum;
397 int ret, wbufsize, word_gap, words;
398 const struct kvec *vec;
399 unsigned long vec_seek;
400 unsigned long prog_buf_ofs;
402 wbufsize = 1 << lpddr->qinfo->BufSizeShift;
404 mutex_lock(&chip->mutex);
405 ret = get_chip(map, chip, FL_WRITING);
406 if (ret) {
407 mutex_unlock(&chip->mutex);
408 return ret;
410 /* Figure out the number of words to write */
411 word_gap = (-adr & (map_bankwidth(map)-1));
412 words = (len - word_gap + map_bankwidth(map) - 1) / map_bankwidth(map);
413 if (!word_gap) {
414 words--;
415 } else {
416 word_gap = map_bankwidth(map) - word_gap;
417 adr -= word_gap;
418 datum = map_word_ff(map);
420 /* Write data */
421 /* Get the program buffer offset from PFOW register data first*/
422 prog_buf_ofs = map->pfow_base + CMDVAL(map_read(map,
423 map->pfow_base + PFOW_PROGRAM_BUFFER_OFFSET));
424 vec = *pvec;
425 vec_seek = *pvec_seek;
426 do {
427 int n = map_bankwidth(map) - word_gap;
429 if (n > vec->iov_len - vec_seek)
430 n = vec->iov_len - vec_seek;
431 if (n > len)
432 n = len;
434 if (!word_gap && (len < map_bankwidth(map)))
435 datum = map_word_ff(map);
437 datum = map_word_load_partial(map, datum,
438 vec->iov_base + vec_seek, word_gap, n);
440 len -= n;
441 word_gap += n;
442 if (!len || word_gap == map_bankwidth(map)) {
443 map_write(map, datum, prog_buf_ofs);
444 prog_buf_ofs += map_bankwidth(map);
445 word_gap = 0;
448 vec_seek += n;
449 if (vec_seek == vec->iov_len) {
450 vec++;
451 vec_seek = 0;
453 } while (len);
454 *pvec = vec;
455 *pvec_seek = vec_seek;
457 /* GO GO GO */
458 send_pfow_command(map, LPDDR_BUFF_PROGRAM, adr, wbufsize, NULL);
459 chip->state = FL_WRITING;
460 ret = wait_for_ready(map, chip, (1<<lpddr->qinfo->ProgBufferTime));
461 if (ret) {
462 printk(KERN_WARNING"%s Buffer program error: %d at %lx; \n",
463 map->name, ret, adr);
464 goto out;
467 out: put_chip(map, chip);
468 mutex_unlock(&chip->mutex);
469 return ret;
472 int do_erase_oneblock(struct mtd_info *mtd, loff_t adr)
474 struct map_info *map = mtd->priv;
475 struct lpddr_private *lpddr = map->fldrv_priv;
476 int chipnum = adr >> lpddr->chipshift;
477 struct flchip *chip = &lpddr->chips[chipnum];
478 int ret;
480 mutex_lock(&chip->mutex);
481 ret = get_chip(map, chip, FL_ERASING);
482 if (ret) {
483 mutex_unlock(&chip->mutex);
484 return ret;
486 send_pfow_command(map, LPDDR_BLOCK_ERASE, adr, 0, NULL);
487 chip->state = FL_ERASING;
488 ret = wait_for_ready(map, chip, (1<<lpddr->qinfo->BlockEraseTime)*1000);
489 if (ret) {
490 printk(KERN_WARNING"%s Erase block error %d at : %llx\n",
491 map->name, ret, adr);
492 goto out;
494 out: put_chip(map, chip);
495 mutex_unlock(&chip->mutex);
496 return ret;
499 static int lpddr_read(struct mtd_info *mtd, loff_t adr, size_t len,
500 size_t *retlen, u_char *buf)
502 struct map_info *map = mtd->priv;
503 struct lpddr_private *lpddr = map->fldrv_priv;
504 int chipnum = adr >> lpddr->chipshift;
505 struct flchip *chip = &lpddr->chips[chipnum];
506 int ret = 0;
508 mutex_lock(&chip->mutex);
509 ret = get_chip(map, chip, FL_READY);
510 if (ret) {
511 mutex_unlock(&chip->mutex);
512 return ret;
515 map_copy_from(map, buf, adr, len);
516 *retlen = len;
518 put_chip(map, chip);
519 mutex_unlock(&chip->mutex);
520 return ret;
523 static int lpddr_point(struct mtd_info *mtd, loff_t adr, size_t len,
524 size_t *retlen, void **mtdbuf, resource_size_t *phys)
526 struct map_info *map = mtd->priv;
527 struct lpddr_private *lpddr = map->fldrv_priv;
528 int chipnum = adr >> lpddr->chipshift;
529 unsigned long ofs, last_end = 0;
530 struct flchip *chip = &lpddr->chips[chipnum];
531 int ret = 0;
533 if (!map->virt || (adr + len > mtd->size))
534 return -EINVAL;
536 /* ofs: offset within the first chip that the first read should start */
537 ofs = adr - (chipnum << lpddr->chipshift);
539 *mtdbuf = (void *)map->virt + chip->start + ofs;
540 *retlen = 0;
542 while (len) {
543 unsigned long thislen;
545 if (chipnum >= lpddr->numchips)
546 break;
548 /* We cannot point across chips that are virtually disjoint */
549 if (!last_end)
550 last_end = chip->start;
551 else if (chip->start != last_end)
552 break;
554 if ((len + ofs - 1) >> lpddr->chipshift)
555 thislen = (1<<lpddr->chipshift) - ofs;
556 else
557 thislen = len;
558 /* get the chip */
559 mutex_lock(&chip->mutex);
560 ret = get_chip(map, chip, FL_POINT);
561 mutex_unlock(&chip->mutex);
562 if (ret)
563 break;
565 chip->state = FL_POINT;
566 chip->ref_point_counter++;
567 *retlen += thislen;
568 len -= thislen;
570 ofs = 0;
571 last_end += 1 << lpddr->chipshift;
572 chipnum++;
573 chip = &lpddr->chips[chipnum];
575 return 0;
578 static void lpddr_unpoint (struct mtd_info *mtd, loff_t adr, size_t len)
580 struct map_info *map = mtd->priv;
581 struct lpddr_private *lpddr = map->fldrv_priv;
582 int chipnum = adr >> lpddr->chipshift;
583 unsigned long ofs;
585 /* ofs: offset within the first chip that the first read should start */
586 ofs = adr - (chipnum << lpddr->chipshift);
588 while (len) {
589 unsigned long thislen;
590 struct flchip *chip;
592 chip = &lpddr->chips[chipnum];
593 if (chipnum >= lpddr->numchips)
594 break;
596 if ((len + ofs - 1) >> lpddr->chipshift)
597 thislen = (1<<lpddr->chipshift) - ofs;
598 else
599 thislen = len;
601 mutex_lock(&chip->mutex);
602 if (chip->state == FL_POINT) {
603 chip->ref_point_counter--;
604 if (chip->ref_point_counter == 0)
605 chip->state = FL_READY;
606 } else
607 printk(KERN_WARNING "%s: Warning: unpoint called on non"
608 "pointed region\n", map->name);
610 put_chip(map, chip);
611 mutex_unlock(&chip->mutex);
613 len -= thislen;
614 ofs = 0;
615 chipnum++;
619 static int lpddr_write_buffers(struct mtd_info *mtd, loff_t to, size_t len,
620 size_t *retlen, const u_char *buf)
622 struct kvec vec;
624 vec.iov_base = (void *) buf;
625 vec.iov_len = len;
627 return lpddr_writev(mtd, &vec, 1, to, retlen);
631 static int lpddr_writev(struct mtd_info *mtd, const struct kvec *vecs,
632 unsigned long count, loff_t to, size_t *retlen)
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;
641 size_t len = 0;
643 for (i = 0; i < count; i++)
644 len += vecs[i].iov_len;
646 *retlen = 0;
647 if (!len)
648 return 0;
650 chipnum = to >> lpddr->chipshift;
652 ofs = to;
653 vec_seek = 0;
655 do {
656 /* We must not cross write block boundaries */
657 int size = wbufsize - (ofs & (wbufsize-1));
659 if (size > len)
660 size = len;
662 ret = do_write_buffer(map, &lpddr->chips[chipnum],
663 ofs, &vecs, &vec_seek, size);
664 if (ret)
665 return ret;
667 ofs += size;
668 (*retlen) += size;
669 len -= size;
671 /* Be nice and reschedule with the chip in a usable
672 * state for other processes */
673 cond_resched();
675 } while (len);
677 return 0;
680 static int lpddr_erase(struct mtd_info *mtd, struct erase_info *instr)
682 unsigned long ofs, len;
683 int ret;
684 struct map_info *map = mtd->priv;
685 struct lpddr_private *lpddr = map->fldrv_priv;
686 int size = 1 << lpddr->qinfo->UniformBlockSizeShift;
688 ofs = instr->addr;
689 len = instr->len;
691 if (ofs > mtd->size || (len + ofs) > mtd->size)
692 return -EINVAL;
694 while (len > 0) {
695 ret = do_erase_oneblock(mtd, ofs);
696 if (ret)
697 return ret;
698 ofs += size;
699 len -= size;
701 instr->state = MTD_ERASE_DONE;
702 mtd_erase_callback(instr);
704 return 0;
707 #define DO_XXLOCK_LOCK 1
708 #define DO_XXLOCK_UNLOCK 2
709 int do_xxlock(struct mtd_info *mtd, loff_t adr, uint32_t len, int thunk)
711 int ret = 0;
712 struct map_info *map = mtd->priv;
713 struct lpddr_private *lpddr = map->fldrv_priv;
714 int chipnum = adr >> lpddr->chipshift;
715 struct flchip *chip = &lpddr->chips[chipnum];
717 mutex_lock(&chip->mutex);
718 ret = get_chip(map, chip, FL_LOCKING);
719 if (ret) {
720 mutex_unlock(&chip->mutex);
721 return ret;
724 if (thunk == DO_XXLOCK_LOCK) {
725 send_pfow_command(map, LPDDR_LOCK_BLOCK, adr, adr + len, NULL);
726 chip->state = FL_LOCKING;
727 } else if (thunk == DO_XXLOCK_UNLOCK) {
728 send_pfow_command(map, LPDDR_UNLOCK_BLOCK, adr, adr + len, NULL);
729 chip->state = FL_UNLOCKING;
730 } else
731 BUG();
733 ret = wait_for_ready(map, chip, 1);
734 if (ret) {
735 printk(KERN_ERR "%s: block unlock error status %d \n",
736 map->name, ret);
737 goto out;
739 out: put_chip(map, chip);
740 mutex_unlock(&chip->mutex);
741 return ret;
744 static int lpddr_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
746 return do_xxlock(mtd, ofs, len, DO_XXLOCK_LOCK);
749 static int lpddr_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
751 return do_xxlock(mtd, ofs, len, DO_XXLOCK_UNLOCK);
754 int word_program(struct map_info *map, loff_t adr, uint32_t curval)
756 int ret;
757 struct lpddr_private *lpddr = map->fldrv_priv;
758 int chipnum = adr >> lpddr->chipshift;
759 struct flchip *chip = &lpddr->chips[chipnum];
761 mutex_lock(&chip->mutex);
762 ret = get_chip(map, chip, FL_WRITING);
763 if (ret) {
764 mutex_unlock(&chip->mutex);
765 return ret;
768 send_pfow_command(map, LPDDR_WORD_PROGRAM, adr, 0x00, (map_word *)&curval);
770 ret = wait_for_ready(map, chip, (1<<lpddr->qinfo->SingleWordProgTime));
771 if (ret) {
772 printk(KERN_WARNING"%s word_program error at: %llx; val: %x\n",
773 map->name, adr, curval);
774 goto out;
777 out: put_chip(map, chip);
778 mutex_unlock(&chip->mutex);
779 return ret;
782 MODULE_LICENSE("GPL");
783 MODULE_AUTHOR("Alexey Korolev <akorolev@infradead.org>");
784 MODULE_DESCRIPTION("MTD driver for LPDDR flash chips");