Linux Audio

Check our new training course

Loading...
Note: File does not exist in v5.9.
  1/*
  2 * Copyright (C) 2015 Matias Bjorling. All rights reserved.
  3 *
  4 * This program is free software; you can redistribute it and/or
  5 * modify it under the terms of the GNU General Public License version
  6 * 2 as published by the Free Software Foundation.
  7 *
  8 * This program is distributed in the hope that it will be useful, but
  9 * WITHOUT ANY WARRANTY; without even the implied warranty of
 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 11 * General Public License for more details.
 12 *
 13 * You should have received a copy of the GNU General Public License
 14 * along with this program; see the file COPYING.  If not, write to
 15 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
 16 * USA.
 17 *
 18 */
 19
 20#include <linux/lightnvm.h>
 21
 22#define MAX_SYSBLKS 3	/* remember to update mapping scheme on change */
 23#define MAX_BLKS_PR_SYSBLK 2 /* 2 blks with 256 pages and 3000 erases
 24			      * enables ~1.5M updates per sysblk unit
 25			      */
 26
 27struct sysblk_scan {
 28	/* A row is a collection of flash blocks for a system block. */
 29	int nr_rows;
 30	int row;
 31	int act_blk[MAX_SYSBLKS];
 32
 33	int nr_ppas;
 34	struct ppa_addr ppas[MAX_SYSBLKS * MAX_BLKS_PR_SYSBLK];/* all sysblks */
 35};
 36
 37static inline int scan_ppa_idx(int row, int blkid)
 38{
 39	return (row * MAX_BLKS_PR_SYSBLK) + blkid;
 40}
 41
 42void nvm_sysblk_to_cpu(struct nvm_sb_info *info, struct nvm_system_block *sb)
 43{
 44	info->seqnr = be32_to_cpu(sb->seqnr);
 45	info->erase_cnt = be32_to_cpu(sb->erase_cnt);
 46	info->version = be16_to_cpu(sb->version);
 47	strncpy(info->mmtype, sb->mmtype, NVM_MMTYPE_LEN);
 48	info->fs_ppa.ppa = be64_to_cpu(sb->fs_ppa);
 49}
 50
 51void nvm_cpu_to_sysblk(struct nvm_system_block *sb, struct nvm_sb_info *info)
 52{
 53	sb->magic = cpu_to_be32(NVM_SYSBLK_MAGIC);
 54	sb->seqnr = cpu_to_be32(info->seqnr);
 55	sb->erase_cnt = cpu_to_be32(info->erase_cnt);
 56	sb->version = cpu_to_be16(info->version);
 57	strncpy(sb->mmtype, info->mmtype, NVM_MMTYPE_LEN);
 58	sb->fs_ppa = cpu_to_be64(info->fs_ppa.ppa);
 59}
 60
 61static int nvm_setup_sysblks(struct nvm_dev *dev, struct ppa_addr *sysblk_ppas)
 62{
 63	int nr_rows = min_t(int, MAX_SYSBLKS, dev->nr_chnls);
 64	int i;
 65
 66	for (i = 0; i < nr_rows; i++)
 67		sysblk_ppas[i].ppa = 0;
 68
 69	/* if possible, place sysblk at first channel, middle channel and last
 70	 * channel of the device. If not, create only one or two sys blocks
 71	 */
 72	switch (dev->nr_chnls) {
 73	case 2:
 74		sysblk_ppas[1].g.ch = 1;
 75		/* fall-through */
 76	case 1:
 77		sysblk_ppas[0].g.ch = 0;
 78		break;
 79	default:
 80		sysblk_ppas[0].g.ch = 0;
 81		sysblk_ppas[1].g.ch = dev->nr_chnls / 2;
 82		sysblk_ppas[2].g.ch = dev->nr_chnls - 1;
 83		break;
 84	}
 85
 86	return nr_rows;
 87}
 88
 89void nvm_setup_sysblk_scan(struct nvm_dev *dev, struct sysblk_scan *s,
 90						struct ppa_addr *sysblk_ppas)
 91{
 92	memset(s, 0, sizeof(struct sysblk_scan));
 93	s->nr_rows = nvm_setup_sysblks(dev, sysblk_ppas);
 94}
 95
 96static int sysblk_get_host_blks(struct ppa_addr ppa, int nr_blks, u8 *blks,
 97								void *private)
 98{
 99	struct sysblk_scan *s = private;
100	int i, nr_sysblk = 0;
101
102	for (i = 0; i < nr_blks; i++) {
103		if (blks[i] != NVM_BLK_T_HOST)
104			continue;
105
106		if (s->nr_ppas == MAX_BLKS_PR_SYSBLK * MAX_SYSBLKS) {
107			pr_err("nvm: too many host blks\n");
108			return -EINVAL;
109		}
110
111		ppa.g.blk = i;
112
113		s->ppas[scan_ppa_idx(s->row, nr_sysblk)] = ppa;
114		s->nr_ppas++;
115		nr_sysblk++;
116	}
117
118	return 0;
119}
120
121static int nvm_get_all_sysblks(struct nvm_dev *dev, struct sysblk_scan *s,
122				struct ppa_addr *ppas, nvm_bb_update_fn *fn)
123{
124	struct ppa_addr dppa;
125	int i, ret;
126
127	s->nr_ppas = 0;
128
129	for (i = 0; i < s->nr_rows; i++) {
130		dppa = generic_to_dev_addr(dev, ppas[i]);
131		s->row = i;
132
133		ret = dev->ops->get_bb_tbl(dev, dppa, dev->blks_per_lun, fn, s);
134		if (ret) {
135			pr_err("nvm: failed bb tbl for ppa (%u %u)\n",
136							ppas[i].g.ch,
137							ppas[i].g.blk);
138			return ret;
139		}
140	}
141
142	return ret;
143}
144
145/*
146 * scans a block for latest sysblk.
147 * Returns:
148 *	0 - newer sysblk not found. PPA is updated to latest page.
149 *	1 - newer sysblk found and stored in *cur. PPA is updated to
150 *	    next valid page.
151 *	<0- error.
152 */
153static int nvm_scan_block(struct nvm_dev *dev, struct ppa_addr *ppa,
154						struct nvm_system_block *sblk)
155{
156	struct nvm_system_block *cur;
157	int pg, cursz, ret, found = 0;
158
159	/* the full buffer for a flash page is allocated. Only the first of it
160	 * contains the system block information
161	 */
162	cursz = dev->sec_size * dev->sec_per_pg * dev->nr_planes;
163	cur = kmalloc(cursz, GFP_KERNEL);
164	if (!cur)
165		return -ENOMEM;
166
167	/* perform linear scan through the block */
168	for (pg = 0; pg < dev->lps_per_blk; pg++) {
169		ppa->g.pg = ppa_to_slc(dev, pg);
170
171		ret = nvm_submit_ppa(dev, ppa, 1, NVM_OP_PREAD, NVM_IO_SLC_MODE,
172								cur, cursz);
173		if (ret) {
174			if (ret == NVM_RSP_ERR_EMPTYPAGE) {
175				pr_debug("nvm: sysblk scan empty ppa (%u %u %u %u)\n",
176							ppa->g.ch,
177							ppa->g.lun,
178							ppa->g.blk,
179							ppa->g.pg);
180				break;
181			}
182			pr_err("nvm: read failed (%x) for ppa (%u %u %u %u)",
183							ret,
184							ppa->g.ch,
185							ppa->g.lun,
186							ppa->g.blk,
187							ppa->g.pg);
188			break; /* if we can't read a page, continue to the
189				* next blk
190				*/
191		}
192
193		if (be32_to_cpu(cur->magic) != NVM_SYSBLK_MAGIC) {
194			pr_debug("nvm: scan break for ppa (%u %u %u %u)\n",
195							ppa->g.ch,
196							ppa->g.lun,
197							ppa->g.blk,
198							ppa->g.pg);
199			break; /* last valid page already found */
200		}
201
202		if (be32_to_cpu(cur->seqnr) < be32_to_cpu(sblk->seqnr))
203			continue;
204
205		memcpy(sblk, cur, sizeof(struct nvm_system_block));
206		found = 1;
207	}
208
209	kfree(cur);
210
211	return found;
212}
213
214static int nvm_set_bb_tbl(struct nvm_dev *dev, struct sysblk_scan *s, int type)
215{
216	struct nvm_rq rqd;
217	int ret;
218
219	if (s->nr_ppas > dev->ops->max_phys_sect) {
220		pr_err("nvm: unable to update all sysblocks atomically\n");
221		return -EINVAL;
222	}
223
224	memset(&rqd, 0, sizeof(struct nvm_rq));
225
226	nvm_set_rqd_ppalist(dev, &rqd, s->ppas, s->nr_ppas);
227	nvm_generic_to_addr_mode(dev, &rqd);
228
229	ret = dev->ops->set_bb_tbl(dev, &rqd, type);
230	nvm_free_rqd_ppalist(dev, &rqd);
231	if (ret) {
232		pr_err("nvm: sysblk failed bb mark\n");
233		return -EINVAL;
234	}
235
236	return 0;
237}
238
239static int sysblk_get_free_blks(struct ppa_addr ppa, int nr_blks, u8 *blks,
240								void *private)
241{
242	struct sysblk_scan *s = private;
243	struct ppa_addr *sppa;
244	int i, blkid = 0;
245
246	for (i = 0; i < nr_blks; i++) {
247		if (blks[i] == NVM_BLK_T_HOST)
248			return -EEXIST;
249
250		if (blks[i] != NVM_BLK_T_FREE)
251			continue;
252
253		sppa = &s->ppas[scan_ppa_idx(s->row, blkid)];
254		sppa->g.ch = ppa.g.ch;
255		sppa->g.lun = ppa.g.lun;
256		sppa->g.blk = i;
257		s->nr_ppas++;
258		blkid++;
259
260		pr_debug("nvm: use (%u %u %u) as sysblk\n",
261					sppa->g.ch, sppa->g.lun, sppa->g.blk);
262		if (blkid > MAX_BLKS_PR_SYSBLK - 1)
263			return 0;
264	}
265
266	pr_err("nvm: sysblk failed get sysblk\n");
267	return -EINVAL;
268}
269
270static int nvm_write_and_verify(struct nvm_dev *dev, struct nvm_sb_info *info,
271							struct sysblk_scan *s)
272{
273	struct nvm_system_block nvmsb;
274	void *buf;
275	int i, sect, ret, bufsz;
276	struct ppa_addr *ppas;
277
278	nvm_cpu_to_sysblk(&nvmsb, info);
279
280	/* buffer for flash page */
281	bufsz = dev->sec_size * dev->sec_per_pg * dev->nr_planes;
282	buf = kzalloc(bufsz, GFP_KERNEL);
283	if (!buf)
284		return -ENOMEM;
285	memcpy(buf, &nvmsb, sizeof(struct nvm_system_block));
286
287	ppas = kcalloc(dev->sec_per_pg, sizeof(struct ppa_addr), GFP_KERNEL);
288	if (!ppas) {
289		ret = -ENOMEM;
290		goto err;
291	}
292
293	/* Write and verify */
294	for (i = 0; i < s->nr_rows; i++) {
295		ppas[0] = s->ppas[scan_ppa_idx(i, s->act_blk[i])];
296
297		pr_debug("nvm: writing sysblk to ppa (%u %u %u %u)\n",
298							ppas[0].g.ch,
299							ppas[0].g.lun,
300							ppas[0].g.blk,
301							ppas[0].g.pg);
302
303		/* Expand to all sectors within a flash page */
304		if (dev->sec_per_pg > 1) {
305			for (sect = 1; sect < dev->sec_per_pg; sect++) {
306				ppas[sect].ppa = ppas[0].ppa;
307				ppas[sect].g.sec = sect;
308			}
309		}
310
311		ret = nvm_submit_ppa(dev, ppas, dev->sec_per_pg, NVM_OP_PWRITE,
312						NVM_IO_SLC_MODE, buf, bufsz);
313		if (ret) {
314			pr_err("nvm: sysblk failed program (%u %u %u)\n",
315							ppas[0].g.ch,
316							ppas[0].g.lun,
317							ppas[0].g.blk);
318			break;
319		}
320
321		ret = nvm_submit_ppa(dev, ppas, dev->sec_per_pg, NVM_OP_PREAD,
322						NVM_IO_SLC_MODE, buf, bufsz);
323		if (ret) {
324			pr_err("nvm: sysblk failed read (%u %u %u)\n",
325							ppas[0].g.ch,
326							ppas[0].g.lun,
327							ppas[0].g.blk);
328			break;
329		}
330
331		if (memcmp(buf, &nvmsb, sizeof(struct nvm_system_block))) {
332			pr_err("nvm: sysblk failed verify (%u %u %u)\n",
333							ppas[0].g.ch,
334							ppas[0].g.lun,
335							ppas[0].g.blk);
336			ret = -EINVAL;
337			break;
338		}
339	}
340
341	kfree(ppas);
342err:
343	kfree(buf);
344
345	return ret;
346}
347
348static int nvm_prepare_new_sysblks(struct nvm_dev *dev, struct sysblk_scan *s)
349{
350	int i, ret;
351	unsigned long nxt_blk;
352	struct ppa_addr *ppa;
353
354	for (i = 0; i < s->nr_rows; i++) {
355		nxt_blk = (s->act_blk[i] + 1) % MAX_BLKS_PR_SYSBLK;
356		ppa = &s->ppas[scan_ppa_idx(i, nxt_blk)];
357		ppa->g.pg = ppa_to_slc(dev, 0);
358
359		ret = nvm_erase_ppa(dev, ppa, 1);
360		if (ret)
361			return ret;
362
363		s->act_blk[i] = nxt_blk;
364	}
365
366	return 0;
367}
368
369int nvm_get_sysblock(struct nvm_dev *dev, struct nvm_sb_info *info)
370{
371	struct ppa_addr sysblk_ppas[MAX_SYSBLKS];
372	struct sysblk_scan s;
373	struct nvm_system_block *cur;
374	int i, j, found = 0;
375	int ret = -ENOMEM;
376
377	/*
378	 * 1. setup sysblk locations
379	 * 2. get bad block list
380	 * 3. filter on host-specific (type 3)
381	 * 4. iterate through all and find the highest seq nr.
382	 * 5. return superblock information
383	 */
384
385	if (!dev->ops->get_bb_tbl)
386		return -EINVAL;
387
388	nvm_setup_sysblk_scan(dev, &s, sysblk_ppas);
389
390	mutex_lock(&dev->mlock);
391	ret = nvm_get_all_sysblks(dev, &s, sysblk_ppas, sysblk_get_host_blks);
392	if (ret)
393		goto err_sysblk;
394
395	/* no sysblocks initialized */
396	if (!s.nr_ppas)
397		goto err_sysblk;
398
399	cur = kzalloc(sizeof(struct nvm_system_block), GFP_KERNEL);
400	if (!cur)
401		goto err_sysblk;
402
403	/* find the latest block across all sysblocks */
404	for (i = 0; i < s.nr_rows; i++) {
405		for (j = 0; j < MAX_BLKS_PR_SYSBLK; j++) {
406			struct ppa_addr ppa = s.ppas[scan_ppa_idx(i, j)];
407
408			ret = nvm_scan_block(dev, &ppa, cur);
409			if (ret > 0)
410				found = 1;
411			else if (ret < 0)
412				break;
413		}
414	}
415
416	nvm_sysblk_to_cpu(info, cur);
417
418	kfree(cur);
419err_sysblk:
420	mutex_unlock(&dev->mlock);
421
422	if (found)
423		return 1;
424	return ret;
425}
426
427int nvm_update_sysblock(struct nvm_dev *dev, struct nvm_sb_info *new)
428{
429	/* 1. for each latest superblock
430	 * 2. if room
431	 *    a. write new flash page entry with the updated information
432	 * 3. if no room
433	 *    a. find next available block on lun (linear search)
434	 *       if none, continue to next lun
435	 *       if none at all, report error. also report that it wasn't
436	 *       possible to write to all superblocks.
437	 *    c. write data to block.
438	 */
439	struct ppa_addr sysblk_ppas[MAX_SYSBLKS];
440	struct sysblk_scan s;
441	struct nvm_system_block *cur;
442	int i, j, ppaidx, found = 0;
443	int ret = -ENOMEM;
444
445	if (!dev->ops->get_bb_tbl)
446		return -EINVAL;
447
448	nvm_setup_sysblk_scan(dev, &s, sysblk_ppas);
449
450	mutex_lock(&dev->mlock);
451	ret = nvm_get_all_sysblks(dev, &s, sysblk_ppas, sysblk_get_host_blks);
452	if (ret)
453		goto err_sysblk;
454
455	cur = kzalloc(sizeof(struct nvm_system_block), GFP_KERNEL);
456	if (!cur)
457		goto err_sysblk;
458
459	/* Get the latest sysblk for each sysblk row */
460	for (i = 0; i < s.nr_rows; i++) {
461		found = 0;
462		for (j = 0; j < MAX_BLKS_PR_SYSBLK; j++) {
463			ppaidx = scan_ppa_idx(i, j);
464			ret = nvm_scan_block(dev, &s.ppas[ppaidx], cur);
465			if (ret > 0) {
466				s.act_blk[i] = j;
467				found = 1;
468			} else if (ret < 0)
469				break;
470		}
471	}
472
473	if (!found) {
474		pr_err("nvm: no valid sysblks found to update\n");
475		ret = -EINVAL;
476		goto err_cur;
477	}
478
479	/*
480	 * All sysblocks found. Check that they have same page id in their flash
481	 * blocks
482	 */
483	for (i = 1; i < s.nr_rows; i++) {
484		struct ppa_addr l = s.ppas[scan_ppa_idx(0, s.act_blk[0])];
485		struct ppa_addr r = s.ppas[scan_ppa_idx(i, s.act_blk[i])];
486
487		if (l.g.pg != r.g.pg) {
488			pr_err("nvm: sysblks not on same page. Previous update failed.\n");
489			ret = -EINVAL;
490			goto err_cur;
491		}
492	}
493
494	/*
495	 * Check that there haven't been another update to the seqnr since we
496	 * began
497	 */
498	if ((new->seqnr - 1) != be32_to_cpu(cur->seqnr)) {
499		pr_err("nvm: seq is not sequential\n");
500		ret = -EINVAL;
501		goto err_cur;
502	}
503
504	/*
505	 * When all pages in a block has been written, a new block is selected
506	 * and writing is performed on the new block.
507	 */
508	if (s.ppas[scan_ppa_idx(0, s.act_blk[0])].g.pg ==
509						dev->lps_per_blk - 1) {
510		ret = nvm_prepare_new_sysblks(dev, &s);
511		if (ret)
512			goto err_cur;
513	}
514
515	ret = nvm_write_and_verify(dev, new, &s);
516err_cur:
517	kfree(cur);
518err_sysblk:
519	mutex_unlock(&dev->mlock);
520
521	return ret;
522}
523
524int nvm_init_sysblock(struct nvm_dev *dev, struct nvm_sb_info *info)
525{
526	struct ppa_addr sysblk_ppas[MAX_SYSBLKS];
527	struct sysblk_scan s;
528	int ret;
529
530	/*
531	 * 1. select master blocks and select first available blks
532	 * 2. get bad block list
533	 * 3. mark MAX_SYSBLKS block as host-based device allocated.
534	 * 4. write and verify data to block
535	 */
536
537	if (!dev->ops->get_bb_tbl || !dev->ops->set_bb_tbl)
538		return -EINVAL;
539
540	if (!(dev->mccap & NVM_ID_CAP_SLC) || !dev->lps_per_blk) {
541		pr_err("nvm: memory does not support SLC access\n");
542		return -EINVAL;
543	}
544
545	/* Index all sysblocks and mark them as host-driven */
546	nvm_setup_sysblk_scan(dev, &s, sysblk_ppas);
547
548	mutex_lock(&dev->mlock);
549	ret = nvm_get_all_sysblks(dev, &s, sysblk_ppas, sysblk_get_free_blks);
550	if (ret)
551		goto err_mark;
552
553	ret = nvm_set_bb_tbl(dev, &s, NVM_BLK_T_HOST);
554	if (ret)
555		goto err_mark;
556
557	/* Write to the first block of each row */
558	ret = nvm_write_and_verify(dev, info, &s);
559err_mark:
560	mutex_unlock(&dev->mlock);
561	return ret;
562}
563
564struct factory_blks {
565	struct nvm_dev *dev;
566	int flags;
567	unsigned long *blks;
568};
569
570static int factory_nblks(int nblks)
571{
572	/* Round up to nearest BITS_PER_LONG */
573	return (nblks + (BITS_PER_LONG - 1)) & ~(BITS_PER_LONG - 1);
574}
575
576static unsigned int factory_blk_offset(struct nvm_dev *dev, int ch, int lun)
577{
578	int nblks = factory_nblks(dev->blks_per_lun);
579
580	return ((ch * dev->luns_per_chnl * nblks) + (lun * nblks)) /
581								BITS_PER_LONG;
582}
583
584static int nvm_factory_blks(struct ppa_addr ppa, int nr_blks, u8 *blks,
585								void *private)
586{
587	struct factory_blks *f = private;
588	struct nvm_dev *dev = f->dev;
589	int i, lunoff;
590
591	lunoff = factory_blk_offset(dev, ppa.g.ch, ppa.g.lun);
592
593	/* non-set bits correspond to the block must be erased */
594	for (i = 0; i < nr_blks; i++) {
595		switch (blks[i]) {
596		case NVM_BLK_T_FREE:
597			if (f->flags & NVM_FACTORY_ERASE_ONLY_USER)
598				set_bit(i, &f->blks[lunoff]);
599			break;
600		case NVM_BLK_T_HOST:
601			if (!(f->flags & NVM_FACTORY_RESET_HOST_BLKS))
602				set_bit(i, &f->blks[lunoff]);
603			break;
604		case NVM_BLK_T_GRWN_BAD:
605			if (!(f->flags & NVM_FACTORY_RESET_GRWN_BBLKS))
606				set_bit(i, &f->blks[lunoff]);
607			break;
608		default:
609			set_bit(i, &f->blks[lunoff]);
610			break;
611		}
612	}
613
614	return 0;
615}
616
617static int nvm_fact_get_blks(struct nvm_dev *dev, struct ppa_addr *erase_list,
618					int max_ppas, struct factory_blks *f)
619{
620	struct ppa_addr ppa;
621	int ch, lun, blkid, idx, done = 0, ppa_cnt = 0;
622	unsigned long *offset;
623
624	while (!done) {
625		done = 1;
626		for (ch = 0; ch < dev->nr_chnls; ch++) {
627			for (lun = 0; lun < dev->luns_per_chnl; lun++) {
628				idx = factory_blk_offset(dev, ch, lun);
629				offset = &f->blks[idx];
630
631				blkid = find_first_zero_bit(offset,
632							dev->blks_per_lun);
633				if (blkid >= dev->blks_per_lun)
634					continue;
635				set_bit(blkid, offset);
636
637				ppa.ppa = 0;
638				ppa.g.ch = ch;
639				ppa.g.lun = lun;
640				ppa.g.blk = blkid;
641				pr_debug("nvm: erase ppa (%u %u %u)\n",
642								ppa.g.ch,
643								ppa.g.lun,
644								ppa.g.blk);
645
646				erase_list[ppa_cnt] = ppa;
647				ppa_cnt++;
648				done = 0;
649
650				if (ppa_cnt == max_ppas)
651					return ppa_cnt;
652			}
653		}
654	}
655
656	return ppa_cnt;
657}
658
659static int nvm_fact_get_bb_tbl(struct nvm_dev *dev, struct ppa_addr ppa,
660					nvm_bb_update_fn *fn, void *priv)
661{
662	struct ppa_addr dev_ppa;
663	int ret;
664
665	dev_ppa = generic_to_dev_addr(dev, ppa);
666
667	ret = dev->ops->get_bb_tbl(dev, dev_ppa, dev->blks_per_lun, fn, priv);
668	if (ret)
669		pr_err("nvm: failed bb tbl for ch%u lun%u\n",
670							ppa.g.ch, ppa.g.blk);
671	return ret;
672}
673
674static int nvm_fact_select_blks(struct nvm_dev *dev, struct factory_blks *f)
675{
676	int ch, lun, ret;
677	struct ppa_addr ppa;
678
679	ppa.ppa = 0;
680	for (ch = 0; ch < dev->nr_chnls; ch++) {
681		for (lun = 0; lun < dev->luns_per_chnl; lun++) {
682			ppa.g.ch = ch;
683			ppa.g.lun = lun;
684
685			ret = nvm_fact_get_bb_tbl(dev, ppa, nvm_factory_blks,
686									f);
687			if (ret)
688				return ret;
689		}
690	}
691
692	return 0;
693}
694
695int nvm_dev_factory(struct nvm_dev *dev, int flags)
696{
697	struct factory_blks f;
698	struct ppa_addr *ppas;
699	int ppa_cnt, ret = -ENOMEM;
700	int max_ppas = dev->ops->max_phys_sect / dev->nr_planes;
701	struct ppa_addr sysblk_ppas[MAX_SYSBLKS];
702	struct sysblk_scan s;
703
704	f.blks = kzalloc(factory_nblks(dev->blks_per_lun) * dev->nr_luns,
705								GFP_KERNEL);
706	if (!f.blks)
707		return ret;
708
709	ppas = kcalloc(max_ppas, sizeof(struct ppa_addr), GFP_KERNEL);
710	if (!ppas)
711		goto err_blks;
712
713	f.dev = dev;
714	f.flags = flags;
715
716	/* create list of blks to be erased */
717	ret = nvm_fact_select_blks(dev, &f);
718	if (ret)
719		goto err_ppas;
720
721	/* continue to erase until list of blks until empty */
722	while ((ppa_cnt = nvm_fact_get_blks(dev, ppas, max_ppas, &f)) > 0)
723		nvm_erase_ppa(dev, ppas, ppa_cnt);
724
725	/* mark host reserved blocks free */
726	if (flags & NVM_FACTORY_RESET_HOST_BLKS) {
727		nvm_setup_sysblk_scan(dev, &s, sysblk_ppas);
728		mutex_lock(&dev->mlock);
729		ret = nvm_get_all_sysblks(dev, &s, sysblk_ppas,
730							sysblk_get_host_blks);
731		if (!ret)
732			ret = nvm_set_bb_tbl(dev, &s, NVM_BLK_T_FREE);
733		mutex_unlock(&dev->mlock);
734	}
735err_ppas:
736	kfree(ppas);
737err_blks:
738	kfree(f.blks);
739	return ret;
740}
741EXPORT_SYMBOL(nvm_dev_factory);