kernel: linux/version.h was removed in kernel 2.6.19 and is now replaced by generated...
[openwrt/svn-archive/archive.git] / target / linux / generic / files / crypto / ocf / hifn / hifnHIPP.c
1 /*-
2 * Driver for Hifn HIPP-I/II chipset
3 * Copyright (c) 2006 Michael Richardson <mcr@xelerance.com>
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * Effort sponsored by Hifn Inc.
29 *
30 */
31
32 /*
33 * Driver for various Hifn encryption processors.
34 */
35 #include <linux/version.h>
36 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
37 #include <generated/autoconf.h>
38 #else
39 #include <linux/autoconf.h>
40 #endif
41 #include <linux/module.h>
42 #include <linux/init.h>
43 #include <linux/list.h>
44 #include <linux/slab.h>
45 #include <linux/wait.h>
46 #include <linux/sched.h>
47 #include <linux/pci.h>
48 #include <linux/delay.h>
49 #include <linux/interrupt.h>
50 #include <linux/spinlock.h>
51 #include <linux/random.h>
52 #include <linux/version.h>
53 #include <linux/skbuff.h>
54 #include <linux/uio.h>
55 #include <linux/sysfs.h>
56 #include <linux/miscdevice.h>
57 #include <asm/io.h>
58
59 #include <cryptodev.h>
60
61 #include "hifnHIPPreg.h"
62 #include "hifnHIPPvar.h"
63
64 #if 1
65 #define DPRINTF(a...) if (hipp_debug) { \
66 printk("%s: ", sc ? \
67 device_get_nameunit(sc->sc_dev) : "hifn"); \
68 printk(a); \
69 } else
70 #else
71 #define DPRINTF(a...)
72 #endif
73
74 typedef int bus_size_t;
75
76 static inline int
77 pci_get_revid(struct pci_dev *dev)
78 {
79 u8 rid = 0;
80 pci_read_config_byte(dev, PCI_REVISION_ID, &rid);
81 return rid;
82 }
83
84 #define debug hipp_debug
85 int hipp_debug = 0;
86 module_param(hipp_debug, int, 0644);
87 MODULE_PARM_DESC(hipp_debug, "Enable debug");
88
89 int hipp_maxbatch = 1;
90 module_param(hipp_maxbatch, int, 0644);
91 MODULE_PARM_DESC(hipp_maxbatch, "max ops to batch w/o interrupt");
92
93 static int hipp_probe(struct pci_dev *dev, const struct pci_device_id *ent);
94 static void hipp_remove(struct pci_dev *dev);
95 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
96 static irqreturn_t hipp_intr(int irq, void *arg);
97 #else
98 static irqreturn_t hipp_intr(int irq, void *arg, struct pt_regs *regs);
99 #endif
100
101 static int hipp_num_chips = 0;
102 static struct hipp_softc *hipp_chip_idx[HIPP_MAX_CHIPS];
103
104 static int hipp_newsession(device_t, u_int32_t *, struct cryptoini *);
105 static int hipp_freesession(device_t, u_int64_t);
106 static int hipp_process(device_t, struct cryptop *, int);
107
108 static device_method_t hipp_methods = {
109 /* crypto device methods */
110 DEVMETHOD(cryptodev_newsession, hipp_newsession),
111 DEVMETHOD(cryptodev_freesession,hipp_freesession),
112 DEVMETHOD(cryptodev_process, hipp_process),
113 };
114
115 static __inline u_int32_t
116 READ_REG(struct hipp_softc *sc, unsigned int barno, bus_size_t reg)
117 {
118 u_int32_t v = readl(sc->sc_bar[barno] + reg);
119 //sc->sc_bar0_lastreg = (bus_size_t) -1;
120 return (v);
121 }
122 static __inline void
123 WRITE_REG(struct hipp_softc *sc, unsigned int barno, bus_size_t reg, u_int32_t val)
124 {
125 writel(val, sc->sc_bar[barno] + reg);
126 }
127
128 #define READ_REG_0(sc, reg) READ_REG(sc, 0, reg)
129 #define WRITE_REG_0(sc, reg, val) WRITE_REG(sc,0, reg, val)
130 #define READ_REG_1(sc, reg) READ_REG(sc, 1, reg)
131 #define WRITE_REG_1(sc, reg, val) WRITE_REG(sc,1, reg, val)
132
133 static int
134 hipp_newsession(device_t dev, u_int32_t *sidp, struct cryptoini *cri)
135 {
136 return EINVAL;
137 }
138
139 static int
140 hipp_freesession(device_t dev, u_int64_t tid)
141 {
142 return EINVAL;
143 }
144
145 static int
146 hipp_process(device_t dev, struct cryptop *crp, int hint)
147 {
148 return EINVAL;
149 }
150
151 static const char*
152 hipp_partname(struct hipp_softc *sc, char buf[128], size_t blen)
153 {
154 char *n = NULL;
155
156 switch (pci_get_vendor(sc->sc_pcidev)) {
157 case PCI_VENDOR_HIFN:
158 switch (pci_get_device(sc->sc_pcidev)) {
159 case PCI_PRODUCT_HIFN_7855: n = "Hifn 7855";
160 case PCI_PRODUCT_HIFN_8155: n = "Hifn 8155";
161 case PCI_PRODUCT_HIFN_6500: n = "Hifn 6500";
162 }
163 }
164
165 if(n==NULL) {
166 snprintf(buf, blen, "VID=%02x,PID=%02x",
167 pci_get_vendor(sc->sc_pcidev),
168 pci_get_device(sc->sc_pcidev));
169 } else {
170 buf[0]='\0';
171 strncat(buf, n, blen);
172 }
173 return buf;
174 }
175
176 struct hipp_fs_entry {
177 struct attribute attr;
178 /* other stuff */
179 };
180
181
182 static ssize_t
183 cryptoid_show(struct device *dev,
184 struct device_attribute *attr,
185 char *buf)
186 {
187 struct hipp_softc *sc;
188
189 sc = pci_get_drvdata(to_pci_dev (dev));
190 return sprintf (buf, "%d\n", sc->sc_cid);
191 }
192
193 struct device_attribute hipp_dev_cryptoid = __ATTR_RO(cryptoid);
194
195 /*
196 * Attach an interface that successfully probed.
197 */
198 static int
199 hipp_probe(struct pci_dev *dev, const struct pci_device_id *ent)
200 {
201 struct hipp_softc *sc = NULL;
202 int i;
203 //char rbase;
204 //u_int16_t ena;
205 int rev;
206 //int rseg;
207 int rc;
208
209 DPRINTF("%s()\n", __FUNCTION__);
210
211 if (pci_enable_device(dev) < 0)
212 return(-ENODEV);
213
214 #ifdef CONFIG_HAVE_PCI_SET_MWI
215 if (pci_set_mwi(dev))
216 return(-ENODEV);
217 #endif
218
219 if (!dev->irq) {
220 printk("hifn: found device with no IRQ assigned. check BIOS settings!");
221 pci_disable_device(dev);
222 return(-ENODEV);
223 }
224
225 sc = (struct hipp_softc *) kmalloc(sizeof(*sc), GFP_KERNEL);
226 if (!sc)
227 return(-ENOMEM);
228 memset(sc, 0, sizeof(*sc));
229
230 softc_device_init(sc, "hifn-hipp", hipp_num_chips, hipp_methods);
231
232 sc->sc_pcidev = dev;
233 sc->sc_irq = -1;
234 sc->sc_cid = -1;
235 sc->sc_num = hipp_num_chips++;
236
237 if (sc->sc_num < HIPP_MAX_CHIPS)
238 hipp_chip_idx[sc->sc_num] = sc;
239
240 pci_set_drvdata(sc->sc_pcidev, sc);
241
242 spin_lock_init(&sc->sc_mtx);
243
244 /*
245 * Setup PCI resources.
246 * The READ_REG_0, WRITE_REG_0, READ_REG_1,
247 * and WRITE_REG_1 macros throughout the driver are used
248 * to permit better debugging.
249 */
250 for(i=0; i<4; i++) {
251 unsigned long mem_start, mem_len;
252 mem_start = pci_resource_start(sc->sc_pcidev, i);
253 mem_len = pci_resource_len(sc->sc_pcidev, i);
254 sc->sc_barphy[i] = (caddr_t)mem_start;
255 sc->sc_bar[i] = (ocf_iomem_t) ioremap(mem_start, mem_len);
256 if (!sc->sc_bar[i]) {
257 device_printf(sc->sc_dev, "cannot map bar%d register space\n", i);
258 goto fail;
259 }
260 }
261
262 //hipp_reset_board(sc, 0);
263 pci_set_master(sc->sc_pcidev);
264
265 /*
266 * Arrange the interrupt line.
267 */
268 rc = request_irq(dev->irq, hipp_intr, IRQF_SHARED, "hifn", sc);
269 if (rc) {
270 device_printf(sc->sc_dev, "could not map interrupt: %d\n", rc);
271 goto fail;
272 }
273 sc->sc_irq = dev->irq;
274
275 rev = READ_REG_1(sc, HIPP_1_REVID) & 0xffff;
276
277 {
278 char b[32];
279 device_printf(sc->sc_dev, "%s, rev %u",
280 hipp_partname(sc, b, sizeof(b)), rev);
281 }
282
283 #if 0
284 if (sc->sc_flags & HIFN_IS_7956)
285 printf(", pll=0x%x<%s clk, %ux mult>",
286 sc->sc_pllconfig,
287 sc->sc_pllconfig & HIFN_PLL_REF_SEL ? "ext" : "pci",
288 2 + 2*((sc->sc_pllconfig & HIFN_PLL_ND) >> 11));
289 #endif
290 printf("\n");
291
292 sc->sc_cid = crypto_get_driverid(softc_get_device(sc),CRYPTOCAP_F_HARDWARE);
293 if (sc->sc_cid < 0) {
294 device_printf(sc->sc_dev, "could not get crypto driver id\n");
295 goto fail;
296 }
297
298 #if 0 /* cannot work with a non-GPL module */
299 /* make a sysfs entry to let the world know what entry we got */
300 sysfs_create_file(&sc->sc_pcidev->dev.kobj, &hipp_dev_cryptoid.attr);
301 #endif
302
303 #if 0
304 init_timer(&sc->sc_tickto);
305 sc->sc_tickto.function = hifn_tick;
306 sc->sc_tickto.data = (unsigned long) sc->sc_num;
307 mod_timer(&sc->sc_tickto, jiffies + HZ);
308 #endif
309
310 #if 0 /* no code here yet ?? */
311 crypto_register(sc->sc_cid, CRYPTO_3DES_CBC, 0, 0);
312 #endif
313
314 return (0);
315
316 fail:
317 if (sc->sc_cid >= 0)
318 crypto_unregister_all(sc->sc_cid);
319 if (sc->sc_irq != -1)
320 free_irq(sc->sc_irq, sc);
321
322 #if 0
323 if (sc->sc_dma) {
324 /* Turn off DMA polling */
325 WRITE_REG_1(sc, HIFN_1_DMA_CNFG, HIFN_DMACNFG_MSTRESET |
326 HIFN_DMACNFG_DMARESET | HIFN_DMACNFG_MODE);
327
328 pci_free_consistent(sc->sc_pcidev,
329 sizeof(*sc->sc_dma),
330 sc->sc_dma, sc->sc_dma_physaddr);
331 }
332 #endif
333 kfree(sc);
334 return (-ENXIO);
335 }
336
337 /*
338 * Detach an interface that successfully probed.
339 */
340 static void
341 hipp_remove(struct pci_dev *dev)
342 {
343 struct hipp_softc *sc = pci_get_drvdata(dev);
344 unsigned long l_flags;
345
346 DPRINTF("%s()\n", __FUNCTION__);
347
348 /* disable interrupts */
349 HIPP_LOCK(sc);
350
351 #if 0
352 WRITE_REG_1(sc, HIFN_1_DMA_IER, 0);
353 HIFN_UNLOCK(sc);
354
355 /*XXX other resources */
356 del_timer_sync(&sc->sc_tickto);
357
358 /* Turn off DMA polling */
359 WRITE_REG_1(sc, HIFN_1_DMA_CNFG, HIFN_DMACNFG_MSTRESET |
360 HIFN_DMACNFG_DMARESET | HIFN_DMACNFG_MODE);
361 #endif
362
363 crypto_unregister_all(sc->sc_cid);
364
365 free_irq(sc->sc_irq, sc);
366
367 #if 0
368 pci_free_consistent(sc->sc_pcidev, sizeof(*sc->sc_dma),
369 sc->sc_dma, sc->sc_dma_physaddr);
370 #endif
371 }
372
373 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
374 static irqreturn_t hipp_intr(int irq, void *arg)
375 #else
376 static irqreturn_t hipp_intr(int irq, void *arg, struct pt_regs *regs)
377 #endif
378 {
379 struct hipp_softc *sc = arg;
380
381 sc = sc; /* shut up compiler */
382
383 return IRQ_HANDLED;
384 }
385
386 static struct pci_device_id hipp_pci_tbl[] = {
387 { PCI_VENDOR_HIFN, PCI_PRODUCT_HIFN_7855,
388 PCI_ANY_ID, PCI_ANY_ID, 0, 0, },
389 { PCI_VENDOR_HIFN, PCI_PRODUCT_HIFN_8155,
390 PCI_ANY_ID, PCI_ANY_ID, 0, 0, },
391 { 0 }
392 };
393 MODULE_DEVICE_TABLE(pci, hipp_pci_tbl);
394
395 static struct pci_driver hipp_driver = {
396 .name = "hipp",
397 .id_table = hipp_pci_tbl,
398 .probe = hipp_probe,
399 .remove = hipp_remove,
400 /* add PM stuff here one day */
401 };
402
403 static int __init hipp_init (void)
404 {
405 struct hipp_softc *sc = NULL;
406 int rc;
407
408 DPRINTF("%s(%p)\n", __FUNCTION__, hipp_init);
409
410 rc = pci_register_driver(&hipp_driver);
411 pci_register_driver_compat(&hipp_driver, rc);
412
413 return rc;
414 }
415
416 static void __exit hipp_exit (void)
417 {
418 pci_unregister_driver(&hipp_driver);
419 }
420
421 module_init(hipp_init);
422 module_exit(hipp_exit);
423
424 MODULE_LICENSE("BSD");
425 MODULE_AUTHOR("Michael Richardson <mcr@xelerance.com>");
426 MODULE_DESCRIPTION("OCF driver for hifn HIPP-I/II PCI crypto devices");