| /**************************************************************************** |
| * drivers/misc/rwbuffer.c |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. The |
| * ASF licenses this file to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance with the |
| * License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations |
| * under the License. |
| * |
| ****************************************************************************/ |
| |
| /**************************************************************************** |
| * Included Files |
| ****************************************************************************/ |
| |
| #include <nuttx/config.h> |
| |
| #include <sys/types.h> |
| #include <inttypes.h> |
| #include <stdint.h> |
| #include <stdbool.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <time.h> |
| #include <assert.h> |
| #include <errno.h> |
| #include <debug.h> |
| |
| #include <nuttx/kmalloc.h> |
| #include <nuttx/semaphore.h> |
| #include <nuttx/wqueue.h> |
| #include <nuttx/drivers/rwbuffer.h> |
| |
| #if defined(CONFIG_DRVR_WRITEBUFFER) || defined(CONFIG_DRVR_READAHEAD) |
| |
| /**************************************************************************** |
| * Pre-processor Definitions |
| ****************************************************************************/ |
| |
| /* Configuration ************************************************************/ |
| |
| #ifndef CONFIG_DRVR_WRDELAY |
| # define CONFIG_DRVR_WRDELAY 350 |
| #endif |
| |
| #if !defined(CONFIG_SCHED_WORKQUEUE) && CONFIG_DRVR_WRDELAY != 0 |
| # error "Worker thread support is required (CONFIG_SCHED_WORKQUEUE)" |
| #endif |
| |
| /**************************************************************************** |
| * Private Function Prototypes |
| ****************************************************************************/ |
| |
| static ssize_t rwb_read_(FAR struct rwbuffer_s *rwb, off_t startblock, |
| size_t nblocks, FAR uint8_t *rdbuffer); |
| |
| /**************************************************************************** |
| * Private Functions |
| ****************************************************************************/ |
| |
| /**************************************************************************** |
| * Name: rwb_lock |
| ****************************************************************************/ |
| |
| #if defined(CONFIG_DRVR_WRITEBUFFER) |
| # define rwb_lock(l) nxmutex_lock(l) |
| #else |
| # define rwb_lock(l) OK |
| #endif |
| |
| /**************************************************************************** |
| * Name: rwb_unlock |
| ****************************************************************************/ |
| |
| #if defined(CONFIG_DRVR_WRITEBUFFER) |
| # define rwb_unlock(l) nxmutex_unlock(l) |
| #else |
| # define rwb_unlock(l) |
| #endif |
| |
| /**************************************************************************** |
| * Name: rwb_overlap |
| ****************************************************************************/ |
| |
| static inline bool rwb_overlap(off_t blockstart1, size_t nblocks1, |
| off_t blockstart2, size_t nblocks2) |
| { |
| off_t blockend1 = blockstart1 + nblocks1 - 1; |
| off_t blockend2 = blockstart2 + nblocks2 - 1; |
| |
| /* If the buffer 1 is wholly outside of buffer 2, return false */ |
| |
| if ((blockend1 < blockstart2) || /* Wholly "below" */ |
| (blockstart1 > blockend2)) /* Wholly "above" */ |
| { |
| return false; |
| } |
| else |
| { |
| return true; |
| } |
| } |
| |
| /**************************************************************************** |
| * Name: rwb_resetwrbuffer |
| ****************************************************************************/ |
| |
| #ifdef CONFIG_DRVR_WRITEBUFFER |
| static inline void rwb_resetwrbuffer(FAR struct rwbuffer_s *rwb) |
| { |
| /* We assume that the caller holds the wrlock */ |
| |
| rwb->wrnblocks = 0; |
| rwb->wrblockstart = -1; |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: rwb_wrflush |
| * |
| * Assumptions: |
| * The caller holds the wrlock mutex. |
| * |
| ****************************************************************************/ |
| |
| #ifdef CONFIG_DRVR_WRITEBUFFER |
| static void rwb_wrflush(FAR struct rwbuffer_s *rwb) |
| { |
| int ret; |
| |
| if (rwb->wrnblocks > 0) |
| { |
| size_t padblocks; |
| |
| DEBUGASSERT(rwb->wrblockstart % rwb->wralignblocks == 0); |
| |
| finfo("Flushing: blockstart=0x%08lx nblocks=%d from buffer=%p\n", |
| (long)rwb->wrblockstart, rwb->wrnblocks, rwb->wrbuffer); |
| |
| padblocks = rwb->wrnblocks % rwb->wralignblocks; |
| if (padblocks) |
| { |
| padblocks = rwb->wralignblocks - padblocks; |
| rwb_read_(rwb, rwb->wrblockstart + rwb->wrnblocks, padblocks, |
| &rwb->wrbuffer[rwb->wrnblocks * rwb->blocksize]); |
| rwb->wrnblocks += padblocks; |
| } |
| |
| /* Flush cache. On success, the flush method will return the number |
| * of blocks written. Anything other than the number requested is |
| * an error. |
| */ |
| |
| ret = rwb->wrflush(rwb->dev, rwb->wrbuffer, rwb->wrblockstart, |
| rwb->wrnblocks); |
| if (ret != rwb->wrnblocks) |
| { |
| ferr("ERROR: Error flushing write buffer: %d\n", ret); |
| } |
| |
| rwb_resetwrbuffer(rwb); |
| } |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: rwb_wrtimeout |
| ****************************************************************************/ |
| |
| #if defined(CONFIG_DRVR_WRITEBUFFER) && CONFIG_DRVR_WRDELAY != 0 |
| static void rwb_wrtimeout(FAR void *arg) |
| { |
| /* The following assumes that the size of a pointer is 4-bytes or less */ |
| |
| FAR struct rwbuffer_s *rwb = (FAR struct rwbuffer_s *)arg; |
| DEBUGASSERT(rwb != NULL); |
| |
| finfo("Timeout!\n"); |
| |
| /* If a timeout elapses with write buffer activity, this watchdog |
| * handler function will be evoked on the thread of execution of the |
| * worker thread. |
| */ |
| |
| rwb_lock(&rwb->wrlock); |
| rwb_wrflush(rwb); |
| rwb_unlock(&rwb->wrlock); |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: rwb_wrstarttimeout |
| ****************************************************************************/ |
| |
| #ifdef CONFIG_DRVR_WRITEBUFFER |
| static void rwb_wrstarttimeout(FAR struct rwbuffer_s *rwb) |
| { |
| #if CONFIG_DRVR_WRDELAY != 0 |
| /* CONFIG_DRVR_WRDELAY provides the delay period in milliseconds. CLK_TCK |
| * provides the clock tick of the system (frequency in Hz). |
| */ |
| |
| int ticks = MSEC2TICK(CONFIG_DRVR_WRDELAY); |
| work_queue(LPWORK, &rwb->work, rwb_wrtimeout, rwb, ticks); |
| #endif |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: rwb_wrcanceltimeout |
| ****************************************************************************/ |
| |
| #ifdef CONFIG_DRVR_WRITEBUFFER |
| static inline void rwb_wrcanceltimeout(FAR struct rwbuffer_s *rwb) |
| { |
| #if CONFIG_DRVR_WRDELAY != 0 |
| work_cancel(LPWORK, &rwb->work); |
| #endif |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: rwb_writebuffer |
| ****************************************************************************/ |
| |
| #ifdef CONFIG_DRVR_WRITEBUFFER |
| static ssize_t rwb_writebuffer(FAR struct rwbuffer_s *rwb, |
| off_t startblock, uint32_t nblocks, |
| FAR const uint8_t *wrbuffer) |
| { |
| uint32_t nwritten = nblocks; |
| |
| /* Write writebuffer Logic */ |
| |
| rwb_wrcanceltimeout(rwb); |
| |
| /* Is data saved in the write buffer? */ |
| |
| if (rwb->wrnblocks > 0) |
| { |
| off_t wrbend; |
| off_t newend; |
| |
| /* Now there are five cases: |
| * |
| * 1. We update the non-overlapping region |
| */ |
| |
| wrbend = rwb->wrblockstart + rwb->wrnblocks; |
| newend = startblock + nblocks; |
| |
| if (wrbend < startblock || rwb->wrblockstart > newend) |
| { |
| /* Nothing to do */; |
| } |
| |
| /* 2. We update the entire write buffer. */ |
| |
| else if (rwb->wrblockstart > startblock && wrbend < newend) |
| { |
| rwb->wrnblocks = 0; |
| } |
| |
| /* We are going to update a subset of the write buffer. Three |
| * more cases to consider: |
| * |
| * 3. We update a portion in the middle of the write buffer |
| */ |
| |
| else if (rwb->wrblockstart <= startblock && wrbend >= newend) |
| { |
| FAR uint8_t *dest; |
| size_t offset; |
| |
| /* Copy the data to the middle of write buffer */ |
| |
| offset = startblock - rwb->wrblockstart; |
| dest = rwb->wrbuffer + offset * rwb->blocksize; |
| memcpy(dest, wrbuffer, nblocks * rwb->blocksize); |
| |
| nblocks = 0; |
| } |
| |
| /* 4. We update a portion at the end of the write buffer */ |
| |
| else if (wrbend >= startblock && wrbend <= newend) |
| { |
| FAR uint8_t *dest; |
| size_t offset; |
| size_t ncopy; |
| |
| /* Copy the data from the updating region to the end |
| * of the write buffer. |
| */ |
| |
| offset = rwb->wrnblocks - (wrbend - startblock); |
| ncopy = rwb->wrmaxblocks - offset; |
| if (ncopy > nblocks) |
| { |
| ncopy = nblocks; |
| } |
| |
| dest = rwb->wrbuffer + offset * rwb->blocksize; |
| memcpy(dest, wrbuffer, ncopy * rwb->blocksize); |
| |
| rwb->wrnblocks = offset + ncopy; |
| wrbuffer += ncopy * rwb->blocksize; |
| startblock += ncopy; |
| nblocks -= ncopy; |
| } |
| |
| /* 5. We update a portion at the beginning of the write buffer. |
| * For writes that are ahead of the writerbuffer, we first flush and |
| * then process the write in the new writebuffer to ensure that each |
| * wrblockstart is aligned according to wralignblocks. |
| */ |
| } |
| |
| /* Use the block cache unless the buffer size is bigger than block cache */ |
| |
| if (nblocks > rwb->wrmaxblocks) |
| { |
| ssize_t ret = rwb->wrflush(rwb->dev, wrbuffer, startblock, nblocks); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| nblocks = 0; |
| } |
| |
| while (nblocks > 0) |
| { |
| size_t padblocks; |
| size_t remain = nblocks; |
| |
| /* Flush the write buffer */ |
| |
| rwb_wrflush(rwb); |
| |
| /* Get the alignment padding of startblock, and read the contents |
| * of the padding area, ensure that wrblockstart is aligned |
| * according to wralignblocks. |
| */ |
| |
| padblocks = startblock % rwb->wralignblocks; |
| rwb->wrblockstart = startblock - padblocks; |
| rwb->wrnblocks = padblocks; |
| rwb_read_(rwb, rwb->wrblockstart, padblocks, rwb->wrbuffer); |
| |
| if (remain > rwb->wrmaxblocks - padblocks) |
| { |
| remain = rwb->wrmaxblocks - padblocks; |
| } |
| |
| /* Buffer the data in the write buffer */ |
| |
| memcpy(rwb->wrbuffer + padblocks * rwb->blocksize, wrbuffer, |
| remain * rwb->blocksize); |
| rwb->wrnblocks += remain; |
| |
| /* Update remain state of write buffer */ |
| |
| nblocks -= remain; |
| startblock += remain; |
| wrbuffer += remain * rwb->blocksize; |
| } |
| |
| if (rwb->wrnblocks > 0) |
| { |
| rwb_wrstarttimeout(rwb); |
| } |
| |
| return nwritten; |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: rwb_resetrhbuffer |
| ****************************************************************************/ |
| |
| #ifdef CONFIG_DRVR_READAHEAD |
| static inline void rwb_resetrhbuffer(FAR struct rwbuffer_s *rwb) |
| { |
| /* We assume that the caller holds the readAheadBufferSemaphore */ |
| |
| rwb->rhnblocks = 0; |
| rwb->rhblockstart = -1; |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: rwb_bufferread |
| ****************************************************************************/ |
| |
| #ifdef CONFIG_DRVR_READAHEAD |
| static inline void |
| rwb_bufferread(FAR struct rwbuffer_s *rwb, off_t startblock, |
| size_t nblocks, FAR uint8_t **rdbuffer) |
| { |
| FAR uint8_t *rhbuffer; |
| |
| /* We assume that: |
| * (1) the caller holds the readAheadBufferSemaphore, and |
| * (2) the caller already knows that all of the blocks are in the |
| * read-ahead buffer. |
| */ |
| |
| /* Convert the units from blocks to bytes */ |
| |
| off_t blockoffset = startblock - rwb->rhblockstart; |
| off_t byteoffset = rwb->blocksize * blockoffset; |
| size_t nbytes = rwb->blocksize * nblocks; |
| |
| /* Get the byte address in the read-ahead buffer */ |
| |
| rhbuffer = rwb->rhbuffer + byteoffset; |
| |
| /* Copy the data from the read-ahead buffer into the IO buffer */ |
| |
| memcpy(*rdbuffer, rhbuffer, nbytes); |
| |
| /* Update the caller's copy for the next address */ |
| |
| *rdbuffer += nbytes; |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: rwb_rhreload |
| ****************************************************************************/ |
| |
| #ifdef CONFIG_DRVR_READAHEAD |
| static int rwb_rhreload(FAR struct rwbuffer_s *rwb, off_t startblock) |
| { |
| off_t endblock; |
| size_t nblocks; |
| int ret; |
| |
| /* Check for attempts to read beyond the end of the media */ |
| |
| if (startblock >= rwb->nblocks) |
| { |
| return -ESPIPE; |
| } |
| |
| /* Get the block number +1 of the last block that will fit in the |
| * read-ahead buffer |
| */ |
| |
| endblock = startblock + rwb->rhmaxblocks; |
| |
| /* Make sure that we don't read past the end of the device */ |
| |
| if (endblock > rwb->nblocks) |
| { |
| endblock = rwb->nblocks; |
| } |
| |
| nblocks = endblock - startblock; |
| |
| /* Reset the read buffer */ |
| |
| rwb_resetrhbuffer(rwb); |
| |
| /* Now perform the read */ |
| |
| ret = rwb->rhreload(rwb->dev, rwb->rhbuffer, startblock, nblocks); |
| if (ret == nblocks) |
| { |
| /* Update information about what is in the read-ahead buffer */ |
| |
| rwb->rhnblocks = nblocks; |
| rwb->rhblockstart = startblock; |
| |
| /* The return value is not the number of blocks we asked to be |
| * loaded. |
| */ |
| |
| return nblocks; |
| } |
| |
| return -EIO; |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: rwb_invalidate_writebuffer |
| * |
| * Description: |
| * Invalidate a region of the write buffer |
| * |
| ****************************************************************************/ |
| |
| #if defined(CONFIG_DRVR_WRITEBUFFER) && defined(CONFIG_DRVR_INVALIDATE) |
| int rwb_invalidate_writebuffer(FAR struct rwbuffer_s *rwb, |
| off_t startblock, size_t blockcount) |
| { |
| int ret = OK; |
| |
| /* Is there a write buffer? Is data saved in the write buffer? */ |
| |
| if (rwb->wrmaxblocks > 0 && rwb->wrnblocks > 0) |
| { |
| off_t wrbend; |
| off_t invend; |
| |
| finfo("startblock=%" PRIdOFF " blockcount=%zu\n", |
| startblock, blockcount); |
| |
| ret = rwb_lock(&rwb->wrlock); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| /* Now there are five cases: |
| * |
| * 1. We invalidate nothing |
| */ |
| |
| wrbend = rwb->wrblockstart + rwb->wrnblocks; |
| invend = startblock + blockcount; |
| |
| if (wrbend <= startblock || rwb->wrblockstart >= invend) |
| { |
| ret = OK; |
| } |
| |
| /* 2. We invalidate the entire write buffer. */ |
| |
| else if (rwb->wrblockstart >= startblock && wrbend <= invend) |
| { |
| rwb->wrnblocks = 0; |
| ret = OK; |
| } |
| |
| /* We are going to invalidate a subset of the write buffer. Three |
| * more cases to consider: |
| * |
| * 3. We invalidate a portion in the middle of the write buffer |
| */ |
| |
| else if (rwb->wrblockstart < startblock && wrbend > invend) |
| { |
| FAR uint8_t *src; |
| off_t block; |
| off_t offset; |
| size_t nblocks; |
| |
| /* Write the blocks at the end of the media to hardware */ |
| |
| nblocks = wrbend - invend; |
| block = invend; |
| offset = block - rwb->wrblockstart; |
| src = rwb->wrbuffer + offset * rwb->blocksize; |
| |
| ret = rwb->wrflush(rwb->dev, src, block, nblocks); |
| if (ret < 0) |
| { |
| ferr("ERROR: wrflush failed: %d\n", ret); |
| } |
| |
| /* Keep the blocks at the beginning of the buffer up the |
| * start of the invalidated region. |
| */ |
| |
| else |
| { |
| rwb->wrnblocks = startblock - rwb->wrblockstart; |
| ret = OK; |
| } |
| } |
| |
| /* 4. We invalidate a portion at the end of the write buffer */ |
| |
| else if (wrbend > startblock && wrbend <= invend) |
| { |
| rwb->wrnblocks -= wrbend - startblock; |
| ret = OK; |
| } |
| |
| /* 5. We invalidate a portion at the beginning of the write buffer */ |
| |
| else /* if (rwb->wrblockstart >= startblock && wrbend > invend) */ |
| { |
| FAR uint8_t *src; |
| size_t ninval; |
| size_t nkeep; |
| |
| DEBUGASSERT(rwb->wrblockstart >= startblock && wrbend > invend); |
| |
| /* Copy the data from the uninvalidated region to the beginning |
| * of the write buffer. |
| * |
| * First calculate the source and destination of the transfer. |
| */ |
| |
| ninval = invend - rwb->wrblockstart; |
| src = rwb->wrbuffer + ninval * rwb->blocksize; |
| |
| /* Calculate the number of blocks we are keeping. We keep |
| * the ones that we don't invalidate. |
| */ |
| |
| nkeep = rwb->wrnblocks - ninval; |
| |
| /* Then move the data that we are keeping to the beginning |
| * the write buffer. |
| */ |
| |
| memcpy(rwb->wrbuffer, src, nkeep * rwb->blocksize); |
| |
| /* Update the block info. The first block is now the one just |
| * after the invalidation region and the number buffered blocks |
| * is the number that we kept. |
| */ |
| |
| rwb->wrblockstart = invend; |
| rwb->wrnblocks = nkeep; |
| ret = OK; |
| } |
| |
| rwb_unlock(&rwb->wrlock); |
| } |
| |
| return ret; |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: rwb_invalidate_readahead |
| * |
| * Description: |
| * Invalidate a region of the read-ahead buffer |
| * |
| ****************************************************************************/ |
| |
| #if defined(CONFIG_DRVR_READAHEAD) && defined(CONFIG_DRVR_INVALIDATE) |
| int rwb_invalidate_readahead(FAR struct rwbuffer_s *rwb, |
| off_t startblock, size_t blockcount) |
| { |
| int ret = OK; |
| |
| if (rwb->rhmaxblocks > 0 && rwb->rhnblocks > 0) |
| { |
| off_t rhbend; |
| off_t invend; |
| |
| finfo("startblock=%" PRIdOFF " blockcount=%zu\n", |
| startblock, blockcount); |
| |
| ret = rwb_lock(&rwb->rhlock); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| /* Now there are five cases: |
| * |
| * 1. We invalidate nothing |
| */ |
| |
| rhbend = rwb->rhblockstart + rwb->rhnblocks; |
| invend = startblock + blockcount; |
| |
| if (rhbend <= startblock || rwb->rhblockstart >= invend) |
| { |
| ret = OK; |
| } |
| |
| /* 2. We invalidate the entire read-ahead buffer. */ |
| |
| else if (rwb->rhblockstart >= startblock && rhbend <= invend) |
| { |
| rwb->rhnblocks = 0; |
| ret = OK; |
| } |
| |
| /* We are going to invalidate a subset of the read-ahead buffer. |
| * Three more cases to consider: |
| * |
| * 2. We invalidate a portion in the middle of the read-ahead buffer |
| */ |
| |
| else if (rwb->rhblockstart < startblock && rhbend > invend) |
| { |
| /* Keep the blocks at the beginning of the buffer up the |
| * start of the invalidated region. |
| */ |
| |
| rwb->rhnblocks = startblock - rwb->rhblockstart; |
| ret = OK; |
| } |
| |
| /* 3. We invalidate a portion at the end of the read-ahead buffer */ |
| |
| else if (rhbend > startblock && rhbend <= invend) |
| { |
| rwb->rhnblocks -= rhbend - startblock; |
| ret = OK; |
| } |
| |
| /* 4. We invalidate a portion at the begin of the read-ahead buffer */ |
| |
| else /* if (rwb->rhblockstart >= startblock && rhbend > invend) */ |
| { |
| FAR uint8_t *src; |
| size_t ninval; |
| size_t nkeep; |
| |
| DEBUGASSERT(rwb->rhblockstart >= startblock && rhbend > invend); |
| /* Copy the data from the uninvalidated region to the beginning |
| * of the read buffer. |
| * |
| * First calculate the source and destination of the transfer. |
| */ |
| |
| ninval = invend - rwb->rhblockstart; |
| src = rwb->rhbuffer + ninval * rwb->blocksize; |
| |
| /* Calculate the number of blocks we are keeping. We keep |
| * the ones that we don't invalidate. |
| */ |
| |
| nkeep = rwb->rhnblocks - ninval; |
| |
| /* Then move the data that we are keeping to the beginning |
| * the read buffer. |
| */ |
| |
| memmove(rwb->rhbuffer, src, nkeep * rwb->blocksize); |
| |
| /* Update the block info. The first block is now the one just |
| * after the invalidation region and the number buffered blocks |
| * is the number that we kept. |
| */ |
| |
| rwb->rhblockstart = invend; |
| rwb->rhnblocks = nkeep; |
| } |
| |
| rwb_unlock(&rwb->rhlock); |
| } |
| |
| return ret; |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Public Functions |
| ****************************************************************************/ |
| |
| /**************************************************************************** |
| * Name: rwb_initialize |
| ****************************************************************************/ |
| |
| int rwb_initialize(FAR struct rwbuffer_s *rwb) |
| { |
| uint32_t allocsize; |
| |
| /* Sanity checking */ |
| |
| DEBUGASSERT(rwb != NULL); |
| DEBUGASSERT(rwb->blocksize > 0); |
| DEBUGASSERT(rwb->nblocks > 0); |
| DEBUGASSERT(rwb->dev != NULL); |
| |
| /* Setup so that rwb_uninitialize can handle a failure */ |
| |
| #ifdef CONFIG_DRVR_WRITEBUFFER |
| DEBUGASSERT(rwb->wrflush != NULL); |
| rwb->wrbuffer = NULL; |
| #endif |
| #ifdef CONFIG_DRVR_READAHEAD |
| DEBUGASSERT(rwb->rhreload != NULL); |
| rwb->rhbuffer = NULL; |
| #endif |
| |
| #ifdef CONFIG_DRVR_WRITEBUFFER |
| if (rwb->wrmaxblocks > 0) |
| { |
| finfo("Initialize the write buffer\n"); |
| |
| if (rwb->wralignblocks == 0) |
| { |
| rwb->wralignblocks = 1; |
| } |
| |
| DEBUGASSERT(rwb->wralignblocks <= rwb->wrmaxblocks && |
| rwb->wrmaxblocks % rwb->wralignblocks == 0); |
| |
| /* Initialize the write buffer access mutex */ |
| |
| nxmutex_init(&rwb->wrlock); |
| |
| /* Initialize write buffer parameters */ |
| |
| rwb_resetwrbuffer(rwb); |
| |
| /* Allocate the write buffer */ |
| |
| allocsize = rwb->wrmaxblocks * rwb->blocksize; |
| rwb->wrbuffer = kmm_malloc(allocsize); |
| if (!rwb->wrbuffer) |
| { |
| ferr("Write buffer kmm_malloc(%" PRIu32 ") failed\n", allocsize); |
| nxmutex_destroy(&rwb->wrlock); |
| return -ENOMEM; |
| } |
| |
| finfo("Write buffer size: %" PRIu32 " bytes\n", allocsize); |
| } |
| #endif /* CONFIG_DRVR_WRITEBUFFER */ |
| |
| #ifdef CONFIG_DRVR_READAHEAD |
| if (rwb->rhmaxblocks > 0) |
| { |
| finfo("Initialize the read-ahead buffer\n"); |
| |
| /* Initialize the read-ahead buffer access mutex */ |
| |
| nxmutex_init(&rwb->rhlock); |
| |
| /* Initialize read-ahead buffer parameters */ |
| |
| rwb_resetrhbuffer(rwb); |
| |
| /* Allocate the read-ahead buffer */ |
| |
| allocsize = rwb->rhmaxblocks * rwb->blocksize; |
| rwb->rhbuffer = kmm_malloc(allocsize); |
| if (!rwb->rhbuffer) |
| { |
| ferr("Read-ahead buffer kmm_malloc(%" PRIu32 ") failed\n", |
| allocsize); |
| nxmutex_destroy(&rwb->rhlock); |
| #ifdef CONFIG_DRVR_WRITEBUFFER |
| if (rwb->wrmaxblocks > 0) |
| { |
| nxmutex_destroy(&rwb->wrlock); |
| } |
| |
| if (rwb->wrbuffer != NULL) |
| { |
| kmm_free(rwb->wrbuffer); |
| } |
| #endif |
| |
| return -ENOMEM; |
| } |
| |
| finfo("Read-ahead buffer size: %" PRIu32 " bytes\n", allocsize); |
| } |
| #endif /* CONFIG_DRVR_READAHEAD */ |
| |
| return OK; |
| } |
| |
| /**************************************************************************** |
| * Name: rwb_uninitialize |
| ****************************************************************************/ |
| |
| void rwb_uninitialize(FAR struct rwbuffer_s *rwb) |
| { |
| #ifdef CONFIG_DRVR_WRITEBUFFER |
| if (rwb->wrmaxblocks > 0) |
| { |
| rwb_wrcanceltimeout(rwb); |
| rwb_wrflush(rwb); |
| nxmutex_destroy(&rwb->wrlock); |
| if (rwb->wrbuffer) |
| { |
| kmm_free(rwb->wrbuffer); |
| } |
| } |
| #endif |
| |
| #ifdef CONFIG_DRVR_READAHEAD |
| if (rwb->rhmaxblocks > 0) |
| { |
| nxmutex_destroy(&rwb->rhlock); |
| if (rwb->rhbuffer) |
| { |
| kmm_free(rwb->rhbuffer); |
| } |
| } |
| #endif |
| } |
| |
| /**************************************************************************** |
| * Name: rwb_read_ |
| ****************************************************************************/ |
| |
| static ssize_t rwb_read_(FAR struct rwbuffer_s *rwb, off_t startblock, |
| size_t nblocks, FAR uint8_t *rdbuffer) |
| { |
| int ret = OK; |
| |
| #ifdef CONFIG_DRVR_READAHEAD |
| if (rwb->rhmaxblocks > 0) |
| { |
| size_t remaining; |
| |
| ret = rwb_lock(&rwb->rhlock); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| /* Loop until we have read all of the requested blocks */ |
| |
| for (remaining = nblocks; remaining > 0; ) |
| { |
| /* Is there anything in the read-ahead buffer? */ |
| |
| if (rwb->rhnblocks > 0) |
| { |
| off_t bufferend; |
| |
| /* How many blocks are available in this buffer? */ |
| |
| bufferend = rwb->rhblockstart + rwb->rhnblocks; |
| if (startblock >= rwb->rhblockstart && startblock < bufferend) |
| { |
| size_t rdblocks = bufferend - startblock; |
| if (rdblocks > remaining) |
| { |
| rdblocks = remaining; |
| } |
| |
| /* Then read the data from the read-ahead buffer */ |
| |
| rwb_bufferread(rwb, startblock, rdblocks, &rdbuffer); |
| startblock += rdblocks; |
| remaining -= rdblocks; |
| } |
| } |
| |
| /* If we did not get all of the data from the buffer, then we have |
| * to refill the buffer and try again. |
| */ |
| |
| if (remaining > 0) |
| { |
| ret = rwb_rhreload(rwb, startblock); |
| if (ret < 0) |
| { |
| ferr("ERROR: Failed to fill the read-ahead buffer: %d\n", |
| ret); |
| |
| rwb_unlock(&rwb->rhlock); |
| return ret; |
| } |
| } |
| } |
| |
| /* On success, return the number of blocks that we were requested to |
| * read. This is for compatibility with the normal return of a block |
| * driver read method |
| */ |
| |
| rwb_unlock(&rwb->rhlock); |
| ret = nblocks; |
| } |
| else |
| #endif |
| { |
| /* No read-ahead buffering, (re)load the data directly into |
| * the user buffer. |
| */ |
| |
| if (nblocks) |
| { |
| ret = rwb->rhreload(rwb->dev, rdbuffer, startblock, nblocks); |
| } |
| } |
| |
| return ret; |
| } |
| |
| /**************************************************************************** |
| * Name: rwb_read |
| ****************************************************************************/ |
| |
| ssize_t rwb_read(FAR struct rwbuffer_s *rwb, off_t startblock, |
| size_t nblocks, FAR uint8_t *rdbuffer) |
| { |
| int ret = OK; |
| size_t readblocks = 0; |
| |
| finfo("startblock=%ld nblocks=%ld rdbuffer=%p\n", |
| (long)startblock, (long)nblocks, rdbuffer); |
| |
| #ifdef CONFIG_DRVR_WRITEBUFFER |
| /* If the new read data overlaps any part of the write buffer, we |
| * directly copy write buffer to read buffer. This boost performance. |
| */ |
| |
| if (rwb->wrmaxblocks > 0) |
| { |
| ret = rwb_lock(&rwb->wrlock); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| /* If the write buffer overlaps the block(s) requested */ |
| |
| if (rwb_overlap(rwb->wrblockstart, rwb->wrnblocks, startblock, |
| nblocks)) |
| { |
| size_t rdblocks = 0; |
| size_t wrnpass = 0; |
| |
| if (rwb->wrblockstart > startblock) |
| { |
| rdblocks = rwb->wrblockstart - startblock; |
| ret = rwb_read_(rwb, startblock, rdblocks, rdbuffer); |
| if (ret < 0) |
| { |
| rwb_unlock(&rwb->wrlock); |
| return ret; |
| } |
| |
| startblock += ret; |
| nblocks -= ret; |
| rdbuffer += ret * rwb->blocksize; |
| readblocks += ret; |
| } |
| |
| if (rwb->wrblockstart < startblock) |
| { |
| wrnpass = startblock - rwb->wrblockstart; |
| } |
| |
| rdblocks = nblocks > (rwb->wrnblocks - wrnpass) ? |
| (rwb->wrnblocks - wrnpass) : nblocks; |
| memcpy(rdbuffer, &rwb->wrbuffer[wrnpass * rwb->blocksize], |
| rdblocks * rwb->blocksize); |
| |
| startblock += rdblocks; |
| nblocks -= rdblocks; |
| rdbuffer += rdblocks * rwb->blocksize; |
| readblocks += rdblocks; |
| } |
| |
| rwb_unlock(&rwb->wrlock); |
| } |
| #endif |
| |
| ret = rwb_read_(rwb, startblock, nblocks, rdbuffer); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| return readblocks + ret; |
| } |
| |
| /**************************************************************************** |
| * Name: rwb_write |
| ****************************************************************************/ |
| |
| ssize_t rwb_write(FAR struct rwbuffer_s *rwb, off_t startblock, |
| size_t nblocks, FAR const uint8_t *wrbuffer) |
| { |
| int ret = OK; |
| |
| #ifdef CONFIG_DRVR_READAHEAD |
| if (rwb->rhmaxblocks > 0) |
| { |
| /* If the new write data overlaps any part of the read buffer, then |
| * flush the data from the read buffer. We could attempt some more |
| * exotic handling -- but this simple logic is well-suited for simple |
| * streaming applications. |
| */ |
| |
| ret = rwb_lock(&rwb->rhlock); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| if (rwb_overlap(rwb->rhblockstart, rwb->rhnblocks, startblock, |
| nblocks)) |
| { |
| #ifdef CONFIG_DRVR_INVALIDATE |
| /* Just invalidate the read buffer startblock + nblocks data */ |
| |
| ret = rwb_invalidate_readahead(rwb, startblock, nblocks); |
| if (ret < 0) |
| { |
| ferr("ERROR: rwb_invalidate_readahead failed: %d\n", ret); |
| rwb_unlock(&rwb->rhlock); |
| return ret; |
| } |
| #else |
| rwb_resetrhbuffer(rwb); |
| #endif |
| } |
| |
| rwb_unlock(&rwb->rhlock); |
| } |
| #endif |
| |
| #ifdef CONFIG_DRVR_WRITEBUFFER |
| if (rwb->wrmaxblocks > 0) |
| { |
| finfo("startblock=%" PRIdOFF " wrbuffer=%p\n", startblock, wrbuffer); |
| |
| ret = rwb_lock(&rwb->wrlock); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| ret = rwb_writebuffer(rwb, startblock, nblocks, wrbuffer); |
| rwb_unlock(&rwb->wrlock); |
| |
| /* On success, return the number of blocks that we were requested to |
| * write. This is for compatibility with the normal return of a block |
| * driver write method |
| */ |
| } |
| else |
| #endif /* CONFIG_DRVR_WRITEBUFFER */ |
| { |
| /* No write buffer.. just pass the write operation through via the |
| * flush callback. |
| */ |
| |
| ret = rwb->wrflush(rwb->dev, wrbuffer, startblock, nblocks); |
| } |
| |
| return ret; |
| } |
| |
| /**************************************************************************** |
| * Name: rwb_readbytes |
| * |
| * Description: |
| * Character-oriented read |
| * |
| ****************************************************************************/ |
| |
| #ifdef CONFIG_DRVR_READBYTES |
| ssize_t rwb_readbytes(FAR struct rwbuffer_s *dev, off_t offset, |
| size_t nbytes, FAR uint8_t *buffer) |
| { |
| /* Loop while there are bytes still be be read */ |
| |
| /* Make sure that the sector containing the next bytes to transfer is in |
| * memory. |
| */ |
| |
| /* How many bytes can be transfer from the in-memory data? */ |
| |
| /* Transfer the bytes */ |
| |
| /* Adjust counts and offsets for the next time through the loop */ |
| |
| #warning Not Implemented |
| return -ENOSYS; |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: rwb_mediaremoved |
| * |
| * Description: |
| * The following function is called when media is removed |
| * |
| ****************************************************************************/ |
| |
| #ifdef CONFIG_DRVR_REMOVABLE |
| int rwb_mediaremoved(FAR struct rwbuffer_s *rwb) |
| { |
| int ret; |
| |
| #ifdef CONFIG_DRVR_WRITEBUFFER |
| if (rwb->wrmaxblocks > 0) |
| { |
| ret = rwb_lock(&rwb->wrlock); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| rwb_resetwrbuffer(rwb); |
| rwb_unlock(&rwb->wrlock); |
| } |
| #endif |
| |
| #ifdef CONFIG_DRVR_READAHEAD |
| if (rwb->rhmaxblocks > 0) |
| { |
| ret = rwb_lock(&rwb->rhlock); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| rwb_resetrhbuffer(rwb); |
| rwb_unlock(&rwb->rhlock); |
| } |
| #endif |
| |
| return OK; |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: rwb_invalidate |
| * |
| * Description: |
| * Invalidate a region of the caches |
| * |
| ****************************************************************************/ |
| |
| #ifdef CONFIG_DRVR_INVALIDATE |
| int rwb_invalidate(FAR struct rwbuffer_s *rwb, |
| off_t startblock, size_t blockcount) |
| { |
| int ret; |
| |
| #ifdef CONFIG_DRVR_WRITEBUFFER |
| ret = rwb_invalidate_writebuffer(rwb, startblock, blockcount); |
| if (ret < 0) |
| { |
| ferr("ERROR: rwb_invalidate_writebuffer failed: %d\n", ret); |
| return ret; |
| } |
| #endif |
| |
| #ifdef CONFIG_DRVR_READAHEAD |
| ret = rwb_invalidate_readahead(rwb, startblock, blockcount); |
| if (ret < 0) |
| { |
| ferr("ERROR: rwb_invalidate_readahead failed: %d\n", ret); |
| return ret; |
| } |
| #endif |
| |
| return OK; |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Name: rwb_flush |
| * |
| * Description: |
| * Flush the write buffer |
| * |
| ****************************************************************************/ |
| |
| #ifdef CONFIG_DRVR_WRITEBUFFER |
| int rwb_flush(FAR struct rwbuffer_s *rwb) |
| { |
| int ret; |
| |
| ret = rwb_lock(&rwb->wrlock); |
| rwb_wrcanceltimeout(rwb); |
| rwb_wrflush(rwb); |
| rwb_unlock(&rwb->wrlock); |
| |
| return ret; |
| } |
| #endif |
| |
| #endif /* CONFIG_DRVR_WRITEBUFFER || CONFIG_DRVR_READAHEAD */ |
