RE: [RFC PATCH 3/4] mtd: atmel_nand: Support 32-bit ECC strength

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--To unsubscribe from this list: send the line "unsubscribe devicetree" inthe body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.orgMore majordomo info at  http://vger.kernel.org/majordomo-info.html