Changeset 12806cd in rtems for cpukit/libblock


Ignore:
Timestamp:
Mar 13, 2012, 1:51:55 PM (8 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
4.11, master
Children:
f9fd0c2
Parents:
790f04d
git-author:
Sebastian Huber <sebastian.huber@…> (03/13/12 13:51:55)
git-committer:
Sebastian Huber <sebastian.huber@…> (03/14/12 09:48:17)
Message:

PR2040: libblock: Use segment control as parameter

File:
1 edited

Legend:

Unmodified
Added
Removed
  • cpukit/libblock/src/flashdisk.c

    r790f04d r12806cd  
    831831 */
    832832static int
    833 rtems_fdisk_seg_read (const rtems_flashdisk* fd,
    834                       uint32_t               device,
    835                       uint32_t               segment,
    836                       uint32_t               offset,
    837                       void*                  buffer,
    838                       uint32_t               size)
    839 {
     833rtems_fdisk_seg_read (const rtems_flashdisk*         fd,
     834                      const rtems_fdisk_segment_ctl* sc,
     835                      uint32_t                       offset,
     836                      void*                          buffer,
     837                      uint32_t                       size)
     838{
     839  uint32_t                           device;
     840  uint32_t                           segment;
    840841  const rtems_fdisk_segment_desc*    sd;
    841842  const rtems_fdisk_driver_handlers* ops;
    842   sd  = rtems_fdisk_seg_descriptor (fd, device, segment);
     843  device = sc->device;
     844  segment = sc->segment;
     845  sd = rtems_fdisk_seg_descriptor (fd, device, segment);
    843846  ops = fd->devices[device].descriptor->flash_ops;
    844847#if RTEMS_FDISK_TRACE
     
    855858 */
    856859static int
    857 rtems_fdisk_seg_write (const rtems_flashdisk* fd,
    858                        uint32_t               device,
    859                        uint32_t               segment,
    860                        uint32_t               offset,
    861                        const void*            buffer,
    862                        uint32_t               size)
    863 {
     860rtems_fdisk_seg_write (const rtems_flashdisk*   fd,
     861                       rtems_fdisk_segment_ctl* sc,
     862                       uint32_t                 offset,
     863                       const void*              buffer,
     864                       uint32_t                 size)
     865{
     866  int ret;
     867  uint32_t                           device;
     868  uint32_t                           segment;
    864869  const rtems_fdisk_segment_desc*    sd;
    865870  const rtems_fdisk_driver_handlers* ops;
    866   sd  = rtems_fdisk_seg_descriptor (fd, device, segment);
     871  device = sc->device;
     872  segment = sc->segment;
     873  sd = rtems_fdisk_seg_descriptor (fd, device, segment);
    867874  ops = fd->devices[device].descriptor->flash_ops;
    868875#if RTEMS_FDISK_TRACE
     
    870877                      device, segment, offset, size);
    871878#endif
    872   return ops->write (sd, device, segment, offset, buffer, size);
     879  ret = ops->write (sd, device, segment, offset, buffer, size);
     880  if (ret)
     881    sc->failed = true;
     882
     883  return ret;
    873884}
    874885
     
    877888 */
    878889static int
    879 rtems_fdisk_seg_blank_check (const rtems_flashdisk* fd,
    880                              uint32_t               device,
    881                              uint32_t               segment,
    882                              uint32_t               offset,
    883                              uint32_t               size)
    884 {
     890rtems_fdisk_seg_blank_check (const rtems_flashdisk*   fd,
     891                             rtems_fdisk_segment_ctl* sc,
     892                             uint32_t                 offset,
     893                             uint32_t                 size)
     894{
     895  uint32_t                           device;
     896  uint32_t                           segment;
    885897  const rtems_fdisk_segment_desc*    sd;
    886898  const rtems_fdisk_driver_handlers* ops;
     899  device = sc->device;
     900  segment = sc->segment;
    887901  sd = rtems_fdisk_seg_descriptor (fd, device, segment);
    888902  ops = fd->devices[device].descriptor->flash_ops;
     
    919933 */
    920934static int
    921 rtems_fdisk_seg_blank_check_page (const rtems_flashdisk* fd,
    922                                   uint32_t               device,
    923                                   uint32_t               segment,
    924                                   uint32_t               page)
    925 {
    926   return rtems_fdisk_seg_blank_check (fd, device, segment,
     935rtems_fdisk_seg_blank_check_page (const rtems_flashdisk*   fd,
     936                                  rtems_fdisk_segment_ctl* sc,
     937                                  uint32_t                 page)
     938{
     939  return rtems_fdisk_seg_blank_check (fd, sc,
    927940                                      page * fd->block_size, fd->block_size);
    928941}
     
    932945 */
    933946static int
    934 rtems_fdisk_seg_read_page (const rtems_flashdisk* fd,
    935                            uint32_t               device,
    936                            uint32_t               segment,
    937                            uint32_t               page,
    938                            void*                  buffer)
    939 {
    940   return rtems_fdisk_seg_read (fd, device, segment,
     947rtems_fdisk_seg_read_page (const rtems_flashdisk*   fd,
     948                           rtems_fdisk_segment_ctl* sc,
     949                           uint32_t                 page,
     950                           void*                    buffer)
     951{
     952  return rtems_fdisk_seg_read (fd, sc,
    941953                               page * fd->block_size, buffer, fd->block_size);
    942954}
     
    946958 */
    947959static int
    948 rtems_fdisk_seg_write_page (const rtems_flashdisk* fd,
    949                             uint32_t               device,
    950                             uint32_t               segment,
    951                             uint32_t               page,
    952                             const void*            buffer)
     960rtems_fdisk_seg_write_page (rtems_flashdisk*         fd,
     961                            rtems_fdisk_segment_ctl* sc,
     962                            uint32_t                 page,
     963                            const void*              buffer)
    953964{
    954965  if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
    955966  {
    956     int ret = rtems_fdisk_seg_blank_check_page (fd, device, segment, page);
     967    int ret = rtems_fdisk_seg_blank_check_page (fd, sc, page);
    957968    if (ret)
    958969      return ret;
    959970  }
    960   return rtems_fdisk_seg_write (fd, device, segment,
     971  return rtems_fdisk_seg_write (fd, sc,
    961972                                page * fd->block_size, buffer, fd->block_size);
    962973}
     
    980991 */
    981992static int
    982 rtems_fdisk_seg_copy_page (const rtems_flashdisk* fd,
    983                            uint32_t               src_device,
    984                            uint32_t               src_segment,
    985                            uint32_t               src_page,
    986                            uint32_t               dst_device,
    987                            uint32_t               dst_segment,
    988                            uint32_t               dst_page)
     993rtems_fdisk_seg_copy_page (rtems_flashdisk*         fd,
     994                           rtems_fdisk_segment_ctl* src_sc,
     995                           uint32_t                 src_page,
     996                           rtems_fdisk_segment_ctl* dst_sc,
     997                           uint32_t                 dst_page)
    989998{
    990999  int ret;
    9911000#if RTEMS_FDISK_TRACE
    9921001  rtems_fdisk_printf (fd, "  seg-copy-page: %02d-%03d~%03d=>%02d-%03d~%03d",
    993                       src_device, src_segment, src_page,
    994                       dst_device, dst_segment, dst_page);
    995 #endif
    996   ret = rtems_fdisk_seg_read_page (fd, src_device, src_segment, src_page,
     1002                      src_sc->device, src_sc->segment, src_page,
     1003                      dst_sc->device, dst_sc->segment, dst_page);
     1004#endif
     1005  ret = rtems_fdisk_seg_read_page (fd, src_sc, src_page,
    9971006                                   fd->copy_buffer);
    9981007  if (ret)
    9991008    return ret;
    1000   return rtems_fdisk_seg_write_page (fd, dst_device, dst_segment, dst_page,
     1009  return rtems_fdisk_seg_write_page (fd, dst_sc, dst_page,
    10011010                                     fd->copy_buffer);
    10021011}
     
    10081017static int
    10091018rtems_fdisk_seg_write_page_desc (const rtems_flashdisk*       fd,
    1010                                  uint32_t                     device,
    1011                                  uint32_t                     segment,
     1019                                 rtems_fdisk_segment_ctl*     sc,
    10121020                                 uint32_t                     page,
    10131021                                 const rtems_fdisk_page_desc* page_desc)
     
    10161024  if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
    10171025  {
    1018     int ret = rtems_fdisk_seg_blank_check (fd, device, segment,
     1026    int ret = rtems_fdisk_seg_blank_check (fd, sc,
    10191027                                           offset,
    10201028                                           sizeof (rtems_fdisk_page_desc));
     
    10221030      return ret;
    10231031  }
    1024   return rtems_fdisk_seg_write (fd, device, segment, offset,
     1032  return rtems_fdisk_seg_write (fd, sc, offset,
    10251033                                page_desc, sizeof (rtems_fdisk_page_desc));
    10261034}
     
    10321040static int
    10331041rtems_fdisk_seg_write_page_desc_flags (const rtems_flashdisk*       fd,
    1034                                        uint32_t                     device,
    1035                                        uint32_t                     segment,
     1042                                       rtems_fdisk_segment_ctl*     sc,
    10361043                                       uint32_t                     page,
    10371044                                       const rtems_fdisk_page_desc* page_desc)
     
    10431050    uint16_t flash_flags;
    10441051    int      ret;
    1045     ret = rtems_fdisk_seg_read (fd, device, segment, offset,
     1052    ret = rtems_fdisk_seg_read (fd, sc, offset,
    10461053                                &flash_flags, sizeof (flash_flags));
    10471054    if (ret)
     
    10491056    if ((flash_flags & page_desc->flags) != page_desc->flags)
    10501057    {
    1051       rtems_fdisk_error ("  seg-write-page-flags: %02d-%03d-%03d: " \
     1058      rtems_fdisk_error ("  seg-write-page-flags: %02d-%03d-%03d: "
    10521059                         "flags not erased: 0x%04 -> 0x%04x",
    1053                          device, segment, page, flash_flags, page_desc->flags);
     1060                         sc->device, sc->segment, page,
     1061                         flash_flags, page_desc->flags);
    10541062      return ret;
    10551063    }
    10561064  }
    1057   return rtems_fdisk_seg_write (fd, device, segment, offset,
     1065  return rtems_fdisk_seg_write (fd, sc, offset,
    10581066                                &page_desc->flags, sizeof (page_desc->flags));
    10591067}
    10601068
    10611069/**
    1062  * Erase a segment.
    1063  */
    1064 static int
    1065 rtems_fdisk_seg_erase (const rtems_flashdisk* fd,
    1066                        uint32_t               device,
    1067                        uint32_t               segment)
    1068 {
     1070 * Erase a device.
     1071 */
     1072static int
     1073rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device)
     1074{
     1075  const rtems_fdisk_driver_handlers* ops;
     1076  ops = fd->devices[device].descriptor->flash_ops;
     1077#if RTEMS_FDISK_TRACE
     1078  rtems_fdisk_printf (fd, " device-erase: %02d", device);
     1079#endif
     1080  return ops->erase_device (fd->devices[device].descriptor, device);
     1081}
     1082
     1083/**
     1084 * Erase all flash.
     1085 */
     1086static int
     1087rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
     1088{
     1089  uint32_t device;
     1090  for (device = 0; device < fd->device_count; device++)
     1091  {
     1092    int ret;
     1093
     1094#if RTEMS_FDISK_TRACE
     1095    rtems_fdisk_info (fd, " erase-flash:%02d", device);
     1096#endif
     1097
     1098    ret = rtems_fdisk_device_erase (fd, device);
     1099
     1100    if (ret != 0)
     1101      return ret;
     1102  }
     1103  return 0;
     1104}
     1105
     1106/**
     1107 * Calculate the checksum of a page in a segment.
     1108 */
     1109static uint16_t
     1110rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
     1111{
     1112  uint16_t cs = 0xffff;
     1113  uint32_t i;
     1114
     1115  for (i = 0; i < page_size; i++, buffer++)
     1116    cs = rtems_fdisk_calc_crc16 (cs, *buffer);
     1117
     1118  return cs;
     1119}
     1120
     1121/**
     1122 * Erase the segment.
     1123 */
     1124static int
     1125rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
     1126{
     1127  int                                ret;
     1128  uint32_t                           device;
     1129  uint32_t                           segment;
    10691130  const rtems_fdisk_segment_desc*    sd;
    10701131  const rtems_fdisk_driver_handlers* ops;
    1071   sd  = rtems_fdisk_seg_descriptor (fd, device, segment);
     1132  device = sc->device;
     1133  segment = sc->segment;
     1134  sd = rtems_fdisk_seg_descriptor (fd, device, segment);
    10721135  ops = fd->devices[device].descriptor->flash_ops;
    1073 #if RTEMS_FDISK_TRACE
    1074   rtems_fdisk_printf (fd, "  seg-erase: %02d-%03d", device, segment);
    1075 #endif
    1076   return ops->erase (sd, device, segment);
    1077 }
    1078 
    1079 /**
    1080  * Erase a device.
    1081  */
    1082 static int
    1083 rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device)
    1084 {
    1085   const rtems_fdisk_driver_handlers* ops;
    1086   ops = fd->devices[device].descriptor->flash_ops;
    1087 #if RTEMS_FDISK_TRACE
    1088   rtems_fdisk_printf (fd, " device-erase: %02d", device);
    1089 #endif
    1090   return ops->erase_device (fd->devices[device].descriptor, device);
    1091 }
    1092 
    1093 /**
    1094  * Erase all flash.
    1095  */
    1096 static int
    1097 rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
    1098 {
    1099   uint32_t device;
    1100   for (device = 0; device < fd->device_count; device++)
    1101   {
    1102     int ret;
    1103 
    1104 #if RTEMS_FDISK_TRACE
    1105     rtems_fdisk_info (fd, " erase-flash:%02d", device);
    1106 #endif
    1107 
    1108     ret = rtems_fdisk_device_erase (fd, device);
    1109 
    1110     if (ret != 0)
    1111       return ret;
    1112   }
    1113   return 0;
    1114 }
    1115 
    1116 /**
    1117  * Calculate the checksum of a page in a segment.
    1118  */
    1119 static uint16_t
    1120 rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
    1121 {
    1122   uint16_t cs = 0xffff;
    1123   uint32_t i;
    1124 
    1125   for (i = 0; i < page_size; i++, buffer++)
    1126     cs = rtems_fdisk_calc_crc16 (cs, *buffer);
    1127 
    1128   return cs;
    1129 }
    1130 
    1131 /**
    1132  * Erase the segment.
    1133  */
    1134 static int
    1135 rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
    1136 {
    1137   int ret = rtems_fdisk_seg_erase (fd, sc->device, sc->segment);
     1136  ret = ops->erase (sd, device, segment);
    11381137  if (ret)
    11391138  {
     
    14301429                              dsc->device, dsc->segment, dpage);
    14311430#endif
    1432             ret = rtems_fdisk_seg_copy_page (fd, ssc->device, ssc->segment,
     1431            ret = rtems_fdisk_seg_copy_page (fd, ssc,
    14331432                                             spage + ssc->pages_desc,
    1434                                              dsc->device, dsc->segment,
     1433                                             dsc,
    14351434                                             dpage + dsc->pages_desc);
    14361435            if (ret)
     
    14421441                                 dsc->device, dsc->segment, dpage,
    14431442                                 strerror (ret), ret);
    1444               dsc->failed = true;
    14451443              rtems_fdisk_queue_segment (fd, dsc);
    14461444              rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
     
    14511449
    14521450            ret = rtems_fdisk_seg_write_page_desc (fd,
    1453                                                    dsc->device, dsc->segment,
     1451                                                   dsc,
    14541452                                                   dpage, dpd);
    14551453
     
    14611459                                 dsc->device, dsc->segment, dpage,
    14621460                                 strerror (ret), ret);
    1463               dsc->failed = true;
    14641461              rtems_fdisk_queue_segment (fd, dsc);
    14651462              rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
     
    15411538   * Scan each segment or each device recovering the valid pages.
    15421539   */
     1540  fd->erased_blocks = 0;
    15431541  for (device = 0; device < fd->device_count; device++)
    15441542  {
     
    15821580       *       so NAND flash could be better supported.
    15831581       */
    1584       ret = rtems_fdisk_seg_read (fd, device, segment, 0, (void*) pd,
     1582      ret = rtems_fdisk_seg_read (fd, sc, 0, (void*) pd,
    15851583                                  sc->pages_desc * fd->block_size);
    15861584
     
    16081606           * Is the page erased ?
    16091607           */
    1610           ret = rtems_fdisk_seg_blank_check_page (fd, device, segment,
     1608          ret = rtems_fdisk_seg_blank_check_page (fd, sc,
    16111609                                                  page + sc->pages_desc);
    16121610
     
    16191617            rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
    16201618
    1621             ret = rtems_fdisk_seg_write_page_desc (fd, device, segment,
     1619            ret = rtems_fdisk_seg_write_page_desc (fd, sc,
    16221620                                                   page, pd);
    16231621
     
    16261624              rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
    16271625                                 device, segment, page);
    1628               sc->failed = true;
    16291626            }
    16301627
     
    17641761       * driver. This skips the page descriptors.
    17651762       */
    1766       int ret = rtems_fdisk_seg_read_page (fd, sc->device, sc->segment,
     1763      int ret = rtems_fdisk_seg_read_page (fd, sc,
    17671764                                           bc->page + sc->pages_desc, buffer);
    17681765
     
    18881885    rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
    18891886
    1890     ret = rtems_fdisk_seg_write_page_desc_flags (fd, sc->device, sc->segment,
    1891                                                  bc->page, pd);
     1887    ret = rtems_fdisk_seg_write_page_desc_flags (fd, sc, bc->page, pd);
    18921888
    18931889    if (ret)
     
    18991895                        strerror (ret), ret);
    19001896#endif
    1901       sc->failed = true;
    19021897    }
    19031898    else
     
    20021997       * driver. This skips the page descriptors.
    20031998       */
    2004       ret = rtems_fdisk_seg_write_page (fd, sc->device, sc->segment,
    2005                                         page + sc->pages_desc, buffer);
     1999      ret = rtems_fdisk_seg_write_page (fd, sc, page + sc->pages_desc, buffer);
    20062000      if (ret)
    20072001      {
     
    20112005                          strerror (ret), ret);
    20122006#endif
    2013         sc->failed = true;
    20142007      }
    20152008      else
    20162009      {
    2017         ret = rtems_fdisk_seg_write_page_desc (fd, sc->device, sc->segment,
    2018                                                page, pd);
     2010        ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);
    20192011        if (ret)
    20202012        {
     
    20252017                            strerror (ret), ret);
    20262018#endif
    2027           sc->failed = true;
    20282019        }
    20292020        else
     
    25462537        return RTEMS_NO_MEMORY;
    25472538      }
    2548      
     2539
    25492540      sc = fd->devices[device].segments;
    25502541
     
    25832574      return ret;
    25842575    }
    2585    
     2576
    25862577    ret = rtems_fdisk_compact (fd);
    25872578    if (ret)
Note: See TracChangeset for help on using the changeset viewer.