drivers/net/ethernet/8390/xsurf100.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
is_xsurf100_network_irq
z_memcpy_fromio32
z_memcpy_toio32
xs100_write
xs100_read
xs100_block_input
xs100_block_output
xsurf100_probe
xsurf100_remove
   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/module.h>
   3 #include <linux/netdevice.h>
   4 #include <linux/platform_device.h>
   5 #include <linux/zorro.h>
   6 #include <net/ax88796.h>
   7 #include <asm/amigaints.h>
   8 
   9 #define ZORRO_PROD_INDIVIDUAL_COMPUTERS_X_SURF100 \
  10                 ZORRO_ID(INDIVIDUAL_COMPUTERS, 0x64, 0)
  11 
  12 #define XS100_IRQSTATUS_BASE 0x40
  13 #define XS100_8390_BASE 0x800
  14 
  15 /* Longword-access area. Translated to 2 16-bit access cycles by the
  16  * X-Surf 100 FPGA
  17  */
  18 #define XS100_8390_DATA32_BASE 0x8000
  19 #define XS100_8390_DATA32_SIZE 0x2000
  20 /* Sub-Areas for fast data register access; addresses relative to area begin */
  21 #define XS100_8390_DATA_READ32_BASE 0x0880
  22 #define XS100_8390_DATA_WRITE32_BASE 0x0C80
  23 #define XS100_8390_DATA_AREA_SIZE 0x80
  24 
  25 #define __NS8390_init ax_NS8390_init
  26 
  27 /* force unsigned long back to 'void __iomem *' */
  28 #define ax_convert_addr(_a) ((void __force __iomem *)(_a))
  29 
  30 #define ei_inb(_a) z_readb(ax_convert_addr(_a))
  31 #define ei_outb(_v, _a) z_writeb(_v, ax_convert_addr(_a))
  32 
  33 #define ei_inw(_a) z_readw(ax_convert_addr(_a))
  34 #define ei_outw(_v, _a) z_writew(_v, ax_convert_addr(_a))
  35 
  36 #define ei_inb_p(_a) ei_inb(_a)
  37 #define ei_outb_p(_v, _a) ei_outb(_v, _a)
  38 
  39 /* define EI_SHIFT() to take into account our register offsets */
  40 #define EI_SHIFT(x) (ei_local->reg_offset[(x)])
  41 
  42 /* Ensure we have our RCR base value */
  43 #define AX88796_PLATFORM
  44 
  45 static unsigned char version[] =
  46                 "ax88796.c: Copyright 2005,2007 Simtec Electronics\n";
  47 
  48 #include "lib8390.c"
  49 
  50 /* from ne.c */
  51 #define NE_CMD          EI_SHIFT(0x00)
  52 #define NE_RESET        EI_SHIFT(0x1f)
  53 #define NE_DATAPORT     EI_SHIFT(0x10)
  54 
  55 struct xsurf100_ax_plat_data {
  56         struct ax_plat_data ax;
  57         void __iomem *base_regs;
  58         void __iomem *data_area;
  59 };
  60 
  61 static int is_xsurf100_network_irq(struct platform_device *pdev)
  62 {
  63         struct xsurf100_ax_plat_data *xs100 = dev_get_platdata(&pdev->dev);
  64 
  65         return (readw(xs100->base_regs + XS100_IRQSTATUS_BASE) & 0xaaaa) != 0;
  66 }
  67 
  68 /* These functions guarantee that the iomem is accessed with 32 bit
  69  * cycles only. z_memcpy_fromio / z_memcpy_toio don't
  70  */
  71 static void z_memcpy_fromio32(void *dst, const void __iomem *src, size_t bytes)
  72 {
  73         while (bytes > 32) {
  74                 asm __volatile__
  75                    ("movem.l (%0)+,%%d0-%%d7\n"
  76                     "movem.l %%d0-%%d7,(%1)\n"
  77                     "adda.l #32,%1" : "=a"(src), "=a"(dst)
  78                     : "0"(src), "1"(dst) : "d0", "d1", "d2", "d3", "d4",
  79                                            "d5", "d6", "d7", "memory");
  80                 bytes -= 32;
  81         }
  82         while (bytes) {
  83                 *(uint32_t *)dst = z_readl(src);
  84                 src += 4;
  85                 dst += 4;
  86                 bytes -= 4;
  87         }
  88 }
  89 
  90 static void z_memcpy_toio32(void __iomem *dst, const void *src, size_t bytes)
  91 {
  92         while (bytes) {
  93                 z_writel(*(const uint32_t *)src, dst);
  94                 src += 4;
  95                 dst += 4;
  96                 bytes -= 4;
  97         }
  98 }
  99 
 100 static void xs100_write(struct net_device *dev, const void *src,
 101                         unsigned int count)
 102 {
 103         struct ei_device *ei_local = netdev_priv(dev);
 104         struct platform_device *pdev = to_platform_device(dev->dev.parent);
 105         struct xsurf100_ax_plat_data *xs100 = dev_get_platdata(&pdev->dev);
 106 
 107         /* copy whole blocks */
 108         while (count > XS100_8390_DATA_AREA_SIZE) {
 109                 z_memcpy_toio32(xs100->data_area +
 110                                 XS100_8390_DATA_WRITE32_BASE, src,
 111                                 XS100_8390_DATA_AREA_SIZE);
 112                 src += XS100_8390_DATA_AREA_SIZE;
 113                 count -= XS100_8390_DATA_AREA_SIZE;
 114         }
 115         /* copy whole dwords */
 116         z_memcpy_toio32(xs100->data_area + XS100_8390_DATA_WRITE32_BASE,
 117                         src, count & ~3);
 118         src += count & ~3;
 119         if (count & 2) {
 120                 ei_outw(*(uint16_t *)src, ei_local->mem + NE_DATAPORT);
 121                 src += 2;
 122         }
 123         if (count & 1)
 124                 ei_outb(*(uint8_t *)src, ei_local->mem + NE_DATAPORT);
 125 }
 126 
 127 static void xs100_read(struct net_device *dev, void *dst, unsigned int count)
 128 {
 129         struct ei_device *ei_local = netdev_priv(dev);
 130         struct platform_device *pdev = to_platform_device(dev->dev.parent);
 131         struct xsurf100_ax_plat_data *xs100 = dev_get_platdata(&pdev->dev);
 132 
 133         /* copy whole blocks */
 134         while (count > XS100_8390_DATA_AREA_SIZE) {
 135                 z_memcpy_fromio32(dst, xs100->data_area +
 136                                   XS100_8390_DATA_READ32_BASE,
 137                                   XS100_8390_DATA_AREA_SIZE);
 138                 dst += XS100_8390_DATA_AREA_SIZE;
 139                 count -= XS100_8390_DATA_AREA_SIZE;
 140         }
 141         /* copy whole dwords */
 142         z_memcpy_fromio32(dst, xs100->data_area + XS100_8390_DATA_READ32_BASE,
 143                           count & ~3);
 144         dst += count & ~3;
 145         if (count & 2) {
 146                 *(uint16_t *)dst = ei_inw(ei_local->mem + NE_DATAPORT);
 147                 dst += 2;
 148         }
 149         if (count & 1)
 150                 *(uint8_t *)dst = ei_inb(ei_local->mem + NE_DATAPORT);
 151 }
 152 
 153 /* Block input and output, similar to the Crynwr packet driver. If
 154  * you are porting to a new ethercard, look at the packet driver
 155  * source for hints. The NEx000 doesn't share the on-board packet
 156  * memory -- you have to put the packet out through the "remote DMA"
 157  * dataport using ei_outb.
 158  */
 159 static void xs100_block_input(struct net_device *dev, int count,
 160                               struct sk_buff *skb, int ring_offset)
 161 {
 162         struct ei_device *ei_local = netdev_priv(dev);
 163         void __iomem *nic_base = ei_local->mem;
 164         char *buf = skb->data;
 165 
 166         if (ei_local->dmaing) {
 167                 netdev_err(dev,
 168                            "DMAing conflict in %s [DMAstat:%d][irqlock:%d]\n",
 169                            __func__,
 170                            ei_local->dmaing, ei_local->irqlock);
 171                 return;
 172         }
 173 
 174         ei_local->dmaing |= 0x01;
 175 
 176         ei_outb(E8390_NODMA + E8390_PAGE0 + E8390_START, nic_base + NE_CMD);
 177         ei_outb(count & 0xff, nic_base + EN0_RCNTLO);
 178         ei_outb(count >> 8, nic_base + EN0_RCNTHI);
 179         ei_outb(ring_offset & 0xff, nic_base + EN0_RSARLO);
 180         ei_outb(ring_offset >> 8, nic_base + EN0_RSARHI);
 181         ei_outb(E8390_RREAD + E8390_START, nic_base + NE_CMD);
 182 
 183         xs100_read(dev, buf, count);
 184 
 185         ei_local->dmaing &= ~1;
 186 }
 187 
 188 static void xs100_block_output(struct net_device *dev, int count,
 189                                const unsigned char *buf, const int start_page)
 190 {
 191         struct ei_device *ei_local = netdev_priv(dev);
 192         void __iomem *nic_base = ei_local->mem;
 193         unsigned long dma_start;
 194 
 195         /* Round the count up for word writes. Do we need to do this?
 196          * What effect will an odd byte count have on the 8390?  I
 197          * should check someday.
 198          */
 199         if (ei_local->word16 && (count & 0x01))
 200                 count++;
 201 
 202         /* This *shouldn't* happen. If it does, it's the last thing
 203          * you'll see
 204          */
 205         if (ei_local->dmaing) {
 206                 netdev_err(dev,
 207                            "DMAing conflict in %s [DMAstat:%d][irqlock:%d]\n",
 208                            __func__,
 209                            ei_local->dmaing, ei_local->irqlock);
 210                 return;
 211         }
 212 
 213         ei_local->dmaing |= 0x01;
 214         /* We should already be in page 0, but to be safe... */
 215         ei_outb(E8390_PAGE0 + E8390_START + E8390_NODMA, nic_base + NE_CMD);
 216 
 217         ei_outb(ENISR_RDC, nic_base + EN0_ISR);
 218 
 219         /* Now the normal output. */
 220         ei_outb(count & 0xff, nic_base + EN0_RCNTLO);
 221         ei_outb(count >> 8, nic_base + EN0_RCNTHI);
 222         ei_outb(0x00, nic_base + EN0_RSARLO);
 223         ei_outb(start_page, nic_base + EN0_RSARHI);
 224 
 225         ei_outb(E8390_RWRITE + E8390_START, nic_base + NE_CMD);
 226 
 227         xs100_write(dev, buf, count);
 228 
 229         dma_start = jiffies;
 230 
 231         while ((ei_inb(nic_base + EN0_ISR) & ENISR_RDC) == 0) {
 232                 if (jiffies - dma_start > 2 * HZ / 100) {       /* 20ms */
 233                         netdev_warn(dev, "timeout waiting for Tx RDC.\n");
 234                         ei_local->reset_8390(dev);
 235                         ax_NS8390_init(dev, 1);
 236                         break;
 237                 }
 238         }
 239 
 240         ei_outb(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
 241         ei_local->dmaing &= ~0x01;
 242 }
 243 
 244 static int xsurf100_probe(struct zorro_dev *zdev,
 245                           const struct zorro_device_id *ent)
 246 {
 247         struct platform_device *pdev;
 248         struct xsurf100_ax_plat_data ax88796_data;
 249         struct resource res[2] = {
 250                 DEFINE_RES_NAMED(IRQ_AMIGA_PORTS, 1, NULL,
 251                                  IORESOURCE_IRQ | IORESOURCE_IRQ_SHAREABLE),
 252                 DEFINE_RES_MEM(zdev->resource.start + XS100_8390_BASE,
 253                                4 * 0x20)
 254         };
 255         int reg;
 256         /* This table is referenced in the device structure, so it must
 257          * outlive the scope of xsurf100_probe.
 258          */
 259         static u32 reg_offsets[32];
 260         int ret = 0;
 261 
 262         /* X-Surf 100 control and 32 bit ring buffer data access areas.
 263          * These resources are not used by the ax88796 driver, so must
 264          * be requested here and passed via platform data.
 265          */
 266 
 267         if (!request_mem_region(zdev->resource.start, 0x100, zdev->name)) {
 268                 dev_err(&zdev->dev, "cannot reserve X-Surf 100 control registers\n");
 269                 return -ENXIO;
 270         }
 271 
 272         if (!request_mem_region(zdev->resource.start +
 273                                 XS100_8390_DATA32_BASE,
 274                                 XS100_8390_DATA32_SIZE,
 275                                 "X-Surf 100 32-bit data access")) {
 276                 dev_err(&zdev->dev, "cannot reserve 32-bit area\n");
 277                 ret = -ENXIO;
 278                 goto exit_req;
 279         }
 280 
 281         for (reg = 0; reg < 0x20; reg++)
 282                 reg_offsets[reg] = 4 * reg;
 283 
 284         memset(&ax88796_data, 0, sizeof(ax88796_data));
 285         ax88796_data.ax.flags = AXFLG_HAS_EEPROM;
 286         ax88796_data.ax.wordlength = 2;
 287         ax88796_data.ax.dcr_val = 0x48;
 288         ax88796_data.ax.rcr_val = 0x40;
 289         ax88796_data.ax.reg_offsets = reg_offsets;
 290         ax88796_data.ax.check_irq = is_xsurf100_network_irq;
 291         ax88796_data.base_regs = ioremap(zdev->resource.start, 0x100);
 292 
 293         /* error handling for ioremap regs */
 294         if (!ax88796_data.base_regs) {
 295                 dev_err(&zdev->dev, "Cannot ioremap area %pR (registers)\n",
 296                         &zdev->resource);
 297 
 298                 ret = -ENXIO;
 299                 goto exit_req2;
 300         }
 301 
 302         ax88796_data.data_area = ioremap(zdev->resource.start +
 303                         XS100_8390_DATA32_BASE, XS100_8390_DATA32_SIZE);
 304 
 305         /* error handling for ioremap data */
 306         if (!ax88796_data.data_area) {
 307                 dev_err(&zdev->dev,
 308                         "Cannot ioremap area %pR offset %x (32-bit access)\n",
 309                         &zdev->resource,  XS100_8390_DATA32_BASE);
 310 
 311                 ret = -ENXIO;
 312                 goto exit_mem;
 313         }
 314 
 315         ax88796_data.ax.block_output = xs100_block_output;
 316         ax88796_data.ax.block_input = xs100_block_input;
 317 
 318         pdev = platform_device_register_resndata(&zdev->dev, "ax88796",
 319                                                  zdev->slotaddr, res, 2,
 320                                                  &ax88796_data,
 321                                                  sizeof(ax88796_data));
 322 
 323         if (IS_ERR(pdev)) {
 324                 dev_err(&zdev->dev, "cannot register platform device\n");
 325                 ret = -ENXIO;
 326                 goto exit_mem2;
 327         }
 328 
 329         zorro_set_drvdata(zdev, pdev);
 330 
 331         if (!ret)
 332                 return 0;
 333 
 334  exit_mem2:
 335         iounmap(ax88796_data.data_area);
 336 
 337  exit_mem:
 338         iounmap(ax88796_data.base_regs);
 339 
 340  exit_req2:
 341         release_mem_region(zdev->resource.start + XS100_8390_DATA32_BASE,
 342                            XS100_8390_DATA32_SIZE);
 343 
 344  exit_req:
 345         release_mem_region(zdev->resource.start, 0x100);
 346 
 347         return ret;
 348 }
 349 
 350 static void xsurf100_remove(struct zorro_dev *zdev)
 351 {
 352         struct platform_device *pdev = zorro_get_drvdata(zdev);
 353         struct xsurf100_ax_plat_data *xs100 = dev_get_platdata(&pdev->dev);
 354 
 355         platform_device_unregister(pdev);
 356 
 357         iounmap(xs100->base_regs);
 358         release_mem_region(zdev->resource.start, 0x100);
 359         iounmap(xs100->data_area);
 360         release_mem_region(zdev->resource.start + XS100_8390_DATA32_BASE,
 361                            XS100_8390_DATA32_SIZE);
 362 }
 363 
 364 static const struct zorro_device_id xsurf100_zorro_tbl[] = {
 365         { ZORRO_PROD_INDIVIDUAL_COMPUTERS_X_SURF100, },
 366         { 0 }
 367 };
 368 
 369 MODULE_DEVICE_TABLE(zorro, xsurf100_zorro_tbl);
 370 
 371 static struct zorro_driver xsurf100_driver = {
 372         .name           = "xsurf100",
 373         .id_table       = xsurf100_zorro_tbl,
 374         .probe          = xsurf100_probe,
 375         .remove         = xsurf100_remove,
 376 };
 377 
 378 module_driver(xsurf100_driver, zorro_register_driver, zorro_unregister_driver);
 379 
 380 MODULE_DESCRIPTION("X-Surf 100 driver");
 381 MODULE_AUTHOR("Michael Karcher <kernel@mkarcher.dialup.fu-berlin.de>");
 382 MODULE_LICENSE("GPL v2");
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/net/ethernet/8390/xsurf100.c

DEFINITIONS
