Loading...
1/*
2 * netup_unidvb_spi.c
3 *
4 * Internal SPI driver for NetUP Universal Dual DVB-CI
5 *
6 * Copyright (C) 2014 NetUP Inc.
7 * Copyright (C) 2014 Sergey Kozlov <serjk@netup.ru>
8 * Copyright (C) 2014 Abylay Ospan <aospan@netup.ru>
9 *
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.
14 *
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.
19 */
20
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>
26
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
31
32#define NETUP_SPI_TIMEOUT 6000
33
34enum netup_spi_state {
35 SPI_STATE_START,
36 SPI_STATE_DONE,
37};
38
39struct netup_spi_regs {
40 __u8 data[1024];
41 __le16 control_stat;
42 __le16 clock_divider;
43} __packed __aligned(1);
44
45struct netup_spi {
46 struct device *dev;
47 struct spi_master *master;
48 struct netup_spi_regs __iomem *regs;
49 u8 __iomem *mmio;
50 spinlock_t lock;
51 wait_queue_head_t waitq;
52 enum netup_spi_state state;
53};
54
55static char netup_spi_name[64] = "fpga";
56
57static struct mtd_partition netup_spi_flash_partitions = {
58 .name = netup_spi_name,
59 .size = 0x1000000, /* 16MB */
60 .offset = 0,
61 .mask_flags = MTD_CAP_ROM
62};
63
64static struct flash_platform_data spi_flash_data = {
65 .name = "netup0_m25p128",
66 .parts = &netup_spi_flash_partitions,
67 .nr_parts = 1,
68};
69
70static struct spi_board_info netup_spi_board = {
71 .modalias = "m25p128",
72 .max_speed_hz = 11000000,
73 .chip_select = 0,
74 .mode = SPI_MODE_0,
75 .platform_data = &spi_flash_data,
76};
77
78irqreturn_t netup_spi_interrupt(struct netup_spi *spi)
79{
80 u16 reg;
81 unsigned long flags;
82
83 if (!spi)
84 return IRQ_NONE;
85
86 spin_lock_irqsave(&spi->lock, flags);
87 reg = readw(&spi->regs->control_stat);
88 if (!(reg & NETUP_SPI_CTRL_IRQ)) {
89 spin_unlock_irqrestore(&spi->lock, flags);
90 dev_dbg(&spi->master->dev,
91 "%s(): not mine interrupt\n", __func__);
92 return IRQ_NONE;
93 }
94 writew(reg | NETUP_SPI_CTRL_IRQ, &spi->regs->control_stat);
95 reg = readw(&spi->regs->control_stat);
96 writew(reg & ~NETUP_SPI_CTRL_IMASK, &spi->regs->control_stat);
97 spi->state = SPI_STATE_DONE;
98 wake_up(&spi->waitq);
99 spin_unlock_irqrestore(&spi->lock, flags);
100 dev_dbg(&spi->master->dev,
101 "%s(): SPI interrupt handled\n", __func__);
102 return IRQ_HANDLED;
103}
104
105static int netup_spi_transfer(struct spi_master *master,
106 struct spi_message *msg)
107{
108 struct netup_spi *spi = spi_master_get_devdata(master);
109 struct spi_transfer *t;
110 int result = 0;
111 u32 tr_size;
112
113 /* reset CS */
114 writew(NETUP_SPI_CTRL_LAST_CS, &spi->regs->control_stat);
115 writew(0, &spi->regs->control_stat);
116 list_for_each_entry(t, &msg->transfers, transfer_list) {
117 tr_size = t->len;
118 while (tr_size) {
119 u32 frag_offset = t->len - tr_size;
120 u32 frag_size = (tr_size > sizeof(spi->regs->data)) ?
121 sizeof(spi->regs->data) : tr_size;
122 int frag_last = 0;
123
124 if (list_is_last(&t->transfer_list,
125 &msg->transfers) &&
126 frag_offset + frag_size == t->len) {
127 frag_last = 1;
128 }
129 if (t->tx_buf) {
130 memcpy_toio(spi->regs->data,
131 t->tx_buf + frag_offset,
132 frag_size);
133 } else {
134 memset_io(spi->regs->data,
135 0, frag_size);
136 }
137 spi->state = SPI_STATE_START;
138 writew((frag_size & 0x3ff) |
139 NETUP_SPI_CTRL_IMASK |
140 NETUP_SPI_CTRL_START |
141 (frag_last ? NETUP_SPI_CTRL_LAST_CS : 0),
142 &spi->regs->control_stat);
143 dev_dbg(&spi->master->dev,
144 "%s(): control_stat 0x%04x\n",
145 __func__, readw(&spi->regs->control_stat));
146 wait_event_timeout(spi->waitq,
147 spi->state != SPI_STATE_START,
148 msecs_to_jiffies(NETUP_SPI_TIMEOUT));
149 if (spi->state == SPI_STATE_DONE) {
150 if (t->rx_buf) {
151 memcpy_fromio(t->rx_buf + frag_offset,
152 spi->regs->data, frag_size);
153 }
154 } else {
155 if (spi->state == SPI_STATE_START) {
156 dev_dbg(&spi->master->dev,
157 "%s(): transfer timeout\n",
158 __func__);
159 } else {
160 dev_dbg(&spi->master->dev,
161 "%s(): invalid state %d\n",
162 __func__, spi->state);
163 }
164 result = -EIO;
165 goto done;
166 }
167 tr_size -= frag_size;
168 msg->actual_length += frag_size;
169 }
170 }
171done:
172 msg->status = result;
173 spi_finalize_current_message(master);
174 return result;
175}
176
177static int netup_spi_setup(struct spi_device *spi)
178{
179 return 0;
180}
181
182int netup_spi_init(struct netup_unidvb_dev *ndev)
183{
184 struct spi_master *master;
185 struct netup_spi *nspi;
186
187 master = spi_alloc_master(&ndev->pci_dev->dev,
188 sizeof(struct netup_spi));
189 if (!master) {
190 dev_err(&ndev->pci_dev->dev,
191 "%s(): unable to alloc SPI master\n", __func__);
192 return -EINVAL;
193 }
194 nspi = spi_master_get_devdata(master);
195 master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST;
196 master->bus_num = -1;
197 master->num_chipselect = 1;
198 master->transfer_one_message = netup_spi_transfer;
199 master->setup = netup_spi_setup;
200 spin_lock_init(&nspi->lock);
201 init_waitqueue_head(&nspi->waitq);
202 nspi->master = master;
203 nspi->regs = (struct netup_spi_regs __iomem *)(ndev->bmmio0 + 0x4000);
204 writew(2, &nspi->regs->clock_divider);
205 writew(NETUP_UNIDVB_IRQ_SPI, ndev->bmmio0 + REG_IMASK_SET);
206 ndev->spi = nspi;
207 if (spi_register_master(master)) {
208 ndev->spi = NULL;
209 dev_err(&ndev->pci_dev->dev,
210 "%s(): unable to register SPI bus\n", __func__);
211 return -EINVAL;
212 }
213 snprintf(netup_spi_name,
214 sizeof(netup_spi_name),
215 "fpga_%02x:%02x.%01x",
216 ndev->pci_bus,
217 ndev->pci_slot,
218 ndev->pci_func);
219 if (!spi_new_device(master, &netup_spi_board)) {
220 ndev->spi = NULL;
221 dev_err(&ndev->pci_dev->dev,
222 "%s(): unable to create SPI device\n", __func__);
223 return -EINVAL;
224 }
225 dev_dbg(&ndev->pci_dev->dev, "%s(): SPI init OK\n", __func__);
226 return 0;
227}
228
229void netup_spi_release(struct netup_unidvb_dev *ndev)
230{
231 u16 reg;
232 unsigned long flags;
233 struct netup_spi *spi = ndev->spi;
234
235 if (!spi)
236 return;
237
238 spin_lock_irqsave(&spi->lock, flags);
239 reg = readw(&spi->regs->control_stat);
240 writew(reg | NETUP_SPI_CTRL_IRQ, &spi->regs->control_stat);
241 reg = readw(&spi->regs->control_stat);
242 writew(reg & ~NETUP_SPI_CTRL_IMASK, &spi->regs->control_stat);
243 spin_unlock_irqrestore(&spi->lock, flags);
244 spi_unregister_master(spi->master);
245 ndev->spi = NULL;
246}
247
248
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * netup_unidvb_spi.c
4 *
5 * Internal SPI driver for NetUP Universal Dual DVB-CI
6 *
7 * Copyright (C) 2014 NetUP Inc.
8 * Copyright (C) 2014 Sergey Kozlov <serjk@netup.ru>
9 * Copyright (C) 2014 Abylay Ospan <aospan@netup.ru>
10 */
11
12#include "netup_unidvb.h"
13#include <linux/spi/spi.h>
14#include <linux/spi/flash.h>
15#include <linux/mtd/partitions.h>
16#include <mtd/mtd-abi.h>
17
18#define NETUP_SPI_CTRL_IRQ 0x1000
19#define NETUP_SPI_CTRL_IMASK 0x2000
20#define NETUP_SPI_CTRL_START 0x8000
21#define NETUP_SPI_CTRL_LAST_CS 0x4000
22
23#define NETUP_SPI_TIMEOUT 6000
24
25enum netup_spi_state {
26 SPI_STATE_START,
27 SPI_STATE_DONE,
28};
29
30struct netup_spi_regs {
31 __u8 data[1024];
32 __le16 control_stat;
33 __le16 clock_divider;
34} __packed __aligned(1);
35
36struct netup_spi {
37 struct device *dev;
38 struct spi_master *master;
39 struct netup_spi_regs __iomem *regs;
40 u8 __iomem *mmio;
41 spinlock_t lock;
42 wait_queue_head_t waitq;
43 enum netup_spi_state state;
44};
45
46static char netup_spi_name[64] = "fpga";
47
48static struct mtd_partition netup_spi_flash_partitions = {
49 .name = netup_spi_name,
50 .size = 0x1000000, /* 16MB */
51 .offset = 0,
52 .mask_flags = MTD_CAP_ROM
53};
54
55static struct flash_platform_data spi_flash_data = {
56 .name = "netup0_m25p128",
57 .parts = &netup_spi_flash_partitions,
58 .nr_parts = 1,
59};
60
61static struct spi_board_info netup_spi_board = {
62 .modalias = "m25p128",
63 .max_speed_hz = 11000000,
64 .chip_select = 0,
65 .mode = SPI_MODE_0,
66 .platform_data = &spi_flash_data,
67};
68
69irqreturn_t netup_spi_interrupt(struct netup_spi *spi)
70{
71 u16 reg;
72 unsigned long flags;
73
74 if (!spi)
75 return IRQ_NONE;
76
77 spin_lock_irqsave(&spi->lock, flags);
78 reg = readw(&spi->regs->control_stat);
79 if (!(reg & NETUP_SPI_CTRL_IRQ)) {
80 spin_unlock_irqrestore(&spi->lock, flags);
81 dev_dbg(&spi->master->dev,
82 "%s(): not mine interrupt\n", __func__);
83 return IRQ_NONE;
84 }
85 writew(reg | NETUP_SPI_CTRL_IRQ, &spi->regs->control_stat);
86 reg = readw(&spi->regs->control_stat);
87 writew(reg & ~NETUP_SPI_CTRL_IMASK, &spi->regs->control_stat);
88 spi->state = SPI_STATE_DONE;
89 wake_up(&spi->waitq);
90 spin_unlock_irqrestore(&spi->lock, flags);
91 dev_dbg(&spi->master->dev,
92 "%s(): SPI interrupt handled\n", __func__);
93 return IRQ_HANDLED;
94}
95
96static int netup_spi_transfer(struct spi_master *master,
97 struct spi_message *msg)
98{
99 struct netup_spi *spi = spi_master_get_devdata(master);
100 struct spi_transfer *t;
101 int result = 0;
102 u32 tr_size;
103
104 /* reset CS */
105 writew(NETUP_SPI_CTRL_LAST_CS, &spi->regs->control_stat);
106 writew(0, &spi->regs->control_stat);
107 list_for_each_entry(t, &msg->transfers, transfer_list) {
108 tr_size = t->len;
109 while (tr_size) {
110 u32 frag_offset = t->len - tr_size;
111 u32 frag_size = (tr_size > sizeof(spi->regs->data)) ?
112 sizeof(spi->regs->data) : tr_size;
113 int frag_last = 0;
114
115 if (list_is_last(&t->transfer_list,
116 &msg->transfers) &&
117 frag_offset + frag_size == t->len) {
118 frag_last = 1;
119 }
120 if (t->tx_buf) {
121 memcpy_toio(spi->regs->data,
122 t->tx_buf + frag_offset,
123 frag_size);
124 } else {
125 memset_io(spi->regs->data,
126 0, frag_size);
127 }
128 spi->state = SPI_STATE_START;
129 writew((frag_size & 0x3ff) |
130 NETUP_SPI_CTRL_IMASK |
131 NETUP_SPI_CTRL_START |
132 (frag_last ? NETUP_SPI_CTRL_LAST_CS : 0),
133 &spi->regs->control_stat);
134 dev_dbg(&spi->master->dev,
135 "%s(): control_stat 0x%04x\n",
136 __func__, readw(&spi->regs->control_stat));
137 wait_event_timeout(spi->waitq,
138 spi->state != SPI_STATE_START,
139 msecs_to_jiffies(NETUP_SPI_TIMEOUT));
140 if (spi->state == SPI_STATE_DONE) {
141 if (t->rx_buf) {
142 memcpy_fromio(t->rx_buf + frag_offset,
143 spi->regs->data, frag_size);
144 }
145 } else {
146 if (spi->state == SPI_STATE_START) {
147 dev_dbg(&spi->master->dev,
148 "%s(): transfer timeout\n",
149 __func__);
150 } else {
151 dev_dbg(&spi->master->dev,
152 "%s(): invalid state %d\n",
153 __func__, spi->state);
154 }
155 result = -EIO;
156 goto done;
157 }
158 tr_size -= frag_size;
159 msg->actual_length += frag_size;
160 }
161 }
162done:
163 msg->status = result;
164 spi_finalize_current_message(master);
165 return result;
166}
167
168static int netup_spi_setup(struct spi_device *spi)
169{
170 return 0;
171}
172
173int netup_spi_init(struct netup_unidvb_dev *ndev)
174{
175 struct spi_master *master;
176 struct netup_spi *nspi;
177
178 master = spi_alloc_master(&ndev->pci_dev->dev,
179 sizeof(struct netup_spi));
180 if (!master) {
181 dev_err(&ndev->pci_dev->dev,
182 "%s(): unable to alloc SPI master\n", __func__);
183 return -EINVAL;
184 }
185 nspi = spi_master_get_devdata(master);
186 master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST;
187 master->bus_num = -1;
188 master->num_chipselect = 1;
189 master->transfer_one_message = netup_spi_transfer;
190 master->setup = netup_spi_setup;
191 spin_lock_init(&nspi->lock);
192 init_waitqueue_head(&nspi->waitq);
193 nspi->master = master;
194 nspi->regs = (struct netup_spi_regs __iomem *)(ndev->bmmio0 + 0x4000);
195 writew(2, &nspi->regs->clock_divider);
196 writew(NETUP_UNIDVB_IRQ_SPI, ndev->bmmio0 + REG_IMASK_SET);
197 ndev->spi = nspi;
198 if (spi_register_master(master)) {
199 ndev->spi = NULL;
200 dev_err(&ndev->pci_dev->dev,
201 "%s(): unable to register SPI bus\n", __func__);
202 return -EINVAL;
203 }
204 snprintf(netup_spi_name,
205 sizeof(netup_spi_name),
206 "fpga_%02x:%02x.%01x",
207 ndev->pci_bus,
208 ndev->pci_slot,
209 ndev->pci_func);
210 if (!spi_new_device(master, &netup_spi_board)) {
211 ndev->spi = NULL;
212 dev_err(&ndev->pci_dev->dev,
213 "%s(): unable to create SPI device\n", __func__);
214 return -EINVAL;
215 }
216 dev_dbg(&ndev->pci_dev->dev, "%s(): SPI init OK\n", __func__);
217 return 0;
218}
219
220void netup_spi_release(struct netup_unidvb_dev *ndev)
221{
222 u16 reg;
223 unsigned long flags;
224 struct netup_spi *spi = ndev->spi;
225
226 if (!spi)
227 return;
228
229 spin_lock_irqsave(&spi->lock, flags);
230 reg = readw(&spi->regs->control_stat);
231 writew(reg | NETUP_SPI_CTRL_IRQ, &spi->regs->control_stat);
232 reg = readw(&spi->regs->control_stat);
233 writew(reg & ~NETUP_SPI_CTRL_IMASK, &spi->regs->control_stat);
234 spin_unlock_irqrestore(&spi->lock, flags);
235 spi_unregister_master(spi->master);
236 ndev->spi = NULL;
237}
238
239