static void ams_delta_write_byte(struct mtd_info *mtd, u_char byte)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        void __iomem *io_base = this->priv;
 
        writew(0, io_base + OMAP_MPUIO_IO_CNTL);
 static u_char ams_delta_read_byte(struct mtd_info *mtd)
 {
        u_char res;
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        void __iomem *io_base = this->priv;
 
        gpio_set_value(AMS_DELTA_GPIO_PIN_NAND_NRE, 0);
 
  */
 static void atmel_nand_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = nand_chip->priv;
 
        if (ctrl & NAND_CTRL_CHANGE) {
  */
 static int atmel_nand_device_ready(struct mtd_info *mtd)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = nand_chip->priv;
 
        return gpio_get_value(host->board.rdy_pin) ^
 /* Set up for hardware ready pin and enable pin. */
 static int atmel_nand_set_enable_ready_pins(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = chip->priv;
        int res = 0;
 
  */
 static void atmel_read_buf8(struct mtd_info *mtd, u8 *buf, int len)
 {
-       struct nand_chip        *nand_chip = mtd->priv;
+       struct nand_chip        *nand_chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = nand_chip->priv;
 
        if (host->nfc && host->nfc->use_nfc_sram && host->nfc->data_in_sram) {
 
 static void atmel_read_buf16(struct mtd_info *mtd, u8 *buf, int len)
 {
-       struct nand_chip        *nand_chip = mtd->priv;
+       struct nand_chip        *nand_chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = nand_chip->priv;
 
        if (host->nfc && host->nfc->use_nfc_sram && host->nfc->data_in_sram) {
 
 static void atmel_write_buf8(struct mtd_info *mtd, const u8 *buf, int len)
 {
-       struct nand_chip        *nand_chip = mtd->priv;
+       struct nand_chip        *nand_chip = mtd_to_nand(mtd);
 
        __raw_writesb(nand_chip->IO_ADDR_W, buf, len);
 }
 
 static void atmel_write_buf16(struct mtd_info *mtd, const u8 *buf, int len)
 {
-       struct nand_chip        *nand_chip = mtd->priv;
+       struct nand_chip        *nand_chip = mtd_to_nand(mtd);
 
        __raw_writesw(nand_chip->IO_ADDR_W, buf, len / 2);
 }
        dma_addr_t dma_src_addr, dma_dst_addr, phys_addr;
        struct dma_async_tx_descriptor *tx = NULL;
        dma_cookie_t cookie;
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = chip->priv;
        void *p = buf;
        int err = -EIO;
 
 static void atmel_read_buf(struct mtd_info *mtd, u8 *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = chip->priv;
 
        if (use_dma && len > mtd->oobsize)
 
 static void atmel_write_buf(struct mtd_info *mtd, const u8 *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = chip->priv;
 
        if (use_dma && len > mtd->oobsize)
 
 static void pmecc_gen_syndrome(struct mtd_info *mtd, int sector)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = nand_chip->priv;
        int i;
        uint32_t value;
 
 static void pmecc_substitute(struct mtd_info *mtd)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = nand_chip->priv;
        int16_t __iomem *alpha_to = host->pmecc_alpha_to;
        int16_t __iomem *index_of = host->pmecc_index_of;
 
 static void pmecc_get_sigma(struct mtd_info *mtd)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = nand_chip->priv;
 
        int16_t *lmu = host->pmecc_lmu;
 
 static int pmecc_err_location(struct mtd_info *mtd)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = nand_chip->priv;
        unsigned long end_time;
        const int cap = host->pmecc_corr_cap;
 static void pmecc_correct_data(struct mtd_info *mtd, uint8_t *buf, uint8_t *ecc,
                int sector_num, int extra_bytes, int err_nbr)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = nand_chip->priv;
        int i = 0;
        int byte_pos, bit_pos, sector_size, pos;
 static int pmecc_correction(struct mtd_info *mtd, u32 pmecc_stat, uint8_t *buf,
        u8 *ecc)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = nand_chip->priv;
        int i, err_nbr;
        uint8_t *buf_pos;
 
 static void atmel_pmecc_core_init(struct mtd_info *mtd)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = nand_chip->priv;
        uint32_t val = 0;
        struct nand_ecclayout *ecc_layout;
 static int atmel_nand_calculate(struct mtd_info *mtd,
                const u_char *dat, unsigned char *ecc_code)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = nand_chip->priv;
        unsigned int ecc_value;
 
 static int atmel_nand_correct(struct mtd_info *mtd, u_char *dat,
                u_char *read_ecc, u_char *isnull)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = nand_chip->priv;
        unsigned int ecc_status;
        unsigned int ecc_word, ecc_bit;
  */
 static void atmel_nand_hwctl(struct mtd_info *mtd, int mode)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = nand_chip->priv;
 
        if (host->board.need_reset_workaround)
 static int nfc_device_ready(struct mtd_info *mtd)
 {
        u32 status, mask;
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = nand_chip->priv;
 
        status = nfc_read_status(host);
 
 static void nfc_select_chip(struct mtd_info *mtd, int chip)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = nand_chip->priv;
 
        if (chip == -1)
 static int nfc_make_addr(struct mtd_info *mtd, int command, int column,
                int page_addr, unsigned int *addr1234, unsigned int *cycle0)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
 
        int acycle = 0;
        unsigned char addr_bytes[8];
 static void nfc_nand_command(struct mtd_info *mtd, unsigned int command,
                                int column, int page_addr)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = chip->priv;
        unsigned long timeout;
        unsigned int nfc_addr_cmd = 0;
 
 static int nfc_sram_init(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct atmel_nand_host *host = chip->priv;
        int res = 0;
 
 
  */
 static u_char au_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        u_char ret = readb(this->IO_ADDR_R);
        wmb(); /* drain writebuffer */
        return ret;
  */
 static void au_write_byte(struct mtd_info *mtd, u_char byte)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        writeb(byte, this->IO_ADDR_W);
        wmb(); /* drain writebuffer */
 }
  */
 static u_char au_read_byte16(struct mtd_info *mtd)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        u_char ret = (u_char) cpu_to_le16(readw(this->IO_ADDR_R));
        wmb(); /* drain writebuffer */
        return ret;
  */
 static void au_write_byte16(struct mtd_info *mtd, u_char byte)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        writew(le16_to_cpu((u16) byte), this->IO_ADDR_W);
        wmb(); /* drain writebuffer */
 }
  */
 static u16 au_read_word(struct mtd_info *mtd)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        u16 ret = readw(this->IO_ADDR_R);
        wmb(); /* drain writebuffer */
        return ret;
 static void au_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
 {
        int i;
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
 
        for (i = 0; i < len; i++) {
                writeb(buf[i], this->IO_ADDR_W);
 static void au_read_buf(struct mtd_info *mtd, u_char *buf, int len)
 {
        int i;
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
 
        for (i = 0; i < len; i++) {
                buf[i] = readb(this->IO_ADDR_R);
 static void au_write_buf16(struct mtd_info *mtd, const u_char *buf, int len)
 {
        int i;
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        u16 *p = (u16 *) buf;
        len >>= 1;
 
 static void au_read_buf16(struct mtd_info *mtd, u_char *buf, int len)
 {
        int i;
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        u16 *p = (u16 *) buf;
        len >>= 1;
 
 static void au1550_hwcontrol(struct mtd_info *mtd, int cmd)
 {
        struct au1550nd_ctx *ctx = container_of(mtd, struct au1550nd_ctx, info);
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
 
        switch (cmd) {
 
 static void au1550_command(struct mtd_info *mtd, unsigned command, int column, int page_addr)
 {
        struct au1550nd_ctx *ctx = container_of(mtd, struct au1550nd_ctx, info);
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        int ce_override = 0, i;
        unsigned long flags = 0;
 
 
 static void bcm47xxnflash_ops_bcm4706_read(struct mtd_info *mtd, uint8_t *buf,
                                           int len)
 {
-       struct nand_chip *nand_chip = (struct nand_chip *)mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct bcm47xxnflash *b47n = (struct bcm47xxnflash *)nand_chip->priv;
 
        u32 ctlcode;
 static void bcm47xxnflash_ops_bcm4706_write(struct mtd_info *mtd,
                                            const uint8_t *buf, int len)
 {
-       struct nand_chip *nand_chip = (struct nand_chip *)mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct bcm47xxnflash *b47n = (struct bcm47xxnflash *)nand_chip->priv;
        struct bcma_drv_cc *cc = b47n->cc;
 
 static void bcm47xxnflash_ops_bcm4706_cmd_ctrl(struct mtd_info *mtd, int cmd,
                                               unsigned int ctrl)
 {
-       struct nand_chip *nand_chip = (struct nand_chip *)mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct bcm47xxnflash *b47n = (struct bcm47xxnflash *)nand_chip->priv;
        u32 code = 0;
 
 
 static int bcm47xxnflash_ops_bcm4706_dev_ready(struct mtd_info *mtd)
 {
-       struct nand_chip *nand_chip = (struct nand_chip *)mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct bcm47xxnflash *b47n = (struct bcm47xxnflash *)nand_chip->priv;
 
        return !!(bcma_cc_read32(b47n->cc, BCMA_CC_NFLASH_CTL) & NCTL_READY);
                                              unsigned command, int column,
                                              int page_addr)
 {
-       struct nand_chip *nand_chip = (struct nand_chip *)mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct bcm47xxnflash *b47n = (struct bcm47xxnflash *)nand_chip->priv;
        struct bcma_drv_cc *cc = b47n->cc;
        u32 ctlcode;
 
 static u8 bcm47xxnflash_ops_bcm4706_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *nand_chip = (struct nand_chip *)mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct bcm47xxnflash *b47n = (struct bcm47xxnflash *)nand_chip->priv;
        struct bcma_drv_cc *cc = b47n->cc;
        u32 tmp = 0;
 static void bcm47xxnflash_ops_bcm4706_read_buf(struct mtd_info *mtd,
                                               uint8_t *buf, int len)
 {
-       struct nand_chip *nand_chip = (struct nand_chip *)mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct bcm47xxnflash *b47n = (struct bcm47xxnflash *)nand_chip->priv;
 
        switch (b47n->curr_command) {
 static void bcm47xxnflash_ops_bcm4706_write_buf(struct mtd_info *mtd,
                                                const uint8_t *buf, int len)
 {
-       struct nand_chip *nand_chip = (struct nand_chip *)mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct bcm47xxnflash *b47n = (struct bcm47xxnflash *)nand_chip->priv;
 
        switch (b47n->curr_command) {
 
 static int bf5xx_nand_correct_data(struct mtd_info *mtd, u_char *dat,
                                        u_char *read_ecc, u_char *calc_ecc)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        int ret;
 
        ret = bf5xx_nand_correct_data_256(mtd, dat, read_ecc, calc_ecc);
                const u_char *dat, u_char *ecc_code)
 {
        struct bf5xx_nand_info *info = mtd_to_nand_info(mtd);
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        u16 ecc0, ecc1;
        u32 code[2];
        u8 *p;
                                uint8_t *buf, int is_read)
 {
        struct bf5xx_nand_info *info = mtd_to_nand_info(mtd);
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        unsigned short val;
 
        dev_dbg(info->device, " mtd->%p, buf->%p, is_read %d\n",
                                        uint8_t *buf, int len)
 {
        struct bf5xx_nand_info *info = mtd_to_nand_info(mtd);
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
 
        dev_dbg(info->device, "mtd->%p, buf->%p, int %d\n", mtd, buf, len);
 
                                const uint8_t *buf, int len)
 {
        struct bf5xx_nand_info *info = mtd_to_nand_info(mtd);
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
 
        dev_dbg(info->device, "mtd->%p, buf->%p, len %d\n", mtd, buf, len);
 
 
 static int bf5xx_nand_scan(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        int ret;
 
        ret = nand_scan_ident(mtd, 1, NULL);
 
 
 static void brcmnand_wp(struct mtd_info *mtd, int wp)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct brcmnand_host *host = chip->priv;
        struct brcmnand_controller *ctrl = host->ctrl;
 
 
 static int brcmnand_waitfunc(struct mtd_info *mtd, struct nand_chip *this)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct brcmnand_host *host = chip->priv;
        struct brcmnand_controller *ctrl = host->ctrl;
        unsigned long timeo = msecs_to_jiffies(100);
 static void brcmnand_cmdfunc(struct mtd_info *mtd, unsigned command,
                             int column, int page_addr)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct brcmnand_host *host = chip->priv;
        struct brcmnand_controller *ctrl = host->ctrl;
        u64 addr = (u64)page_addr << chip->page_shift;
 
 static uint8_t brcmnand_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct brcmnand_host *host = chip->priv;
        struct brcmnand_controller *ctrl = host->ctrl;
        uint8_t ret = 0;
                                   int len)
 {
        int i;
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct brcmnand_host *host = chip->priv;
 
        switch (host->last_cmd) {
 
        list_for_each_entry(host, &ctrl->host_list, node) {
                struct mtd_info *mtd = &host->mtd;
-               struct nand_chip *chip = mtd->priv;
+               struct nand_chip *chip = mtd_to_nand(mtd);
 
                brcmnand_save_restore_cs_config(host, 1);
 
 
 
 static int cafe_device_ready(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct cafe_priv *cafe = chip->priv;
        int result = !!(cafe_readl(cafe, NAND_STATUS) & 0x40000000);
        uint32_t irqs = cafe_readl(cafe, NAND_IRQ);
 
 static void cafe_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct cafe_priv *cafe = chip->priv;
 
        if (usedma)
 
 static void cafe_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct cafe_priv *cafe = chip->priv;
 
        if (usedma)
 
 static uint8_t cafe_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct cafe_priv *cafe = chip->priv;
        uint8_t d;
 
 static void cafe_nand_cmdfunc(struct mtd_info *mtd, unsigned command,
                              int column, int page_addr)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct cafe_priv *cafe = chip->priv;
        int adrbytes = 0;
        uint32_t ctl1;
 
 static void cafe_select_chip(struct mtd_info *mtd, int chipnr)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct cafe_priv *cafe = chip->priv;
 
        cafe_dev_dbg(&cafe->pdev->dev, "select_chip %d\n", chipnr);
 static irqreturn_t cafe_nand_interrupt(int irq, void *id)
 {
        struct mtd_info *mtd = id;
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct cafe_priv *cafe = chip->priv;
        uint32_t irqs = cafe_readl(cafe, NAND_IRQ);
        cafe_writel(cafe, irqs & ~0x90000000, NAND_IRQ);
 static void cafe_nand_remove(struct pci_dev *pdev)
 {
        struct mtd_info *mtd = pci_get_drvdata(pdev);
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct cafe_priv *cafe = chip->priv;
 
        /* Disable NAND IRQ in global IRQ mask register */
 {
        uint32_t ctrl;
        struct mtd_info *mtd = pci_get_drvdata(pdev);
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct cafe_priv *cafe = chip->priv;
 
        /* Start off by resetting the NAND controller completely */
 
 
 static u_char cmx270_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
 
        return (readl(this->IO_ADDR_R) >> 16);
 }
 static void cmx270_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
 {
        int i;
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
 
        for (i=0; i<len; i++)
                writel((*buf++ << 16), this->IO_ADDR_W);
 static void cmx270_read_buf(struct mtd_info *mtd, u_char *buf, int len)
 {
        int i;
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
 
        for (i=0; i<len; i++)
                *buf++ = readl(this->IO_ADDR_R) >> 16;
 static void cmx270_hwcontrol(struct mtd_info *mtd, int dat,
                             unsigned int ctrl)
 {
-       struct nand_chip* this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        unsigned int nandaddr = (unsigned int)this->IO_ADDR_W;
 
        dsb();
 
 
 static void cs553x_read_buf(struct mtd_info *mtd, u_char *buf, int len)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
 
        while (unlikely(len > 0x800)) {
                memcpy_fromio(buf, this->IO_ADDR_R, 0x800);
 
 static void cs553x_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
 
        while (unlikely(len > 0x800)) {
                memcpy_toio(this->IO_ADDR_R, buf, 0x800);
 
 static unsigned char cs553x_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        return readb(this->IO_ADDR_R);
 }
 
 static void cs553x_write_byte(struct mtd_info *mtd, u_char byte)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        int i = 100000;
 
        while (i && readb(this->IO_ADDR_R + MM_NAND_STS) & CS_NAND_CTLR_BUSY) {
 static void cs553x_hwcontrol(struct mtd_info *mtd, int cmd,
                             unsigned int ctrl)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        void __iomem *mmio_base = this->IO_ADDR_R;
        if (ctrl & NAND_CTRL_CHANGE) {
                unsigned char ctl = (ctrl & ~NAND_CTRL_CHANGE ) ^ 0x01;
 
 static int cs553x_device_ready(struct mtd_info *mtd)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        void __iomem *mmio_base = this->IO_ADDR_R;
        unsigned char foo = readb(mmio_base + MM_NAND_STS);
 
 
 static void cs_enable_hwecc(struct mtd_info *mtd, int mode)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        void __iomem *mmio_base = this->IO_ADDR_R;
 
        writeb(0x07, mmio_base + MM_NAND_ECC_CTL);
 static int cs_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code)
 {
        uint32_t ecc;
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        void __iomem *mmio_base = this->IO_ADDR_R;
 
        ecc = readl(mmio_base + MM_NAND_STS);
                if (!mtd)
                        continue;
 
-               this = cs553x_mtd[i]->priv;
+               this = mtd_to_nand(cs553x_mtd[i]);
                mmio_base = this->IO_ADDR_R;
 
                /* Release resources, unregister device */
 
 {
        struct davinci_nand_info        *info = to_davinci_nand(mtd);
        uint32_t                        addr = info->current_cs;
-       struct nand_chip                *nand = mtd->priv;
+       struct nand_chip                *nand = mtd_to_nand(mtd);
 
        /* Did the control lines change? */
        if (ctrl & NAND_CTRL_CHANGE) {
 static int nand_davinci_correct_1bit(struct mtd_info *mtd, u_char *dat,
                                     u_char *read_ecc, u_char *calc_ecc)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        uint32_t eccNand = read_ecc[0] | (read_ecc[1] << 8) |
                                          (read_ecc[2] << 16);
        uint32_t eccCalc = calc_ecc[0] | (calc_ecc[1] << 8) |
  */
 static void nand_davinci_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
 
        if ((0x03 & ((unsigned)buf)) == 0 && (0x03 & len) == 0)
                ioread32_rep(chip->IO_ADDR_R, buf, len >> 2);
 static void nand_davinci_write_buf(struct mtd_info *mtd,
                const uint8_t *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
 
        if ((0x03 & ((unsigned)buf)) == 0 && (0x03 & len) == 0)
                iowrite32_rep(chip->IO_ADDR_R, buf, len >> 2);
 
 
 static void doc2000_write_byte(struct mtd_info *mtd, u_char datum)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
 
 
 static u_char doc2000_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
        u_char ret;
 
 static void doc2000_writebuf(struct mtd_info *mtd, const u_char *buf, int len)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
        int i;
 
 static void doc2000_readbuf(struct mtd_info *mtd, u_char *buf, int len)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
        int i;
 
 static void doc2000_readbuf_dword(struct mtd_info *mtd, u_char *buf, int len)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
        int i;
 
 static uint16_t __init doc200x_ident_chip(struct mtd_info *mtd, int nr)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        uint16_t ret;
 
 
 static void __init doc2000_count_chips(struct mtd_info *mtd)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        uint16_t mfrid;
        int i;
 
 static void doc2001_write_byte(struct mtd_info *mtd, u_char datum)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
 
 
 static u_char doc2001_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
 
 
 static void doc2001_writebuf(struct mtd_info *mtd, const u_char *buf, int len)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
        int i;
 
 static void doc2001_readbuf(struct mtd_info *mtd, u_char *buf, int len)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
        int i;
 
 static u_char doc2001plus_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
        u_char ret;
 
 static void doc2001plus_writebuf(struct mtd_info *mtd, const u_char *buf, int len)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
        int i;
 
 static void doc2001plus_readbuf(struct mtd_info *mtd, u_char *buf, int len)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
        int i;
 
 static void doc2001plus_select_chip(struct mtd_info *mtd, int chip)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
        int floor = 0;
 
 static void doc200x_select_chip(struct mtd_info *mtd, int chip)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
        int floor = 0;
 static void doc200x_hwcontrol(struct mtd_info *mtd, int cmd,
                              unsigned int ctrl)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
 
 
 static void doc2001plus_command(struct mtd_info *mtd, unsigned command, int column, int page_addr)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
 
 
 static int doc200x_dev_ready(struct mtd_info *mtd)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
 
 
 static void doc200x_enable_hwecc(struct mtd_info *mtd, int mode)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
 
 
 static void doc2001plus_enable_hwecc(struct mtd_info *mtd, int mode)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
 
 /* This code is only called on write */
 static int doc200x_calculate_ecc(struct mtd_info *mtd, const u_char *dat, unsigned char *ecc_code)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
        int i;
                                u_char *read_ecc, u_char *isnull)
 {
        int i, ret = 0;
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        void __iomem *docptr = doc->virtadr;
        uint8_t calc_ecc[6];
    mh1_page in the DOC private structure. */
 static int __init find_media_headers(struct mtd_info *mtd, u_char *buf, const char *id, int findmirror)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        unsigned offs;
        int ret;
 
 static inline int __init nftl_partscan(struct mtd_info *mtd, struct mtd_partition *parts)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        int ret = 0;
        u_char *buf;
 /* This is a stripped-down copy of the code in inftlmount.c */
 static inline int __init inftl_partscan(struct mtd_info *mtd, struct mtd_partition *parts)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        int ret = 0;
        u_char *buf;
 static int __init nftl_scan_bbt(struct mtd_info *mtd)
 {
        int ret, numparts;
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        struct mtd_partition parts[2];
 
 static int __init inftl_scan_bbt(struct mtd_info *mtd)
 {
        int ret, numparts;
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
        struct mtd_partition parts[5];
 
 
 static inline int __init doc2000_init(struct mtd_info *mtd)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
 
        this->read_byte = doc2000_read_byte;
 
 static inline int __init doc2001_init(struct mtd_info *mtd)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
 
        this->read_byte = doc2001_read_byte;
 
 static inline int __init doc2001plus_init(struct mtd_info *mtd)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct doc_priv *doc = this->priv;
 
        this->read_byte = doc2001plus_read_byte;
        for (mtd = doclist; mtd; mtd = doc->nextdoc) {
                unsigned char oldval;
                unsigned char newval;
-               nand = mtd->priv;
+               nand = mtd_to_nand(mtd);
                doc = nand->priv;
                /* Use the alias resolution register to determine if this is
                   in fact the same DOC aliased to a new address.  If writes
        struct doc_priv *doc;
 
        for (mtd = doclist; mtd; mtd = nextmtd) {
-               nand = mtd->priv;
+               nand = mtd_to_nand(mtd);
                doc = nand->priv;
 
                nextmtd = doc->nextdoc;
 
 static void docg4_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 {
        int i;
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        uint16_t *p = (uint16_t *) buf;
        len >>= 1;
 
 static void docg4_write_buf16(struct mtd_info *mtd, const uint8_t *buf, int len)
 {
        int i;
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        uint16_t *p = (uint16_t *) buf;
        len >>= 1;
 
         * Select among multiple cascaded chips ("floors").  Multiple floors are
         * not yet supported, so the only valid non-negative value is 0.
         */
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct docg4_priv *doc = nand->priv;
        void __iomem *docptr = doc->virtadr;
 
 {
        /* full device reset */
 
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct docg4_priv *doc = nand->priv;
        void __iomem *docptr = doc->virtadr;
 
         * Up to four bitflips can be corrected.
         */
 
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct docg4_priv *doc = nand->priv;
        void __iomem *docptr = doc->virtadr;
        int i, numerrs, errpos[4];
 
 static uint8_t docg4_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct docg4_priv *doc = nand->priv;
 
        dev_dbg(doc->dev, "%s\n", __func__);
         * internal buffer out to the flash array, or some such.
         */
 
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct docg4_priv *doc = nand->priv;
        void __iomem *docptr = doc->virtadr;
        int retval = 0;
 {
        /* common starting sequence for all operations */
 
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct docg4_priv *doc = nand->priv;
        void __iomem *docptr = doc->virtadr;
 
 {
        /* first step in reading a page */
 
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct docg4_priv *doc = nand->priv;
        void __iomem *docptr = doc->virtadr;
 
 {
        /* first step in writing a page */
 
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct docg4_priv *doc = nand->priv;
        void __iomem *docptr = doc->virtadr;
 
 {
        /* handle standard nand commands */
 
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct docg4_priv *doc = nand->priv;
        uint32_t g4_addr = mtd_to_docg4_address(page_addr, column);
 
 
 static int docg4_erase_block(struct mtd_info *mtd, int page)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct docg4_priv *doc = nand->priv;
        void __iomem *docptr = doc->virtadr;
        uint16_t g4_page;
         * update the memory-based bbt accordingly.
         */
 
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct docg4_priv *doc = nand->priv;
        uint32_t g4_addr = mtd_to_docg4_address(DOCG4_FACTORY_BBT_PAGE, 0);
        uint8_t *buf;
 
        int ret, i;
        uint8_t *buf;
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct docg4_priv *doc = nand->priv;
        struct nand_bbt_descr *bbtd = nand->badblock_pattern;
        int page = (int)(ofs >> nand->page_shift);
         * things as well, such as call nand_set_defaults().
         */
 
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct docg4_priv *doc = nand->priv;
 
        mtd->size = DOCG4_CHIP_SIZE;
 
 static int __init read_id_reg(struct mtd_info *mtd)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct docg4_priv *doc = nand->priv;
        void __iomem *docptr = doc->virtadr;
        uint16_t id1, id2;
        iounmap(virtadr);
        if (mtd) {
                /* re-declarations avoid compiler warning */
-               struct nand_chip *nand = mtd->priv;
+               struct nand_chip *nand = mtd_to_nand(mtd);
                struct docg4_priv *doc = nand->priv;
                nand_release(mtd); /* deletes partitions and mtd devices */
                free_bch(doc->bch);
 
  */
 static void set_addr(struct mtd_info *mtd, int column, int page_addr, int oob)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_elbc_mtd *priv = chip->priv;
        struct fsl_lbc_ctrl *ctrl = priv->ctrl;
        struct fsl_lbc_regs __iomem *lbc = ctrl->regs;
  */
 static int fsl_elbc_run_command(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_elbc_mtd *priv = chip->priv;
        struct fsl_lbc_ctrl *ctrl = priv->ctrl;
        struct fsl_elbc_fcm_ctrl *elbc_fcm_ctrl = ctrl->nand;
 static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
                              int column, int page_addr)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_elbc_mtd *priv = chip->priv;
        struct fsl_lbc_ctrl *ctrl = priv->ctrl;
        struct fsl_elbc_fcm_ctrl *elbc_fcm_ctrl = ctrl->nand;
  */
 static void fsl_elbc_write_buf(struct mtd_info *mtd, const u8 *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_elbc_mtd *priv = chip->priv;
        struct fsl_elbc_fcm_ctrl *elbc_fcm_ctrl = priv->ctrl->nand;
        unsigned int bufsize = mtd->writesize + mtd->oobsize;
  */
 static u8 fsl_elbc_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_elbc_mtd *priv = chip->priv;
        struct fsl_elbc_fcm_ctrl *elbc_fcm_ctrl = priv->ctrl->nand;
 
  */
 static void fsl_elbc_read_buf(struct mtd_info *mtd, u8 *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_elbc_mtd *priv = chip->priv;
        struct fsl_elbc_fcm_ctrl *elbc_fcm_ctrl = priv->ctrl->nand;
        int avail;
 
 static int fsl_elbc_chip_init_tail(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_elbc_mtd *priv = chip->priv;
        struct fsl_lbc_ctrl *ctrl = priv->ctrl;
        struct fsl_lbc_regs __iomem *lbc = ctrl->regs;
 
  */
 static void set_addr(struct mtd_info *mtd, int column, int page_addr, int oob)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_ifc_mtd *priv = chip->priv;
        struct fsl_ifc_ctrl *ctrl = priv->ctrl;
        struct fsl_ifc_regs __iomem *ifc = ctrl->regs;
 
 static int is_blank(struct mtd_info *mtd, unsigned int bufnum)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_ifc_mtd *priv = chip->priv;
        u8 __iomem *addr = priv->vbase + bufnum * (mtd->writesize * 2);
        u32 __iomem *mainarea = (u32 __iomem *)addr;
  */
 static void fsl_ifc_run_command(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_ifc_mtd *priv = chip->priv;
        struct fsl_ifc_ctrl *ctrl = priv->ctrl;
        struct fsl_ifc_nand_ctrl *nctrl = ifc_nand_ctrl;
 /* cmdfunc send commands to the IFC NAND Machine */
 static void fsl_ifc_cmdfunc(struct mtd_info *mtd, unsigned int command,
                             int column, int page_addr) {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_ifc_mtd *priv = chip->priv;
        struct fsl_ifc_ctrl *ctrl = priv->ctrl;
        struct fsl_ifc_regs __iomem *ifc = ctrl->regs;
  */
 static void fsl_ifc_write_buf(struct mtd_info *mtd, const u8 *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_ifc_mtd *priv = chip->priv;
        unsigned int bufsize = mtd->writesize + mtd->oobsize;
 
  */
 static uint8_t fsl_ifc_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_ifc_mtd *priv = chip->priv;
        unsigned int offset;
 
  */
 static uint8_t fsl_ifc_read_byte16(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_ifc_mtd *priv = chip->priv;
        uint16_t data;
 
  */
 static void fsl_ifc_read_buf(struct mtd_info *mtd, u8 *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_ifc_mtd *priv = chip->priv;
        int avail;
 
 
 static int fsl_ifc_chip_init_tail(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_ifc_mtd *priv = chip->priv;
 
        dev_dbg(priv->dev, "%s: nand->numchips = %d\n", __func__,
 
 
 static void fun_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_upm_nand *fun = to_fsl_upm_nand(mtd);
        u32 mar;
 
 
 static void fun_select_chip(struct mtd_info *mtd, int mchip_nr)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsl_upm_nand *fun = to_fsl_upm_nand(mtd);
 
        if (mchip_nr == -1) {
 
 /* Assert CS signal based on chipnr */
 static void fsmc_select_chip(struct mtd_info *mtd, int chipnr)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct fsmc_nand_data *host;
 
        host = container_of(mtd, struct fsmc_nand_data, mtd);
  */
 static void fsmc_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct fsmc_nand_data *host = container_of(mtd,
                                        struct fsmc_nand_data, mtd);
        void __iomem *regs = host->regs_va;
 static void fsmc_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 {
        int i;
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
 
        if (IS_ALIGNED((uint32_t)buf, sizeof(uint32_t)) &&
                        IS_ALIGNED(len, sizeof(uint32_t))) {
 static void fsmc_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 {
        int i;
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
 
        if (IS_ALIGNED((uint32_t)buf, sizeof(uint32_t)) &&
                        IS_ALIGNED(len, sizeof(uint32_t))) {
 {
        struct fsmc_nand_data *host = container_of(mtd,
                                        struct fsmc_nand_data, mtd);
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        void __iomem *regs = host->regs_va;
        unsigned int bank = host->bank;
        uint32_t err_idx[8];
 
 {
        struct bch_geometry *geo = &this->bch_geometry;
        struct mtd_info *mtd = &this->mtd;
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct nand_oobfree *of = gpmi_hw_ecclayout.oobfree;
        unsigned int block_mark_bit_offset;
 
 
 static void gpmi_cmd_ctrl(struct mtd_info *mtd, int data, unsigned int ctrl)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct gpmi_nand_data *this = chip->priv;
        int ret;
 
 
 static int gpmi_dev_ready(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct gpmi_nand_data *this = chip->priv;
 
        return gpmi_is_ready(this, this->current_chip);
 
 static void gpmi_select_chip(struct mtd_info *mtd, int chipnr)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct gpmi_nand_data *this = chip->priv;
 
        if ((this->current_chip < 0) && (chipnr >= 0))
 
 static void gpmi_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct gpmi_nand_data *this = chip->priv;
 
        dev_dbg(this->dev, "len is %d\n", len);
 
 static void gpmi_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct gpmi_nand_data *this = chip->priv;
 
        dev_dbg(this->dev, "len is %d\n", len);
 
 static uint8_t gpmi_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct gpmi_nand_data *this = chip->priv;
        uint8_t *buf = this->data_buffer_dma;
 
 
 static int gpmi_block_markbad(struct mtd_info *mtd, loff_t ofs)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct gpmi_nand_data *this = chip->priv;
        int ret = 0;
        uint8_t *block_mark;
 static int gpmi_init_last(struct gpmi_nand_data *this)
 {
        struct mtd_info *mtd = &this->mtd;
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct nand_ecc_ctrl *ecc = &chip->ecc;
        struct bch_geometry *bch_geo = &this->bch_geometry;
        int ret;
 
 static void hisi_nfc_dma_transfer(struct hinfc_host *host, int todev)
 {
        struct mtd_info *mtd = &host->mtd;
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        unsigned long val;
        int ret;
 
 
 static void hisi_nfc_select_chip(struct mtd_info *mtd, int chipselect)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct hinfc_host *host = chip->priv;
 
        if (chipselect < 0)
 
 static uint8_t hisi_nfc_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct hinfc_host *host = chip->priv;
 
        if (host->command == NAND_CMD_STATUS)
 
 static u16 hisi_nfc_read_word(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct hinfc_host *host = chip->priv;
 
        host->offset += 2;
 static void
 hisi_nfc_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct hinfc_host *host = chip->priv;
 
        memcpy(host->buffer + host->offset, buf, len);
 
 static void hisi_nfc_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct hinfc_host *host = chip->priv;
 
        memcpy(buf, host->buffer + host->offset, len);
 
 static void set_addr(struct mtd_info *mtd, int column, int page_addr)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct hinfc_host *host = chip->priv;
        unsigned int command = host->command;
 
 static void hisi_nfc_cmdfunc(struct mtd_info *mtd, unsigned command, int column,
                int page_addr)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct hinfc_host *host = chip->priv;
        int is_cache_invalid = 1;
        unsigned int flag = 0;
 
 static void jz_nand_select_chip(struct mtd_info *mtd, int chipnr)
 {
        struct jz_nand *nand = mtd_to_jz_nand(mtd);
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        uint32_t ctrl;
        int banknr;
 
 static void jz_nand_cmd_ctrl(struct mtd_info *mtd, int dat, unsigned int ctrl)
 {
        struct jz_nand *nand = mtd_to_jz_nand(mtd);
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        uint32_t reg;
        void __iomem *bank_base = nand->bank_base[nand->selected_bank];
 
 
 static void lpc32xx_nand_cmd_ctrl(struct mtd_info *mtd, int cmd,
                                  unsigned int ctrl)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct lpc32xx_nand_host *host = nand_chip->priv;
 
        if (cmd != NAND_CMD_NONE) {
  */
 static int lpc32xx_nand_device_ready(struct mtd_info *mtd)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct lpc32xx_nand_host *host = nand_chip->priv;
 
        if ((readb(MLC_ISR(host->io_base)) &
 static int lpc32xx_xmit_dma(struct mtd_info *mtd, void *mem, int len,
                            enum dma_transfer_direction dir)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct lpc32xx_nand_host *host = chip->priv;
        struct dma_async_tx_descriptor *desc;
        int flags = DMA_CTRL_ACK | DMA_PREP_INTERRUPT;
 
        unsigned int ctrl)
 {
        uint32_t tmp;
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct lpc32xx_nand_host *host = chip->priv;
 
        /* Does CE state need to be changed? */
  */
 static int lpc32xx_nand_device_ready(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct lpc32xx_nand_host *host = chip->priv;
        int rdy = 0;
 
  */
 static uint8_t lpc32xx_nand_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct lpc32xx_nand_host *host = chip->priv;
 
        return (uint8_t)readl(SLC_DATA(host->io_base));
  */
 static void lpc32xx_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct lpc32xx_nand_host *host = chip->priv;
 
        /* Direct device read with no ECC */
  */
 static void lpc32xx_nand_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct lpc32xx_nand_host *host = chip->priv;
 
        /* Direct device write with no ECC */
 static int lpc32xx_xmit_dma(struct mtd_info *mtd, dma_addr_t dma,
                            void *mem, int len, enum dma_transfer_direction dir)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct lpc32xx_nand_host *host = chip->priv;
        struct dma_async_tx_descriptor *desc;
        int flags = DMA_CTRL_ACK | DMA_PREP_INTERRUPT;
 static int lpc32xx_xfer(struct mtd_info *mtd, uint8_t *buf, int eccsubpages,
                        int read)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct lpc32xx_nand_host *host = chip->priv;
        int i, status = 0;
        unsigned long timeout;
 
 /* Read NFC register */
 static inline u16 nfc_read(struct mtd_info *mtd, uint reg)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct mpc5121_nfc_prv *prv = chip->priv;
 
        return in_be16(prv->regs + reg);
 /* Write NFC register */
 static inline void nfc_write(struct mtd_info *mtd, uint reg, u16 val)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct mpc5121_nfc_prv *prv = chip->priv;
 
        out_be16(prv->regs + reg, val);
 static irqreturn_t mpc5121_nfc_irq(int irq, void *data)
 {
        struct mtd_info *mtd = data;
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct mpc5121_nfc_prv *prv = chip->priv;
 
        nfc_set(mtd, NFC_CONFIG1, NFC_INT_MASK);
 /* Wait for operation complete */
 static void mpc5121_nfc_done(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct mpc5121_nfc_prv *prv = chip->priv;
        int rv;
 
 /* Do address cycle(s) */
 static void mpc5121_nfc_addr_cycle(struct mtd_info *mtd, int column, int page)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        u32 pagemask = chip->pagemask;
 
        if (column != -1) {
 /* Init external chip select logic on ADS5121 board */
 static int ads5121_chipselect_init(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct mpc5121_nfc_prv *prv = chip->priv;
        struct device_node *dn;
 
 /* Control chips select signal on ADS5121 board */
 static void ads5121_select_chip(struct mtd_info *mtd, int chip)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct mpc5121_nfc_prv *prv = nand->priv;
        u8 v;
 
 static void mpc5121_nfc_command(struct mtd_info *mtd, unsigned command,
                                                        int column, int page)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct mpc5121_nfc_prv *prv = chip->priv;
 
        prv->column = (column >= 0) ? column : 0;
 static void mpc5121_nfc_copy_spare(struct mtd_info *mtd, uint offset,
                                                u8 *buffer, uint size, int wr)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct mpc5121_nfc_prv *prv = nand->priv;
        uint o, s, sbsize, blksize;
 
 static void mpc5121_nfc_buf_copy(struct mtd_info *mtd, u_char *buf, int len,
                                                                        int wr)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct mpc5121_nfc_prv *prv = chip->priv;
        uint c = prv->column;
        uint l;
  */
 static int mpc5121_nfc_read_hw_config(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct mpc5121_nfc_prv *prv = chip->priv;
        struct mpc512x_reset_module *rm;
        struct device_node *rmnode;
 /* Free driver resources */
 static void mpc5121_nfc_free(struct device *dev, struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct mpc5121_nfc_prv *prv = chip->priv;
 
        if (prv->clk)
 
 
 static void send_page_v3(struct mtd_info *mtd, unsigned int ops)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct mxc_nand_host *host = nand_chip->priv;
        uint32_t tmp;
 
 
 static void send_page_v2(struct mtd_info *mtd, unsigned int ops)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct mxc_nand_host *host = nand_chip->priv;
 
        /* NANDFC buffer 0 is used for page read/write */
 
 static void send_page_v1(struct mtd_info *mtd, unsigned int ops)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct mxc_nand_host *host = nand_chip->priv;
        int bufs, i;
 
 static int mxc_nand_correct_data_v1(struct mtd_info *mtd, u_char *dat,
                                 u_char *read_ecc, u_char *calc_ecc)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct mxc_nand_host *host = nand_chip->priv;
 
        /*
 static int mxc_nand_correct_data_v2_v3(struct mtd_info *mtd, u_char *dat,
                                 u_char *read_ecc, u_char *calc_ecc)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct mxc_nand_host *host = nand_chip->priv;
        u32 ecc_stat, err;
        int no_subpages = 1;
 
 static u_char mxc_nand_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct mxc_nand_host *host = nand_chip->priv;
        uint8_t ret;
 
 
 static uint16_t mxc_nand_read_word(struct mtd_info *mtd)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct mxc_nand_host *host = nand_chip->priv;
        uint16_t ret;
 
 static void mxc_nand_write_buf(struct mtd_info *mtd,
                                const u_char *buf, int len)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct mxc_nand_host *host = nand_chip->priv;
        u16 col = host->buf_start;
        int n = mtd->oobsize + mtd->writesize - col;
  */
 static void mxc_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct mxc_nand_host *host = nand_chip->priv;
        u16 col = host->buf_start;
        int n = mtd->oobsize + mtd->writesize - col;
  * deselect of the NAND chip */
 static void mxc_nand_select_chip_v1_v3(struct mtd_info *mtd, int chip)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct mxc_nand_host *host = nand_chip->priv;
 
        if (chip == -1) {
 
 static void mxc_nand_select_chip_v2(struct mtd_info *mtd, int chip)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct mxc_nand_host *host = nand_chip->priv;
 
        if (chip == -1) {
  */
 static void copy_spare(struct mtd_info *mtd, bool bfrom)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct mxc_nand_host *host = this->priv;
        u16 i, oob_chunk_size;
        u16 num_chunks = mtd->writesize / 512;
  */
 static void mxc_do_addr_cycle(struct mtd_info *mtd, int column, int page_addr)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct mxc_nand_host *host = nand_chip->priv;
 
        /* Write out column address, if necessary */
 
 static void preset_v1(struct mtd_info *mtd)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct mxc_nand_host *host = nand_chip->priv;
        uint16_t config1 = 0;
 
 
 static void preset_v2(struct mtd_info *mtd)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct mxc_nand_host *host = nand_chip->priv;
        uint16_t config1 = 0;
 
 
 static void preset_v3(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct mxc_nand_host *host = chip->priv;
        uint32_t config2, config3;
        int i, addr_phases;
 static void mxc_nand_command(struct mtd_info *mtd, unsigned command,
                                int column, int page_addr)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct mxc_nand_host *host = nand_chip->priv;
 
        pr_debug("mxc_nand_command (cmd = 0x%x, col = 0x%x, page = 0x%x)\n",
 
 static void ndfc_select_chip(struct mtd_info *mtd, int chip)
 {
        uint32_t ccr;
-       struct nand_chip *nchip = mtd->priv;
+       struct nand_chip *nchip = mtd_to_nand(mtd);
        struct ndfc_controller *ndfc = nchip->priv;
 
        ccr = in_be32(ndfc->ndfcbase + NDFC_CCR);
 
 static void ndfc_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int ctrl)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct ndfc_controller *ndfc = chip->priv;
 
        if (cmd == NAND_CMD_NONE)
 
 static int ndfc_ready(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct ndfc_controller *ndfc = chip->priv;
 
        return in_be32(ndfc->ndfcbase + NDFC_STAT) & NDFC_STAT_IS_READY;
 static void ndfc_enable_hwecc(struct mtd_info *mtd, int mode)
 {
        uint32_t ccr;
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct ndfc_controller *ndfc = chip->priv;
 
        ccr = in_be32(ndfc->ndfcbase + NDFC_CCR);
 static int ndfc_calculate_ecc(struct mtd_info *mtd,
                              const u_char *dat, u_char *ecc_code)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct ndfc_controller *ndfc = chip->priv;
        uint32_t ecc;
        uint8_t *p = (uint8_t *)&ecc;
  */
 static void ndfc_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct ndfc_controller *ndfc = chip->priv;
        uint32_t *p = (uint32_t *) buf;
 
 
 static void ndfc_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct ndfc_controller *ndfc = chip->priv;
        uint32_t *p = (uint32_t *) buf;
 
 
 static void nuc900_nand_command_lp(struct mtd_info *mtd, unsigned int command,
                                   int column, int page_addr)
 {
-       register struct nand_chip *chip = mtd->priv;
+       register struct nand_chip *chip = mtd_to_nand(mtd);
        struct nuc900_nand *nand;
 
        nand = container_of(mtd, struct nuc900_nand, mtd);
 
  */
 static void omap_read_buf8(struct mtd_info *mtd, u_char *buf, int len)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
 
        ioread8_rep(nand->IO_ADDR_R, buf, len);
 }
  */
 static void omap_read_buf16(struct mtd_info *mtd, u_char *buf, int len)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
 
        ioread16_rep(nand->IO_ADDR_R, buf, len / 2);
 }
 {
        struct omap_nand_info *info = container_of(mtd, struct omap_nand_info,
                                                        mtd);
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        unsigned int dev_width = (chip->options & NAND_BUSWIDTH_16) ? 1 : 0;
        u32 val;
 
  */
 static int omap_wait(struct mtd_info *mtd, struct nand_chip *chip)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct omap_nand_info *info = container_of(mtd, struct omap_nand_info,
                                                        mtd);
        unsigned long timeo = jiffies;
        struct omap_nand_info *info = container_of(mtd, struct omap_nand_info,
                                                   mtd);
        enum omap_ecc ecc_opt = info->ecc_opt;
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        u32 val, wr_mode;
        unsigned int ecc_size1, ecc_size0;
 
 static int omap_nand_remove(struct platform_device *pdev)
 {
        struct mtd_info *mtd = platform_get_drvdata(pdev);
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct omap_nand_info *info = container_of(mtd, struct omap_nand_info,
                                                        mtd);
        if (nand_chip->ecc.priv) {
 
 
 static void orion_nand_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
 {
-       struct nand_chip *nc = mtd->priv;
+       struct nand_chip *nc = mtd_to_nand(mtd);
        struct orion_nand_data *board = nc->priv;
        u32 offs;
 
 
 static void orion_nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        void __iomem *io_base = chip->IO_ADDR_R;
        uint64_t *buf64;
        int i = 0;
 
 
 static void pasemi_read_buf(struct mtd_info *mtd, u_char *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
 
        while (len > 0x800) {
                memcpy_fromio(buf, chip->IO_ADDR_R, 0x800);
 
 static void pasemi_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
 
        while (len > 0x800) {
                memcpy_toio(chip->IO_ADDR_R, buf, 0x800);
 static void pasemi_hwcontrol(struct mtd_info *mtd, int cmd,
                             unsigned int ctrl)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
 
        if (cmd == NAND_CMD_NONE)
                return;
        if (!pasemi_nand_mtd)
                return 0;
 
-       chip = pasemi_nand_mtd->priv;
+       chip = mtd_to_nand(pasemi_nand_mtd);
 
        /* Release resources, unregister device */
        nand_release(pasemi_nand_mtd);
 
 static void nand_cmdfunc(struct mtd_info *mtd, unsigned command,
                         int column, int page_addr)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct pxa3xx_nand_host *host = chip->priv;
        struct pxa3xx_nand_info *info = host->info_data;
        int exec_cmd;
                                  const unsigned command,
                                  int column, int page_addr)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct pxa3xx_nand_host *host = chip->priv;
        struct pxa3xx_nand_info *info = host->info_data;
        int exec_cmd, ext_cmd_type;
 
 static uint8_t pxa3xx_nand_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct pxa3xx_nand_host *host = chip->priv;
        struct pxa3xx_nand_info *info = host->info_data;
        char retval = 0xFF;
 
 static u16 pxa3xx_nand_read_word(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct pxa3xx_nand_host *host = chip->priv;
        struct pxa3xx_nand_info *info = host->info_data;
        u16 retval = 0xFFFF;
 
 static void pxa3xx_nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct pxa3xx_nand_host *host = chip->priv;
        struct pxa3xx_nand_info *info = host->info_data;
        int real_len = min_t(size_t, len, info->buf_count - info->buf_start);
 static void pxa3xx_nand_write_buf(struct mtd_info *mtd,
                const uint8_t *buf, int len)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct pxa3xx_nand_host *host = chip->priv;
        struct pxa3xx_nand_info *info = host->info_data;
        int real_len = min_t(size_t, len, info->buf_count - info->buf_start);
 
 static int pxa3xx_nand_waitfunc(struct mtd_info *mtd, struct nand_chip *this)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct pxa3xx_nand_host *host = chip->priv;
        struct pxa3xx_nand_info *info = host->info_data;
 
 {
        struct pxa3xx_nand_host *host = info->host[info->cs];
        struct mtd_info *mtd = host->mtd;
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
 
        info->reg_ndcr |= (host->col_addr_cycles == 2) ? NDCR_RA_START : 0;
        info->reg_ndcr |= (chip->page_shift == 6) ? NDCR_PG_PER_BLK : 0;
 
 static int pxa3xx_nand_scan(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct pxa3xx_nand_host *host = chip->priv;
        struct pxa3xx_nand_info *info = host->info_data;
        struct platform_device *pdev = info->pdev;
 
 /* returns pointer to our private structure */
 static inline struct r852_device *r852_get_dev(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        return chip->priv;
 }
 
 
 {
        struct s3c2410_nand_info *info;
        struct s3c2410_nand_mtd *nmtd;
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        unsigned long cur;
 
        nmtd = this->priv;
 
 static void s3c2410_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        readsb(this->IO_ADDR_R, buf, len);
 }
 
 static void s3c2410_nand_write_buf(struct mtd_info *mtd, const u_char *buf,
                                   int len)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        writesb(this->IO_ADDR_W, buf, len);
 }
 
 
                                   unsigned int ctrl)
 {
        struct sharpsl_nand *sharpsl = mtd_to_sharpsl(mtd);
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
 
        if (ctrl & NAND_CTRL_CHANGE) {
                unsigned char bits = ctrl & 0x07;
 
 
 int sm_register_device(struct mtd_info *mtd, int smartmedia)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        int ret;
 
        chip->options |= NAND_SKIP_BBTSCAN;
 
                const uint8_t *buf, int len)
 {
        int i;
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct socrates_nand_host *host = this->priv;
 
        for (i = 0; i < len; i++) {
 static void socrates_nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 {
        int i;
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        struct socrates_nand_host *host = this->priv;
        uint32_t val;
 
 static void socrates_nand_cmd_ctrl(struct mtd_info *mtd, int cmd,
                unsigned int ctrl)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct socrates_nand_host *host = nand_chip->priv;
        uint32_t val;
 
  */
 static int socrates_nand_device_ready(struct mtd_info *mtd)
 {
-       struct nand_chip *nand_chip = mtd->priv;
+       struct nand_chip *nand_chip = mtd_to_nand(mtd);
        struct socrates_nand_host *host = nand_chip->priv;
 
        if (in_be32(host->io_base) & FPGA_NAND_BUSY)
 
 
 static int sunxi_nfc_dev_ready(struct mtd_info *mtd)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand);
        struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller);
        struct sunxi_nand_rb *rb;
 
 static void sunxi_nfc_select_chip(struct mtd_info *mtd, int chip)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand);
        struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller);
        struct sunxi_nand_chip_sel *sel;
 
 static void sunxi_nfc_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand);
        struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller);
        int ret;
 static void sunxi_nfc_write_buf(struct mtd_info *mtd, const uint8_t *buf,
                                int len)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand);
        struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller);
        int ret;
 static void sunxi_nfc_cmd_ctrl(struct mtd_info *mtd, int dat,
                               unsigned int ctrl)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand);
        struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller);
        int ret;
 
 static void sunxi_nfc_hw_ecc_enable(struct mtd_info *mtd)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);
        struct sunxi_nand_hw_ecc *data = nand->ecc.priv;
        u32 ecc_ctl;
 
 static void sunxi_nfc_hw_ecc_disable(struct mtd_info *mtd)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);
 
        writel(readl(nfc->regs + NFC_REG_ECC_CTL) & ~NFC_ECC_EN,
                                       int *cur_off,
                                       unsigned int *max_bitflips)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);
        struct nand_ecc_ctrl *ecc = &nand->ecc;
        u32 status;
 static void sunxi_nfc_hw_ecc_read_extra_oob(struct mtd_info *mtd,
                                            u8 *oob, int *cur_off)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct nand_ecc_ctrl *ecc = &nand->ecc;
        int offset = ((ecc->bytes + 4) * ecc->steps);
        int len = mtd->oobsize - offset;
                                        const u8 *oob, int oob_off,
                                        int *cur_off)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);
        struct nand_ecc_ctrl *ecc = &nand->ecc;
        int ret;
 static void sunxi_nfc_hw_ecc_write_extra_oob(struct mtd_info *mtd,
                                             u8 *oob, int *cur_off)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct nand_ecc_ctrl *ecc = &nand->ecc;
        int offset = ((ecc->bytes + 4) * ecc->steps);
        int len = mtd->oobsize - offset;
                                              struct device_node *np)
 {
        static const u8 strengths[] = { 16, 24, 28, 32, 40, 48, 56, 60, 64 };
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand);
        struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller);
        struct sunxi_nand_hw_ecc *data;
 static int sunxi_nand_ecc_init(struct mtd_info *mtd, struct nand_ecc_ctrl *ecc,
                               struct device_node *np)
 {
-       struct nand_chip *nand = mtd->priv;
+       struct nand_chip *nand = mtd_to_nand(mtd);
        int ret;
 
        if (!ecc->size) {
 
                                   unsigned int ctrl)
 {
        struct tmio_nand *tmio = mtd_to_tmio(mtd);
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
 
        if (ctrl & NAND_CTRL_CHANGE) {
                u8 mode;
 
 
 static struct platform_device *mtd_to_platdev(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct txx9ndfmc_priv *txx9_priv = chip->priv;
        return txx9_priv->dev;
 }
 static void txx9ndfmc_cmd_ctrl(struct mtd_info *mtd, int cmd,
                               unsigned int ctrl)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        struct txx9ndfmc_priv *txx9_priv = chip->priv;
        struct platform_device *dev = txx9_priv->dev;
        struct txx9ndfmc_platform_data *plat = dev_get_platdata(&dev->dev);
                                   uint8_t *ecc_code)
 {
        struct platform_device *dev = mtd_to_platdev(mtd);
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        int eccbytes;
        u32 mcr = txx9ndfmc_read(dev, TXX9_NDFMCR);
 
 static int txx9ndfmc_correct_data(struct mtd_info *mtd, unsigned char *buf,
                unsigned char *read_ecc, unsigned char *calc_ecc)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        int eccsize;
        int corrected = 0;
        int stat;
 
 static int txx9ndfmc_nand_scan(struct mtd_info *mtd)
 {
-       struct nand_chip *chip = mtd->priv;
+       struct nand_chip *chip = mtd_to_nand(mtd);
        int ret;
 
        ret = nand_scan_ident(mtd, 1, NULL);
 
                if (!mtd)
                        continue;
-               chip = mtd->priv;
+               chip = mtd_to_nand(mtd);
                txx9_priv = chip->priv;
 
                nand_release(mtd);
 
 
 static void xway_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        unsigned long nandaddr = (unsigned long) this->IO_ADDR_W;
        unsigned long flags;
 
 
 static unsigned char xway_read_byte(struct mtd_info *mtd)
 {
-       struct nand_chip *this = mtd->priv;
+       struct nand_chip *this = mtd_to_nand(mtd);
        unsigned long nandaddr = (unsigned long) this->IO_ADDR_R;
        unsigned long flags;
        int ret;