| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Piotr Sroka | 12714 | 98.25% | 5 | 23.81% |
| Valentin Korenblit | 156 | 1.21% | 1 | 4.76% |
| Miquel Raynal | 32 | 0.25% | 4 | 19.05% |
| Rob Herring | 7 | 0.05% | 1 | 4.76% |
| Boris Brezillon | 7 | 0.05% | 1 | 4.76% |
| Stefan Agner | 5 | 0.04% | 1 | 4.76% |
| Kees Cook | 5 | 0.04% | 1 | 4.76% |
| Yang Yingliang | 4 | 0.03% | 1 | 4.76% |
| Vasyl Gomonovych | 4 | 0.03% | 1 | 4.76% |
| Uwe Kleine-König | 2 | 0.02% | 1 | 4.76% |
| Linus Torvalds (pre-git) | 2 | 0.02% | 1 | 4.76% |
| Linus Torvalds | 1 | 0.01% | 1 | 4.76% |
| ye xingchen | 1 | 0.01% | 1 | 4.76% |
| Yue haibing | 1 | 0.01% | 1 | 4.76% |
| Total | 12941 | 21 |
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072
// SPDX-License-Identifier: GPL-2.0+ /* * Cadence NAND flash controller driver * * Copyright (C) 2019 Cadence * * Author: Piotr Sroka <piotrs@cadence.com> */ #include <linux/bitfield.h> #include <linux/clk.h> #include <linux/dma-mapping.h> #include <linux/dmaengine.h> #include <linux/interrupt.h> #include <linux/module.h> #include <linux/mtd/mtd.h> #include <linux/mtd/rawnand.h> #include <linux/iopoll.h> #include <linux/of.h> #include <linux/platform_device.h> #include <linux/property.h> #include <linux/slab.h> /* * HPNFC can work in 3 modes: * - PIO - can work in master or slave DMA * - CDMA - needs Master DMA for accessing command descriptors. * - Generic mode - can use only slave DMA. * CDMA and PIO modes can be used to execute only base commands. * Generic mode can be used to execute any command * on NAND flash memory. Driver uses CDMA mode for * block erasing, page reading, page programing. * Generic mode is used for executing rest of commands. */ #define MAX_ADDRESS_CYC 6 #define MAX_ERASE_ADDRESS_CYC 3 #define MAX_DATA_SIZE 0xFFFC #define DMA_DATA_SIZE_ALIGN 8 /* Register definition. */ /* * Command register 0. * Writing data to this register will initiate a new transaction * of the NF controller. */ #define CMD_REG0 0x0000 /* Command type field mask. */ #define CMD_REG0_CT GENMASK(31, 30) /* Command type CDMA. */ #define CMD_REG0_CT_CDMA 0uL /* Command type generic. */ #define CMD_REG0_CT_GEN 3uL /* Command thread number field mask. */ #define CMD_REG0_TN GENMASK(27, 24) /* Command register 2. */ #define CMD_REG2 0x0008 /* Command register 3. */ #define CMD_REG3 0x000C /* Pointer register to select which thread status will be selected. */ #define CMD_STATUS_PTR 0x0010 /* Command status register for selected thread. */ #define CMD_STATUS 0x0014 /* Interrupt status register. */ #define INTR_STATUS 0x0110 #define INTR_STATUS_SDMA_ERR BIT(22) #define INTR_STATUS_SDMA_TRIGG BIT(21) #define INTR_STATUS_UNSUPP_CMD BIT(19) #define INTR_STATUS_DDMA_TERR BIT(18) #define INTR_STATUS_CDMA_TERR BIT(17) #define INTR_STATUS_CDMA_IDL BIT(16) /* Interrupt enable register. */ #define INTR_ENABLE 0x0114 #define INTR_ENABLE_INTR_EN BIT(31) #define INTR_ENABLE_SDMA_ERR_EN BIT(22) #define INTR_ENABLE_SDMA_TRIGG_EN BIT(21) #define INTR_ENABLE_UNSUPP_CMD_EN BIT(19) #define INTR_ENABLE_DDMA_TERR_EN BIT(18) #define INTR_ENABLE_CDMA_TERR_EN BIT(17) #define INTR_ENABLE_CDMA_IDLE_EN BIT(16) /* Controller internal state. */ #define CTRL_STATUS 0x0118 #define CTRL_STATUS_INIT_COMP BIT(9) #define CTRL_STATUS_CTRL_BUSY BIT(8) /* Command Engine threads state. */ #define TRD_STATUS 0x0120 /* Command Engine interrupt thread error status. */ #define TRD_ERR_INT_STATUS 0x0128 /* Command Engine interrupt thread error enable. */ #define TRD_ERR_INT_STATUS_EN 0x0130 /* Command Engine interrupt thread complete status. */ #define TRD_COMP_INT_STATUS 0x0138 /* * Transfer config 0 register. * Configures data transfer parameters. */ #define TRAN_CFG_0 0x0400 /* Offset value from the beginning of the page. */ #define TRAN_CFG_0_OFFSET GENMASK(31, 16) /* Numbers of sectors to transfer within singlNF device's page. */ #define TRAN_CFG_0_SEC_CNT GENMASK(7, 0) /* * Transfer config 1 register. * Configures data transfer parameters. */ #define TRAN_CFG_1 0x0404 /* Size of last data sector. */ #define TRAN_CFG_1_LAST_SEC_SIZE GENMASK(31, 16) /* Size of not-last data sector. */ #define TRAN_CFG_1_SECTOR_SIZE GENMASK(15, 0) /* ECC engine configuration register 0. */ #define ECC_CONFIG_0 0x0428 /* Correction strength. */ #define ECC_CONFIG_0_CORR_STR GENMASK(10, 8) /* Enable erased pages detection mechanism. */ #define ECC_CONFIG_0_ERASE_DET_EN BIT(1) /* Enable controller ECC check bits generation and correction. */ #define ECC_CONFIG_0_ECC_EN BIT(0) /* ECC engine configuration register 1. */ #define ECC_CONFIG_1 0x042C /* Multiplane settings register. */ #define MULTIPLANE_CFG 0x0434 /* Cache operation settings. */ #define CACHE_CFG 0x0438 /* DMA settings register. */ #define DMA_SETINGS 0x043C /* Enable SDMA error report on access unprepared slave DMA interface. */ #define DMA_SETINGS_SDMA_ERR_RSP BIT(17) /* Transferred data block size for the slave DMA module. */ #define SDMA_SIZE 0x0440 /* Thread number associated with transferred data block * for the slave DMA module. */ #define SDMA_TRD_NUM 0x0444 /* Thread number mask. */ #define SDMA_TRD_NUM_SDMA_TRD GENMASK(2, 0) #define CONTROL_DATA_CTRL 0x0494 /* Thread number mask. */ #define CONTROL_DATA_CTRL_SIZE GENMASK(15, 0) #define CTRL_VERSION 0x800 #define CTRL_VERSION_REV GENMASK(7, 0) /* Available hardware features of the controller. */ #define CTRL_FEATURES 0x804 /* Support for NV-DDR2/3 work mode. */ #define CTRL_FEATURES_NVDDR_2_3 BIT(28) /* Support for NV-DDR work mode. */ #define CTRL_FEATURES_NVDDR BIT(27) /* Support for asynchronous work mode. */ #define CTRL_FEATURES_ASYNC BIT(26) /* Support for asynchronous work mode. */ #define CTRL_FEATURES_N_BANKS GENMASK(25, 24) /* Slave and Master DMA data width. */ #define CTRL_FEATURES_DMA_DWITH64 BIT(21) /* Availability of Control Data feature.*/ #define CTRL_FEATURES_CONTROL_DATA BIT(10) /* BCH Engine identification register 0 - correction strengths. */ #define BCH_CFG_0 0x838 #define BCH_CFG_0_CORR_CAP_0 GENMASK(7, 0) #define BCH_CFG_0_CORR_CAP_1 GENMASK(15, 8) #define BCH_CFG_0_CORR_CAP_2 GENMASK(23, 16) #define BCH_CFG_0_CORR_CAP_3 GENMASK(31, 24) /* BCH Engine identification register 1 - correction strengths. */ #define BCH_CFG_1 0x83C #define BCH_CFG_1_CORR_CAP_4 GENMASK(7, 0) #define BCH_CFG_1_CORR_CAP_5 GENMASK(15, 8) #define BCH_CFG_1_CORR_CAP_6 GENMASK(23, 16) #define BCH_CFG_1_CORR_CAP_7 GENMASK(31, 24) /* BCH Engine identification register 2 - sector sizes. */ #define BCH_CFG_2 0x840 #define BCH_CFG_2_SECT_0 GENMASK(15, 0) #define BCH_CFG_2_SECT_1 GENMASK(31, 16) /* BCH Engine identification register 3. */ #define BCH_CFG_3 0x844 #define BCH_CFG_3_METADATA_SIZE GENMASK(23, 16) /* Ready/Busy# line status. */ #define RBN_SETINGS 0x1004 /* Common settings. */ #define COMMON_SET 0x1008 /* 16 bit device connected to the NAND Flash interface. */ #define COMMON_SET_DEVICE_16BIT BIT(8) /* Skip_bytes registers. */ #define SKIP_BYTES_CONF 0x100C #define SKIP_BYTES_MARKER_VALUE GENMASK(31, 16) #define SKIP_BYTES_NUM_OF_BYTES GENMASK(7, 0) #define SKIP_BYTES_OFFSET 0x1010 #define SKIP_BYTES_OFFSET_VALUE GENMASK(23, 0) /* Timings configuration. */ #define ASYNC_TOGGLE_TIMINGS 0x101c #define ASYNC_TOGGLE_TIMINGS_TRH GENMASK(28, 24) #define ASYNC_TOGGLE_TIMINGS_TRP GENMASK(20, 16) #define ASYNC_TOGGLE_TIMINGS_TWH GENMASK(12, 8) #define ASYNC_TOGGLE_TIMINGS_TWP GENMASK(4, 0) #define TIMINGS0 0x1024 #define TIMINGS0_TADL GENMASK(31, 24) #define TIMINGS0_TCCS GENMASK(23, 16) #define TIMINGS0_TWHR GENMASK(15, 8) #define TIMINGS0_TRHW GENMASK(7, 0) #define TIMINGS1 0x1028 #define TIMINGS1_TRHZ GENMASK(31, 24) #define TIMINGS1_TWB GENMASK(23, 16) #define TIMINGS1_TVDLY GENMASK(7, 0) #define TIMINGS2 0x102c #define TIMINGS2_TFEAT GENMASK(25, 16) #define TIMINGS2_CS_HOLD_TIME GENMASK(13, 8) #define TIMINGS2_CS_SETUP_TIME GENMASK(5, 0) /* Configuration of the resynchronization of slave DLL of PHY. */ #define DLL_PHY_CTRL 0x1034 #define DLL_PHY_CTRL_DLL_RST_N BIT(24) #define DLL_PHY_CTRL_EXTENDED_WR_MODE BIT(17) #define DLL_PHY_CTRL_EXTENDED_RD_MODE BIT(16) #define DLL_PHY_CTRL_RS_HIGH_WAIT_CNT GENMASK(11, 8) #define DLL_PHY_CTRL_RS_IDLE_CNT GENMASK(7, 0) /* Register controlling DQ related timing. */ #define PHY_DQ_TIMING 0x2000 /* Register controlling DSQ related timing. */ #define PHY_DQS_TIMING 0x2004 #define PHY_DQS_TIMING_DQS_SEL_OE_END GENMASK(3, 0) #define PHY_DQS_TIMING_PHONY_DQS_SEL BIT(16) #define PHY_DQS_TIMING_USE_PHONY_DQS BIT(20) /* Register controlling the gate and loopback control related timing. */ #define PHY_GATE_LPBK_CTRL 0x2008 #define PHY_GATE_LPBK_CTRL_RDS GENMASK(24, 19) /* Register holds the control for the master DLL logic. */ #define PHY_DLL_MASTER_CTRL 0x200C #define PHY_DLL_MASTER_CTRL_BYPASS_MODE BIT(23) /* Register holds the control for the slave DLL logic. */ #define PHY_DLL_SLAVE_CTRL 0x2010 /* This register handles the global control settings for the PHY. */ #define PHY_CTRL 0x2080 #define PHY_CTRL_SDR_DQS BIT(14) #define PHY_CTRL_PHONY_DQS GENMASK(9, 4) /* * This register handles the global control settings * for the termination selects for reads. */ #define PHY_TSEL 0x2084 /* Generic command layout. */ #define GCMD_LAY_CS GENMASK_ULL(11, 8) /* * This bit informs the minicotroller if it has to wait for tWB * after sending the last CMD/ADDR/DATA in the sequence. */ #define GCMD_LAY_TWB BIT_ULL(6) /* Type of generic instruction. */ #define GCMD_LAY_INSTR GENMASK_ULL(5, 0) /* Generic CMD sequence type. */ #define GCMD_LAY_INSTR_CMD 0 /* Generic ADDR sequence type. */ #define GCMD_LAY_INSTR_ADDR 1 /* Generic data transfer sequence type. */ #define GCMD_LAY_INSTR_DATA 2 /* Input part of generic command type of input is command. */ #define GCMD_LAY_INPUT_CMD GENMASK_ULL(23, 16) /* Generic command address sequence - address fields. */ #define GCMD_LAY_INPUT_ADDR GENMASK_ULL(63, 16) /* Generic command address sequence - address size. */ #define GCMD_LAY_INPUT_ADDR_SIZE GENMASK_ULL(13, 11) /* Transfer direction field of generic command data sequence. */ #define GCMD_DIR BIT_ULL(11) /* Read transfer direction of generic command data sequence. */ #define GCMD_DIR_READ 0 /* Write transfer direction of generic command data sequence. */ #define GCMD_DIR_WRITE 1 /* ECC enabled flag of generic command data sequence - ECC enabled. */ #define GCMD_ECC_EN BIT_ULL(12) /* Generic command data sequence - sector size. */ #define GCMD_SECT_SIZE GENMASK_ULL(31, 16) /* Generic command data sequence - sector count. */ #define GCMD_SECT_CNT GENMASK_ULL(39, 32) /* Generic command data sequence - last sector size. */ #define GCMD_LAST_SIZE GENMASK_ULL(55, 40) /* CDMA descriptor fields. */ /* Erase command type of CDMA descriptor. */ #define CDMA_CT_ERASE 0x1000 /* Program page command type of CDMA descriptor. */ #define CDMA_CT_WR 0x2100 /* Read page command type of CDMA descriptor. */ #define CDMA_CT_RD 0x2200 /* Flash pointer memory shift. */ #define CDMA_CFPTR_MEM_SHIFT 24 /* Flash pointer memory mask. */ #define CDMA_CFPTR_MEM GENMASK(26, 24) /* * Command DMA descriptor flags. If set causes issue interrupt after * the completion of descriptor processing. */ #define CDMA_CF_INT BIT(8) /* * Command DMA descriptor flags - the next descriptor * address field is valid and descriptor processing should continue. */ #define CDMA_CF_CONT BIT(9) /* DMA master flag of command DMA descriptor. */ #define CDMA_CF_DMA_MASTER BIT(10) /* Operation complete status of command descriptor. */ #define CDMA_CS_COMP BIT(15) /* Operation complete status of command descriptor. */ /* Command descriptor status - operation fail. */ #define CDMA_CS_FAIL BIT(14) /* Command descriptor status - page erased. */ #define CDMA_CS_ERP BIT(11) /* Command descriptor status - timeout occurred. */ #define CDMA_CS_TOUT BIT(10) /* * Maximum amount of correction applied to one ECC sector. * It is part of command descriptor status. */ #define CDMA_CS_MAXERR GENMASK(9, 2) /* Command descriptor status - uncorrectable ECC error. */ #define CDMA_CS_UNCE BIT(1) /* Command descriptor status - descriptor error. */ #define CDMA_CS_ERR BIT(0) /* Status of operation - OK. */ #define STAT_OK 0 /* Status of operation - FAIL. */ #define STAT_FAIL 2 /* Status of operation - uncorrectable ECC error. */ #define STAT_ECC_UNCORR 3 /* Status of operation - page erased. */ #define STAT_ERASED 5 /* Status of operation - correctable ECC error. */ #define STAT_ECC_CORR 6 /* Status of operation - unsuspected state. */ #define STAT_UNKNOWN 7 /* Status of operation - operation is not completed yet. */ #define STAT_BUSY 0xFF #define BCH_MAX_NUM_CORR_CAPS 8 #define BCH_MAX_NUM_SECTOR_SIZES 2 struct cadence_nand_timings { u32 async_toggle_timings; u32 timings0; u32 timings1; u32 timings2; u32 dll_phy_ctrl; u32 phy_ctrl; u32 phy_dqs_timing; u32 phy_gate_lpbk_ctrl; }; /* Command DMA descriptor. */ struct cadence_nand_cdma_desc { /* Next descriptor address. */ u64 next_pointer; /* Flash address is a 32-bit address comprising of BANK and ROW ADDR. */ u32 flash_pointer; /*field appears in HPNFC version 13*/ u16 bank; u16 rsvd0; /* Operation the controller needs to perform. */ u16 command_type; u16 rsvd1; /* Flags for operation of this command. */ u16 command_flags; u16 rsvd2; /* System/host memory address required for data DMA commands. */ u64 memory_pointer; /* Status of operation. */ u32 status; u32 rsvd3; /* Address pointer to sync buffer location. */ u64 sync_flag_pointer; /* Controls the buffer sync mechanism. */ u32 sync_arguments; u32 rsvd4; /* Control data pointer. */ u64 ctrl_data_ptr; }; /* Interrupt status. */ struct cadence_nand_irq_status { /* Thread operation complete status. */ u32 trd_status; /* Thread operation error. */ u32 trd_error; /* Controller status. */ u32 status; }; /* Cadence NAND flash controller capabilities get from driver data. */ struct cadence_nand_dt_devdata { /* Skew value of the output signals of the NAND Flash interface. */ u32 if_skew; /* It informs if slave DMA interface is connected to DMA engine. */ unsigned int has_dma:1; }; /* Cadence NAND flash controller capabilities read from registers. */ struct cdns_nand_caps { /* Maximum number of banks supported by hardware. */ u8 max_banks; /* Slave and Master DMA data width in bytes (4 or 8). */ u8 data_dma_width; /* Control Data feature supported. */ bool data_control_supp; /* Is PHY type DLL. */ bool is_phy_type_dll; }; struct cdns_nand_ctrl { struct device *dev; struct nand_controller controller; struct cadence_nand_cdma_desc *cdma_desc; /* IP capability. */ const struct cadence_nand_dt_devdata *caps1; struct cdns_nand_caps caps2; u8 ctrl_rev; dma_addr_t dma_cdma_desc; u8 *buf; u32 buf_size; u8 curr_corr_str_idx; /* Register interface. */ void __iomem *reg; struct { void __iomem *virt; dma_addr_t dma; } io; int irq; /* Interrupts that have happened. */ struct cadence_nand_irq_status irq_status; /* Interrupts we are waiting for. */ struct cadence_nand_irq_status irq_mask; struct completion complete; /* Protect irq_mask and irq_status. */ spinlock_t irq_lock; int ecc_strengths[BCH_MAX_NUM_CORR_CAPS]; struct nand_ecc_step_info ecc_stepinfos[BCH_MAX_NUM_SECTOR_SIZES]; struct nand_ecc_caps ecc_caps; int curr_trans_type; struct dma_chan *dmac; u32 nf_clk_rate; /* * Estimated Board delay. The value includes the total * round trip delay for the signals and is used for deciding on values * associated with data read capture. */ u32 board_delay; struct nand_chip *selected_chip; unsigned long assigned_cs; struct list_head chips; u8 bch_metadata_size; }; struct cdns_nand_chip { struct cadence_nand_timings timings; struct nand_chip chip; u8 nsels; struct list_head node; /* * part of oob area of NAND flash memory page. * This part is available for user to read or write. */ u32 avail_oob_size; /* Sector size. There are few sectors per mtd->writesize */ u32 sector_size; u32 sector_count; /* Offset of BBM. */ u8 bbm_offs; /* Number of bytes reserved for BBM. */ u8 bbm_len; /* ECC strength index. */ u8 corr_str_idx; u8 cs[] __counted_by(nsels); }; static inline struct cdns_nand_chip *to_cdns_nand_chip(struct nand_chip *chip) { return container_of(chip, struct cdns_nand_chip, chip); } static inline struct cdns_nand_ctrl *to_cdns_nand_ctrl(struct nand_controller *controller) { return container_of(controller, struct cdns_nand_ctrl, controller); } static bool cadence_nand_dma_buf_ok(struct cdns_nand_ctrl *cdns_ctrl, const void *buf, u32 buf_len) { u8 data_dma_width = cdns_ctrl->caps2.data_dma_width; return buf && virt_addr_valid(buf) && likely(IS_ALIGNED((uintptr_t)buf, data_dma_width)) && likely(IS_ALIGNED(buf_len, DMA_DATA_SIZE_ALIGN)); } static int cadence_nand_wait_for_value(struct cdns_nand_ctrl *cdns_ctrl, u32 reg_offset, u32 timeout_us, u32 mask, bool is_clear) { u32 val; int ret; ret = readl_relaxed_poll_timeout(cdns_ctrl->reg + reg_offset, val, !(val & mask) == is_clear, 10, timeout_us); if (ret < 0) { dev_err(cdns_ctrl->dev, "Timeout while waiting for reg %x with mask %x is clear %d\n", reg_offset, mask, is_clear); } return ret; } static int cadence_nand_set_ecc_enable(struct cdns_nand_ctrl *cdns_ctrl, bool enable) { u32 reg; if (cadence_nand_wait_for_value(cdns_ctrl, CTRL_STATUS, 1000000, CTRL_STATUS_CTRL_BUSY, true)) return -ETIMEDOUT; reg = readl_relaxed(cdns_ctrl->reg + ECC_CONFIG_0); if (enable) reg |= ECC_CONFIG_0_ECC_EN; else reg &= ~ECC_CONFIG_0_ECC_EN; writel_relaxed(reg, cdns_ctrl->reg + ECC_CONFIG_0); return 0; } static void cadence_nand_set_ecc_strength(struct cdns_nand_ctrl *cdns_ctrl, u8 corr_str_idx) { u32 reg; if (cdns_ctrl->curr_corr_str_idx == corr_str_idx) return; reg = readl_relaxed(cdns_ctrl->reg + ECC_CONFIG_0); reg &= ~ECC_CONFIG_0_CORR_STR; reg |= FIELD_PREP(ECC_CONFIG_0_CORR_STR, corr_str_idx); writel_relaxed(reg, cdns_ctrl->reg + ECC_CONFIG_0); cdns_ctrl->curr_corr_str_idx = corr_str_idx; } static int cadence_nand_get_ecc_strength_idx(struct cdns_nand_ctrl *cdns_ctrl, u8 strength) { int i, corr_str_idx = -1; for (i = 0; i < BCH_MAX_NUM_CORR_CAPS; i++) { if (cdns_ctrl->ecc_strengths[i] == strength) { corr_str_idx = i; break; } } return corr_str_idx; } static int cadence_nand_set_skip_marker_val(struct cdns_nand_ctrl *cdns_ctrl, u16 marker_value) { u32 reg; if (cadence_nand_wait_for_value(cdns_ctrl, CTRL_STATUS, 1000000, CTRL_STATUS_CTRL_BUSY, true)) return -ETIMEDOUT; reg = readl_relaxed(cdns_ctrl->reg + SKIP_BYTES_CONF); reg &= ~SKIP_BYTES_MARKER_VALUE; reg |= FIELD_PREP(SKIP_BYTES_MARKER_VALUE, marker_value); writel_relaxed(reg, cdns_ctrl->reg + SKIP_BYTES_CONF); return 0; } static int cadence_nand_set_skip_bytes_conf(struct cdns_nand_ctrl *cdns_ctrl, u8 num_of_bytes, u32 offset_value, int enable) { u32 reg, skip_bytes_offset; if (cadence_nand_wait_for_value(cdns_ctrl, CTRL_STATUS, 1000000, CTRL_STATUS_CTRL_BUSY, true)) return -ETIMEDOUT; if (!enable) { num_of_bytes = 0; offset_value = 0; } reg = readl_relaxed(cdns_ctrl->reg + SKIP_BYTES_CONF); reg &= ~SKIP_BYTES_NUM_OF_BYTES; reg |= FIELD_PREP(SKIP_BYTES_NUM_OF_BYTES, num_of_bytes); skip_bytes_offset = FIELD_PREP(SKIP_BYTES_OFFSET_VALUE, offset_value); writel_relaxed(reg, cdns_ctrl->reg + SKIP_BYTES_CONF); writel_relaxed(skip_bytes_offset, cdns_ctrl->reg + SKIP_BYTES_OFFSET); return 0; } /* Functions enables/disables hardware detection of erased data */ static void cadence_nand_set_erase_detection(struct cdns_nand_ctrl *cdns_ctrl, bool enable, u8 bitflips_threshold) { u32 reg; reg = readl_relaxed(cdns_ctrl->reg + ECC_CONFIG_0); if (enable) reg |= ECC_CONFIG_0_ERASE_DET_EN; else reg &= ~ECC_CONFIG_0_ERASE_DET_EN; writel_relaxed(reg, cdns_ctrl->reg + ECC_CONFIG_0); writel_relaxed(bitflips_threshold, cdns_ctrl->reg + ECC_CONFIG_1); } static int cadence_nand_set_access_width16(struct cdns_nand_ctrl *cdns_ctrl, bool bit_bus16) { u32 reg; if (cadence_nand_wait_for_value(cdns_ctrl, CTRL_STATUS, 1000000, CTRL_STATUS_CTRL_BUSY, true)) return -ETIMEDOUT; reg = readl_relaxed(cdns_ctrl->reg + COMMON_SET); if (!bit_bus16) reg &= ~COMMON_SET_DEVICE_16BIT; else reg |= COMMON_SET_DEVICE_16BIT; writel_relaxed(reg, cdns_ctrl->reg + COMMON_SET); return 0; } static void cadence_nand_clear_interrupt(struct cdns_nand_ctrl *cdns_ctrl, struct cadence_nand_irq_status *irq_status) { writel_relaxed(irq_status->status, cdns_ctrl->reg + INTR_STATUS); writel_relaxed(irq_status->trd_status, cdns_ctrl->reg + TRD_COMP_INT_STATUS); writel_relaxed(irq_status->trd_error, cdns_ctrl->reg + TRD_ERR_INT_STATUS); } static void cadence_nand_read_int_status(struct cdns_nand_ctrl *cdns_ctrl, struct cadence_nand_irq_status *irq_status) { irq_status->status = readl_relaxed(cdns_ctrl->reg + INTR_STATUS); irq_status->trd_status = readl_relaxed(cdns_ctrl->reg + TRD_COMP_INT_STATUS); irq_status->trd_error = readl_relaxed(cdns_ctrl->reg + TRD_ERR_INT_STATUS); } static u32 irq_detected(struct cdns_nand_ctrl *cdns_ctrl, struct cadence_nand_irq_status *irq_status) { cadence_nand_read_int_status(cdns_ctrl, irq_status); return irq_status->status || irq_status->trd_status || irq_status->trd_error; } static void cadence_nand_reset_irq(struct cdns_nand_ctrl *cdns_ctrl) { unsigned long flags; spin_lock_irqsave(&cdns_ctrl->irq_lock, flags); memset(&cdns_ctrl->irq_status, 0, sizeof(cdns_ctrl->irq_status)); memset(&cdns_ctrl->irq_mask, 0, sizeof(cdns_ctrl->irq_mask)); spin_unlock_irqrestore(&cdns_ctrl->irq_lock, flags); } /* * This is the interrupt service routine. It handles all interrupts * sent to this device. */ static irqreturn_t cadence_nand_isr(int irq, void *dev_id) { struct cdns_nand_ctrl *cdns_ctrl = dev_id; struct cadence_nand_irq_status irq_status; irqreturn_t result = IRQ_NONE; spin_lock(&cdns_ctrl->irq_lock); if (irq_detected(cdns_ctrl, &irq_status)) { /* Handle interrupt. */ /* First acknowledge it. */ cadence_nand_clear_interrupt(cdns_ctrl, &irq_status); /* Status in the device context for someone to read. */ cdns_ctrl->irq_status.status |= irq_status.status; cdns_ctrl->irq_status.trd_status |= irq_status.trd_status; cdns_ctrl->irq_status.trd_error |= irq_status.trd_error; /* Notify anyone who cares that it happened. */ complete(&cdns_ctrl->complete); /* Tell the OS that we've handled this. */ result = IRQ_HANDLED; } spin_unlock(&cdns_ctrl->irq_lock); return result; } static void cadence_nand_set_irq_mask(struct cdns_nand_ctrl *cdns_ctrl, struct cadence_nand_irq_status *irq_mask) { writel_relaxed(INTR_ENABLE_INTR_EN | irq_mask->status, cdns_ctrl->reg + INTR_ENABLE); writel_relaxed(irq_mask->trd_error, cdns_ctrl->reg + TRD_ERR_INT_STATUS_EN); } static void cadence_nand_wait_for_irq(struct cdns_nand_ctrl *cdns_ctrl, struct cadence_nand_irq_status *irq_mask, struct cadence_nand_irq_status *irq_status) { unsigned long timeout = msecs_to_jiffies(10000); unsigned long time_left; time_left = wait_for_completion_timeout(&cdns_ctrl->complete, timeout); *irq_status = cdns_ctrl->irq_status; if (time_left == 0) { /* Timeout error. */ dev_err(cdns_ctrl->dev, "timeout occurred:\n"); dev_err(cdns_ctrl->dev, "\tstatus = 0x%x, mask = 0x%x\n", irq_status->status, irq_mask->status); dev_err(cdns_ctrl->dev, "\ttrd_status = 0x%x, trd_status mask = 0x%x\n", irq_status->trd_status, irq_mask->trd_status); dev_err(cdns_ctrl->dev, "\t trd_error = 0x%x, trd_error mask = 0x%x\n", irq_status->trd_error, irq_mask->trd_error); } } /* Execute generic command on NAND controller. */ static int cadence_nand_generic_cmd_send(struct cdns_nand_ctrl *cdns_ctrl, u8 chip_nr, u64 mini_ctrl_cmd) { u32 mini_ctrl_cmd_l, mini_ctrl_cmd_h, reg; mini_ctrl_cmd |= FIELD_PREP(GCMD_LAY_CS, chip_nr); mini_ctrl_cmd_l = mini_ctrl_cmd & 0xFFFFFFFF; mini_ctrl_cmd_h = mini_ctrl_cmd >> 32; if (cadence_nand_wait_for_value(cdns_ctrl, CTRL_STATUS, 1000000, CTRL_STATUS_CTRL_BUSY, true)) return -ETIMEDOUT; cadence_nand_reset_irq(cdns_ctrl); writel_relaxed(mini_ctrl_cmd_l, cdns_ctrl->reg + CMD_REG2); writel_relaxed(mini_ctrl_cmd_h, cdns_ctrl->reg + CMD_REG3); /* Select generic command. */ reg = FIELD_PREP(CMD_REG0_CT, CMD_REG0_CT_GEN); /* Thread number. */ reg |= FIELD_PREP(CMD_REG0_TN, 0); /* Issue command. */ writel_relaxed(reg, cdns_ctrl->reg + CMD_REG0); return 0; } /* Wait for data on slave DMA interface. */ static int cadence_nand_wait_on_sdma(struct cdns_nand_ctrl *cdns_ctrl, u8 *out_sdma_trd, u32 *out_sdma_size) { struct cadence_nand_irq_status irq_mask, irq_status; irq_mask.trd_status = 0; irq_mask.trd_error = 0; irq_mask.status = INTR_STATUS_SDMA_TRIGG | INTR_STATUS_SDMA_ERR | INTR_STATUS_UNSUPP_CMD; cadence_nand_set_irq_mask(cdns_ctrl, &irq_mask); cadence_nand_wait_for_irq(cdns_ctrl, &irq_mask, &irq_status); if (irq_status.status == 0) { dev_err(cdns_ctrl->dev, "Timeout while waiting for SDMA\n"); return -ETIMEDOUT; } if (irq_status.status & INTR_STATUS_SDMA_TRIGG) { *out_sdma_size = readl_relaxed(cdns_ctrl->reg + SDMA_SIZE); *out_sdma_trd = readl_relaxed(cdns_ctrl->reg + SDMA_TRD_NUM); *out_sdma_trd = FIELD_GET(SDMA_TRD_NUM_SDMA_TRD, *out_sdma_trd); } else { dev_err(cdns_ctrl->dev, "SDMA error - irq_status %x\n", irq_status.status); return -EIO; } return 0; } static void cadence_nand_get_caps(struct cdns_nand_ctrl *cdns_ctrl) { u32 reg; reg = readl_relaxed(cdns_ctrl->reg + CTRL_FEATURES); cdns_ctrl->caps2.max_banks = 1 << FIELD_GET(CTRL_FEATURES_N_BANKS, reg); if (FIELD_GET(CTRL_FEATURES_DMA_DWITH64, reg)) cdns_ctrl->caps2.data_dma_width = 8; else cdns_ctrl->caps2.data_dma_width = 4; if (reg & CTRL_FEATURES_CONTROL_DATA) cdns_ctrl->caps2.data_control_supp = true; if (reg & (CTRL_FEATURES_NVDDR_2_3 | CTRL_FEATURES_NVDDR)) cdns_ctrl->caps2.is_phy_type_dll = true; } /* Prepare CDMA descriptor. */ static void cadence_nand_cdma_desc_prepare(struct cdns_nand_ctrl *cdns_ctrl, char nf_mem, u32 flash_ptr, dma_addr_t mem_ptr, dma_addr_t ctrl_data_ptr, u16 ctype) { struct cadence_nand_cdma_desc *cdma_desc = cdns_ctrl->cdma_desc; memset(cdma_desc, 0, sizeof(struct cadence_nand_cdma_desc)); /* Set fields for one descriptor. */ cdma_desc->flash_pointer = flash_ptr; if (cdns_ctrl->ctrl_rev >= 13) cdma_desc->bank = nf_mem; else cdma_desc->flash_pointer |= (nf_mem << CDMA_CFPTR_MEM_SHIFT); cdma_desc->command_flags |= CDMA_CF_DMA_MASTER; cdma_desc->command_flags |= CDMA_CF_INT; cdma_desc->memory_pointer = mem_ptr; cdma_desc->status = 0; cdma_desc->sync_flag_pointer = 0; cdma_desc->sync_arguments = 0; cdma_desc->command_type = ctype; cdma_desc->ctrl_data_ptr = ctrl_data_ptr; } static u8 cadence_nand_check_desc_error(struct cdns_nand_ctrl *cdns_ctrl, u32 desc_status) { if (desc_status & CDMA_CS_ERP) return STAT_ERASED; if (desc_status & CDMA_CS_UNCE) return STAT_ECC_UNCORR; if (desc_status & CDMA_CS_ERR) { dev_err(cdns_ctrl->dev, ":CDMA desc error flag detected.\n"); return STAT_FAIL; } if (FIELD_GET(CDMA_CS_MAXERR, desc_status)) return STAT_ECC_CORR; return STAT_FAIL; } static int cadence_nand_cdma_finish(struct cdns_nand_ctrl *cdns_ctrl) { struct cadence_nand_cdma_desc *desc_ptr = cdns_ctrl->cdma_desc; u8 status = STAT_BUSY; if (desc_ptr->status & CDMA_CS_FAIL) { status = cadence_nand_check_desc_error(cdns_ctrl, desc_ptr->status); dev_err(cdns_ctrl->dev, ":CDMA error %x\n", desc_ptr->status); } else if (desc_ptr->status & CDMA_CS_COMP) { /* Descriptor finished with no errors. */ if (desc_ptr->command_flags & CDMA_CF_CONT) { dev_info(cdns_ctrl->dev, "DMA unsupported flag is set"); status = STAT_UNKNOWN; } else { /* Last descriptor. */ status = STAT_OK; } } return status; } static int cadence_nand_cdma_send(struct cdns_nand_ctrl *cdns_ctrl, u8 thread) { u32 reg; int status; /* Wait for thread ready. */ status = cadence_nand_wait_for_value(cdns_ctrl, TRD_STATUS, 1000000, BIT(thread), true); if (status) return status; cadence_nand_reset_irq(cdns_ctrl); reinit_completion(&cdns_ctrl->complete); writel_relaxed((u32)cdns_ctrl->dma_cdma_desc, cdns_ctrl->reg + CMD_REG2); writel_relaxed(0, cdns_ctrl->reg + CMD_REG3); /* Select CDMA mode. */ reg = FIELD_PREP(CMD_REG0_CT, CMD_REG0_CT_CDMA); /* Thread number. */ reg |= FIELD_PREP(CMD_REG0_TN, thread); /* Issue command. */ writel_relaxed(reg, cdns_ctrl->reg + CMD_REG0); return 0; } /* Send SDMA command and wait for finish. */ static u32 cadence_nand_cdma_send_and_wait(struct cdns_nand_ctrl *cdns_ctrl, u8 thread) { struct cadence_nand_irq_status irq_mask, irq_status = {0}; int status; irq_mask.trd_status = BIT(thread); irq_mask.trd_error = BIT(thread); irq_mask.status = INTR_STATUS_CDMA_TERR; cadence_nand_set_irq_mask(cdns_ctrl, &irq_mask); status = cadence_nand_cdma_send(cdns_ctrl, thread); if (status) return status; cadence_nand_wait_for_irq(cdns_ctrl, &irq_mask, &irq_status); if (irq_status.status == 0 && irq_status.trd_status == 0 && irq_status.trd_error == 0) { dev_err(cdns_ctrl->dev, "CDMA command timeout\n"); return -ETIMEDOUT; } if (irq_status.status & irq_mask.status) { dev_err(cdns_ctrl->dev, "CDMA command failed\n"); return -EIO; } return 0; } /* * ECC size depends on configured ECC strength and on maximum supported * ECC step size. */ static int cadence_nand_calc_ecc_bytes(int max_step_size, int strength) { int nbytes = DIV_ROUND_UP(fls(8 * max_step_size) * strength, 8); return ALIGN(nbytes, 2); } #define CADENCE_NAND_CALC_ECC_BYTES(max_step_size) \ static int \ cadence_nand_calc_ecc_bytes_##max_step_size(int step_size, \ int strength)\ {\ return cadence_nand_calc_ecc_bytes(max_step_size, strength);\ } CADENCE_NAND_CALC_ECC_BYTES(256) CADENCE_NAND_CALC_ECC_BYTES(512) CADENCE_NAND_CALC_ECC_BYTES(1024) CADENCE_NAND_CALC_ECC_BYTES(2048) CADENCE_NAND_CALC_ECC_BYTES(4096) /* Function reads BCH capabilities. */ static int cadence_nand_read_bch_caps(struct cdns_nand_ctrl *cdns_ctrl) { struct nand_ecc_caps *ecc_caps = &cdns_ctrl->ecc_caps; int max_step_size = 0, nstrengths, i; u32 reg; reg = readl_relaxed(cdns_ctrl->reg + BCH_CFG_3); cdns_ctrl->bch_metadata_size = FIELD_GET(BCH_CFG_3_METADATA_SIZE, reg); if (cdns_ctrl->bch_metadata_size < 4) { dev_err(cdns_ctrl->dev, "Driver needs at least 4 bytes of BCH meta data\n"); return -EIO; } reg = readl_relaxed(cdns_ctrl->reg + BCH_CFG_0); cdns_ctrl->ecc_strengths[0] = FIELD_GET(BCH_CFG_0_CORR_CAP_0, reg); cdns_ctrl->ecc_strengths[1] = FIELD_GET(BCH_CFG_0_CORR_CAP_1, reg); cdns_ctrl->ecc_strengths[2] = FIELD_GET(BCH_CFG_0_CORR_CAP_2, reg); cdns_ctrl->ecc_strengths[3] = FIELD_GET(BCH_CFG_0_CORR_CAP_3, reg); reg = readl_relaxed(cdns_ctrl->reg + BCH_CFG_1); cdns_ctrl->ecc_strengths[4] = FIELD_GET(BCH_CFG_1_CORR_CAP_4, reg); cdns_ctrl->ecc_strengths[5] = FIELD_GET(BCH_CFG_1_CORR_CAP_5, reg); cdns_ctrl->ecc_strengths[6] = FIELD_GET(BCH_CFG_1_CORR_CAP_6, reg); cdns_ctrl->ecc_strengths[7] = FIELD_GET(BCH_CFG_1_CORR_CAP_7, reg); reg = readl_relaxed(cdns_ctrl->reg + BCH_CFG_2); cdns_ctrl->ecc_stepinfos[0].stepsize = FIELD_GET(BCH_CFG_2_SECT_0, reg); cdns_ctrl->ecc_stepinfos[1].stepsize = FIELD_GET(BCH_CFG_2_SECT_1, reg); nstrengths = 0; for (i = 0; i < BCH_MAX_NUM_CORR_CAPS; i++) { if (cdns_ctrl->ecc_strengths[i] != 0) nstrengths++; } ecc_caps->nstepinfos = 0; for (i = 0; i < BCH_MAX_NUM_SECTOR_SIZES; i++) { /* ECC strengths are common for all step infos. */ cdns_ctrl->ecc_stepinfos[i].nstrengths = nstrengths; cdns_ctrl->ecc_stepinfos[i].strengths = cdns_ctrl->ecc_strengths; if (cdns_ctrl->ecc_stepinfos[i].stepsize != 0) ecc_caps->nstepinfos++; if (cdns_ctrl->ecc_stepinfos[i].stepsize > max_step_size) max_step_size = cdns_ctrl->ecc_stepinfos[i].stepsize; } ecc_caps->stepinfos = &cdns_ctrl->ecc_stepinfos[0]; switch (max_step_size) { case 256: ecc_caps->calc_ecc_bytes = &cadence_nand_calc_ecc_bytes_256; break; case 512: ecc_caps->calc_ecc_bytes = &cadence_nand_calc_ecc_bytes_512; break; case 1024: ecc_caps->calc_ecc_bytes = &cadence_nand_calc_ecc_bytes_1024; break; case 2048: ecc_caps->calc_ecc_bytes = &cadence_nand_calc_ecc_bytes_2048; break; case 4096: ecc_caps->calc_ecc_bytes = &cadence_nand_calc_ecc_bytes_4096; break; default: dev_err(cdns_ctrl->dev, "Unsupported sector size(ecc step size) %d\n", max_step_size); return -EIO; } return 0; } /* Hardware initialization. */ static int cadence_nand_hw_init(struct cdns_nand_ctrl *cdns_ctrl) { int status; u32 reg; status = cadence_nand_wait_for_value(cdns_ctrl, CTRL_STATUS, 1000000, CTRL_STATUS_INIT_COMP, false); if (status) return status; reg = readl_relaxed(cdns_ctrl->reg + CTRL_VERSION); cdns_ctrl->ctrl_rev = FIELD_GET(CTRL_VERSION_REV, reg); dev_info(cdns_ctrl->dev, "%s: cadence nand controller version reg %x\n", __func__, reg); /* Disable cache and multiplane. */ writel_relaxed(0, cdns_ctrl->reg + MULTIPLANE_CFG); writel_relaxed(0, cdns_ctrl->reg + CACHE_CFG); /* Clear all interrupts. */ writel_relaxed(0xFFFFFFFF, cdns_ctrl->reg + INTR_STATUS); cadence_nand_get_caps(cdns_ctrl); if (cadence_nand_read_bch_caps(cdns_ctrl)) return -EIO; #ifndef CONFIG_64BIT if (cdns_ctrl->caps2.data_dma_width == 8) { dev_err(cdns_ctrl->dev, "cannot access 64-bit dma on !64-bit architectures"); return -EIO; } #endif /* * Set IO width access to 8. * It is because during SW device discovering width access * is expected to be 8. */ status = cadence_nand_set_access_width16(cdns_ctrl, false); return status; } #define TT_MAIN_OOB_AREAS 2 #define TT_RAW_PAGE 3 #define TT_BBM 4 #define TT_MAIN_OOB_AREA_EXT 5 /* Prepare size of data to transfer. */ static void cadence_nand_prepare_data_size(struct nand_chip *chip, int transfer_type) { struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); struct cdns_nand_chip *cdns_chip = to_cdns_nand_chip(chip); struct mtd_info *mtd = nand_to_mtd(chip); u32 sec_size = 0, offset = 0, sec_cnt = 1; u32 last_sec_size = cdns_chip->sector_size; u32 data_ctrl_size = 0; u32 reg = 0; if (cdns_ctrl->curr_trans_type == transfer_type) return; switch (transfer_type) { case TT_MAIN_OOB_AREA_EXT: sec_cnt = cdns_chip->sector_count; sec_size = cdns_chip->sector_size; data_ctrl_size = cdns_chip->avail_oob_size; break; case TT_MAIN_OOB_AREAS: sec_cnt = cdns_chip->sector_count; last_sec_size = cdns_chip->sector_size + cdns_chip->avail_oob_size; sec_size = cdns_chip->sector_size; break; case TT_RAW_PAGE: last_sec_size = mtd->writesize + mtd->oobsize; break; case TT_BBM: offset = mtd->writesize + cdns_chip->bbm_offs; last_sec_size = 8; break; } reg = 0; reg |= FIELD_PREP(TRAN_CFG_0_OFFSET, offset); reg |= FIELD_PREP(TRAN_CFG_0_SEC_CNT, sec_cnt); writel_relaxed(reg, cdns_ctrl->reg + TRAN_CFG_0); reg = 0; reg |= FIELD_PREP(TRAN_CFG_1_LAST_SEC_SIZE, last_sec_size); reg |= FIELD_PREP(TRAN_CFG_1_SECTOR_SIZE, sec_size); writel_relaxed(reg, cdns_ctrl->reg + TRAN_CFG_1); if (cdns_ctrl->caps2.data_control_supp) { reg = readl_relaxed(cdns_ctrl->reg + CONTROL_DATA_CTRL); reg &= ~CONTROL_DATA_CTRL_SIZE; reg |= FIELD_PREP(CONTROL_DATA_CTRL_SIZE, data_ctrl_size); writel_relaxed(reg, cdns_ctrl->reg + CONTROL_DATA_CTRL); } cdns_ctrl->curr_trans_type = transfer_type; } static int cadence_nand_cdma_transfer(struct cdns_nand_ctrl *cdns_ctrl, u8 chip_nr, int page, void *buf, void *ctrl_dat, u32 buf_size, u32 ctrl_dat_size, enum dma_data_direction dir, bool with_ecc) { dma_addr_t dma_buf, dma_ctrl_dat = 0; u8 thread_nr = chip_nr; int status; u16 ctype; if (dir == DMA_FROM_DEVICE) ctype = CDMA_CT_RD; else ctype = CDMA_CT_WR; cadence_nand_set_ecc_enable(cdns_ctrl, with_ecc); dma_buf = dma_map_single(cdns_ctrl->dev, buf, buf_size, dir); if (dma_mapping_error(cdns_ctrl->dev, dma_buf)) { dev_err(cdns_ctrl->dev, "Failed to map DMA buffer\n"); return -EIO; } if (ctrl_dat && ctrl_dat_size) { dma_ctrl_dat = dma_map_single(cdns_ctrl->dev, ctrl_dat, ctrl_dat_size, dir); if (dma_mapping_error(cdns_ctrl->dev, dma_ctrl_dat)) { dma_unmap_single(cdns_ctrl->dev, dma_buf, buf_size, dir); dev_err(cdns_ctrl->dev, "Failed to map DMA buffer\n"); return -EIO; } } cadence_nand_cdma_desc_prepare(cdns_ctrl, chip_nr, page, dma_buf, dma_ctrl_dat, ctype); status = cadence_nand_cdma_send_and_wait(cdns_ctrl, thread_nr); dma_unmap_single(cdns_ctrl->dev, dma_buf, buf_size, dir); if (ctrl_dat && ctrl_dat_size) dma_unmap_single(cdns_ctrl->dev, dma_ctrl_dat, ctrl_dat_size, dir); if (status) return status; return cadence_nand_cdma_finish(cdns_ctrl); } static void cadence_nand_set_timings(struct cdns_nand_ctrl *cdns_ctrl, struct cadence_nand_timings *t) { writel_relaxed(t->async_toggle_timings, cdns_ctrl->reg + ASYNC_TOGGLE_TIMINGS); writel_relaxed(t->timings0, cdns_ctrl->reg + TIMINGS0); writel_relaxed(t->timings1, cdns_ctrl->reg + TIMINGS1); writel_relaxed(t->timings2, cdns_ctrl->reg + TIMINGS2); if (cdns_ctrl->caps2.is_phy_type_dll) writel_relaxed(t->dll_phy_ctrl, cdns_ctrl->reg + DLL_PHY_CTRL); writel_relaxed(t->phy_ctrl, cdns_ctrl->reg + PHY_CTRL); if (cdns_ctrl->caps2.is_phy_type_dll) { writel_relaxed(0, cdns_ctrl->reg + PHY_TSEL); writel_relaxed(2, cdns_ctrl->reg + PHY_DQ_TIMING); writel_relaxed(t->phy_dqs_timing, cdns_ctrl->reg + PHY_DQS_TIMING); writel_relaxed(t->phy_gate_lpbk_ctrl, cdns_ctrl->reg + PHY_GATE_LPBK_CTRL); writel_relaxed(PHY_DLL_MASTER_CTRL_BYPASS_MODE, cdns_ctrl->reg + PHY_DLL_MASTER_CTRL); writel_relaxed(0, cdns_ctrl->reg + PHY_DLL_SLAVE_CTRL); } } static int cadence_nand_select_target(struct nand_chip *chip) { struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); struct cdns_nand_chip *cdns_chip = to_cdns_nand_chip(chip); if (chip == cdns_ctrl->selected_chip) return 0; if (cadence_nand_wait_for_value(cdns_ctrl, CTRL_STATUS, 1000000, CTRL_STATUS_CTRL_BUSY, true)) return -ETIMEDOUT; cadence_nand_set_timings(cdns_ctrl, &cdns_chip->timings); cadence_nand_set_ecc_strength(cdns_ctrl, cdns_chip->corr_str_idx); cadence_nand_set_erase_detection(cdns_ctrl, true, chip->ecc.strength); cdns_ctrl->curr_trans_type = -1; cdns_ctrl->selected_chip = chip; return 0; } static int cadence_nand_erase(struct nand_chip *chip, u32 page) { struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); struct cdns_nand_chip *cdns_chip = to_cdns_nand_chip(chip); int status; u8 thread_nr = cdns_chip->cs[chip->cur_cs]; cadence_nand_cdma_desc_prepare(cdns_ctrl, cdns_chip->cs[chip->cur_cs], page, 0, 0, CDMA_CT_ERASE); status = cadence_nand_cdma_send_and_wait(cdns_ctrl, thread_nr); if (status) { dev_err(cdns_ctrl->dev, "erase operation failed\n"); return -EIO; } status = cadence_nand_cdma_finish(cdns_ctrl); if (status) return status; return 0; } static int cadence_nand_read_bbm(struct nand_chip *chip, int page, u8 *buf) { int status; struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); struct cdns_nand_chip *cdns_chip = to_cdns_nand_chip(chip); struct mtd_info *mtd = nand_to_mtd(chip); cadence_nand_prepare_data_size(chip, TT_BBM); cadence_nand_set_skip_bytes_conf(cdns_ctrl, 0, 0, 0); /* * Read only bad block marker from offset * defined by a memory manufacturer. */ status = cadence_nand_cdma_transfer(cdns_ctrl, cdns_chip->cs[chip->cur_cs], page, cdns_ctrl->buf, NULL, mtd->oobsize, 0, DMA_FROM_DEVICE, false); if (status) { dev_err(cdns_ctrl->dev, "read BBM failed\n"); return -EIO; } memcpy(buf + cdns_chip->bbm_offs, cdns_ctrl->buf, cdns_chip->bbm_len); return 0; } static int cadence_nand_write_page(struct nand_chip *chip, const u8 *buf, int oob_required, int page) { struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); struct cdns_nand_chip *cdns_chip = to_cdns_nand_chip(chip); struct mtd_info *mtd = nand_to_mtd(chip); int status; u16 marker_val = 0xFFFF; status = cadence_nand_select_target(chip); if (status) return status; cadence_nand_set_skip_bytes_conf(cdns_ctrl, cdns_chip->bbm_len, mtd->writesize + cdns_chip->bbm_offs, 1); if (oob_required) { marker_val = *(u16 *)(chip->oob_poi + cdns_chip->bbm_offs); } else { /* Set oob data to 0xFF. */ memset(cdns_ctrl->buf + mtd->writesize, 0xFF, cdns_chip->avail_oob_size); } cadence_nand_set_skip_marker_val(cdns_ctrl, marker_val); cadence_nand_prepare_data_size(chip, TT_MAIN_OOB_AREA_EXT); if (cadence_nand_dma_buf_ok(cdns_ctrl, buf, mtd->writesize) && cdns_ctrl->caps2.data_control_supp) { u8 *oob; if (oob_required) oob = chip->oob_poi; else oob = cdns_ctrl->buf + mtd->writesize; status = cadence_nand_cdma_transfer(cdns_ctrl, cdns_chip->cs[chip->cur_cs], page, (void *)buf, oob, mtd->writesize, cdns_chip->avail_oob_size, DMA_TO_DEVICE, true); if (status) { dev_err(cdns_ctrl->dev, "write page failed\n"); return -EIO; } return 0; } if (oob_required) { /* Transfer the data to the oob area. */ memcpy(cdns_ctrl->buf + mtd->writesize, chip->oob_poi, cdns_chip->avail_oob_size); } memcpy(cdns_ctrl->buf, buf, mtd->writesize); cadence_nand_prepare_data_size(chip, TT_MAIN_OOB_AREAS); return cadence_nand_cdma_transfer(cdns_ctrl, cdns_chip->cs[chip->cur_cs], page, cdns_ctrl->buf, NULL, mtd->writesize + cdns_chip->avail_oob_size, 0, DMA_TO_DEVICE, true); } static int cadence_nand_write_oob(struct nand_chip *chip, int page) { struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); struct mtd_info *mtd = nand_to_mtd(chip); memset(cdns_ctrl->buf, 0xFF, mtd->writesize); return cadence_nand_write_page(chip, cdns_ctrl->buf, 1, page); } static int cadence_nand_write_page_raw(struct nand_chip *chip, const u8 *buf, int oob_required, int page) { struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); struct cdns_nand_chip *cdns_chip = to_cdns_nand_chip(chip); struct mtd_info *mtd = nand_to_mtd(chip); int writesize = mtd->writesize; int oobsize = mtd->oobsize; int ecc_steps = chip->ecc.steps; int ecc_size = chip->ecc.size; int ecc_bytes = chip->ecc.bytes; void *tmp_buf = cdns_ctrl->buf; int oob_skip = cdns_chip->bbm_len; size_t size = writesize + oobsize; int i, pos, len; int status = 0; status = cadence_nand_select_target(chip); if (status) return status; /* * Fill the buffer with 0xff first except the full page transfer. * This simplifies the logic. */ if (!buf || !oob_required) memset(tmp_buf, 0xff, size); cadence_nand_set_skip_bytes_conf(cdns_ctrl, 0, 0, 0); /* Arrange the buffer for syndrome payload/ecc layout. */ if (buf) { for (i = 0; i < ecc_steps; i++) { pos = i * (ecc_size + ecc_bytes); len = ecc_size; if (pos >= writesize) pos += oob_skip; else if (pos + len > writesize) len = writesize - pos; memcpy(tmp_buf + pos, buf, len); buf += len; if (len < ecc_size) { len = ecc_size - len; memcpy(tmp_buf + writesize + oob_skip, buf, len); buf += len; } } } if (oob_required) { const u8 *oob = chip->oob_poi; u32 oob_data_offset = (cdns_chip->sector_count - 1) * (cdns_chip->sector_size + chip->ecc.bytes) + cdns_chip->sector_size + oob_skip; /* BBM at the beginning of the OOB area. */ memcpy(tmp_buf + writesize, oob, oob_skip); /* OOB free. */ memcpy(tmp_buf + oob_data_offset, oob, cdns_chip->avail_oob_size); oob += cdns_chip->avail_oob_size; /* OOB ECC. */ for (i = 0; i < ecc_steps; i++) { pos = ecc_size + i * (ecc_size + ecc_bytes); if (i == (ecc_steps - 1)) pos += cdns_chip->avail_oob_size; len = ecc_bytes; if (pos >= writesize) pos += oob_skip; else if (pos + len > writesize) len = writesize - pos; memcpy(tmp_buf + pos, oob, len); oob += len; if (len < ecc_bytes) { len = ecc_bytes - len; memcpy(tmp_buf + writesize + oob_skip, oob, len); oob += len; } } } cadence_nand_prepare_data_size(chip, TT_RAW_PAGE); return cadence_nand_cdma_transfer(cdns_ctrl, cdns_chip->cs[chip->cur_cs], page, cdns_ctrl->buf, NULL, mtd->writesize + mtd->oobsize, 0, DMA_TO_DEVICE, false); } static int cadence_nand_write_oob_raw(struct nand_chip *chip, int page) { return cadence_nand_write_page_raw(chip, NULL, true, page); } static int cadence_nand_read_page(struct nand_chip *chip, u8 *buf, int oob_required, int page) { struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); struct cdns_nand_chip *cdns_chip = to_cdns_nand_chip(chip); struct mtd_info *mtd = nand_to_mtd(chip); int status = 0; int ecc_err_count = 0; status = cadence_nand_select_target(chip); if (status) return status; cadence_nand_set_skip_bytes_conf(cdns_ctrl, cdns_chip->bbm_len, mtd->writesize + cdns_chip->bbm_offs, 1); /* * If data buffer can be accessed by DMA and data_control feature * is supported then transfer data and oob directly. */ if (cadence_nand_dma_buf_ok(cdns_ctrl, buf, mtd->writesize) && cdns_ctrl->caps2.data_control_supp) { u8 *oob; if (oob_required) oob = chip->oob_poi; else oob = cdns_ctrl->buf + mtd->writesize; cadence_nand_prepare_data_size(chip, TT_MAIN_OOB_AREA_EXT); status = cadence_nand_cdma_transfer(cdns_ctrl, cdns_chip->cs[chip->cur_cs], page, buf, oob, mtd->writesize, cdns_chip->avail_oob_size, DMA_FROM_DEVICE, true); /* Otherwise use bounce buffer. */ } else { cadence_nand_prepare_data_size(chip, TT_MAIN_OOB_AREAS); status = cadence_nand_cdma_transfer(cdns_ctrl, cdns_chip->cs[chip->cur_cs], page, cdns_ctrl->buf, NULL, mtd->writesize + cdns_chip->avail_oob_size, 0, DMA_FROM_DEVICE, true); memcpy(buf, cdns_ctrl->buf, mtd->writesize); if (oob_required) memcpy(chip->oob_poi, cdns_ctrl->buf + mtd->writesize, mtd->oobsize); } switch (status) { case STAT_ECC_UNCORR: mtd->ecc_stats.failed++; ecc_err_count++; break; case STAT_ECC_CORR: ecc_err_count = FIELD_GET(CDMA_CS_MAXERR, cdns_ctrl->cdma_desc->status); mtd->ecc_stats.corrected += ecc_err_count; break; case STAT_ERASED: case STAT_OK: break; default: dev_err(cdns_ctrl->dev, "read page failed\n"); return -EIO; } if (oob_required) if (cadence_nand_read_bbm(chip, page, chip->oob_poi)) return -EIO; return ecc_err_count; } /* Reads OOB data from the device. */ static int cadence_nand_read_oob(struct nand_chip *chip, int page) { struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); return cadence_nand_read_page(chip, cdns_ctrl->buf, 1, page); } static int cadence_nand_read_page_raw(struct nand_chip *chip, u8 *buf, int oob_required, int page) { struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); struct cdns_nand_chip *cdns_chip = to_cdns_nand_chip(chip); struct mtd_info *mtd = nand_to_mtd(chip); int oob_skip = cdns_chip->bbm_len; int writesize = mtd->writesize; int ecc_steps = chip->ecc.steps; int ecc_size = chip->ecc.size; int ecc_bytes = chip->ecc.bytes; void *tmp_buf = cdns_ctrl->buf; int i, pos, len; int status = 0; status = cadence_nand_select_target(chip); if (status) return status; cadence_nand_set_skip_bytes_conf(cdns_ctrl, 0, 0, 0); cadence_nand_prepare_data_size(chip, TT_RAW_PAGE); status = cadence_nand_cdma_transfer(cdns_ctrl, cdns_chip->cs[chip->cur_cs], page, cdns_ctrl->buf, NULL, mtd->writesize + mtd->oobsize, 0, DMA_FROM_DEVICE, false); switch (status) { case STAT_ERASED: case STAT_OK: break; default: dev_err(cdns_ctrl->dev, "read raw page failed\n"); return -EIO; } /* Arrange the buffer for syndrome payload/ecc layout. */ if (buf) { for (i = 0; i < ecc_steps; i++) { pos = i * (ecc_size + ecc_bytes); len = ecc_size; if (pos >= writesize) pos += oob_skip; else if (pos + len > writesize) len = writesize - pos; memcpy(buf, tmp_buf + pos, len); buf += len; if (len < ecc_size) { len = ecc_size - len; memcpy(buf, tmp_buf + writesize + oob_skip, len); buf += len; } } } if (oob_required) { u8 *oob = chip->oob_poi; u32 oob_data_offset = (cdns_chip->sector_count - 1) * (cdns_chip->sector_size + chip->ecc.bytes) + cdns_chip->sector_size + oob_skip; /* OOB free. */ memcpy(oob, tmp_buf + oob_data_offset, cdns_chip->avail_oob_size); /* BBM at the beginning of the OOB area. */ memcpy(oob, tmp_buf + writesize, oob_skip); oob += cdns_chip->avail_oob_size; /* OOB ECC */ for (i = 0; i < ecc_steps; i++) { pos = ecc_size + i * (ecc_size + ecc_bytes); len = ecc_bytes; if (i == (ecc_steps - 1)) pos += cdns_chip->avail_oob_size; if (pos >= writesize) pos += oob_skip; else if (pos + len > writesize) len = writesize - pos; memcpy(oob, tmp_buf + pos, len); oob += len; if (len < ecc_bytes) { len = ecc_bytes - len; memcpy(oob, tmp_buf + writesize + oob_skip, len); oob += len; } } } return 0; } static int cadence_nand_read_oob_raw(struct nand_chip *chip, int page) { return cadence_nand_read_page_raw(chip, NULL, true, page); } static void cadence_nand_slave_dma_transfer_finished(void *data) { struct completion *finished = data; complete(finished); } static int cadence_nand_slave_dma_transfer(struct cdns_nand_ctrl *cdns_ctrl, void *buf, dma_addr_t dev_dma, size_t len, enum dma_data_direction dir) { DECLARE_COMPLETION_ONSTACK(finished); struct dma_chan *chan; struct dma_device *dma_dev; dma_addr_t src_dma, dst_dma, buf_dma; struct dma_async_tx_descriptor *tx; dma_cookie_t cookie; chan = cdns_ctrl->dmac; dma_dev = chan->device; buf_dma = dma_map_single(dma_dev->dev, buf, len, dir); if (dma_mapping_error(dma_dev->dev, buf_dma)) { dev_err(cdns_ctrl->dev, "Failed to map DMA buffer\n"); goto err; } if (dir == DMA_FROM_DEVICE) { src_dma = cdns_ctrl->io.dma; dst_dma = buf_dma; } else { src_dma = buf_dma; dst_dma = cdns_ctrl->io.dma; } tx = dmaengine_prep_dma_memcpy(cdns_ctrl->dmac, dst_dma, src_dma, len, DMA_CTRL_ACK | DMA_PREP_INTERRUPT); if (!tx) { dev_err(cdns_ctrl->dev, "Failed to prepare DMA memcpy\n"); goto err_unmap; } tx->callback = cadence_nand_slave_dma_transfer_finished; tx->callback_param = &finished; cookie = dmaengine_submit(tx); if (dma_submit_error(cookie)) { dev_err(cdns_ctrl->dev, "Failed to do DMA tx_submit\n"); goto err_unmap; } dma_async_issue_pending(cdns_ctrl->dmac); wait_for_completion(&finished); dma_unmap_single(cdns_ctrl->dev, buf_dma, len, dir); return 0; err_unmap: dma_unmap_single(cdns_ctrl->dev, buf_dma, len, dir); err: dev_dbg(cdns_ctrl->dev, "Fall back to CPU I/O\n"); return -EIO; } static int cadence_nand_read_buf(struct cdns_nand_ctrl *cdns_ctrl, u8 *buf, int len) { u8 thread_nr = 0; u32 sdma_size; int status; /* Wait until slave DMA interface is ready to data transfer. */ status = cadence_nand_wait_on_sdma(cdns_ctrl, &thread_nr, &sdma_size); if (status) return status; if (!cdns_ctrl->caps1->has_dma) { u8 data_dma_width = cdns_ctrl->caps2.data_dma_width; int len_in_words = (data_dma_width == 4) ? len >> 2 : len >> 3; /* read alingment data */ if (data_dma_width == 4) ioread32_rep(cdns_ctrl->io.virt, buf, len_in_words); #ifdef CONFIG_64BIT else readsq(cdns_ctrl->io.virt, buf, len_in_words); #endif if (sdma_size > len) { int read_bytes = (data_dma_width == 4) ? len_in_words << 2 : len_in_words << 3; /* read rest data from slave DMA interface if any */ if (data_dma_width == 4) ioread32_rep(cdns_ctrl->io.virt, cdns_ctrl->buf, sdma_size / 4 - len_in_words); #ifdef CONFIG_64BIT else readsq(cdns_ctrl->io.virt, cdns_ctrl->buf, sdma_size / 8 - len_in_words); #endif /* copy rest of data */ memcpy(buf + read_bytes, cdns_ctrl->buf, len - read_bytes); } return 0; } if (cadence_nand_dma_buf_ok(cdns_ctrl, buf, len)) { status = cadence_nand_slave_dma_transfer(cdns_ctrl, buf, cdns_ctrl->io.dma, len, DMA_FROM_DEVICE); if (status == 0) return 0; dev_warn(cdns_ctrl->dev, "Slave DMA transfer failed. Try again using bounce buffer."); } /* If DMA transfer is not possible or failed then use bounce buffer. */ status = cadence_nand_slave_dma_transfer(cdns_ctrl, cdns_ctrl->buf, cdns_ctrl->io.dma, sdma_size, DMA_FROM_DEVICE); if (status) { dev_err(cdns_ctrl->dev, "Slave DMA transfer failed"); return status; } memcpy(buf, cdns_ctrl->buf, len); return 0; } static int cadence_nand_write_buf(struct cdns_nand_ctrl *cdns_ctrl, const u8 *buf, int len) { u8 thread_nr = 0; u32 sdma_size; int status; /* Wait until slave DMA interface is ready to data transfer. */ status = cadence_nand_wait_on_sdma(cdns_ctrl, &thread_nr, &sdma_size); if (status) return status; if (!cdns_ctrl->caps1->has_dma) { u8 data_dma_width = cdns_ctrl->caps2.data_dma_width; int len_in_words = (data_dma_width == 4) ? len >> 2 : len >> 3; if (data_dma_width == 4) iowrite32_rep(cdns_ctrl->io.virt, buf, len_in_words); #ifdef CONFIG_64BIT else writesq(cdns_ctrl->io.virt, buf, len_in_words); #endif if (sdma_size > len) { int written_bytes = (data_dma_width == 4) ? len_in_words << 2 : len_in_words << 3; /* copy rest of data */ memcpy(cdns_ctrl->buf, buf + written_bytes, len - written_bytes); /* write all expected by nand controller data */ if (data_dma_width == 4) iowrite32_rep(cdns_ctrl->io.virt, cdns_ctrl->buf, sdma_size / 4 - len_in_words); #ifdef CONFIG_64BIT else writesq(cdns_ctrl->io.virt, cdns_ctrl->buf, sdma_size / 8 - len_in_words); #endif } return 0; } if (cadence_nand_dma_buf_ok(cdns_ctrl, buf, len)) { status = cadence_nand_slave_dma_transfer(cdns_ctrl, (void *)buf, cdns_ctrl->io.dma, len, DMA_TO_DEVICE); if (status == 0) return 0; dev_warn(cdns_ctrl->dev, "Slave DMA transfer failed. Try again using bounce buffer."); } /* If DMA transfer is not possible or failed then use bounce buffer. */ memcpy(cdns_ctrl->buf, buf, len); status = cadence_nand_slave_dma_transfer(cdns_ctrl, cdns_ctrl->buf, cdns_ctrl->io.dma, sdma_size, DMA_TO_DEVICE); if (status) dev_err(cdns_ctrl->dev, "Slave DMA transfer failed"); return status; } static int cadence_nand_force_byte_access(struct nand_chip *chip, bool force_8bit) { struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); /* * Callers of this function do not verify if the NAND is using a 16-bit * an 8-bit bus for normal operations, so we need to take care of that * here by leaving the configuration unchanged if the NAND does not have * the NAND_BUSWIDTH_16 flag set. */ if (!(chip->options & NAND_BUSWIDTH_16)) return 0; return cadence_nand_set_access_width16(cdns_ctrl, !force_8bit); } static int cadence_nand_cmd_opcode(struct nand_chip *chip, const struct nand_subop *subop) { struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); struct cdns_nand_chip *cdns_chip = to_cdns_nand_chip(chip); const struct nand_op_instr *instr; unsigned int op_id = 0; u64 mini_ctrl_cmd = 0; int ret; instr = &subop->instrs[op_id]; if (instr->delay_ns > 0) mini_ctrl_cmd |= GCMD_LAY_TWB; mini_ctrl_cmd |= FIELD_PREP(GCMD_LAY_INSTR, GCMD_LAY_INSTR_CMD); mini_ctrl_cmd |= FIELD_PREP(GCMD_LAY_INPUT_CMD, instr->ctx.cmd.opcode); ret = cadence_nand_generic_cmd_send(cdns_ctrl, cdns_chip->cs[chip->cur_cs], mini_ctrl_cmd); if (ret) dev_err(cdns_ctrl->dev, "send cmd %x failed\n", instr->ctx.cmd.opcode); return ret; } static int cadence_nand_cmd_address(struct nand_chip *chip, const struct nand_subop *subop) { struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); struct cdns_nand_chip *cdns_chip = to_cdns_nand_chip(chip); const struct nand_op_instr *instr; unsigned int op_id = 0; u64 mini_ctrl_cmd = 0; unsigned int offset, naddrs; u64 address = 0; const u8 *addrs; int ret; int i; instr = &subop->instrs[op_id]; if (instr->delay_ns > 0) mini_ctrl_cmd |= GCMD_LAY_TWB; mini_ctrl_cmd |= FIELD_PREP(GCMD_LAY_INSTR, GCMD_LAY_INSTR_ADDR); offset = nand_subop_get_addr_start_off(subop, op_id); naddrs = nand_subop_get_num_addr_cyc(subop, op_id); addrs = &instr->ctx.addr.addrs[offset]; for (i = 0; i < naddrs; i++) address |= (u64)addrs[i] << (8 * i); mini_ctrl_cmd |= FIELD_PREP(GCMD_LAY_INPUT_ADDR, address); mini_ctrl_cmd |= FIELD_PREP(GCMD_LAY_INPUT_ADDR_SIZE, naddrs - 1); ret = cadence_nand_generic_cmd_send(cdns_ctrl, cdns_chip->cs[chip->cur_cs], mini_ctrl_cmd); if (ret) dev_err(cdns_ctrl->dev, "send address %llx failed\n", address); return ret; } static int cadence_nand_cmd_erase(struct nand_chip *chip, const struct nand_subop *subop) { unsigned int op_id; if (subop->instrs[0].ctx.cmd.opcode == NAND_CMD_ERASE1) { int i; const struct nand_op_instr *instr = NULL; unsigned int offset, naddrs; const u8 *addrs; u32 page = 0; instr = &subop->instrs[1]; offset = nand_subop_get_addr_start_off(subop, 1); naddrs = nand_subop_get_num_addr_cyc(subop, 1); addrs = &instr->ctx.addr.addrs[offset]; for (i = 0; i < naddrs; i++) page |= (u32)addrs[i] << (8 * i); return cadence_nand_erase(chip, page); } /* * If it is not an erase operation then handle operation * by calling exec_op function. */ for (op_id = 0; op_id < subop->ninstrs; op_id++) { int ret; const struct nand_operation nand_op = { .cs = chip->cur_cs, .instrs = &subop->instrs[op_id], .ninstrs = 1}; ret = chip->controller->ops->exec_op(chip, &nand_op, false); if (ret) return ret; } return 0; } static int cadence_nand_cmd_data(struct nand_chip *chip, const struct nand_subop *subop) { struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); struct cdns_nand_chip *cdns_chip = to_cdns_nand_chip(chip); const struct nand_op_instr *instr; unsigned int offset, op_id = 0; u64 mini_ctrl_cmd = 0; int len = 0; int ret; instr = &subop->instrs[op_id]; if (instr->delay_ns > 0) mini_ctrl_cmd |= GCMD_LAY_TWB; mini_ctrl_cmd |= FIELD_PREP(GCMD_LAY_INSTR, GCMD_LAY_INSTR_DATA); if (instr->type == NAND_OP_DATA_OUT_INSTR) mini_ctrl_cmd |= FIELD_PREP(GCMD_DIR, GCMD_DIR_WRITE); len = nand_subop_get_data_len(subop, op_id); offset = nand_subop_get_data_start_off(subop, op_id); mini_ctrl_cmd |= FIELD_PREP(GCMD_SECT_CNT, 1); mini_ctrl_cmd |= FIELD_PREP(GCMD_LAST_SIZE, len); if (instr->ctx.data.force_8bit) { ret = cadence_nand_force_byte_access(chip, true); if (ret) { dev_err(cdns_ctrl->dev, "cannot change byte access generic data cmd failed\n"); return ret; } } ret = cadence_nand_generic_cmd_send(cdns_ctrl, cdns_chip->cs[chip->cur_cs], mini_ctrl_cmd); if (ret) { dev_err(cdns_ctrl->dev, "send generic data cmd failed\n"); return ret; } if (instr->type == NAND_OP_DATA_IN_INSTR) { void *buf = instr->ctx.data.buf.in + offset; ret = cadence_nand_read_buf(cdns_ctrl, buf, len); } else { const void *buf = instr->ctx.data.buf.out + offset; ret = cadence_nand_write_buf(cdns_ctrl, buf, len); } if (ret) { dev_err(cdns_ctrl->dev, "data transfer failed for generic command\n"); return ret; } if (instr->ctx.data.force_8bit) { ret = cadence_nand_force_byte_access(chip, false); if (ret) { dev_err(cdns_ctrl->dev, "cannot change byte access generic data cmd failed\n"); } } return ret; } static int cadence_nand_cmd_waitrdy(struct nand_chip *chip, const struct nand_subop *subop) { int status; unsigned int op_id = 0; struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); struct cdns_nand_chip *cdns_chip = to_cdns_nand_chip(chip); const struct nand_op_instr *instr = &subop->instrs[op_id]; u32 timeout_us = instr->ctx.waitrdy.timeout_ms * 1000; status = cadence_nand_wait_for_value(cdns_ctrl, RBN_SETINGS, timeout_us, BIT(cdns_chip->cs[chip->cur_cs]), false); return status; } static const struct nand_op_parser cadence_nand_op_parser = NAND_OP_PARSER( NAND_OP_PARSER_PATTERN( cadence_nand_cmd_erase, NAND_OP_PARSER_PAT_CMD_ELEM(false), NAND_OP_PARSER_PAT_ADDR_ELEM(false, MAX_ERASE_ADDRESS_CYC), NAND_OP_PARSER_PAT_CMD_ELEM(false), NAND_OP_PARSER_PAT_WAITRDY_ELEM(false)), NAND_OP_PARSER_PATTERN( cadence_nand_cmd_opcode, NAND_OP_PARSER_PAT_CMD_ELEM(false)), NAND_OP_PARSER_PATTERN( cadence_nand_cmd_address, NAND_OP_PARSER_PAT_ADDR_ELEM(false, MAX_ADDRESS_CYC)), NAND_OP_PARSER_PATTERN( cadence_nand_cmd_data, NAND_OP_PARSER_PAT_DATA_IN_ELEM(false, MAX_DATA_SIZE)), NAND_OP_PARSER_PATTERN( cadence_nand_cmd_data, NAND_OP_PARSER_PAT_DATA_OUT_ELEM(false, MAX_DATA_SIZE)), NAND_OP_PARSER_PATTERN( cadence_nand_cmd_waitrdy, NAND_OP_PARSER_PAT_WAITRDY_ELEM(false)) ); static int cadence_nand_exec_op(struct nand_chip *chip, const struct nand_operation *op, bool check_only) { if (!check_only) { int status = cadence_nand_select_target(chip); if (status) return status; } return nand_op_parser_exec_op(chip, &cadence_nand_op_parser, op, check_only); } static int cadence_nand_ooblayout_free(struct mtd_info *mtd, int section, struct mtd_oob_region *oobregion) { struct nand_chip *chip = mtd_to_nand(mtd); struct cdns_nand_chip *cdns_chip = to_cdns_nand_chip(chip); if (section) return -ERANGE; oobregion->offset = cdns_chip->bbm_len; oobregion->length = cdns_chip->avail_oob_size - cdns_chip->bbm_len; return 0; } static int cadence_nand_ooblayout_ecc(struct mtd_info *mtd, int section, struct mtd_oob_region *oobregion) { struct nand_chip *chip = mtd_to_nand(mtd); struct cdns_nand_chip *cdns_chip = to_cdns_nand_chip(chip); if (section) return -ERANGE; oobregion->offset = cdns_chip->avail_oob_size; oobregion->length = chip->ecc.total; return 0; } static const struct mtd_ooblayout_ops cadence_nand_ooblayout_ops = { .free = cadence_nand_ooblayout_free, .ecc = cadence_nand_ooblayout_ecc, }; static int calc_cycl(u32 timing, u32 clock) { if (timing == 0 || clock == 0) return 0; if ((timing % clock) > 0) return timing / clock; else return timing / clock - 1; } /* Calculate max data valid window. */ static inline u32 calc_tdvw_max(u32 trp_cnt, u32 clk_period, u32 trhoh_min, u32 board_delay_skew_min, u32 ext_mode) { if (ext_mode == 0) clk_period /= 2; return (trp_cnt + 1) * clk_period + trhoh_min + board_delay_skew_min; } /* Calculate data valid window. */ static inline u32 calc_tdvw(u32 trp_cnt, u32 clk_period, u32 trhoh_min, u32 trea_max, u32 ext_mode) { if (ext_mode == 0) clk_period /= 2; return (trp_cnt + 1) * clk_period + trhoh_min - trea_max; } static int cadence_nand_setup_interface(struct nand_chip *chip, int chipnr, const struct nand_interface_config *conf) { const struct nand_sdr_timings *sdr; struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); struct cdns_nand_chip *cdns_chip = to_cdns_nand_chip(chip); struct cadence_nand_timings *t = &cdns_chip->timings; u32 reg; u32 board_delay = cdns_ctrl->board_delay; u32 clk_period = DIV_ROUND_DOWN_ULL(1000000000000ULL, cdns_ctrl->nf_clk_rate); u32 tceh_cnt, tcs_cnt, tadl_cnt, tccs_cnt; u32 tfeat_cnt, trhz_cnt, tvdly_cnt; u32 trhw_cnt, twb_cnt, twh_cnt = 0, twhr_cnt; u32 twp_cnt = 0, trp_cnt = 0, trh_cnt = 0; u32 if_skew = cdns_ctrl->caps1->if_skew; u32 board_delay_skew_min = board_delay - if_skew; u32 board_delay_skew_max = board_delay + if_skew; u32 dqs_sampl_res, phony_dqs_mod; u32 tdvw, tdvw_min, tdvw_max; u32 ext_rd_mode, ext_wr_mode; u32 dll_phy_dqs_timing = 0, phony_dqs_timing = 0, rd_del_sel = 0; u32 sampling_point; sdr = nand_get_sdr_timings(conf); if (IS_ERR(sdr)) return PTR_ERR(sdr); memset(t, 0, sizeof(*t)); /* Sampling point calculation. */ if (cdns_ctrl->caps2.is_phy_type_dll) phony_dqs_mod = 2; else phony_dqs_mod = 1; dqs_sampl_res = clk_period / phony_dqs_mod; tdvw_min = sdr->tREA_max + board_delay_skew_max; /* * The idea of those calculation is to get the optimum value * for tRP and tRH timings. If it is NOT possible to sample data * with optimal tRP/tRH settings, the parameters will be extended. * If clk_period is 50ns (the lowest value) this condition is met * for SDR timing modes 1, 2, 3, 4 and 5. * If clk_period is 20ns the condition is met only for SDR timing * mode 5. */ if (sdr->tRC_min <= clk_period && sdr->tRP_min <= (clk_period / 2) && sdr->tREH_min <= (clk_period / 2)) { /* Performance mode. */ ext_rd_mode = 0; tdvw = calc_tdvw(trp_cnt, clk_period, sdr->tRHOH_min, sdr->tREA_max, ext_rd_mode); tdvw_max = calc_tdvw_max(trp_cnt, clk_period, sdr->tRHOH_min, board_delay_skew_min, ext_rd_mode); /* * Check if data valid window and sampling point can be found * and is not on the edge (ie. we have hold margin). * If not extend the tRP timings. */ if (tdvw > 0) { if (tdvw_max <= tdvw_min || (tdvw_max % dqs_sampl_res) == 0) { /* * No valid sampling point so the RE pulse need * to be widen widening by half clock cycle. */ ext_rd_mode = 1; } } else { /* * There is no valid window * to be able to sample data the tRP need to be widen. * Very safe calculations are performed here. */ trp_cnt = (sdr->tREA_max + board_delay_skew_max + dqs_sampl_res) / clk_period; ext_rd_mode = 1; } } else { /* Extended read mode. */ u32 trh; ext_rd_mode = 1; trp_cnt = calc_cycl(sdr->tRP_min, clk_period); trh = sdr->tRC_min - ((trp_cnt + 1) * clk_period); if (sdr->tREH_min >= trh) trh_cnt = calc_cycl(sdr->tREH_min, clk_period); else trh_cnt = calc_cycl(trh, clk_period); tdvw = calc_tdvw(trp_cnt, clk_period, sdr->tRHOH_min, sdr->tREA_max, ext_rd_mode); /* * Check if data valid window and sampling point can be found * or if it is at the edge check if previous is valid * - if not extend the tRP timings. */ if (tdvw > 0) { tdvw_max = calc_tdvw_max(trp_cnt, clk_period, sdr->tRHOH_min, board_delay_skew_min, ext_rd_mode); if ((((tdvw_max / dqs_sampl_res) * dqs_sampl_res) <= tdvw_min) || (((tdvw_max % dqs_sampl_res) == 0) && (((tdvw_max / dqs_sampl_res - 1) * dqs_sampl_res) <= tdvw_min))) { /* * Data valid window width is lower than * sampling resolution and do not hit any * sampling point to be sure the sampling point * will be found the RE low pulse width will be * extended by one clock cycle. */ trp_cnt = trp_cnt + 1; } } else { /* * There is no valid window to be able to sample data. * The tRP need to be widen. * Very safe calculations are performed here. */ trp_cnt = (sdr->tREA_max + board_delay_skew_max + dqs_sampl_res) / clk_period; } } tdvw_max = calc_tdvw_max(trp_cnt, clk_period, sdr->tRHOH_min, board_delay_skew_min, ext_rd_mode); if (sdr->tWC_min <= clk_period && (sdr->tWP_min + if_skew) <= (clk_period / 2) && (sdr->tWH_min + if_skew) <= (clk_period / 2)) { ext_wr_mode = 0; } else { u32 twh; ext_wr_mode = 1; twp_cnt = calc_cycl(sdr->tWP_min + if_skew, clk_period); if ((twp_cnt + 1) * clk_period < (sdr->tALS_min + if_skew)) twp_cnt = calc_cycl(sdr->tALS_min + if_skew, clk_period); twh = (sdr->tWC_min - (twp_cnt + 1) * clk_period); if (sdr->tWH_min >= twh) twh = sdr->tWH_min; twh_cnt = calc_cycl(twh + if_skew, clk_period); } reg = FIELD_PREP(ASYNC_TOGGLE_TIMINGS_TRH, trh_cnt); reg |= FIELD_PREP(ASYNC_TOGGLE_TIMINGS_TRP, trp_cnt); reg |= FIELD_PREP(ASYNC_TOGGLE_TIMINGS_TWH, twh_cnt); reg |= FIELD_PREP(ASYNC_TOGGLE_TIMINGS_TWP, twp_cnt); t->async_toggle_timings = reg; dev_dbg(cdns_ctrl->dev, "ASYNC_TOGGLE_TIMINGS_SDR\t%x\n", reg); tadl_cnt = calc_cycl((sdr->tADL_min + if_skew), clk_period); tccs_cnt = calc_cycl((sdr->tCCS_min + if_skew), clk_period); twhr_cnt = calc_cycl((sdr->tWHR_min + if_skew), clk_period); trhw_cnt = calc_cycl((sdr->tRHW_min + if_skew), clk_period); reg = FIELD_PREP(TIMINGS0_TADL, tadl_cnt); /* * If timing exceeds delay field in timing register * then use maximum value. */ if (FIELD_FIT(TIMINGS0_TCCS, tccs_cnt)) reg |= FIELD_PREP(TIMINGS0_TCCS, tccs_cnt); else reg |= TIMINGS0_TCCS; reg |= FIELD_PREP(TIMINGS0_TWHR, twhr_cnt); reg |= FIELD_PREP(TIMINGS0_TRHW, trhw_cnt); t->timings0 = reg; dev_dbg(cdns_ctrl->dev, "TIMINGS0_SDR\t%x\n", reg); /* The following is related to single signal so skew is not needed. */ trhz_cnt = calc_cycl(sdr->tRHZ_max, clk_period); trhz_cnt = trhz_cnt + 1; twb_cnt = calc_cycl((sdr->tWB_max + board_delay), clk_period); /* * Because of the two stage syncflop the value must be increased by 3 * first value is related with sync, second value is related * with output if delay. */ twb_cnt = twb_cnt + 3 + 5; /* * The following is related to the we edge of the random data input * sequence so skew is not needed. */ tvdly_cnt = calc_cycl(500000 + if_skew, clk_period); reg = FIELD_PREP(TIMINGS1_TRHZ, trhz_cnt); reg |= FIELD_PREP(TIMINGS1_TWB, twb_cnt); reg |= FIELD_PREP(TIMINGS1_TVDLY, tvdly_cnt); t->timings1 = reg; dev_dbg(cdns_ctrl->dev, "TIMINGS1_SDR\t%x\n", reg); tfeat_cnt = calc_cycl(sdr->tFEAT_max, clk_period); if (tfeat_cnt < twb_cnt) tfeat_cnt = twb_cnt; tceh_cnt = calc_cycl(sdr->tCEH_min, clk_period); tcs_cnt = calc_cycl((sdr->tCS_min + if_skew), clk_period); reg = FIELD_PREP(TIMINGS2_TFEAT, tfeat_cnt); reg |= FIELD_PREP(TIMINGS2_CS_HOLD_TIME, tceh_cnt); reg |= FIELD_PREP(TIMINGS2_CS_SETUP_TIME, tcs_cnt); t->timings2 = reg; dev_dbg(cdns_ctrl->dev, "TIMINGS2_SDR\t%x\n", reg); if (cdns_ctrl->caps2.is_phy_type_dll) { reg = DLL_PHY_CTRL_DLL_RST_N; if (ext_wr_mode) reg |= DLL_PHY_CTRL_EXTENDED_WR_MODE; if (ext_rd_mode) reg |= DLL_PHY_CTRL_EXTENDED_RD_MODE; reg |= FIELD_PREP(DLL_PHY_CTRL_RS_HIGH_WAIT_CNT, 7); reg |= FIELD_PREP(DLL_PHY_CTRL_RS_IDLE_CNT, 7); t->dll_phy_ctrl = reg; dev_dbg(cdns_ctrl->dev, "DLL_PHY_CTRL_SDR\t%x\n", reg); } /* Sampling point calculation. */ if ((tdvw_max % dqs_sampl_res) > 0) sampling_point = tdvw_max / dqs_sampl_res; else sampling_point = (tdvw_max / dqs_sampl_res - 1); if (sampling_point * dqs_sampl_res > tdvw_min) { dll_phy_dqs_timing = FIELD_PREP(PHY_DQS_TIMING_DQS_SEL_OE_END, 4); dll_phy_dqs_timing |= PHY_DQS_TIMING_USE_PHONY_DQS; phony_dqs_timing = sampling_point / phony_dqs_mod; if ((sampling_point % 2) > 0) { dll_phy_dqs_timing |= PHY_DQS_TIMING_PHONY_DQS_SEL; if ((tdvw_max % dqs_sampl_res) == 0) /* * Calculation for sampling point at the edge * of data and being odd number. */ phony_dqs_timing = (tdvw_max / dqs_sampl_res) / phony_dqs_mod - 1; if (!cdns_ctrl->caps2.is_phy_type_dll) phony_dqs_timing--; } else { phony_dqs_timing--; } rd_del_sel = phony_dqs_timing + 3; } else { dev_warn(cdns_ctrl->dev, "ERROR : cannot find valid sampling point\n"); } reg = FIELD_PREP(PHY_CTRL_PHONY_DQS, phony_dqs_timing); if (cdns_ctrl->caps2.is_phy_type_dll) reg |= PHY_CTRL_SDR_DQS; t->phy_ctrl = reg; dev_dbg(cdns_ctrl->dev, "PHY_CTRL_REG_SDR\t%x\n", reg); if (cdns_ctrl->caps2.is_phy_type_dll) { dev_dbg(cdns_ctrl->dev, "PHY_TSEL_REG_SDR\t%x\n", 0); dev_dbg(cdns_ctrl->dev, "PHY_DQ_TIMING_REG_SDR\t%x\n", 2); dev_dbg(cdns_ctrl->dev, "PHY_DQS_TIMING_REG_SDR\t%x\n", dll_phy_dqs_timing); t->phy_dqs_timing = dll_phy_dqs_timing; reg = FIELD_PREP(PHY_GATE_LPBK_CTRL_RDS, rd_del_sel); dev_dbg(cdns_ctrl->dev, "PHY_GATE_LPBK_CTRL_REG_SDR\t%x\n", reg); t->phy_gate_lpbk_ctrl = reg; dev_dbg(cdns_ctrl->dev, "PHY_DLL_MASTER_CTRL_REG_SDR\t%lx\n", PHY_DLL_MASTER_CTRL_BYPASS_MODE); dev_dbg(cdns_ctrl->dev, "PHY_DLL_SLAVE_CTRL_REG_SDR\t%x\n", 0); } return 0; } static int cadence_nand_attach_chip(struct nand_chip *chip) { struct cdns_nand_ctrl *cdns_ctrl = to_cdns_nand_ctrl(chip->controller); struct cdns_nand_chip *cdns_chip = to_cdns_nand_chip(chip); u32 ecc_size; struct mtd_info *mtd = nand_to_mtd(chip); int ret; if (chip->options & NAND_BUSWIDTH_16) { ret = cadence_nand_set_access_width16(cdns_ctrl, true); if (ret) return ret; } chip->bbt_options |= NAND_BBT_USE_FLASH; chip->bbt_options |= NAND_BBT_NO_OOB; chip->ecc.engine_type = NAND_ECC_ENGINE_TYPE_ON_HOST; chip->options |= NAND_NO_SUBPAGE_WRITE; cdns_chip->bbm_offs = chip->badblockpos; cdns_chip->bbm_offs &= ~0x01; /* this value should be even number */ cdns_chip->bbm_len = 2; ret = nand_ecc_choose_conf(chip, &cdns_ctrl->ecc_caps, mtd->oobsize - cdns_chip->bbm_len); if (ret) { dev_err(cdns_ctrl->dev, "ECC configuration failed\n"); return ret; } dev_dbg(cdns_ctrl->dev, "chosen ECC settings: step=%d, strength=%d, bytes=%d\n", chip->ecc.size, chip->ecc.strength, chip->ecc.bytes); /* Error correction configuration. */ cdns_chip->sector_size = chip->ecc.size; cdns_chip->sector_count = mtd->writesize / cdns_chip->sector_size; ecc_size = cdns_chip->sector_count * chip->ecc.bytes; cdns_chip->avail_oob_size = mtd->oobsize - ecc_size; if (cdns_chip->avail_oob_size > cdns_ctrl->bch_metadata_size) cdns_chip->avail_oob_size = cdns_ctrl->bch_metadata_size; if ((cdns_chip->avail_oob_size + cdns_chip->bbm_len + ecc_size) > mtd->oobsize) cdns_chip->avail_oob_size -= 4; ret = cadence_nand_get_ecc_strength_idx(cdns_ctrl, chip->ecc.strength); if (ret < 0) return -EINVAL; cdns_chip->corr_str_idx = (u8)ret; if (cadence_nand_wait_for_value(cdns_ctrl, CTRL_STATUS, 1000000, CTRL_STATUS_CTRL_BUSY, true)) return -ETIMEDOUT; cadence_nand_set_ecc_strength(cdns_ctrl, cdns_chip->corr_str_idx); cadence_nand_set_erase_detection(cdns_ctrl, true, chip->ecc.strength); /* Override the default read operations. */ chip->ecc.read_page = cadence_nand_read_page; chip->ecc.read_page_raw = cadence_nand_read_page_raw; chip->ecc.write_page = cadence_nand_write_page; chip->ecc.write_page_raw = cadence_nand_write_page_raw; chip->ecc.read_oob = cadence_nand_read_oob; chip->ecc.write_oob = cadence_nand_write_oob; chip->ecc.read_oob_raw = cadence_nand_read_oob_raw; chip->ecc.write_oob_raw = cadence_nand_write_oob_raw; if ((mtd->writesize + mtd->oobsize) > cdns_ctrl->buf_size) cdns_ctrl->buf_size = mtd->writesize + mtd->oobsize; /* Is 32-bit DMA supported? */ ret = dma_set_mask(cdns_ctrl->dev, DMA_BIT_MASK(32)); if (ret) { dev_err(cdns_ctrl->dev, "no usable DMA configuration\n"); return ret; } mtd_set_ooblayout(mtd, &cadence_nand_ooblayout_ops); return 0; } static const struct nand_controller_ops cadence_nand_controller_ops = { .attach_chip = cadence_nand_attach_chip, .exec_op = cadence_nand_exec_op, .setup_interface = cadence_nand_setup_interface, }; static int cadence_nand_chip_init(struct cdns_nand_ctrl *cdns_ctrl, struct device_node *np) { struct cdns_nand_chip *cdns_chip; struct mtd_info *mtd; struct nand_chip *chip; int nsels, ret, i; u32 cs; nsels = of_property_count_elems_of_size(np, "reg", sizeof(u32)); if (nsels <= 0) { dev_err(cdns_ctrl->dev, "missing/invalid reg property\n"); return -EINVAL; } /* Allocate the nand chip structure. */ cdns_chip = devm_kzalloc(cdns_ctrl->dev, sizeof(*cdns_chip) + (nsels * sizeof(u8)), GFP_KERNEL); if (!cdns_chip) { dev_err(cdns_ctrl->dev, "could not allocate chip structure\n"); return -ENOMEM; } cdns_chip->nsels = nsels; for (i = 0; i < nsels; i++) { /* Retrieve CS id. */ ret = of_property_read_u32_index(np, "reg", i, &cs); if (ret) { dev_err(cdns_ctrl->dev, "could not retrieve reg property: %d\n", ret); return ret; } if (cs >= cdns_ctrl->caps2.max_banks) { dev_err(cdns_ctrl->dev, "invalid reg value: %u (max CS = %d)\n", cs, cdns_ctrl->caps2.max_banks); return -EINVAL; } if (test_and_set_bit(cs, &cdns_ctrl->assigned_cs)) { dev_err(cdns_ctrl->dev, "CS %d already assigned\n", cs); return -EINVAL; } cdns_chip->cs[i] = cs; } chip = &cdns_chip->chip; chip->controller = &cdns_ctrl->controller; nand_set_flash_node(chip, np); mtd = nand_to_mtd(chip); mtd->dev.parent = cdns_ctrl->dev; /* * Default to HW ECC engine mode. If the nand-ecc-mode property is given * in the DT node, this entry will be overwritten in nand_scan_ident(). */ chip->ecc.engine_type = NAND_ECC_ENGINE_TYPE_ON_HOST; ret = nand_scan(chip, cdns_chip->nsels); if (ret) { dev_err(cdns_ctrl->dev, "could not scan the nand chip\n"); return ret; } ret = mtd_device_register(mtd, NULL, 0); if (ret) { dev_err(cdns_ctrl->dev, "failed to register mtd device: %d\n", ret); nand_cleanup(chip); return ret; } list_add_tail(&cdns_chip->node, &cdns_ctrl->chips); return 0; } static void cadence_nand_chips_cleanup(struct cdns_nand_ctrl *cdns_ctrl) { struct cdns_nand_chip *entry, *temp; struct nand_chip *chip; int ret; list_for_each_entry_safe(entry, temp, &cdns_ctrl->chips, node) { chip = &entry->chip; ret = mtd_device_unregister(nand_to_mtd(chip)); WARN_ON(ret); nand_cleanup(chip); list_del(&entry->node); } } static int cadence_nand_chips_init(struct cdns_nand_ctrl *cdns_ctrl) { struct device_node *np = cdns_ctrl->dev->of_node; struct device_node *nand_np; int max_cs = cdns_ctrl->caps2.max_banks; int nchips, ret; nchips = of_get_child_count(np); if (nchips > max_cs) { dev_err(cdns_ctrl->dev, "too many NAND chips: %d (max = %d CS)\n", nchips, max_cs); return -EINVAL; } for_each_child_of_node(np, nand_np) { ret = cadence_nand_chip_init(cdns_ctrl, nand_np); if (ret) { of_node_put(nand_np); cadence_nand_chips_cleanup(cdns_ctrl); return ret; } } return 0; } static void cadence_nand_irq_cleanup(int irqnum, struct cdns_nand_ctrl *cdns_ctrl) { /* Disable interrupts. */ writel_relaxed(INTR_ENABLE_INTR_EN, cdns_ctrl->reg + INTR_ENABLE); } static int cadence_nand_init(struct cdns_nand_ctrl *cdns_ctrl) { dma_cap_mask_t mask; int ret; cdns_ctrl->cdma_desc = dma_alloc_coherent(cdns_ctrl->dev, sizeof(*cdns_ctrl->cdma_desc), &cdns_ctrl->dma_cdma_desc, GFP_KERNEL); if (!cdns_ctrl->dma_cdma_desc) return -ENOMEM; cdns_ctrl->buf_size = SZ_16K; cdns_ctrl->buf = kmalloc(cdns_ctrl->buf_size, GFP_KERNEL); if (!cdns_ctrl->buf) { ret = -ENOMEM; goto free_buf_desc; } if (devm_request_irq(cdns_ctrl->dev, cdns_ctrl->irq, cadence_nand_isr, IRQF_SHARED, "cadence-nand-controller", cdns_ctrl)) { dev_err(cdns_ctrl->dev, "Unable to allocate IRQ\n"); ret = -ENODEV; goto free_buf; } spin_lock_init(&cdns_ctrl->irq_lock); init_completion(&cdns_ctrl->complete); ret = cadence_nand_hw_init(cdns_ctrl); if (ret) goto disable_irq; dma_cap_zero(mask); dma_cap_set(DMA_MEMCPY, mask); if (cdns_ctrl->caps1->has_dma) { cdns_ctrl->dmac = dma_request_channel(mask, NULL, NULL); if (!cdns_ctrl->dmac) { dev_err(cdns_ctrl->dev, "Unable to get a DMA channel\n"); ret = -EBUSY; goto disable_irq; } } nand_controller_init(&cdns_ctrl->controller); INIT_LIST_HEAD(&cdns_ctrl->chips); cdns_ctrl->controller.ops = &cadence_nand_controller_ops; cdns_ctrl->curr_corr_str_idx = 0xFF; ret = cadence_nand_chips_init(cdns_ctrl); if (ret) { dev_err(cdns_ctrl->dev, "Failed to register MTD: %d\n", ret); goto dma_release_chnl; } kfree(cdns_ctrl->buf); cdns_ctrl->buf = kzalloc(cdns_ctrl->buf_size, GFP_KERNEL); if (!cdns_ctrl->buf) { ret = -ENOMEM; goto dma_release_chnl; } return 0; dma_release_chnl: if (cdns_ctrl->dmac) dma_release_channel(cdns_ctrl->dmac); disable_irq: cadence_nand_irq_cleanup(cdns_ctrl->irq, cdns_ctrl); free_buf: kfree(cdns_ctrl->buf); free_buf_desc: dma_free_coherent(cdns_ctrl->dev, sizeof(struct cadence_nand_cdma_desc), cdns_ctrl->cdma_desc, cdns_ctrl->dma_cdma_desc); return ret; } /* Driver exit point. */ static void cadence_nand_remove(struct cdns_nand_ctrl *cdns_ctrl) { cadence_nand_chips_cleanup(cdns_ctrl); cadence_nand_irq_cleanup(cdns_ctrl->irq, cdns_ctrl); kfree(cdns_ctrl->buf); dma_free_coherent(cdns_ctrl->dev, sizeof(struct cadence_nand_cdma_desc), cdns_ctrl->cdma_desc, cdns_ctrl->dma_cdma_desc); if (cdns_ctrl->dmac) dma_release_channel(cdns_ctrl->dmac); } struct cadence_nand_dt { struct cdns_nand_ctrl cdns_ctrl; struct clk *clk; }; static const struct cadence_nand_dt_devdata cadence_nand_default = { .if_skew = 0, .has_dma = 1, }; static const struct of_device_id cadence_nand_dt_ids[] = { { .compatible = "cdns,hp-nfc", .data = &cadence_nand_default }, {} }; MODULE_DEVICE_TABLE(of, cadence_nand_dt_ids); static int cadence_nand_dt_probe(struct platform_device *ofdev) { struct resource *res; struct cadence_nand_dt *dt; struct cdns_nand_ctrl *cdns_ctrl; int ret; const struct cadence_nand_dt_devdata *devdata; u32 val; devdata = device_get_match_data(&ofdev->dev); if (!devdata) { pr_err("Failed to find the right device id.\n"); return -ENOMEM; } dt = devm_kzalloc(&ofdev->dev, sizeof(*dt), GFP_KERNEL); if (!dt) return -ENOMEM; cdns_ctrl = &dt->cdns_ctrl; cdns_ctrl->caps1 = devdata; cdns_ctrl->dev = &ofdev->dev; cdns_ctrl->irq = platform_get_irq(ofdev, 0); if (cdns_ctrl->irq < 0) return cdns_ctrl->irq; dev_info(cdns_ctrl->dev, "IRQ: nr %d\n", cdns_ctrl->irq); cdns_ctrl->reg = devm_platform_ioremap_resource(ofdev, 0); if (IS_ERR(cdns_ctrl->reg)) return PTR_ERR(cdns_ctrl->reg); cdns_ctrl->io.virt = devm_platform_get_and_ioremap_resource(ofdev, 1, &res); if (IS_ERR(cdns_ctrl->io.virt)) return PTR_ERR(cdns_ctrl->io.virt); cdns_ctrl->io.dma = res->start; dt->clk = devm_clk_get(cdns_ctrl->dev, "nf_clk"); if (IS_ERR(dt->clk)) return PTR_ERR(dt->clk); cdns_ctrl->nf_clk_rate = clk_get_rate(dt->clk); ret = of_property_read_u32(ofdev->dev.of_node, "cdns,board-delay-ps", &val); if (ret) { val = 4830; dev_info(cdns_ctrl->dev, "missing cdns,board-delay-ps property, %d was set\n", val); } cdns_ctrl->board_delay = val; ret = cadence_nand_init(cdns_ctrl); if (ret) return ret; platform_set_drvdata(ofdev, dt); return 0; } static void cadence_nand_dt_remove(struct platform_device *ofdev) { struct cadence_nand_dt *dt = platform_get_drvdata(ofdev); cadence_nand_remove(&dt->cdns_ctrl); } static struct platform_driver cadence_nand_dt_driver = { .probe = cadence_nand_dt_probe, .remove_new = cadence_nand_dt_remove, .driver = { .name = "cadence-nand-controller", .of_match_table = cadence_nand_dt_ids, }, }; module_platform_driver(cadence_nand_dt_driver); MODULE_AUTHOR("Piotr Sroka <piotrs@cadence.com>"); MODULE_LICENSE("GPL v2"); MODULE_DESCRIPTION("Driver for Cadence NAND flash controller");
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1