RT-Thread1.1RC elm 文件系统 read函数要4字节对齐？

发布于 2012-12-29 16:52:16 浏览：5573 订阅该版

[tocm]

硬件系统stm32f4,用sdio驱动。

发现read函数中形参buf要4字节对齐，同样形参len也要否则会导致失败。
lseek函数也出现问题。

```
rt_size_t fd_fetch(void* parameter, rt_uint8_t *buffer, rt_size_t length)
{
  int fd = (int)parameter;
  int read_bytes;
#if 1
  int d4= (unsigned long)buffer%4;
  if(d4)
  {
    rt_uint8_t *new_ptr;
    unsigned long k;
    rt_uint8_t *p=(rt_uint8_t*)&k;

new_ptr = buffer -d4;
    //backup;
    k = *(unsigned long*)new_ptr;
    read_bytes = read(fd, (char*)new_ptr, length);
    if (read_bytes <= 0) return 0;
    memmove(buffer,new_ptr,read_bytes);
    while(d4--)
    {
      *new_ptr++ = *p++;
    }
  }
  else
#endif
  {
    read_bytes = read(fd, (char*)buffer, length);
  }
  if (read_bytes <= 0) return 0;
  
  return read_bytes;
}```

这个是系统自带的helix mp3解码中的一个函数，若不对其的话会出错

```
#if 1
      t = Remaining%4;
      if(t)
      {//没有对齐
#	if 0        
        unsigned char	*ReadNewStart = ReadStart-t;
        //备份数据
        rt_uint32_t k = *(rt_uint32_t*)ReadNewStart;
        unsigned char *p = (unsigned char*)&k;
        ReadSize = ReadSize&0xfffffffc;
        ReadSize=read(InputFp,ReadNewStart,ReadSize);
        if(ReadSize>0)
        {
          memmove(ReadStart,ReadNewStart,ReadSize);
          //还原
          while(t--)
          {
            *ReadNewStart++ = *p++;
          }
        }
#	elif 0
        unsigned char	*ReadNewStart = ReadStart-t;
        ReadSize = (ReadSize+t)&0xfffffffc;
        lseek(InputFp,-t,SEEK_CUR);
        ReadSize=read(InputFp,ReadNewStart,ReadSize)-t;
#   else 
        ReadSize=read(InputFp,ReadStart,ReadSize);
#	endif
      }
      else //Mp3ToWave("b.mp3","b.wma")
#endif
      {
        ReadSize=read(InputFp,ReadStart,ReadSize);
      }
```
这个是libmad0.15中的播放mp3的代码，也要对齐！
lseek会出错

9 个回答

aozima 2012-12-29

调网络不抓包，调I2C等时序不上逻辑分析仪，就像电工不用万用表！多用整理的好的文字，比截图更省流量，还能在整理过程中思考。

lixun00 2012-12-29

这家伙很懒，什么也没写！

prife 2012-12-30

这家伙很懒，什么也没写！

lixun00 2012-12-30

这家伙很懒，什么也没写！

aozima 2012-12-30

调网络不抓包，调I2C等时序不上逻辑分析仪，就像电工不用万用表！多用整理的好的文字，比截图更省流量，还能在整理过程中思考。

lixun00 2013-01-01

这家伙很懒，什么也没写！

对sdio了解的不多，在block_dev.c里简单修复了下，测试未发现问题。

```
static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card, rt_uint32_t sector, void *buf, rt_size_t blks, rt_uint8_t dir)
{
	//void *aligned_buf;
	
	struct rt_mmcsd_cmd  cmd, stop;
	struct rt_mmcsd_data  data;
	struct rt_mmcsd_req  req;
	struct rt_mmcsd_host *host = card->host;
	rt_uint32_t r_cmd, w_cmd;
        static rt_uint8_t sd_buf[512];

mmcsd_host_lock(host);
	
    if((rt_uint32_t)buf&3)
    {
      rt_uint8_t *p_buf = (rt_uint8_t*)buf;
      while(blks--)
      {
        rt_memset(&req, 0, sizeof(struct rt_mmcsd_req));
        rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
        rt_memset(&stop, 0, sizeof(struct rt_mmcsd_cmd));
        rt_memset(&data, 0, sizeof(struct rt_mmcsd_data));
        req.cmd = &cmd;
        req.data = &data;
        
        cmd.arg = sector;
        if (!(card->flags & CARD_FLAG_SDHC)) 
        {
            cmd.arg <<= 9;
        }
        cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_ADTC;

data.blksize = SECTOR_SIZE;
        data.blks  = 1;
        
        req.stop = RT_NULL;
        r_cmd = READ_SINGLE_BLOCK;
        w_cmd = WRITE_BLOCK;

if (!dir) 
        {
            cmd.cmd_code = r_cmd;
            data.flags |= DATA_DIR_READ;
        }
        else
        {
            cmd.cmd_code = w_cmd;
            data.flags |= DATA_DIR_WRITE;
            rt_memcpy(sd_buf,p_buf,512);
        }

mmcsd_set_data_timeout(&data, card);
        data.buf = (rt_uint32_t*)sd_buf;
        mmcsd_send_request(host, &req);

if (!controller_is_spi(card->host) && dir != 0) 
        {
            do 
            {
                rt_int32_t err;

cmd.cmd_code = SEND_STATUS;
                cmd.arg = card->rca << 16;
                cmd.flags = RESP_R1 | CMD_AC;
                err = mmcsd_send_cmd(card->host, &cmd, 5);
                if (err) 
                {
                    rt_kprintf("error %d requesting status
", err);
                    break;
                }
                /*
                 * Some cards mishandle the status bits,
                 * so make sure to check both the busy
                 * indication and the card state.
                 */
           } while (!(cmd.resp[0] & R1_READY_FOR_DATA) ||
              (R1_CURRENT_STATE(cmd.resp[0]) == 7));
        }
        if (!dir) 
        {
          rt_memcpy(p_buf,sd_buf,512);
        }
        p_buf += 512;
        sector++;
      }
    }
    else
    {
      rt_memset(&req, 0, sizeof(struct rt_mmcsd_req));
      rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
      rt_memset(&stop, 0, sizeof(struct rt_mmcsd_cmd));
      rt_memset(&data, 0, sizeof(struct rt_mmcsd_data));
      req.cmd = &cmd;
      req.data = &data;
      
      cmd.arg = sector;
      if (!(card->flags & CARD_FLAG_SDHC)) 
      {
          cmd.arg <<= 9;
      }
      cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_ADTC;

data.blksize = SECTOR_SIZE;
      data.blks  = blks;
      if (blks > 1) 
      {
          if (!controller_is_spi(card->host) || !dir)
          {
              req.stop = &stop;
              stop.cmd_code = STOP_TRANSMISSION;
              stop.arg = 0;
              stop.flags = RESP_SPI_R1B | RESP_R1B | CMD_AC;
          }
          r_cmd = READ_MULTIPLE_BLOCK;
          w_cmd = WRITE_MULTIPLE_BLOCK;
      }
      else
      {
          req.stop = RT_NULL;
          r_cmd = READ_SINGLE_BLOCK;
          w_cmd = WRITE_BLOCK;
      }

if (!dir) 
      {
          cmd.cmd_code = r_cmd;
          data.flags |= DATA_DIR_READ;
      }
      else
      {
          cmd.cmd_code = w_cmd;
          data.flags |= DATA_DIR_WRITE;
      }

mmcsd_set_data_timeout(&data, card);
      data.buf = buf;
      mmcsd_send_request(host, &req);

if (!controller_is_spi(card->host) && dir != 0) 
      {
          do 
          {
              rt_int32_t err;

mmcsd_host_unlock(host);

if (cmd.err || data.err || stop.err) 
	{
		rt_kprintf("mmcsd request blocks error
");
		rt_kprintf("%d,%d,%d, 0x%08x,0x%08x
", cmd.err, data.err, stop.err, data.flags, sector);

return -RT_ERROR;
	}

return RT_EOK;
}

```