4 * Internal SPI driver for NetUP Universal Dual DVB-CI
6 * Copyright (C) 2014 NetUP Inc.
7 * Copyright (C) 2014 Sergey Kozlov <serjk@netup.ru>
8 * Copyright (C) 2014 Abylay Ospan <aospan@netup.ru>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
21 #include "netup_unidvb.h"
22 #include <linux/spi/spi.h>
23 #include <linux/spi/flash.h>
24 #include <linux/mtd/partitions.h>
25 #include <mtd/mtd-abi.h>
27 #define NETUP_SPI_CTRL_IRQ 0x1000
28 #define NETUP_SPI_CTRL_IMASK 0x2000
29 #define NETUP_SPI_CTRL_START 0x8000
30 #define NETUP_SPI_CTRL_LAST_CS 0x4000
32 #define NETUP_SPI_TIMEOUT 6000
34 enum netup_spi_state {
39 struct netup_spi_regs {
43 } __packed __aligned(1);
47 struct spi_master *master;
48 struct netup_spi_regs *regs;
51 wait_queue_head_t waitq;
52 enum netup_spi_state state;
55 static char netup_spi_name[64] = "fpga";
57 static struct mtd_partition netup_spi_flash_partitions = {
58 .name = netup_spi_name,
59 .size = 0x1000000, /* 16MB */
61 .mask_flags = MTD_CAP_ROM
64 static struct flash_platform_data spi_flash_data = {
65 .name = "netup0_m25p128",
66 .parts = &netup_spi_flash_partitions,
70 static struct spi_board_info netup_spi_board = {
71 .modalias = "m25p128",
72 .max_speed_hz = 11000000,
75 .platform_data = &spi_flash_data,
78 irqreturn_t netup_spi_interrupt(struct netup_spi *spi)
84 dev_dbg(&spi->master->dev,
85 "%s(): SPI not initialized\n", __func__);
88 spin_lock_irqsave(&spi->lock, flags);
89 reg = readw(&spi->regs->control_stat);
90 if (!(reg & NETUP_SPI_CTRL_IRQ)) {
91 spin_unlock_irqrestore(&spi->lock, flags);
92 dev_dbg(&spi->master->dev,
93 "%s(): not mine interrupt\n", __func__);
96 writew(reg | NETUP_SPI_CTRL_IRQ, &spi->regs->control_stat);
97 reg = readw(&spi->regs->control_stat);
98 writew(reg & ~NETUP_SPI_CTRL_IMASK, &spi->regs->control_stat);
99 spi->state = SPI_STATE_DONE;
100 wake_up(&spi->waitq);
101 spin_unlock_irqrestore(&spi->lock, flags);
102 dev_dbg(&spi->master->dev,
103 "%s(): SPI interrupt handled\n", __func__);
107 static int netup_spi_transfer(struct spi_master *master,
108 struct spi_message *msg)
110 struct netup_spi *spi = spi_master_get_devdata(master);
111 struct spi_transfer *t;
116 writew(NETUP_SPI_CTRL_LAST_CS, &spi->regs->control_stat);
117 writew(0, &spi->regs->control_stat);
118 list_for_each_entry(t, &msg->transfers, transfer_list) {
121 u32 frag_offset = t->len - tr_size;
122 u32 frag_size = (tr_size > sizeof(spi->regs->data)) ?
123 sizeof(spi->regs->data) : tr_size;
126 if (list_is_last(&t->transfer_list,
128 frag_offset + frag_size == t->len) {
132 memcpy_toio(spi->regs->data,
133 t->tx_buf + frag_offset,
136 memset_io(spi->regs->data,
139 spi->state = SPI_STATE_START;
140 writew((frag_size & 0x3ff) |
141 NETUP_SPI_CTRL_IMASK |
142 NETUP_SPI_CTRL_START |
143 (frag_last ? NETUP_SPI_CTRL_LAST_CS : 0),
144 &spi->regs->control_stat);
145 dev_dbg(&spi->master->dev,
146 "%s(): control_stat 0x%04x\n",
147 __func__, readw(&spi->regs->control_stat));
148 wait_event_timeout(spi->waitq,
149 spi->state != SPI_STATE_START,
150 msecs_to_jiffies(NETUP_SPI_TIMEOUT));
151 if (spi->state == SPI_STATE_DONE) {
153 memcpy_fromio(t->rx_buf + frag_offset,
154 spi->regs->data, frag_size);
157 if (spi->state == SPI_STATE_START) {
158 dev_dbg(&spi->master->dev,
159 "%s(): transfer timeout\n",
162 dev_dbg(&spi->master->dev,
163 "%s(): invalid state %d\n",
164 __func__, spi->state);
169 tr_size -= frag_size;
170 msg->actual_length += frag_size;
174 msg->status = result;
175 spi_finalize_current_message(master);
179 static int netup_spi_setup(struct spi_device *spi)
184 int netup_spi_init(struct netup_unidvb_dev *ndev)
186 struct spi_master *master;
187 struct netup_spi *nspi;
189 master = spi_alloc_master(&ndev->pci_dev->dev,
190 sizeof(struct netup_spi));
192 dev_err(&ndev->pci_dev->dev,
193 "%s(): unable to alloc SPI master\n", __func__);
196 nspi = spi_master_get_devdata(master);
197 master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST;
198 master->bus_num = -1;
199 master->num_chipselect = 1;
200 master->transfer_one_message = netup_spi_transfer;
201 master->setup = netup_spi_setup;
202 spin_lock_init(&nspi->lock);
203 init_waitqueue_head(&nspi->waitq);
204 nspi->master = master;
205 nspi->regs = (struct netup_spi_regs *)(ndev->bmmio0 + 0x4000);
206 writew(2, &nspi->regs->clock_divider);
207 writew(NETUP_UNIDVB_IRQ_SPI, ndev->bmmio0 + REG_IMASK_SET);
209 if (spi_register_master(master)) {
211 dev_err(&ndev->pci_dev->dev,
212 "%s(): unable to register SPI bus\n", __func__);
215 snprintf(netup_spi_name,
216 sizeof(netup_spi_name),
217 "fpga_%02x:%02x.%01x",
221 if (!spi_new_device(master, &netup_spi_board)) {
223 dev_err(&ndev->pci_dev->dev,
224 "%s(): unable to create SPI device\n", __func__);
227 dev_dbg(&ndev->pci_dev->dev, "%s(): SPI init OK\n", __func__);
231 void netup_spi_release(struct netup_unidvb_dev *ndev)
235 struct netup_spi *spi = ndev->spi;
238 dev_dbg(&spi->master->dev,
239 "%s(): SPI not initialized\n", __func__);
242 spin_lock_irqsave(&spi->lock, flags);
243 reg = readw(&spi->regs->control_stat);
244 writew(reg | NETUP_SPI_CTRL_IRQ, &spi->regs->control_stat);
245 reg = readw(&spi->regs->control_stat);
246 writew(reg & ~NETUP_SPI_CTRL_IMASK, &spi->regs->control_stat);
247 spin_unlock_irqrestore(&spi->lock, flags);
248 spi_unregister_master(spi->master);