drivers/mtd/lpddr/lpddr_cmds.c

   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 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);
  47
  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                 printk(KERN_ERR "Failed to allocate memory for MTD device\n");
  60                 return NULL;
  61         }
  62         mtd->priv = map;
  63         mtd->type = MTD_NORFLASH;
  64
  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;
  78         }
  79         mtd->size = 1 << lpddr->qinfo->DevSizeShift;
  80         mtd->erasesize = 1 << lpddr->qinfo->UniformBlockSizeShift;
  81         mtd->writesize = 1 << lpddr->qinfo->BufSizeShift;
  82
  83         shared = kmalloc(sizeof(struct flchip_shared) * lpddr->numchips,
  84                                                 GFP_KERNEL);
  85         if (!shared) {
  86                 kfree(lpddr);
  87                 kfree(mtd);
  88                 return NULL;
  89         }
  90
  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++;
 106                 }
 107         }
 108
 109         return mtd;
 110 }
 111 EXPORT_SYMBOL(lpddr_cmdset);
 112
 113 static int wait_for_ready(struct map_info *map, struct flchip *chip,
 114                 unsigned int chip_op_time)
 115 {
 116         unsigned int timeo, reset_timeo, sleep_time;
 117         unsigned int dsr;
 118         flstate_t chip_state = chip->state;
 119         int ret = 0;
 120
 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;
 127
 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;
 137                 }
 138
 139                 /* OK Still waiting. Drop the lock, wait a while and retry. */
 140                 mutex_unlock(&chip->mutex);
 141                 if (sleep_time >= 1000000/HZ) {
 142                         /*
 143                          * Half of the normal delay still remaining
 144                          * can be performed with a sleeping delay instead
 145                          * of busy waiting.
 146                          */
 147                         msleep(sleep_time/1000);
 148                         timeo -= sleep_time;
 149                         sleep_time = 1000000/HZ;
 150                 } else {
 151                         udelay(1);
 152                         cond_resched();
 153                         timeo--;
 154                 }
 155                 mutex_lock(&chip->mutex);
 156
 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);
 166                 }
 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;
 171                 }
 172         }
 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;
 181         }
 182         chip->state = FL_READY;
 183         return ret;
 184 }
 185
 186 static int get_chip(struct map_info *map, struct flchip *chip, int mode)
 187 {
 188         int ret;
 189         DECLARE_WAITQUEUE(wait, current);
 190
 191  retry:
 192         if (chip->priv && (mode == FL_WRITING || mode == FL_ERASING)
 193                 && chip->state != FL_SYNCING) {
 194                 /*
 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.
 199                  *
 200                  * The rules are as follows:
 201                  *
 202                  * - any write operation must own shared->writing.
 203                  *
 204                  * - any erase operation must own _both_ shared->writing and
 205                  *   shared->erasing.
 206                  *
 207                  * - contension arbitration is handled in the owner's context.
 208                  *
 209                  * The 'shared' struct can be read and/or written only when
 210                  * its lock is taken.
 211                  */
 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) {
 217                         /*
 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.
 225                          */
 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);
 233
 234                         if (ret == -EAGAIN) {
 235                                 mutex_unlock(&contender->mutex);
 236                                 goto retry;
 237                         }
 238                         if (ret) {
 239                                 mutex_unlock(&contender->mutex);
 240                                 return ret;
 241                         }
 242                         mutex_lock(&shared->lock);
 243
 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;
 250                         }
 251                         mutex_unlock(&contender->mutex);
 252                 }
 253
 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;
 266                 }
 267
 268                 /* We now own it */
 269                 shared->writing = chip;
 270                 if (mode == FL_ERASING)
 271                         shared->erasing = chip;
 272                 mutex_unlock(&shared->lock);
 273         }
 274
 275         ret = chip_ready(map, chip, mode);
 276         if (ret == -EAGAIN)
 277                 goto retry;
 278
 279         return ret;
 280 }
 281
 282 static int chip_ready(struct map_info *map, struct flchip *chip, int mode)
 283 {
 284         struct lpddr_private *lpddr = map->fldrv_priv;
 285         int ret = 0;
 286         DECLARE_WAITQUEUE(wait, current);
 287
 288         /* Prevent setting state FL_SYNCING for chip in suspended state. */
 289         if (FL_SYNCING == mode && FL_READY != chip->oldstate)
 290                 goto sleep;
 291
 292         switch (chip->state) {
 293         case FL_READY:
 294         case FL_JEDEC_QUERY:
 295                 return 0;
 296
 297         case FL_ERASING:
 298                 if (!lpddr->qinfo->SuspEraseSupp ||
 299                         !(mode == FL_READY || mode == FL_POINT))
 300                         goto sleep;
 301
 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;
 314                 }
 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;
 323
 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;
 333         }
 334 }
 335
 336 static void put_chip(struct map_info *map, struct flchip *chip)
 337 {
 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;
 355                         }
 356                         shared->erasing = NULL;
 357                         shared->writing = NULL;
 358                 } else if (shared->erasing == chip && shared->writing != chip) {
 359                         /*
 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.
 365                          */
 366                         mutex_unlock(&shared->lock);
 367                         wake_up(&chip->wq);
 368                         return;
 369                 }
 370                 mutex_unlock(&shared->lock);
 371         }
 372
 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);
 387         }
 388         wake_up(&chip->wq);
 389 }
 390
 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)
 394 {
 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;
 401
 402         wbufsize = 1 << lpddr->qinfo->BufSizeShift;
 403
 404         mutex_lock(&chip->mutex);
 405         ret = get_chip(map, chip, FL_WRITING);
 406         if (ret) {
 407                 mutex_unlock(&chip->mutex);
 408                 return ret;
 409         }
 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);
 419         }
 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;
 428
 429                 if (n > vec->iov_len - vec_seek)
 430                         n = vec->iov_len - vec_seek;
 431                 if (n > len)
 432                         n = len;
 433
 434                 if (!word_gap && (len < map_bankwidth(map)))
 435                         datum = map_word_ff(map);
 436
 437                 datum = map_word_load_partial(map, datum,
 438                                 vec->iov_base + vec_seek, word_gap, n);
 439
 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;
 446                 }
 447
 448                 vec_seek += n;
 449                 if (vec_seek == vec->iov_len) {
 450                         vec++;
 451                         vec_seek = 0;
 452                 }
 453         } while (len);
 454         *pvec = vec;
 455         *pvec_seek = vec_seek;
 456
 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;
 465         }
 466
 467  out:   put_chip(map, chip);
 468         mutex_unlock(&chip->mutex);
 469         return ret;
 470 }
 471
 472 int do_erase_oneblock(struct mtd_info *mtd, loff_t adr)
 473 {
 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;
 479
 480         mutex_lock(&chip->mutex);
 481         ret = get_chip(map, chip, FL_ERASING);
 482         if (ret) {
 483                 mutex_unlock(&chip->mutex);
 484                 return ret;
 485         }
 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;
 493         }
 494  out:   put_chip(map, chip);
 495         mutex_unlock(&chip->mutex);
 496         return ret;
 497 }
 498
 499 static int lpddr_read(struct mtd_info *mtd, loff_t adr, size_t len,
 500                         size_t *retlen, u_char *buf)
 501 {
 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;
 507
 508         mutex_lock(&chip->mutex);
 509         ret = get_chip(map, chip, FL_READY);
 510         if (ret) {
 511                 mutex_unlock(&chip->mutex);
 512                 return ret;
 513         }
 514
 515         map_copy_from(map, buf, adr, len);
 516         *retlen = len;
 517
 518         put_chip(map, chip);
 519         mutex_unlock(&chip->mutex);
 520         return ret;
 521 }
 522
 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)
 525 {
 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;
 532
 533         if (!map->virt || (adr + len > mtd->size))
 534                 return -EINVAL;
 535
 536         /* ofs: offset within the first chip that the first read should start */
 537         ofs = adr - (chipnum << lpddr->chipshift);
 538
 539         *mtdbuf = (void *)map->virt + chip->start + ofs;
 540         *retlen = 0;
 541
 542         while (len) {
 543                 unsigned long thislen;
 544
 545                 if (chipnum >= lpddr->numchips)
 546                         break;
 547
 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;
 553
 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;
 564
 565                 chip->state = FL_POINT;
 566                 chip->ref_point_counter++;
 567                 *retlen += thislen;
 568                 len -= thislen;
 569
 570                 ofs = 0;
 571                 last_end += 1 << lpddr->chipshift;
 572                 chipnum++;
 573                 chip = &lpddr->chips[chipnum];
 574         }
 575         return 0;
 576 }
 577
 578 static void lpddr_unpoint (struct mtd_info *mtd, loff_t adr, size_t len)
 579 {
 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;
 584
 585         /* ofs: offset within the first chip that the first read should start */
 586         ofs = adr - (chipnum << lpddr->chipshift);
 587
 588         while (len) {
 589                 unsigned long thislen;
 590                 struct flchip *chip;
 591
 592                 chip = &lpddr->chips[chipnum];
 593                 if (chipnum >= lpddr->numchips)
 594                         break;
 595
 596                 if ((len + ofs - 1) >> lpddr->chipshift)
 597                         thislen = (1<<lpddr->chipshift) - ofs;
 598                 else
 599                         thislen = len;
 600
 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);
 609
 610                 put_chip(map, chip);
 611                 mutex_unlock(&chip->mutex);
 612
 613                 len -= thislen;
 614                 ofs = 0;
 615                 chipnum++;
 616         }
 617 }
 618
 619 static int lpddr_write_buffers(struct mtd_info *mtd, loff_t to, size_t len,
 620                                 size_t *retlen, const u_char *buf)
 621 {
 622         struct kvec vec;
 623
 624         vec.iov_base = (void *) buf;
 625         vec.iov_len = len;
 626
 627         return lpddr_writev(mtd, &vec, 1, to, retlen);
 628 }
 629
 630
 631 static int lpddr_writev(struct mtd_info *mtd, const struct kvec *vecs,
 632                                 unsigned long count, loff_t to, size_t *retlen)
 633 {
 634         struct map_info *map = mtd->priv;
 635         struct lpddr_private *lpddr = map->fldrv_priv;
 636         int ret = 0;
 637         int chipnum;
 638         unsigned long ofs, vec_seek, i;
 639         int wbufsize = 1 << lpddr->qinfo->BufSizeShift;
 640
 641         size_t len = 0;
 642
 643         for (i = 0; i < count; i++)
 644                 len += vecs[i].iov_len;
 645
 646         *retlen = 0;
 647         if (!len)
 648                 return 0;
 649
 650         chipnum = to >> lpddr->chipshift;
 651
 652         ofs = to;
 653         vec_seek = 0;
 654
 655         do {
 656                 /* We must not cross write block boundaries */
 657                 int size = wbufsize - (ofs & (wbufsize-1));
 658
 659                 if (size > len)
 660                         size = len;
 661
 662                 ret = do_write_buffer(map, &lpddr->chips[chipnum],
 663                                           ofs, &vecs, &vec_seek, size);
 664                 if (ret)
 665                         return ret;
 666
 667                 ofs += size;
 668                 (*retlen) += size;
 669                 len -= size;
 670
 671                 /* Be nice and reschedule with the chip in a usable
 672                  * state for other processes */
 673                 cond_resched();
 674
 675         } while (len);
 676
 677         return 0;
 678 }
 679
 680 static int lpddr_erase(struct mtd_info *mtd, struct erase_info *instr)
 681 {
 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;
 687
 688         ofs = instr->addr;
 689         len = instr->len;
 690
 691         if (ofs > mtd->size || (len + ofs) > mtd->size)
 692                 return -EINVAL;
 693
 694         while (len > 0) {
 695                 ret = do_erase_oneblock(mtd, ofs);
 696                 if (ret)
 697                         return ret;
 698                 ofs += size;
 699                 len -= size;
 700         }
 701         instr->state = MTD_ERASE_DONE;
 702         mtd_erase_callback(instr);
 703
 704         return 0;
 705 }
 706
 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)
 710 {
 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];
 716
 717         mutex_lock(&chip->mutex);
 718         ret = get_chip(map, chip, FL_LOCKING);
 719         if (ret) {
 720                 mutex_unlock(&chip->mutex);
 721                 return ret;
 722         }
 723
 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();
 732
 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;
 738         }
 739 out:    put_chip(map, chip);
 740         mutex_unlock(&chip->mutex);
 741         return ret;
 742 }
 743
 744 static int lpddr_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
 745 {
 746         return do_xxlock(mtd, ofs, len, DO_XXLOCK_LOCK);
 747 }
 748
 749 static int lpddr_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
 750 {
 751         return do_xxlock(mtd, ofs, len, DO_XXLOCK_UNLOCK);
 752 }
 753
 754 int word_program(struct map_info *map, loff_t adr, uint32_t curval)
 755 {
 756     int ret;
 757         struct lpddr_private *lpddr = map->fldrv_priv;
 758         int chipnum = adr >> lpddr->chipshift;
 759         struct flchip *chip = &lpddr->chips[chipnum];
 760
 761         mutex_lock(&chip->mutex);
 762         ret = get_chip(map, chip, FL_WRITING);
 763         if (ret) {
 764                 mutex_unlock(&chip->mutex);
 765                 return ret;
 766         }
 767
 768         send_pfow_command(map, LPDDR_WORD_PROGRAM, adr, 0x00, (map_word *)&curval);
 769
 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;
 775         }
 776
 777 out:    put_chip(map, chip);
 778         mutex_unlock(&chip->mutex);
 779         return ret;
 780 }
 781
 782 MODULE_LICENSE("GPL");
 783 MODULE_AUTHOR("Alexey Korolev <akorolev@infradead.org>");
 784 MODULE_DESCRIPTION("MTD driver for LPDDR flash chips");