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