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