Ticket #9461: ralink_spi.patch

File ralink_spi.patch, 18.3 KB (added by Sergiy <piratfm@…>, 6 years ago)

SPI bus driver for RT305x/RT288x

  • target/linux/ramips/files/arch/mips/ralink/rt305x/devices.c

     
    217217 
    218218        platform_device_register(&rt305x_wdt_device); 
    219219} 
     220 
     221static struct resource rt305x_spi_resources[] = { 
     222        { 
     223                .name   = "spi-regs", 
     224                .flags  = IORESOURCE_MEM, 
     225                .start  = RT305X_SPI_BASE, 
     226                .end    = RT305X_SPI_BASE + RT305X_SPI_SIZE - 1, 
     227        }, 
     228}; 
     229 
     230static struct platform_device rt305x_spi_device = { 
     231        .name           = "ramips-spi", 
     232        .id             = 0, 
     233        .resource       = rt305x_spi_resources, 
     234        .num_resources  = ARRAY_SIZE(rt305x_spi_resources), 
     235}; 
     236 
     237void __init rt305x_register_spi(void) 
     238{ 
     239        platform_device_register(&rt305x_spi_device); 
     240}; 
  • target/linux/ramips/files/arch/mips/ralink/rt305x/devices.h

     
    2121void rt305x_register_ethernet(void); 
    2222void rt305x_register_wifi(void); 
    2323void rt305x_register_wdt(void); 
     24void rt305x_register_spi(void); 
    2425 
    2526#endif  /* __RT305X_DEVICES_H */ 
    2627 
  • target/linux/ramips/files/arch/mips/include/asm/mach-ralink/ramips_spi.h

     
     1/* 
     2 * SPI Controller 
     3 * 
     4 * Copyright (C) 2011 Sergiy <piratfm@gmail.com> 
     5 * 
     6 * This code is free software; you can redistribute it and/or modify 
     7 * it under the terms of the GNU General Public License version 2 as 
     8 * published by the Free Software Foundation. 
     9 * 
     10 */ 
     11#ifndef __RAMIPS_SPIFLASH_H 
     12#define __RAMIPS_SPIFLASH_H 
     13 
     14#define RAMIPS_SPI_STAT         0x00 
     15#define RAMIPS_SPI_CFG          0x10 
     16#define RAMIPS_SPI_CTL          0x14 
     17#define RAMIPS_SPI_DATA         0x20 
     18 
     19/* SPISTAT register bit field */ 
     20#define SPISTAT_BUSY           0x00000001 
     21 
     22/* SPICFG register bit field */ 
     23#define SPICFG_LSBFIRST                 (0<<8) 
     24#define SPICFG_MSBFIRST                 (1<<8) 
     25#define SPICFG_RXCLKEDGE_FALLING        (1<<5)    /* rx on the falling edge of the SPICLK signal */ 
     26#define SPICFG_TXCLKEDGE_FALLING        (1<<4)    /* tx on the falling edge of the SPICLK signal */ 
     27#define SPICFG_SPICLK_DIV2              (0<<0)    /* system clock rate / 2  */ 
     28#define SPICFG_SPICLK_DIV4              (1<<0)    /* system clock rate / 4  */ 
     29#define SPICFG_SPICLK_DIV8              (2<<0)    /* system clock rate / 8  */ 
     30#define SPICFG_SPICLK_DIV16             (3<<0)    /* system clock rate / 16  */ 
     31#define SPICFG_SPICLK_DIV32             (4<<0)    /* system clock rate / 32  */ 
     32#define SPICFG_SPICLK_DIV64             (5<<0)    /* system clock rate / 64  */ 
     33#define SPICFG_SPICLK_DIV128            (6<<0)    /* system clock rate / 128 */ 
     34#define SPICFG_SPICLK_DISABLE           (7<<0)    /* system clock disabled */ 
     35#define SPICFG_SPICLKPOL                (1<<6)    /* spi clk*/ 
     36 
     37/* SPICTL register bit field */ 
     38#define SPICTL_HIZSDO                   (1<<3) 
     39#define SPICTL_STARTWR                  (1<<2) 
     40#define SPICTL_STARTRD                  (1<<1) 
     41#define SPICTL_SPIENA                   (1<<0) 
     42 
     43#define CFG_CLK_DIV             SPICFG_SPICLK_DIV16 
     44 
     45#endif 
  • target/linux/ramips/files/arch/mips/include/asm/mach-ralink/rt305x_regs.h

     
    4242#define RT305X_UART0_SIZE       0x100 
    4343#define RT305X_PIO_SIZE         0x100 
    4444#define RT305X_UART1_SIZE       0x100 
     45#define RT305X_SPI_SIZE         0x100 
    4546#define RT305X_FLASH1_SIZE      (16 * 1024 * 1024) 
    4647#define RT305X_FLASH0_SIZE      (8 * 1024 * 1024) 
    4748 
  • target/linux/ramips/files/drivers/spi/ramips_spi.c

     
     1/* 
     2 * ramips_spi.c -- Ralink RT288x/RT305x SPI controller driver 
     3 * 
     4 * Author: Sergiy <piratfm@gmail.com> 
     5 * Copyright (C) 2011 OpenWrt.org. 
     6 * 
     7 * This program is free software; you can redistribute it and/or modify 
     8 * it under the terms of the GNU General Public License version 2 as 
     9 * published by the Free Software Foundation. 
     10 */ 
     11 
     12#include <linux/init.h> 
     13#include <linux/clk.h> 
     14#include <linux/err.h> 
     15#include <linux/delay.h> 
     16#include <linux/platform_device.h> 
     17#include <linux/err.h> 
     18#include <linux/io.h> 
     19#include <linux/spi/spi.h> 
     20#include <asm/unaligned.h> 
     21 
     22 
     23#if defined(CONFIG_RALINK_RT305X) 
     24#include <rt305x.h> 
     25#include <rt305x_regs.h> 
     26#elif defined(CONFIG_RALINK_RT288X) 
     27#include <rt288x.h> 
     28#include <rt288x_regs.h> 
     29#else 
     30#error "Add support for your platform" 
     31#endif 
     32 
     33#include <asm/mach-ralink/ramips_spi.h> 
     34 
     35#define DRIVER_NAME                     "ramips-spi" 
     36#define RALINK_NUM_CHIPSELECTS          1 /* only one slave is supported*/ 
     37#define RALINK_SPI_WAIT_RDY_MAX_LOOP    2000 /* in usec */ 
     38#define SPICFG_CLK_PRESCALE_MASK        0x07 
     39 
     40//#define DEBUG 
     41 
     42#ifdef DEBUG 
     43#define spi_debug(args...) printk(args) 
     44#else 
     45#define spi_debug(args...) 
     46#endif 
     47 
     48 
     49struct ramips_spi { 
     50        struct work_struct      work; 
     51 
     52        /* Lock access to transfer list.        */ 
     53        spinlock_t              lock; 
     54 
     55        struct list_head        msg_queue; 
     56        struct spi_master       *master; 
     57        void __iomem            *base; 
     58        unsigned int            sys_freq; 
     59        unsigned int            speed; 
     60}; 
     61 
     62static struct workqueue_struct *ramips_spi_wq; 
     63 
     64static inline void __iomem *spi_reg(struct ramips_spi *ramips_spi, u32 reg) 
     65{ 
     66        return ramips_spi->base + reg; 
     67} 
     68 
     69static inline void 
     70ramips_spi_setbits(struct ramips_spi *ramips_spi, u32 reg, u32 mask) 
     71{ 
     72        void __iomem *reg_addr = spi_reg(ramips_spi, reg); 
     73        u32 val; 
     74 
     75        val = readl(reg_addr); 
     76        val |= mask; 
     77        writel(val, reg_addr); 
     78} 
     79 
     80static inline void 
     81ramips_spi_clrbits(struct ramips_spi *ramips_spi, u32 reg, u32 mask) 
     82{ 
     83        void __iomem *reg_addr = spi_reg(ramips_spi, reg); 
     84        u32 val; 
     85 
     86        val = readl(reg_addr); 
     87        val &= ~mask; 
     88        writel(val, reg_addr); 
     89} 
     90 
     91static int ramips_spi_baudrate_set(struct spi_device *spi, unsigned int speed) 
     92{ 
     93 
     94        u32 rate; 
     95        u32 prescale; 
     96        u32 reg; 
     97        struct ramips_spi *ramips_spi = spi_master_get_devdata(spi->master); 
     98 
     99        spi_debug("%s: speed:%u\n", __func__, speed); 
     100 
     101        /* 
     102         * the supported rates are: 2,4,8...128 
     103         * round up as we look for equal or less speed 
     104         */ 
     105        rate = DIV_ROUND_UP(ramips_spi->sys_freq, speed); 
     106        spi_debug("%s: rate-1:%u\n", __func__, rate); 
     107        rate = roundup_pow_of_two(rate); 
     108        spi_debug("%s: rate-2:%u\n", __func__, rate); 
     109 
     110        /* check if requested speed is too small */ 
     111        if (rate > 128) 
     112                return -EINVAL; 
     113 
     114        if (rate < 2) 
     115                rate = 2; 
     116 
     117        /* Convert the rate to SPI clock divisor value. */ 
     118        prescale = ilog2(rate/2); 
     119        spi_debug("%s: prescale:%u\n", __func__, prescale); 
     120 
     121        reg = readl(spi_reg(ramips_spi, RAMIPS_SPI_CFG)); 
     122        reg = ((reg & ~SPICFG_CLK_PRESCALE_MASK) | prescale); 
     123        writel(reg, spi_reg(ramips_spi, RAMIPS_SPI_CFG)); 
     124        ramips_spi->speed = speed; 
     125        return 0; 
     126} 
     127 
     128/* 
     129 * called only when no transfer is active on the bus 
     130 */ 
     131static int 
     132ramips_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t) 
     133{ 
     134        struct ramips_spi *ramips_spi = spi_master_get_devdata(spi->master); 
     135        unsigned int speed = spi->max_speed_hz; 
     136        int     rc; 
     137        unsigned int bits_per_word = 8; 
     138 
     139        if ((t != NULL) && t->speed_hz) 
     140                speed = t->speed_hz; 
     141 
     142        if ((t != NULL) && t->bits_per_word) 
     143                bits_per_word = t->bits_per_word; 
     144 
     145        if(ramips_spi->speed != speed){ 
     146                spi_debug("%s: speed_hz:%u\n", __func__, speed); 
     147                rc = ramips_spi_baudrate_set(spi, speed); 
     148                if (rc) 
     149                        return rc; 
     150        } 
     151 
     152        if(bits_per_word != 8) { 
     153                spi_debug("%s: bad bits_per_word: %u\n", __func__, bits_per_word); 
     154                return -EINVAL; 
     155        } 
     156 
     157        return 0; 
     158} 
     159 
     160static void ramips_spi_set_cs(struct ramips_spi *ramips_spi, int enable) 
     161{ 
     162        if (enable) 
     163                ramips_spi_clrbits(ramips_spi, RAMIPS_SPI_CTL, SPICTL_SPIENA); 
     164        else 
     165                ramips_spi_setbits(ramips_spi, RAMIPS_SPI_CTL, SPICTL_SPIENA); 
     166} 
     167 
     168static inline int ramips_spi_wait_till_ready(struct ramips_spi *ramips_spi) 
     169{ 
     170        int i; 
     171 
     172        for (i = 0; i < RALINK_SPI_WAIT_RDY_MAX_LOOP; i++) { 
     173                if (readl(spi_reg(ramips_spi, RAMIPS_SPI_STAT)) & SPISTAT_BUSY) 
     174                        udelay(1); 
     175                else 
     176                        return 1; 
     177        } 
     178 
     179        return -1; 
     180} 
     181 
     182static unsigned int 
     183ramips_spi_write_read(struct spi_device *spi, struct spi_transfer *xfer) 
     184{ 
     185        struct ramips_spi *ramips_spi = spi_master_get_devdata(spi->master); 
     186        unsigned count = 0; 
     187        u8 *rx = xfer->rx_buf; 
     188        const u8 *tx = xfer->tx_buf; 
     189        void __iomem *tx_rx_reg = spi_reg(ramips_spi, RAMIPS_SPI_DATA); 
     190 
     191        spi_debug("%s(%d): %s %s\n", __func__, xfer->len, (tx!=NULL)?("tx"):("  "), (rx!=NULL)?("rx"):("  ")); 
     192        if(tx) { 
     193                for(count=0; count<xfer->len; count++){ 
     194                        writel(tx[count], tx_rx_reg); 
     195                        ramips_spi_setbits(ramips_spi, RAMIPS_SPI_CTL, SPICTL_STARTWR); 
     196                        if (ramips_spi_wait_till_ready(ramips_spi) < 0) { 
     197                                dev_err(&spi->dev, "TXS timed out in %s\n", __func__); 
     198                                goto out; 
     199                        } 
     200                } 
     201        } 
     202 
     203        if(rx) { 
     204                for(count=0; count<xfer->len; count++){ 
     205                        ramips_spi_setbits(ramips_spi, RAMIPS_SPI_CTL, SPICTL_STARTRD); 
     206                        if (ramips_spi_wait_till_ready(ramips_spi) < 0) { 
     207                                dev_err(&spi->dev, "RXS timed out in %s\n", __func__); 
     208                                goto out; 
     209                        } 
     210                        rx[count] = (u8 ) readl(tx_rx_reg); 
     211                } 
     212        } 
     213 
     214out: 
     215        return count; 
     216} 
     217 
     218 
     219static void ramips_spi_work(struct work_struct *work) 
     220{ 
     221        struct ramips_spi *ramips_spi = 
     222                container_of(work, struct ramips_spi, work); 
     223 
     224        spin_lock_irq(&ramips_spi->lock); 
     225        while (!list_empty(&ramips_spi->msg_queue)) { 
     226                struct spi_message *m; 
     227                struct spi_device *spi; 
     228                struct spi_transfer *t = NULL; 
     229                int par_override = 0; 
     230                int status = 0; 
     231                int cs_active = 0; 
     232 
     233                m = container_of(ramips_spi->msg_queue.next, struct spi_message, 
     234                                 queue); 
     235 
     236                list_del_init(&m->queue); 
     237                spin_unlock_irq(&ramips_spi->lock); 
     238 
     239                spi = m->spi; 
     240 
     241                /* Load defaults */ 
     242                status = ramips_spi_setup_transfer(spi, NULL); 
     243 
     244                if (status < 0) 
     245                        goto msg_done; 
     246 
     247                list_for_each_entry(t, &m->transfers, transfer_list) { 
     248                        if (par_override || t->speed_hz || t->bits_per_word) { 
     249                                par_override = 1; 
     250                                status = ramips_spi_setup_transfer(spi, t); 
     251                                if (status < 0) 
     252                                        break; 
     253                                if (!t->speed_hz && !t->bits_per_word) 
     254                                        par_override = 0; 
     255                        } 
     256 
     257                        if (!cs_active) { 
     258                                ramips_spi_set_cs(ramips_spi, 1); 
     259                                cs_active = 1; 
     260                        } 
     261 
     262                        if (t->len) 
     263                                m->actual_length += 
     264                                        ramips_spi_write_read(spi, t); 
     265 
     266                        if (t->delay_usecs) 
     267                                udelay(t->delay_usecs); 
     268 
     269                        if (t->cs_change) { 
     270                                ramips_spi_set_cs(ramips_spi, 0); 
     271                                cs_active = 0; 
     272                        } 
     273                } 
     274 
     275msg_done: 
     276                if (cs_active) 
     277                        ramips_spi_set_cs(ramips_spi, 0); 
     278 
     279                m->status = status; 
     280                m->complete(m->context); 
     281 
     282                spin_lock_irq(&ramips_spi->lock); 
     283        } 
     284 
     285        spin_unlock_irq(&ramips_spi->lock); 
     286} 
     287 
     288static int __init ramips_spi_reset(struct ramips_spi *ramips_spi) 
     289{ 
     290        u32 reg; 
     291        void __iomem *cfg_reg, *ctl_reg; 
     292 
     293        cfg_reg = spi_reg(ramips_spi, RAMIPS_SPI_CFG); 
     294        ctl_reg = spi_reg(ramips_spi, RAMIPS_SPI_CTL); 
     295 
     296        // GPIO-SPI mode 
     297        reg = rt305x_sysc_rr(SYSC_REG_GPIO_MODE); 
     298        reg &= ~(RT305X_GPIO_MODE_SPI); 
     299        rt305x_sysc_wr(reg, SYSC_REG_GPIO_MODE); 
     300 
     301        rt305x_sysc_wr(RT305X_RESET_SPI, SYSC_REG_RESET_CTRL); 
     302        udelay(1); 
     303 
     304        writel(SPICFG_MSBFIRST | SPICFG_TXCLKEDGE_FALLING | SPICFG_SPICLK_DIV16 | SPICFG_SPICLKPOL, cfg_reg); 
     305        writel(SPICTL_HIZSDO | SPICTL_SPIENA, ctl_reg); 
     306 
     307        return 0; 
     308} 
     309 
     310static int ramips_spi_setup(struct spi_device *spi) 
     311{ 
     312        struct ramips_spi *ramips_spi = spi_master_get_devdata(spi->master); 
     313 
     314        if ((spi->max_speed_hz == 0) 
     315                        || (spi->max_speed_hz > (ramips_spi->sys_freq/2))) 
     316                spi->max_speed_hz = (ramips_spi->sys_freq/2); 
     317 
     318        if (spi->max_speed_hz < (ramips_spi->sys_freq/128)) { 
     319                dev_err(&spi->dev, "setup: requested speed too low %d Hz\n", 
     320                        spi->max_speed_hz); 
     321                return -EINVAL; 
     322        } 
     323 
     324        if(spi->bits_per_word != 0 && spi->bits_per_word != 8) { 
     325                dev_err(&spi->dev, "setup: requested bits per words - os wrong %d bpw\n", 
     326                        spi->bits_per_word); 
     327                return -EINVAL; 
     328        } 
     329 
     330        if(spi->bits_per_word == 0) 
     331                spi->bits_per_word = 8; 
     332 
     333        /* 
     334         * baudrate & width will be set ramips_spi_setup_transfer 
     335         */ 
     336        return 0; 
     337} 
     338 
     339static int ramips_spi_transfer(struct spi_device *spi, struct spi_message *m) 
     340{ 
     341        struct ramips_spi *ramips_spi; 
     342        struct spi_transfer *t = NULL; 
     343        unsigned long flags; 
     344 
     345        m->actual_length = 0; 
     346        m->status = 0; 
     347 
     348        /* reject invalid messages and transfers */ 
     349        if (list_empty(&m->transfers) || !m->complete) 
     350                return -EINVAL; 
     351 
     352        ramips_spi = spi_master_get_devdata(spi->master); 
     353 
     354        list_for_each_entry(t, &m->transfers, transfer_list) { 
     355                unsigned int bits_per_word = spi->bits_per_word; 
     356 
     357                if (t->tx_buf == NULL && t->rx_buf == NULL && t->len) { 
     358                        dev_err(&spi->dev, 
     359                                "message rejected : " 
     360                                "invalid transfer data buffers\n"); 
     361                        goto msg_rejected; 
     362                } 
     363 
     364                if (t->bits_per_word) 
     365                        bits_per_word = t->bits_per_word; 
     366 
     367                if (bits_per_word != 8) { 
     368                        dev_err(&spi->dev, 
     369                                "message rejected : " 
     370                                "invalid transfer bits_per_word (%d bits)\n", 
     371                                bits_per_word); 
     372                        goto msg_rejected; 
     373                } 
     374 
     375                if (t->speed_hz && t->speed_hz < (ramips_spi->sys_freq/128)) { 
     376                        dev_err(&spi->dev, 
     377                                "message rejected : " 
     378                                "device min speed (%d Hz) exceeds " 
     379                                "required transfer speed (%d Hz)\n", 
     380                                (ramips_spi->sys_freq/128), t->speed_hz); 
     381                        goto msg_rejected; 
     382                } 
     383        } 
     384 
     385 
     386        spin_lock_irqsave(&ramips_spi->lock, flags); 
     387        list_add_tail(&m->queue, &ramips_spi->msg_queue); 
     388        queue_work(ramips_spi_wq, &ramips_spi->work); 
     389        spin_unlock_irqrestore(&ramips_spi->lock, flags); 
     390 
     391        return 0; 
     392msg_rejected: 
     393        /* Message rejected and not queued */ 
     394        m->status = -EINVAL; 
     395        if (m->complete) 
     396                m->complete(m->context); 
     397        return -EINVAL; 
     398} 
     399 
     400static int __init ramips_spi_probe(struct platform_device *pdev) 
     401{ 
     402        struct spi_master *master; 
     403        struct ramips_spi *spi; 
     404        struct resource *r; 
     405        struct clk *clk; 
     406        int status = 0; 
     407 
     408        master = spi_alloc_master(&pdev->dev, sizeof *spi); 
     409        if (master == NULL) { 
     410                dev_dbg(&pdev->dev, "master allocation failed\n"); 
     411                return -ENOMEM; 
     412        } 
     413 
     414        if (pdev->id != -1) 
     415                master->bus_num = pdev->id; 
     416 
     417        /* we support only mode 0, and no options */ 
     418        master->mode_bits = 0; 
     419 
     420        master->setup = ramips_spi_setup; 
     421        master->transfer = ramips_spi_transfer; 
     422        master->num_chipselect = RALINK_NUM_CHIPSELECTS; 
     423 
     424        dev_set_drvdata(&pdev->dev, master); 
     425 
     426        spi = spi_master_get_devdata(master); 
     427        spi->master = master; 
     428 
     429 
     430        clk = clk_get(NULL, "sys"); 
     431        if (IS_ERR(clk)) 
     432                panic("unable to get SYS clock, err=%ld", PTR_ERR(clk)); 
     433 
     434        spi->sys_freq = clk_get_rate(clk); 
     435        spi_debug("%s: sys_freq: %ld \n", __func__, spi->sys_freq); 
     436 
     437        r = platform_get_resource(pdev, IORESOURCE_MEM, 0); 
     438        if (r == NULL) { 
     439                status = -ENODEV; 
     440                goto out; 
     441        } 
     442 
     443        if (!request_mem_region(r->start, (r->end - r->start) + 1, 
     444                                dev_name(&pdev->dev))) { 
     445                status = -EBUSY; 
     446                goto out; 
     447        } 
     448        spi->base = ioremap(r->start, resource_size(r)); 
     449 
     450        INIT_WORK(&spi->work, ramips_spi_work); 
     451 
     452        spin_lock_init(&spi->lock); 
     453        INIT_LIST_HEAD(&spi->msg_queue); 
     454 
     455        if (ramips_spi_reset(spi) < 0) 
     456                goto out_rel_mem; 
     457 
     458        status = spi_register_master(master); 
     459        if (status < 0) 
     460                goto out_rel_mem; 
     461 
     462        return status; 
     463 
     464out_rel_mem: 
     465        release_mem_region(r->start, (r->end - r->start) + 1); 
     466 
     467out: 
     468        spi_master_put(master); 
     469        return status; 
     470} 
     471 
     472 
     473static int __exit ramips_spi_remove(struct platform_device *pdev) 
     474{ 
     475        struct spi_master *master; 
     476        struct ramips_spi *spi; 
     477        struct resource *r; 
     478 
     479        master = dev_get_drvdata(&pdev->dev); 
     480        spi = spi_master_get_devdata(master); 
     481 
     482        cancel_work_sync(&spi->work); 
     483 
     484        r = platform_get_resource(pdev, IORESOURCE_MEM, 0); 
     485        release_mem_region(r->start, (r->end - r->start) + 1); 
     486 
     487        spi_unregister_master(master); 
     488 
     489        return 0; 
     490} 
     491 
     492MODULE_ALIAS("platform:" DRIVER_NAME); 
     493 
     494static struct platform_driver ramips_spi_driver = { 
     495        .driver = { 
     496                .name   = DRIVER_NAME, 
     497                .owner  = THIS_MODULE, 
     498        }, 
     499        .remove         = __exit_p(ramips_spi_remove), 
     500}; 
     501 
     502static int __init ramips_spi_init(void) 
     503{ 
     504        ramips_spi_wq = create_singlethread_workqueue( 
     505                                ramips_spi_driver.driver.name); 
     506        if (ramips_spi_wq == NULL) 
     507                return -ENOMEM; 
     508 
     509        return platform_driver_probe(&ramips_spi_driver, ramips_spi_probe); 
     510} 
     511module_init(ramips_spi_init); 
     512 
     513static void __exit ramips_spi_exit(void) 
     514{ 
     515        flush_workqueue(ramips_spi_wq); 
     516        platform_driver_unregister(&ramips_spi_driver); 
     517 
     518        destroy_workqueue(ramips_spi_wq); 
     519} 
     520module_exit(ramips_spi_exit); 
     521 
     522MODULE_DESCRIPTION("Ralink SPI driver"); 
     523MODULE_AUTHOR("Sergiy <piratfm@gmail.com>"); 
     524MODULE_LICENSE("GPL"); 
  • target/linux/ramips/patches-2.6.37/105-ramips-spi-driver.patch

     
     1--- a/drivers/spi/Kconfig 
     2+++ b/drivers/spi/Kconfig 
     3@@ -283,6 +283,12 @@ config SPI_PXA2XX 
     4          The driver can be configured to use any SSP port and additional 
     5          documentation can be found a Documentation/spi/pxa2xx. 
     6  
     7+config SPI_RAMIPS 
     8+       tristate "Ralink RT288x/RT305x SPI Controller" 
     9+       depends on (SOC_RT288X || SOC_RT305X) && SPI_MASTER 
     10+       help 
     11+         This selects a driver for the Ralink RT288x/RT305x SPI Controller. 
     12+ 
     13 config SPI_S3C24XX 
     14        tristate "Samsung S3C24XX series SPI" 
     15        depends on ARCH_S3C2410 && EXPERIMENTAL 
     16--- a/drivers/spi/Makefile 
     17+++ b/drivers/spi/Makefile 
     18@@ -37,6 +37,7 @@ obj-$(CONFIG_SPI_FSL_LIB)             += spi_fsl_li 
     19 obj-$(CONFIG_SPI_FSL_ESPI)             += spi_fsl_espi.o 
     20 obj-$(CONFIG_SPI_FSL_SPI)              += spi_fsl_spi.o 
     21 obj-$(CONFIG_SPI_PPC4xx)               += spi_ppc4xx.o 
     22+obj-$(CONFIG_SPI_RAMIPS)               += ramips_spi.o 
     23 obj-$(CONFIG_SPI_S3C24XX_GPIO)         += spi_s3c24xx_gpio.o 
     24 obj-$(CONFIG_SPI_S3C24XX)              += spi_s3c24xx_hw.o 
     25 obj-$(CONFIG_SPI_S3C64XX)              += spi_s3c64xx.o 
  • target/linux/ramips/rt305x/config-2.6.37

     
    106109# CONFIG_SLAB is not set 
    107110CONFIG_SLUB=y 
    108111CONFIG_SOC_RT305X=y 
     112CONFIG_SPI=y 
     113# CONFIG_SPI_BITBANG is not set 
     114# CONFIG_SPI_GPIO is not set 
     115CONFIG_SPI_MASTER=y 
     116CONFIG_SPI_RAMIPS=y 
    109117CONFIG_SYS_HAS_CPU_MIPS32_R1=y 
    110118CONFIG_SYS_HAS_CPU_MIPS32_R2=y 
    111119CONFIG_SYS_HAS_EARLY_PRINTK=y