Use local variables for the list entry, mtd_info, and private data while initializing a new device. This keeps the initialization path easier to read and publishes the new list entry only after mtd_device_register() has succeeded.
Unified · Split
| @@ -129,6 +129,9 @@ static int slram_write(struct mtd_info *mtd, loff_t to, size_t len, · 128 unmodified lines | |||
| 129 | static int register_device(char *name, unsigned long start, unsigned long length) | 129 | static int register_device(char *name, unsigned long start, unsigned long length) |
| 130 | { | 130 | { |
| 131 | slram_mtd_list_t **curmtd; | 131 | slram_mtd_list_t **curmtd; |
| 132 | slram_mtd_list_t *new_mtd; | ||
| 133 | struct mtd_info *mtdinfo; | ||
| 134 | slram_priv_t *priv; | ||
| 132 | int ret = -ENOMEM; | 135 | int ret = -ENOMEM; |
| 133 | 136 | ||
| 134 | curmtd = &slram_mtdlist; | 137 | curmtd = &slram_mtdlist; |
| @@ -136,73 +139,68 @@ static int register_device(char *name, unsigned long start, unsigned long length · 1 unmodified line | |||
| 136 | curmtd = &(*curmtd)->next; | 139 | curmtd = &(*curmtd)->next; |
| 137 | } | 140 | } |
| 138 | 141 | ||
| 139 | *curmtd = kmalloc_obj(slram_mtd_list_t); | 142 | new_mtd = kmalloc_obj(slram_mtd_list_t); |
| 140 | if (!(*curmtd)) { | 143 | if (!new_mtd) { |
| 141 | E("slram: Cannot allocate new MTD device.\n"); | 144 | E("slram: Cannot allocate new MTD device.\n"); |
| 142 | return(-ENOMEM); | 145 | return(-ENOMEM); |
| 143 | } | 146 | } |
| 144 | (*curmtd)->mtdinfo = kzalloc_obj(struct mtd_info); | 147 | new_mtd->next = NULL; |
| 145 | (*curmtd)->next = NULL; | ||
| 146 | |||
| 147 | if ((*curmtd)->mtdinfo) { | ||
| 148 | (*curmtd)->mtdinfo->priv = | ||
| 149 | kzalloc_obj(slram_priv_t); | ||
| 150 | 148 | ||
| 151 | if (!(*curmtd)->mtdinfo->priv) { | 149 | mtdinfo = kzalloc_obj(struct mtd_info); |
| 152 | kfree((*curmtd)->mtdinfo); | 150 | if (!mtdinfo) { |
| 153 | (*curmtd)->mtdinfo = NULL; | 151 | E("slram: Cannot allocate new MTD device.\n"); |
| 154 | } | 152 | goto err_free_list; |
| 155 | } | 153 | } |
| 154 | new_mtd->mtdinfo = mtdinfo; | ||
| 156 | 155 | ||
| 157 | if (!(*curmtd)->mtdinfo) { | 156 | priv = kzalloc_obj(slram_priv_t); |
| 157 | if (!priv) { | ||
| 158 | E("slram: Cannot allocate new MTD device.\n"); | 158 | E("slram: Cannot allocate new MTD device.\n"); |
| 159 | goto err_free_list; | 159 | goto err_free_mtdinfo; |
| 160 | } | 160 | } |
| 161 | mtdinfo->priv = priv; | ||
| 161 | 162 | ||
| 162 | if (!(((slram_priv_t *)(*curmtd)->mtdinfo->priv)->start = | 163 | priv->start = memremap(start, length, |
| 163 | memremap(start, length, | 164 | MEMREMAP_WB | MEMREMAP_WT | MEMREMAP_WC); |
| 164 | MEMREMAP_WB | MEMREMAP_WT | MEMREMAP_WC))) { | 165 | if (!priv->start) { |
| 165 | E("slram: memremap failed\n"); | 166 | E("slram: memremap failed\n"); |
| 166 | ret = -EIO; | 167 | ret = -EIO; |
| 167 | goto err_free_priv; | 168 | goto err_free_priv; |
| 168 | } | 169 | } |
| 169 | ((slram_priv_t *)(*curmtd)->mtdinfo->priv)->end = | 170 | priv->end = priv->start + length; |
| 170 | ((slram_priv_t *)(*curmtd)->mtdinfo->priv)->start + length; | 171 | |
| 171 | 172 | mtdinfo->name = name; | |
| 172 | 173 | mtdinfo->size = length; | |
| 173 | (*curmtd)->mtdinfo->name = name; | 174 | mtdinfo->flags = MTD_CAP_RAM; |
| 174 | (*curmtd)->mtdinfo->size = length; | 175 | mtdinfo->_erase = slram_erase; |
| 175 | (*curmtd)->mtdinfo->flags = MTD_CAP_RAM; | 176 | mtdinfo->_point = slram_point; |
| 176 | (*curmtd)->mtdinfo->_erase = slram_erase; | 177 | mtdinfo->_unpoint = slram_unpoint; |
| 177 | (*curmtd)->mtdinfo->_point = slram_point; | 178 | mtdinfo->_read = slram_read; |
| 178 | (*curmtd)->mtdinfo->_unpoint = slram_unpoint; | 179 | mtdinfo->_write = slram_write; |
| 179 | (*curmtd)->mtdinfo->_read = slram_read; | 180 | mtdinfo->owner = THIS_MODULE; |
| 180 | (*curmtd)->mtdinfo->_write = slram_write; | 181 | mtdinfo->type = MTD_RAM; |
| 181 | (*curmtd)->mtdinfo->owner = THIS_MODULE; | 182 | mtdinfo->erasesize = SLRAM_BLK_SZ; |
| 182 | (*curmtd)->mtdinfo->type = MTD_RAM; | 183 | mtdinfo->writesize = 1; |
| 183 | (*curmtd)->mtdinfo->erasesize = SLRAM_BLK_SZ; | 184 | |
| 184 | (*curmtd)->mtdinfo->writesize = 1; | 185 | if (mtd_device_register(mtdinfo, NULL, 0)) { |
| 185 | |||
| 186 | if (mtd_device_register((*curmtd)->mtdinfo, NULL, 0)) { | ||
| 187 | E("slram: Failed to register new device\n"); | 186 | E("slram: Failed to register new device\n"); |
| 188 | ret = -EAGAIN; | 187 | ret = -EAGAIN; |
| 189 | goto err_unmap; | 188 | goto err_unmap; |
| 190 | } | 189 | } |
| 190 | *curmtd = new_mtd; | ||
| 191 | T("slram: Registered device %s from %luKiB to %luKiB\n", name, | 191 | T("slram: Registered device %s from %luKiB to %luKiB\n", name, |
| 192 | (start / 1024), ((start + length) / 1024)); | 192 | (start / 1024), ((start + length) / 1024)); |
| 193 | T("slram: Mapped from 0x%p to 0x%p\n", | 193 | T("slram: Mapped from 0x%p to 0x%p\n", priv->start, priv->end); |
| 194 | ((slram_priv_t *)(*curmtd)->mtdinfo->priv)->start, | 194 | return 0; |
| 195 | ((slram_priv_t *)(*curmtd)->mtdinfo->priv)->end); | ||
| 196 | return(0); | ||
| 197 | 195 | ||
| 198 | err_unmap: | 196 | err_unmap: |
| 199 | memunmap(((slram_priv_t *)(*curmtd)->mtdinfo->priv)->start); | 197 | memunmap(priv->start); |
| 200 | err_free_priv: | 198 | err_free_priv: |
| 201 | kfree((*curmtd)->mtdinfo->priv); | 199 | kfree(priv); |
| 200 | err_free_mtdinfo: | ||
| 201 | kfree(mtdinfo); | ||
| 202 | err_free_list: | 202 | err_free_list: |
| 203 | kfree((*curmtd)->mtdinfo); | 203 | kfree(new_mtd); |
| 204 | kfree(*curmtd); | ||
| 205 | *curmtd = NULL; | ||
| 206 | return ret; | 204 | return ret; |
| 207 | } | 205 | } |
| 208 | 206 | ||