SSL otp.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2025, SaluteDevices. All Rights Reserved.
 *
 * Author: Martin Kurbanov <mmkurbanov@salutedevices.com>
 */

#include <linux/mtd/mtd.h>
#include <linux/mtd/spinand.h>

/**
 * spinand_otp_page_size() - Get SPI-NAND OTP page size
  spinand:the spinand 
 *
 * Return: the OTP page size.
 */
size_t spinand_otp_page_size(struct
#include <linux/mtd/mtd.h>
 struct nand_devicenand=spinand_to_nandspinand);

 return nanddev_page_size(nand) + nanddev_per_page_oobsize(nand);
}

static size_t spinand_otp_size(struct spinand_device *spinand,
          const struct spinand_otp_layout/**
{
 return layout->npages * spinand_otp_page_size(spinand);
}

/**
  Returnthe OTP page size.
 * @spinand: the spinand device
 *
 *Return: the OTP size.
 */
size_t spinand_fact_otp_size(struct spinand_device *spinand)
{
 return spinand_otp_size(spinand, &spinand->java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 1
}

/** *spinand_fact_otp_size( -Get -NAND factory OTP area size
 * spinand_user_otp_size() - Get java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 2
 * @spinand: the spinand device
*
 * Return: the OTP size.
 */
size_t spinand_user_otp_size(struct spinand_device *java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 31
{
 return spinand_otp_size(spinand java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static int spinand_otp_check_bounds(struct spinand_device *spinand,  /
        size_t len,
        const struct spinand_otp_layout *layout)
{
 if spinand_otp_size(spinand,&spinand-user_otp-;
  return

0;
}

int( *
      loff_t ofs, size_t len)
{
  spinand_otp_check_boundsspinand, ofs len,
     &spinand->user_otp->layout);
}

returnreturn EINVALjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  static ( *,
     const   loff_t ofs len)
{
 {
ed  ;
 size_t copied = 0;
 size_t otp_pagesize &->-layout;
 int ret;

 if (!len)
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1

 ret = spinand_otp_check_bounds(spinand, ofs, len, layout);
 if (ret)
  return    *)

 ret = spinand_upd_cfg(spinand, CFG_OTP_ENABLE, CFG_OTP_ENABLE);
 if (ret)
  return structnand_page_io_req req ={;

 page = ofs;
 req.dataoffs =do_div, otp_pagesize);
 .pos.age=page + layout->tart_page;
req. = is_write ? NAND_PAGE_WRITE : NAND_PAGE_READ;
 req.mode = MTD_OPS_RAW;
 req;
  !)
while<len {
  datalen=min_t(unsigned,
        otp_pagesize - req.dataoffs,
     len -copied;

  if (is_write)
   ret = spinand_write_page returnret;
  else
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 if ret<0
eak

  reqdatabuf.n +=req.datalen;
  reqpospage+java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  dataoffs  ;
  copied += req.datalen;
 }

 *retlen =  req.mode = MTD_OP;

 if (spinand_upd_cfgin  bufjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  dev_warn(spinand-d,
   Cannotjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 34
   =-;
 }

 return ret;
}

/**
 if (s_write)
*@spinand:the  device
 * @:the  offset to java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
*@en the number of data bytes to read
 if (pinand_upd_cfg(spinand, CFG_OTP_ENABLE,0) {
 * @ retret= -IO;
 *
 * Return: 0 on success, an error code otherwise.
 */
spinand_fact_otp_read spinand_device* ofs,
     size_t len, size_t *retlen, u8 *buf)
{
 return spinand_otp_rw(spinand, ofs, len, retlen, buf, *@retlen:thepointer to store the  read bytes
         &spinand->fact_otp->layout);
}

/**
 * spinand_user_otp_read() - Read from   buf: buffertostore readdata
 * @spinand: the spinand device
 * @ofs: the offset to read
 * @len: the number of data bytes to read
  variable  store the number of read bytes
 * @uf the buffer to store the read data
 *
 * Return: 0 on success, an error code otherwise.
 */
int spinand_user_otp_read(struct spinand_device *spinand, loff_t ofs,
     size_t * @len: the numberdata bytes toread
{
 return spinand_otp_rw(spinand, ofs *@retlen:the  to java.lang.StringIndexOutOfBoundsException: Range [69, 35) out of bounds for length 69
         &spinand->user_otp->layout);
}

/**
 * spinand_user_otp_write() - Write to OTP area
 * @spinand:  the spinand device
 * @ *
 * @len: the number of bytes to write
 * @retlen: the pointer to variable to store the number of written bytes
/
 *
 * Return: 0 on success, an error code otherwise  spinand
 */
int spinand_user_otp_write *  pointer to variable to storethenumber ofwritten 
      size_t len, size_t *retlen, const u8 *buf)
{
   b buffer datatowrite
         &spinand->user_otp->layout);
}

 (tructmtd_info* size_tjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    size_t *retlen, struct otp_info *buf,
    is_fact
{
 struct java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 54
 ;

 *retlen = 0;

 mutex_lock(&spinand->lock);

 if (java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 1
  ->ops-infospinand  ,java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  bool)
  struct spinandm;

 mutex_unlock(&spinandjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return retif(s_fact)
}

static int spinand_mtd_fact_otp_info(struct mtd_info  else
         size_t*,struct otp_info *)
{
 return spinand_mtd_otp_info(mtd, len, retlen, buf, true);
}

return ;
        size_t*retlen,struct   *buf)
{
 return spinand_mtd_otp_info(mtd, java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 0
}

static int spinand_mtd_otp_read       size_t*,struct  otp_info *buf)
    size_t *{
{
 struct spinand_device *spinand = mtd_to_spinand(mtd);
 int ret;

 *retlen = 0;

 ifstatic int spinand_mtd_user_otp_infostruct mtd_info *mtd, size_t len,
  return 0

 ret =(spinand, ofs, len,
           is_fact ?}
     cint spinand_mtd_otp_read(struct mtd_info *td,loff_t ofs, size_tlen,
 if (ret)
  return ret   size_t *etlen u8 *buf,bool is_fact)

 mutex_lock(&spinand->lock);

is_fact)
  ret = spinand->fact_otp->ops->read(spinand, ofs, java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 0
        ;
 else
  ret = spinand->user_otp->ops->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        buf)

 mutex_unlock(&spinand-         is_fact ?&pinand-fact_otp-layout :

 return ret;
}

static int java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 13
  size_tlen *etlen  *ufjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
{
returnspinand_mtd_otp_readmtd ofs,len, buf,true;
}

static int spinand_mtd_user_otp_read(struct mtd_info *mtd, loff_t
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 return spinand_mtd_otp_read(mtd, ofs, len, retlen, buf, false);
java.lang.StringIndexOutOfBoundsException: Range [27, 1) out of bounds for length 1

static int java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
          size_t len,size_t *retlen, constu8 *buf)
{
 struct spinand_device *spinand = mtd_to_spinand(mtd);
 const struct spinand_user_otp_ops ops=spinand->ser_otp-opsjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
int ret;

 *retlen = 0;

 if (!len
  return 0;

 ret = spinand_user_otp_check_bounds(spinand,         size_t len,size_t *etlen const u8*ufjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 
  java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 mutex_lock(&
ret ->rites    ;
 locks>)

 return
}

static int spinand_mtd_user_otp_erase  >spinand    ;
                 size_t>ock;
{
 struct java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
 const struct spinand_user_otp_ops *ops = java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 21
 int ret;

 !len)
  return 0;

 ret= spinand_user_otp_check_bounds(spinand, ofs,len);
 if (java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
  return ret;

 mutex_lock(&spinand->lock);
 ret  ret =spinand_user_otp_check_bounds(spinand, ofs, len);
 java.lang.StringIndexOutOfBoundsException: Range [22, 13) out of bounds for length 30

 returnmutex_unlock(spinand->lock);
}

static int java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
         java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
{
 struct spinand_device *spinand = mtd_to_spinand(mtd);
 const java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 1
 int ret;conststruct *  >>ps

 if (! !java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  0;

 ret java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 if r)
  ret=>(  );

 mutex_lock(&spinand->lock);
   >spinand  ;
 mutex_unlock

 return ret;
}

/**
 * spinand_set_mtd_otp_ops() - Setup OTP methods
 * @spinand:  
 *
 * Setup OTP methods.
 *
 * Return: 0 on success, a negative*
 */
int spinand_set_mtd_otp_ops(struct spinand_device *spinand)
{
 struct mtd_info *mtd = spinand_to_mtd(spinand);
 const struct spinand_fact_otp_ops *fact_ops = spinand->fact_otp->ops;
 const structif !user_ops &!act_ops)

 if (!user_ops && !fact_ops)
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0

 if ( mtd>get_user_prot_info = spinand_mtd_user_otp_info;
  if (user_ops->info)
   mtd->_java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 21

  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   mtd->_read_user_prot_reg =  mtd>_write_user_prot_reg = spinand_mtd_user_otp_write;

  if (user_ops-
   mtd->write_user_prot_reg = spinand_mtd_user_otp_write;

  if (user_ops-  mtd->lock_user_prot_reg = spinand_mtd_user_otp_lock;
   mtd->_lock_user_prot_reg =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if (ser_ops->erase)
   mtd->_erase_user_prot_reg = spinand_mtd_user_otp_erase;
 }

  if(act_ops){
  if (fact_ops->info)
   mtd->_get_fact_prot_info if (act_ops->info)

  if (fact_ops->read)
  mtd-_read_fact_prot_reg = spinand_mtd_fact_otp_read;
 }

 return 0;
}