Merge tag 'rmobile-for-linus' of git://github.com/pmundt/linux-sh

+15 -14

arch/arm/mach-shmobile/board-ag5evm.c

··· 30 30 #include <linux/serial_sci.h> 31 31 #include <linux/smsc911x.h> 32 32 #include <linux/gpio.h> 33 + #include <linux/videodev2.h> 33 34 #include <linux/input.h> 34 35 #include <linux/input/sh_keysc.h> 35 36 #include <linux/mmc/host.h> ··· 38 37 #include <linux/mmc/sh_mobile_sdhi.h> 39 38 #include <linux/mfd/tmio.h> 40 39 #include <linux/sh_clk.h> 41 - #include <linux/dma-mapping.h> 42 40 #include <video/sh_mobile_lcdc.h> 43 41 #include <video/sh_mipi_dsi.h> 44 42 #include <sound/sh_fsi.h> ··· 159 159 }, 160 160 }; 161 161 162 - static struct sh_mmcif_dma sh_mmcif_dma = { 163 - .chan_priv_rx = { 164 - .slave_id = SHDMA_SLAVE_MMCIF_RX, 165 - }, 166 - .chan_priv_tx = { 167 - .slave_id = SHDMA_SLAVE_MMCIF_TX, 168 - }, 169 - }; 170 162 static struct sh_mmcif_plat_data sh_mmcif_platdata = { 171 163 .sup_pclk = 0, 172 164 .ocr = MMC_VDD_165_195, 173 165 .caps = MMC_CAP_8_BIT_DATA | MMC_CAP_NONREMOVABLE, 174 - .dma = &sh_mmcif_dma, 166 + .slave_id_tx = SHDMA_SLAVE_MMCIF_TX, 167 + .slave_id_rx = SHDMA_SLAVE_MMCIF_RX, 175 168 }; 176 169 177 170 static struct platform_device mmc_device = { ··· 314 321 }, 315 322 }; 316 323 317 - #define DSI0PHYCR 0xe615006c 318 324 static int sh_mipi_set_dot_clock(struct platform_device *pdev, 319 325 void __iomem *base, 320 326 int enable) 321 327 { 322 - struct clk *pck; 328 + struct clk *pck, *phy; 323 329 int ret; 324 330 325 331 pck = clk_get(&pdev->dev, "dsip_clk"); ··· 327 335 goto sh_mipi_set_dot_clock_pck_err; 328 336 } 329 337 338 + phy = clk_get(&pdev->dev, "dsiphy_clk"); 339 + if (IS_ERR(phy)) { 340 + ret = PTR_ERR(phy); 341 + goto sh_mipi_set_dot_clock_phy_err; 342 + } 343 + 330 344 if (enable) { 331 345 clk_set_rate(pck, clk_round_rate(pck, 24000000)); 332 - __raw_writel(0x2a809010, DSI0PHYCR); 346 + clk_set_rate(phy, clk_round_rate(pck, 510000000)); 333 347 clk_enable(pck); 348 + clk_enable(phy); 334 349 } else { 335 350 clk_disable(pck); 351 + clk_disable(phy); 336 352 } 337 353 338 354 ret = 0; 339 355 356 + clk_put(phy); 357 + sh_mipi_set_dot_clock_phy_err: 340 358 clk_put(pck); 341 - 342 359 sh_mipi_set_dot_clock_pck_err: 343 360 return ret; 344 361 }

+2 -10

arch/arm/mach-shmobile/board-ap4evb.c

··· 295 295 }, 296 296 }; 297 297 298 - static struct sh_mmcif_dma sh_mmcif_dma = { 299 - .chan_priv_rx = { 300 - .slave_id = SHDMA_SLAVE_MMCIF_RX, 301 - }, 302 - .chan_priv_tx = { 303 - .slave_id = SHDMA_SLAVE_MMCIF_TX, 304 - }, 305 - }; 306 - 307 298 static struct sh_mmcif_plat_data sh_mmcif_plat = { 308 299 .sup_pclk = 0, 309 300 .ocr = MMC_VDD_165_195 | MMC_VDD_32_33 | MMC_VDD_33_34, ··· 302 311 MMC_CAP_8_BIT_DATA | 303 312 MMC_CAP_NEEDS_POLL, 304 313 .get_cd = slot_cn7_get_cd, 305 - .dma = &sh_mmcif_dma, 314 + .slave_id_tx = SHDMA_SLAVE_MMCIF_TX, 315 + .slave_id_rx = SHDMA_SLAVE_MMCIF_RX, 306 316 }; 307 317 308 318 static struct platform_device sh_mmcif_device = {

+1 -2

arch/arm/mach-shmobile/board-kota2.c

··· 143 143 static struct gpio_keys_platform_data gpio_key_info = { 144 144 .buttons = gpio_buttons, 145 145 .nbuttons = ARRAY_SIZE(gpio_buttons), 146 - .poll_interval = 250, /* polled for now */ 147 146 }; 148 147 149 148 static struct platform_device gpio_keys_device = { 150 - .name = "gpio-keys-polled", /* polled for now */ 149 + .name = "gpio-keys", 151 150 .id = -1, 152 151 .dev = { 153 152 .platform_data = &gpio_key_info,

+21 -74

arch/arm/mach-shmobile/board-mackerel.c

··· 43 43 #include <linux/smsc911x.h> 44 44 #include <linux/sh_intc.h> 45 45 #include <linux/tca6416_keypad.h> 46 - #include <linux/usb/r8a66597.h> 47 46 #include <linux/usb/renesas_usbhs.h> 48 47 #include <linux/dma-mapping.h> 49 48 ··· 144 145 * 1-2 short | VBUS 5V | Host 145 146 * open | external VBUS | Function 146 147 * 147 - * *1 148 - * CN31 is used as 149 - * CONFIG_USB_R8A66597_HCD Host 150 - * CONFIG_USB_RENESAS_USBHS Function 151 - * 152 148 * CAUTION 153 149 * 154 150 * renesas_usbhs driver can use external interrupt mode ··· 155 161 * mackerel can not use external interrupt (IRQ7-PORT167) mode on "USB0", 156 162 * because Touchscreen is using IRQ7-PORT40. 157 163 * It is impossible to use IRQ7 demux on this board. 158 - * 159 - * We can use external interrupt mode USB-Function on "USB1". 160 - * USB1 can become Host by r8a66597, and become Function by renesas_usbhs. 161 - * But don't select both drivers in same time. 162 - * These uses same IRQ number for request_irq(), and aren't supporting 163 - * IRQF_SHARED / IORESOURCE_IRQ_SHAREABLE. 164 - * 165 - * Actually these are old/new version of USB driver. 166 - * This mean its register will be broken if it supports shared IRQ, 167 164 */ 168 165 169 166 /* ··· 190 205 * 191 206 * microSD card sloct 192 207 * 208 + */ 209 + 210 + /* 211 + * FSI - AK4642 212 + * 213 + * it needs amixer settings for playing 214 + * 215 + * amixer set "Headphone" on 216 + * amixer set "HPOUTL Mixer DACH" on 217 + * amixer set "HPOUTR Mixer DACH" on 193 218 */ 194 219 195 220 /* ··· 671 676 * Use J30 to select between Host and Function. This setting 672 677 * can however not be detected by software. Hotplug of USBHS1 673 678 * is provided via IRQ8. 679 + * 680 + * Current USB1 works as "USB Host". 681 + * - set J30 "short" 682 + * 683 + * If you want to use it as "USB gadget", 684 + * - J30 "open" 685 + * - modify usbhs1_get_id() USBHS_HOST -> USBHS_GADGET 686 + * - add .get_vbus = usbhs_get_vbus in usbhs1_private 674 687 */ 675 688 #define IRQ8 evt2irq(0x0300) 676 - 677 - /* USBHS1 USB Host support via r8a66597_hcd */ 678 - static void usb1_host_port_power(int port, int power) 679 - { 680 - if (!power) /* only power-on is supported for now */ 681 - return; 682 - 683 - /* set VBOUT/PWEN and EXTLP1 in DVSTCTR */ 684 - __raw_writew(__raw_readw(0xE68B0008) | 0x600, 0xE68B0008); 685 - } 686 - 687 - static struct r8a66597_platdata usb1_host_data = { 688 - .on_chip = 1, 689 - .port_power = usb1_host_port_power, 690 - }; 691 - 692 - static struct resource usb1_host_resources[] = { 693 - [0] = { 694 - .name = "USBHS1", 695 - .start = 0xe68b0000, 696 - .end = 0xe68b00e6 - 1, 697 - .flags = IORESOURCE_MEM, 698 - }, 699 - [1] = { 700 - .start = evt2irq(0x1ce0) /* USB1_USB1I0 */, 701 - .flags = IORESOURCE_IRQ, 702 - }, 703 - }; 704 - 705 - static struct platform_device usb1_host_device = { 706 - .name = "r8a66597_hcd", 707 - .id = 1, 708 - .dev = { 709 - .dma_mask = NULL, /* not use dma */ 710 - .coherent_dma_mask = 0xffffffff, 711 - .platform_data = &usb1_host_data, 712 - }, 713 - .num_resources = ARRAY_SIZE(usb1_host_resources), 714 - .resource = usb1_host_resources, 715 - }; 716 - 717 - /* USBHS1 USB Function support via renesas_usbhs */ 718 - 719 689 #define USB_PHY_MODE (1 << 4) 720 690 #define USB_PHY_INT_EN ((1 << 3) | (1 << 2)) 721 691 #define USB_PHY_ON (1 << 1) ··· 736 776 737 777 static int usbhs1_get_id(struct platform_device *pdev) 738 778 { 739 - return USBHS_GADGET; 779 + return USBHS_HOST; 740 780 } 741 781 742 782 static u32 usbhs1_pipe_cfg[] = { ··· 767 807 .hardware_exit = usbhs1_hardware_exit, 768 808 .get_id = usbhs1_get_id, 769 809 .phy_reset = usbhs_phy_reset, 770 - .get_vbus = usbhs_get_vbus, 771 810 }, 772 811 .driver_param = { 773 812 .buswait_bwait = 4, ··· 1143 1184 }, 1144 1185 }; 1145 1186 1146 - static struct sh_mmcif_dma sh_mmcif_dma = { 1147 - .chan_priv_rx = { 1148 - .slave_id = SHDMA_SLAVE_MMCIF_RX, 1149 - }, 1150 - .chan_priv_tx = { 1151 - .slave_id = SHDMA_SLAVE_MMCIF_TX, 1152 - }, 1153 - }; 1154 - 1155 1187 static struct sh_mmcif_plat_data sh_mmcif_plat = { 1156 1188 .sup_pclk = 0, 1157 1189 .ocr = MMC_VDD_165_195 | MMC_VDD_32_33 | MMC_VDD_33_34, ··· 1150 1200 MMC_CAP_8_BIT_DATA | 1151 1201 MMC_CAP_NEEDS_POLL, 1152 1202 .get_cd = slot_cn7_get_cd, 1153 - .dma = &sh_mmcif_dma, 1203 + .slave_id_tx = SHDMA_SLAVE_MMCIF_TX, 1204 + .slave_id_rx = SHDMA_SLAVE_MMCIF_RX, 1154 1205 }; 1155 1206 1156 1207 static struct platform_device sh_mmcif_device = { ··· 1262 1311 &nor_flash_device, 1263 1312 &smc911x_device, 1264 1313 &lcdc_device, 1265 - &usb1_host_device, 1266 1314 &usbhs1_device, 1267 1315 &usbhs0_device, 1268 1316 &leds_device, ··· 1422 1472 gpio_request(GPIO_FN_VBUS0_1, NULL); 1423 1473 gpio_pull_down(GPIO_PORT167CR); /* VBUS0_1 pull down */ 1424 1474 gpio_request(GPIO_FN_IDIN_1_113, NULL); 1425 - 1426 - /* USB phy tweak to make the r8a66597_hcd host driver work */ 1427 - __raw_writew(0x8a0a, 0xe6058130); /* USBCR4 */ 1428 1475 1429 1476 /* enable FSI2 port A (ak4643) */ 1430 1477 gpio_request(GPIO_FN_FSIAIBT, NULL);

+113

arch/arm/mach-shmobile/clock-sh73a0.c

··· 365 365 dsi_parent, ARRAY_SIZE(dsi_parent), 12, 3), 366 366 }; 367 367 368 + /* DSI DIV */ 369 + static unsigned long dsiphy_recalc(struct clk *clk) 370 + { 371 + u32 value; 372 + 373 + value = __raw_readl(clk->mapping->base); 374 + 375 + /* FIXME */ 376 + if (!(value & 0x000B8000)) 377 + return clk->parent->rate; 378 + 379 + value &= 0x3f; 380 + value += 1; 381 + 382 + if ((value < 12) || 383 + (value > 33)) { 384 + pr_err("DSIPHY has wrong value (%d)", value); 385 + return 0; 386 + } 387 + 388 + return clk->parent->rate / value; 389 + } 390 + 391 + static long dsiphy_round_rate(struct clk *clk, unsigned long rate) 392 + { 393 + return clk_rate_mult_range_round(clk, 12, 33, rate); 394 + } 395 + 396 + static void dsiphy_disable(struct clk *clk) 397 + { 398 + u32 value; 399 + 400 + value = __raw_readl(clk->mapping->base); 401 + value &= ~0x000B8000; 402 + 403 + __raw_writel(value , clk->mapping->base); 404 + } 405 + 406 + static int dsiphy_enable(struct clk *clk) 407 + { 408 + u32 value; 409 + int multi; 410 + 411 + value = __raw_readl(clk->mapping->base); 412 + multi = (value & 0x3f) + 1; 413 + 414 + if ((multi < 12) || (multi > 33)) 415 + return -EIO; 416 + 417 + __raw_writel(value | 0x000B8000, clk->mapping->base); 418 + 419 + return 0; 420 + } 421 + 422 + static int dsiphy_set_rate(struct clk *clk, unsigned long rate) 423 + { 424 + u32 value; 425 + int idx; 426 + 427 + idx = rate / clk->parent->rate; 428 + if ((idx < 12) || (idx > 33)) 429 + return -EINVAL; 430 + 431 + idx += -1; 432 + 433 + value = __raw_readl(clk->mapping->base); 434 + value = (value & ~0x3f) + idx; 435 + 436 + __raw_writel(value, clk->mapping->base); 437 + 438 + return 0; 439 + } 440 + 441 + static struct clk_ops dsiphy_clk_ops = { 442 + .recalc = dsiphy_recalc, 443 + .round_rate = dsiphy_round_rate, 444 + .set_rate = dsiphy_set_rate, 445 + .enable = dsiphy_enable, 446 + .disable = dsiphy_disable, 447 + }; 448 + 449 + static struct clk_mapping dsi0phy_clk_mapping = { 450 + .phys = DSI0PHYCR, 451 + .len = 4, 452 + }; 453 + 454 + static struct clk_mapping dsi1phy_clk_mapping = { 455 + .phys = DSI1PHYCR, 456 + .len = 4, 457 + }; 458 + 459 + static struct clk dsi0phy_clk = { 460 + .ops = &dsiphy_clk_ops, 461 + .parent = &div6_clks[DIV6_DSI0P], /* late install */ 462 + .mapping = &dsi0phy_clk_mapping, 463 + }; 464 + 465 + static struct clk dsi1phy_clk = { 466 + .ops = &dsiphy_clk_ops, 467 + .parent = &div6_clks[DIV6_DSI1P], /* late install */ 468 + .mapping = &dsi1phy_clk_mapping, 469 + }; 470 + 471 + static struct clk *late_main_clks[] = { 472 + &dsi0phy_clk, 473 + &dsi1phy_clk, 474 + }; 475 + 368 476 enum { MSTP001, 369 477 MSTP129, MSTP128, MSTP127, MSTP126, MSTP125, MSTP118, MSTP116, MSTP100, 370 478 MSTP219, ··· 537 429 CLKDEV_ICK_ID("dsit_clk", "sh-mipi-dsi.1", &div6_clks[DIV6_DSIT]), 538 430 CLKDEV_ICK_ID("dsip_clk", "sh-mipi-dsi.0", &div6_clks[DIV6_DSI0P]), 539 431 CLKDEV_ICK_ID("dsip_clk", "sh-mipi-dsi.1", &div6_clks[DIV6_DSI1P]), 432 + CLKDEV_ICK_ID("dsiphy_clk", "sh-mipi-dsi.0", &dsi0phy_clk), 433 + CLKDEV_ICK_ID("dsiphy_clk", "sh-mipi-dsi.1", &dsi1phy_clk), 540 434 541 435 /* MSTP32 clocks */ 542 436 CLKDEV_DEV_ID("i2c-sh_mobile.2", &mstp_clks[MSTP001]), /* I2C2 */ ··· 613 503 614 504 if (!ret) 615 505 ret = sh_clk_mstp32_register(mstp_clks, MSTP_NR); 506 + 507 + for (k = 0; !ret && (k < ARRAY_SIZE(late_main_clks)); k++) 508 + ret = clk_register(late_main_clks[k]); 616 509 617 510 clkdev_add_table(lookups, ARRAY_SIZE(lookups)); 618 511

+3 -3

arch/arm/mach-shmobile/include/mach/sh73a0.h

··· 515 515 SHDMA_SLAVE_MMCIF_RX, 516 516 }; 517 517 518 - /* PINT interrupts are located at Linux IRQ 768 and up */ 519 - #define SH73A0_PINT0_IRQ(irq) ((irq) + 768) 520 - #define SH73A0_PINT1_IRQ(irq) ((irq) + 800) 518 + /* PINT interrupts are located at Linux IRQ 800 and up */ 519 + #define SH73A0_PINT0_IRQ(irq) ((irq) + 800) 520 + #define SH73A0_PINT1_IRQ(irq) ((irq) + 832) 521 521 522 522 #endif /* __ASM_SH73A0_H__ */

+2

arch/arm/mach-shmobile/intc-sh73a0.c

··· 19 19 #include <linux/kernel.h> 20 20 #include <linux/init.h> 21 21 #include <linux/interrupt.h> 22 + #include <linux/module.h> 22 23 #include <linux/irq.h> 23 24 #include <linux/io.h> 24 25 #include <linux/sh_intc.h> ··· 446 445 setup_irq(gic_spi(1 + k), &sh73a0_irq_pin_cascade[k]); 447 446 448 447 n = intcs_evt2irq(to_intc_vect(gic_spi(1 + k))); 448 + WARN_ON(irq_alloc_desc_at(n, numa_node_id()) != n); 449 449 irq_set_chip_and_handler_name(n, &intca_gic_irq_chip, 450 450 handle_level_irq, "level"); 451 451 set_irq_flags(n, IRQF_VALID); /* yuck */

+1 -1

arch/arm/mach-shmobile/pfc-r8a7779.c

··· 2120 2120 FN_AUDATA3, 0, 0, 0 } 2121 2121 }, 2122 2122 { PINMUX_CFG_REG_VAR("IPSR4", 0xfffc0030, 32, 2123 - 3, 1, 1, 1, 1, 1, 1, 3, 3, 1, 2123 + 3, 1, 1, 1, 1, 1, 1, 3, 3, 2124 2124 1, 1, 1, 1, 1, 1, 3, 3, 3, 2) { 2125 2125 /* IP4_31_29 [3] */ 2126 2126 FN_DU1_DB0, FN_VI2_DATA4_VI2_B4, FN_SCL2_B, FN_SD3_DAT0,

+41

arch/arm/mach-shmobile/pfc-sh7372.c

··· 23 23 #include <linux/init.h> 24 24 #include <linux/kernel.h> 25 25 #include <linux/gpio.h> 26 + #include <mach/irqs.h> 26 27 #include <mach/sh7372.h> 27 28 28 29 #define CPU_ALL_PORT(fn, pfx, sfx) \ ··· 1595 1594 { }, 1596 1595 }; 1597 1596 1597 + #define EXT_IRQ16L(n) evt2irq(0x200 + ((n) << 5)) 1598 + #define EXT_IRQ16H(n) evt2irq(0x3200 + (((n) - 16) << 5)) 1599 + static struct pinmux_irq pinmux_irqs[] = { 1600 + PINMUX_IRQ(EXT_IRQ16L(0), PORT6_FN0, PORT162_FN0), 1601 + PINMUX_IRQ(EXT_IRQ16L(1), PORT12_FN0), 1602 + PINMUX_IRQ(EXT_IRQ16L(2), PORT4_FN0, PORT5_FN0), 1603 + PINMUX_IRQ(EXT_IRQ16L(3), PORT8_FN0, PORT16_FN0), 1604 + PINMUX_IRQ(EXT_IRQ16L(4), PORT17_FN0, PORT163_FN0), 1605 + PINMUX_IRQ(EXT_IRQ16L(5), PORT18_FN0), 1606 + PINMUX_IRQ(EXT_IRQ16L(6), PORT39_FN0, PORT164_FN0), 1607 + PINMUX_IRQ(EXT_IRQ16L(7), PORT40_FN0, PORT167_FN0), 1608 + PINMUX_IRQ(EXT_IRQ16L(8), PORT41_FN0, PORT168_FN0), 1609 + PINMUX_IRQ(EXT_IRQ16L(9), PORT42_FN0, PORT169_FN0), 1610 + PINMUX_IRQ(EXT_IRQ16L(10), PORT65_FN0), 1611 + PINMUX_IRQ(EXT_IRQ16L(11), PORT67_FN0), 1612 + PINMUX_IRQ(EXT_IRQ16L(12), PORT80_FN0, PORT137_FN0), 1613 + PINMUX_IRQ(EXT_IRQ16L(13), PORT81_FN0, PORT145_FN0), 1614 + PINMUX_IRQ(EXT_IRQ16L(14), PORT82_FN0, PORT146_FN0), 1615 + PINMUX_IRQ(EXT_IRQ16L(15), PORT83_FN0, PORT147_FN0), 1616 + PINMUX_IRQ(EXT_IRQ16H(16), PORT84_FN0, PORT170_FN0), 1617 + PINMUX_IRQ(EXT_IRQ16H(17), PORT85_FN0), 1618 + PINMUX_IRQ(EXT_IRQ16H(18), PORT86_FN0), 1619 + PINMUX_IRQ(EXT_IRQ16H(19), PORT87_FN0), 1620 + PINMUX_IRQ(EXT_IRQ16H(20), PORT92_FN0), 1621 + PINMUX_IRQ(EXT_IRQ16H(21), PORT93_FN0), 1622 + PINMUX_IRQ(EXT_IRQ16H(22), PORT94_FN0), 1623 + PINMUX_IRQ(EXT_IRQ16H(23), PORT95_FN0), 1624 + PINMUX_IRQ(EXT_IRQ16H(24), PORT112_FN0), 1625 + PINMUX_IRQ(EXT_IRQ16H(25), PORT119_FN0), 1626 + PINMUX_IRQ(EXT_IRQ16H(26), PORT121_FN0, PORT172_FN0), 1627 + PINMUX_IRQ(EXT_IRQ16H(27), PORT122_FN0, PORT180_FN0), 1628 + PINMUX_IRQ(EXT_IRQ16H(28), PORT123_FN0, PORT181_FN0), 1629 + PINMUX_IRQ(EXT_IRQ16H(29), PORT129_FN0, PORT182_FN0), 1630 + PINMUX_IRQ(EXT_IRQ16H(30), PORT130_FN0, PORT183_FN0), 1631 + PINMUX_IRQ(EXT_IRQ16H(31), PORT138_FN0, PORT184_FN0), 1632 + }; 1633 + 1598 1634 static struct pinmux_info sh7372_pinmux_info = { 1599 1635 .name = "sh7372_pfc", 1600 1636 .reserved_id = PINMUX_RESERVED, ··· 1652 1614 1653 1615 .gpio_data = pinmux_data, 1654 1616 .gpio_data_size = ARRAY_SIZE(pinmux_data), 1617 + 1618 + .gpio_irq = pinmux_irqs, 1619 + .gpio_irq_size = ARRAY_SIZE(pinmux_irqs), 1655 1620 }; 1656 1621 1657 1622 void sh7372_pinmux_init(void)

+1 -1

arch/arm/mach-shmobile/smp-sh73a0.c

··· 80 80 /* enable cache coherency */ 81 81 modify_scu_cpu_psr(0, 3 << (cpu * 8)); 82 82 83 - if (((__raw_readw(__io(PSTR)) >> (4 * cpu)) & 3) == 3) 83 + if (((__raw_readl(__io(PSTR)) >> (4 * cpu)) & 3) == 3) 84 84 __raw_writel(1 << cpu, __io(WUPCR)); /* wake up */ 85 85 else 86 86 __raw_writel(1 << cpu, __io(SRESCR)); /* reset */

Configure Feed

Configure Feed