+1 -1

arch/sh/Kconfig

reviewed

··· 161 161 162 162 config NO_IOPORT 163 163 def_bool !PCI 164 164 - depends on !SH_CAYMAN && !SH_SH4202_MICRODEV 164 164 + depends on !SH_CAYMAN && !SH_SH4202_MICRODEV && !SH_SHMIN 165 165 166 166 config IO_TRAPPED 167 167 bool

+14 -20

arch/sh/boards/mach-ap325rxa/setup.c

reviewed

··· 359 359 .priv = &camera_info, 360 360 }; 361 361 362 362 - static void dummy_release(struct device *dev) 363 363 - { 364 364 - } 362 362 + static struct platform_device *camera_device; 365 363 366 366 - static struct platform_device camera_device = { 367 367 - .name = "soc_camera_platform", 368 368 - .dev = { 369 369 - .platform_data = &camera_info, 370 370 - .release = dummy_release, 371 371 - }, 372 372 - }; 364 364 + static void ap325rxa_camera_release(struct device *dev) 365 365 + { 366 366 + soc_camera_platform_release(&camera_device); 367 367 + } 373 368 374 369 static int ap325rxa_camera_add(struct soc_camera_link *icl, 375 370 struct device *dev) 376 371 { 377 377 - if (icl != &camera_link || camera_probe() <= 0) 378 378 - return -ENODEV; 372 372 + int ret = soc_camera_platform_add(icl, dev, &camera_device, &camera_link, 373 373 + ap325rxa_camera_release, 0); 374 374 + if (ret < 0) 375 375 + return ret; 379 376 380 380 - camera_info.dev = dev; 377 377 + ret = camera_probe(); 378 378 + if (ret < 0) 379 379 + soc_camera_platform_del(icl, camera_device, &camera_link); 381 380 382 382 - return platform_device_register(&camera_device); 381 381 + return ret; 383 382 } 384 383 385 384 static void ap325rxa_camera_del(struct soc_camera_link *icl) 386 385 { 387 387 - if (icl != &camera_link) 388 388 - return; 389 389 - 390 390 - platform_device_unregister(&camera_device); 391 391 - memset(&camera_device.dev.kobj, 0, 392 392 - sizeof(camera_device.dev.kobj)); 386 386 + soc_camera_platform_del(icl, camera_device, &camera_link); 393 387 } 394 388 #endif /* CONFIG_I2C */ 395 389

+3

arch/sh/boards/mach-ecovec24/setup.c

reviewed

··· 885 885 }, 886 886 .num_resources = ARRAY_SIZE(sh_mmcif_resources), 887 887 .resource = sh_mmcif_resources, 888 888 + .archdata = { 889 889 + .hwblk_id = HWBLK_MMC, 890 890 + }, 888 891 }; 889 892 #endif 890 893

+1

arch/sh/include/asm/pgtable.h

reviewed

··· 18 18 #include <asm/pgtable-2level.h> 19 19 #endif 20 20 #include <asm/page.h> 21 21 + #include <asm/mmu.h> 21 22 22 23 #ifndef __ASSEMBLY__ 23 24 #include <asm/addrspace.h>

+4 -2

arch/sh/include/asm/ptrace.h

reviewed

··· 41 41 42 42 #define user_mode(regs) (((regs)->sr & 0x40000000)==0) 43 43 #define kernel_stack_pointer(_regs) ((unsigned long)(_regs)->regs[15]) 44 44 - #define GET_USP(regs) ((regs)->regs[15]) 44 44 + 45 45 + #define GET_FP(regs) ((regs)->regs[14]) 46 46 + #define GET_USP(regs) ((regs)->regs[15]) 45 47 46 48 extern void show_regs(struct pt_regs *); 47 49 ··· 133 131 134 132 static inline unsigned long profile_pc(struct pt_regs *regs) 135 133 { 136 136 - unsigned long pc = instruction_pointer(regs); 134 134 + unsigned long pc = regs->pc; 137 135 138 136 if (virt_addr_uncached(pc)) 139 137 return CAC_ADDR(pc);

+1

arch/sh/include/asm/tlb.h

reviewed

··· 9 9 #include <linux/pagemap.h> 10 10 11 11 #ifdef CONFIG_MMU 12 12 + #include <linux/swap.h> 12 13 #include <asm/pgalloc.h> 13 14 #include <asm/tlbflush.h> 14 15 #include <asm/mmu_context.h>

+1

arch/sh/include/cpu-sh4/cpu/sh7722.h

reviewed

··· 236 236 }; 237 237 238 238 enum { 239 239 + SHDMA_SLAVE_INVALID, 239 240 SHDMA_SLAVE_SCIF0_TX, 240 241 SHDMA_SLAVE_SCIF0_RX, 241 242 SHDMA_SLAVE_SCIF1_TX,

+1

arch/sh/include/cpu-sh4/cpu/sh7724.h

reviewed

··· 285 285 }; 286 286 287 287 enum { 288 288 + SHDMA_SLAVE_INVALID, 288 289 SHDMA_SLAVE_SCIF0_TX, 289 290 SHDMA_SLAVE_SCIF0_RX, 290 291 SHDMA_SLAVE_SCIF1_TX,

+1

arch/sh/include/cpu-sh4/cpu/sh7757.h

reviewed

··· 252 252 }; 253 253 254 254 enum { 255 255 + SHDMA_SLAVE_INVALID, 255 256 SHDMA_SLAVE_SDHI_TX, 256 257 SHDMA_SLAVE_SDHI_RX, 257 258 SHDMA_SLAVE_MMCIF_TX,

+1

arch/sh/kernel/process_32.c

reviewed

··· 21 21 #include <linux/fs.h> 22 22 #include <linux/ftrace.h> 23 23 #include <linux/hw_breakpoint.h> 24 24 + #include <linux/prefetch.h> 24 25 #include <asm/uaccess.h> 25 26 #include <asm/mmu_context.h> 26 27 #include <asm/system.h>

+1 -1

arch/sh/mm/consistent.c

reviewed

··· 82 82 void *addr; 83 83 84 84 addr = __in_29bit_mode() ? 85 85 - (void *)P1SEGADDR((unsigned long)vaddr) : vaddr; 85 85 + (void *)CAC_ADDR((unsigned long)vaddr) : vaddr; 86 86 87 87 switch (direction) { 88 88 case DMA_FROM_DEVICE: /* invalidate only */

+2 -10

drivers/clocksource/sh_cmt.c

reviewed

··· 24 24 #include <linux/ioport.h> 25 25 #include <linux/io.h> 26 26 #include <linux/clk.h> 27 27 - #include <linux/pm_runtime.h> 28 27 #include <linux/irq.h> 29 28 #include <linux/err.h> 30 29 #include <linux/clocksource.h> ··· 152 153 { 153 154 int ret; 154 155 155 155 - /* wake up device and enable clock */ 156 156 - pm_runtime_get_sync(&p->pdev->dev); 156 156 + /* enable clock */ 157 157 ret = clk_enable(p->clk); 158 158 if (ret) { 159 159 dev_err(&p->pdev->dev, "cannot enable clock\n"); 160 160 - pm_runtime_put_sync(&p->pdev->dev); 161 160 return ret; 162 161 } 163 162 ··· 187 190 /* disable interrupts in CMT block */ 188 191 sh_cmt_write(p, CMCSR, 0); 189 192 190 190 - /* stop clock and mark device as idle */ 193 193 + /* stop clock */ 191 194 clk_disable(p->clk); 192 192 - pm_runtime_put_sync(&p->pdev->dev); 193 195 } 194 196 195 197 /* private flags */ ··· 660 664 661 665 if (p) { 662 666 dev_info(&pdev->dev, "kept as earlytimer\n"); 663 663 - pm_runtime_enable(&pdev->dev); 664 667 return 0; 665 668 } 666 669 ··· 674 679 kfree(p); 675 680 platform_set_drvdata(pdev, NULL); 676 681 } 677 677 - 678 678 - if (!is_early_platform_device(pdev)) 679 679 - pm_runtime_enable(&pdev->dev); 680 682 return ret; 681 683 } 682 684

+2 -10

drivers/clocksource/sh_tmu.c

reviewed

··· 25 25 #include <linux/delay.h> 26 26 #include <linux/io.h> 27 27 #include <linux/clk.h> 28 28 - #include <linux/pm_runtime.h> 29 28 #include <linux/irq.h> 30 29 #include <linux/err.h> 31 30 #include <linux/clocksource.h> ··· 109 110 { 110 111 int ret; 111 112 112 112 - /* wake up device and enable clock */ 113 113 - pm_runtime_get_sync(&p->pdev->dev); 113 113 + /* enable clock */ 114 114 ret = clk_enable(p->clk); 115 115 if (ret) { 116 116 dev_err(&p->pdev->dev, "cannot enable clock\n"); 117 117 - pm_runtime_put_sync(&p->pdev->dev); 118 117 return ret; 119 118 } 120 119 ··· 141 144 /* disable interrupts in TMU block */ 142 145 sh_tmu_write(p, TCR, 0x0000); 143 146 144 144 - /* stop clock and mark device as idle */ 147 147 + /* stop clock */ 145 148 clk_disable(p->clk); 146 146 - pm_runtime_put_sync(&p->pdev->dev); 147 149 } 148 150 149 151 static void sh_tmu_set_next(struct sh_tmu_priv *p, unsigned long delta, ··· 411 415 412 416 if (p) { 413 417 dev_info(&pdev->dev, "kept as earlytimer\n"); 414 414 - pm_runtime_enable(&pdev->dev); 415 418 return 0; 416 419 } 417 420 ··· 425 430 kfree(p); 426 431 platform_set_drvdata(pdev, NULL); 427 432 } 428 428 - 429 429 - if (!is_early_platform_device(pdev)) 430 430 - pm_runtime_enable(&pdev->dev); 431 433 return ret; 432 434 } 433 435

+7 -2

drivers/dma/shdma.c

reviewed

··· 343 343 344 344 dmae_set_dmars(sh_chan, cfg->mid_rid); 345 345 dmae_set_chcr(sh_chan, cfg->chcr); 346 346 - } else if ((sh_dmae_readl(sh_chan, CHCR) & 0xf00) != 0x400) { 346 346 + } else { 347 347 dmae_init(sh_chan); 348 348 } 349 349 ··· 1144 1144 /* platform data */ 1145 1145 shdev->pdata = pdata; 1146 1146 1147 1147 + platform_set_drvdata(pdev, shdev); 1148 1148 + 1147 1149 pm_runtime_enable(&pdev->dev); 1148 1150 pm_runtime_get_sync(&pdev->dev); 1149 1151 ··· 1258 1256 1259 1257 pm_runtime_put(&pdev->dev); 1260 1258 1261 1261 - platform_set_drvdata(pdev, shdev); 1262 1259 dma_async_device_register(&shdev->common); 1263 1260 1264 1261 return err; ··· 1279 1278 1280 1279 if (dmars) 1281 1280 iounmap(shdev->dmars); 1281 1281 + 1282 1282 + platform_set_drvdata(pdev, NULL); 1282 1283 emapdmars: 1283 1284 iounmap(shdev->chan_reg); 1284 1285 synchronize_rcu(); ··· 1318 1315 if (shdev->dmars) 1319 1316 iounmap(shdev->dmars); 1320 1317 iounmap(shdev->chan_reg); 1318 1318 + 1319 1319 + platform_set_drvdata(pdev, NULL); 1321 1320 1322 1321 synchronize_rcu(); 1323 1322 kfree(shdev);