1 /* 2 * Driver for the Solos PCI ADSL2+ card, designed to support Linux by 3 * Traverse Technologies -- http://www.traverse.com.au/ 4 * Xrio Limited -- http://www.xrio.com/ 5 * 6 * 7 * Copyright © 2008 Traverse Technologies 8 * Copyright © 2008 Intel Corporation 9 * 10 * Authors: Nathan Williams <nathan@traverse.com.au> 11 * David Woodhouse <dwmw2@infradead.org> 12 * Treker Chen <treker@xrio.com> 13 * 14 * This program is free software; you can redistribute it and/or 15 * modify it under the terms of the GNU General Public License 16 * version 2, as published by the Free Software Foundation. 17 * 18 * This program is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 * GNU General Public License for more details. 22 */ 23 24 #define DEBUG 25 #define VERBOSE_DEBUG 26 27 #include <linux/interrupt.h> 28 #include <linux/module.h> 29 #include <linux/kernel.h> 30 #include <linux/errno.h> 31 #include <linux/ioport.h> 32 #include <linux/types.h> 33 #include <linux/pci.h> 34 #include <linux/atm.h> 35 #include <linux/atmdev.h> 36 #include <linux/skbuff.h> 37 #include <linux/sysfs.h> 38 #include <linux/device.h> 39 #include <linux/kobject.h> 40 #include <linux/firmware.h> 41 #include <linux/ctype.h> 42 #include <linux/swab.h> 43 #include <linux/slab.h> 44 45 #define VERSION "1.04" 46 #define DRIVER_VERSION 0x01 47 #define PTAG "solos-pci" 48 49 #define CONFIG_RAM_SIZE 128 50 #define FLAGS_ADDR 0x7C 51 #define IRQ_EN_ADDR 0x78 52 #define FPGA_VER 0x74 53 #define IRQ_CLEAR 0x70 54 #define WRITE_FLASH 0x6C 55 #define PORTS 0x68 56 #define FLASH_BLOCK 0x64 57 #define FLASH_BUSY 0x60 58 #define FPGA_MODE 0x5C 59 #define FLASH_MODE 0x58 60 #define GPIO_STATUS 0x54 61 #define DRIVER_VER 0x50 62 #define TX_DMA_ADDR(port) (0x40 + (4 * (port))) 63 #define RX_DMA_ADDR(port) (0x30 + (4 * (port))) 64 65 #define DATA_RAM_SIZE 32768 66 #define BUF_SIZE 2048 67 #define OLD_BUF_SIZE 4096 /* For FPGA versions <= 2*/ 68 /* Old boards use ATMEL AD45DB161D flash */ 69 #define ATMEL_FPGA_PAGE 528 /* FPGA flash page size*/ 70 #define ATMEL_SOLOS_PAGE 512 /* Solos flash page size*/ 71 #define ATMEL_FPGA_BLOCK (ATMEL_FPGA_PAGE * 8) /* FPGA block size*/ 72 #define ATMEL_SOLOS_BLOCK (ATMEL_SOLOS_PAGE * 8) /* Solos block size*/ 73 /* Current boards use M25P/M25PE SPI flash */ 74 #define SPI_FLASH_BLOCK (256 * 64) 75 76 #define RX_BUF(card, nr) ((card->buffers) + (nr)*(card->buffer_size)*2) 77 #define TX_BUF(card, nr) ((card->buffers) + (nr)*(card->buffer_size)*2 + (card->buffer_size)) 78 #define FLASH_BUF ((card->buffers) + 4*(card->buffer_size)*2) 79 80 #define RX_DMA_SIZE 2048 81 82 #define FPGA_VERSION(a,b) (((a) << 8) + (b)) 83 #define LEGACY_BUFFERS 2 84 #define DMA_SUPPORTED 4 85 86 static int reset = 0; 87 static int atmdebug = 0; 88 static int firmware_upgrade = 0; 89 static int fpga_upgrade = 0; 90 static int db_firmware_upgrade = 0; 91 static int db_fpga_upgrade = 0; 92 93 struct pkt_hdr { 94 __le16 size; 95 __le16 vpi; 96 __le16 vci; 97 __le16 type; 98 }; 99 100 struct solos_skb_cb { 101 struct atm_vcc *vcc; 102 uint32_t dma_addr; 103 }; 104 105 106 #define SKB_CB(skb) ((struct solos_skb_cb *)skb->cb) 107 108 #define PKT_DATA 0 109 #define PKT_COMMAND 1 110 #define PKT_POPEN 3 111 #define PKT_PCLOSE 4 112 #define PKT_STATUS 5 113 114 struct solos_card { 115 void __iomem *config_regs; 116 void __iomem *buffers; 117 int nr_ports; 118 int tx_mask; 119 struct pci_dev *dev; 120 struct atm_dev *atmdev[4]; 121 struct tasklet_struct tlet; 122 spinlock_t tx_lock; 123 spinlock_t tx_queue_lock; 124 spinlock_t cli_queue_lock; 125 spinlock_t param_queue_lock; 126 struct list_head param_queue; 127 struct sk_buff_head tx_queue[4]; 128 struct sk_buff_head cli_queue[4]; 129 struct sk_buff *tx_skb[4]; 130 struct sk_buff *rx_skb[4]; 131 unsigned char *dma_bounce; 132 wait_queue_head_t param_wq; 133 wait_queue_head_t fw_wq; 134 int using_dma; 135 int dma_alignment; 136 int fpga_version; 137 int buffer_size; 138 int atmel_flash; 139 }; 140 141 142 struct solos_param { 143 struct list_head list; 144 pid_t pid; 145 int port; 146 struct sk_buff *response; 147 }; 148 149 #define SOLOS_CHAN(atmdev) ((int)(unsigned long)(atmdev)->phy_data) 150 151 MODULE_AUTHOR("Traverse Technologies <support@traverse.com.au>"); 152 MODULE_DESCRIPTION("Solos PCI driver"); 153 MODULE_VERSION(VERSION); 154 MODULE_LICENSE("GPL"); 155 MODULE_FIRMWARE("solos-FPGA.bin"); 156 MODULE_FIRMWARE("solos-Firmware.bin"); 157 MODULE_FIRMWARE("solos-db-FPGA.bin"); 158 MODULE_PARM_DESC(reset, "Reset Solos chips on startup"); 159 MODULE_PARM_DESC(atmdebug, "Print ATM data"); 160 MODULE_PARM_DESC(firmware_upgrade, "Initiate Solos firmware upgrade"); 161 MODULE_PARM_DESC(fpga_upgrade, "Initiate FPGA upgrade"); 162 MODULE_PARM_DESC(db_firmware_upgrade, "Initiate daughter board Solos firmware upgrade"); 163 MODULE_PARM_DESC(db_fpga_upgrade, "Initiate daughter board FPGA upgrade"); 164 module_param(reset, int, 0444); 165 module_param(atmdebug, int, 0644); 166 module_param(firmware_upgrade, int, 0444); 167 module_param(fpga_upgrade, int, 0444); 168 module_param(db_firmware_upgrade, int, 0444); 169 module_param(db_fpga_upgrade, int, 0444); 170 171 static void fpga_queue(struct solos_card *card, int port, struct sk_buff *skb, 172 struct atm_vcc *vcc); 173 static uint32_t fpga_tx(struct solos_card *); 174 static irqreturn_t solos_irq(int irq, void *dev_id); 175 static struct atm_vcc* find_vcc(struct atm_dev *dev, short vpi, int vci); 176 static int atm_init(struct solos_card *, struct device *); 177 static void atm_remove(struct solos_card *); 178 static int send_command(struct solos_card *card, int dev, const char *buf, size_t size); 179 static void solos_bh(unsigned long); 180 static int print_buffer(struct sk_buff *buf); 181 182 static inline void solos_pop(struct atm_vcc *vcc, struct sk_buff *skb) 183 { 184 if (vcc->pop) 185 vcc->pop(vcc, skb); 186 else 187 dev_kfree_skb_any(skb); 188 } 189 190 static ssize_t solos_param_show(struct device *dev, struct device_attribute *attr, 191 char *buf) 192 { 193 struct atm_dev *atmdev = container_of(dev, struct atm_dev, class_dev); 194 struct solos_card *card = atmdev->dev_data; 195 struct solos_param prm; 196 struct sk_buff *skb; 197 struct pkt_hdr *header; 198 int buflen; 199 200 buflen = strlen(attr->attr.name) + 10; 201 202 skb = alloc_skb(sizeof(*header) + buflen, GFP_KERNEL); 203 if (!skb) { 204 dev_warn(&card->dev->dev, "Failed to allocate sk_buff in solos_param_show()\n"); 205 return -ENOMEM; 206 } 207 208 header = (void *)skb_put(skb, sizeof(*header)); 209 210 buflen = snprintf((void *)&header[1], buflen - 1, 211 "L%05d\n%s\n", current->pid, attr->attr.name); 212 skb_put(skb, buflen); 213 214 header->size = cpu_to_le16(buflen); 215 header->vpi = cpu_to_le16(0); 216 header->vci = cpu_to_le16(0); 217 header->type = cpu_to_le16(PKT_COMMAND); 218 219 prm.pid = current->pid; 220 prm.response = NULL; 221 prm.port = SOLOS_CHAN(atmdev); 222 223 spin_lock_irq(&card->param_queue_lock); 224 list_add(&prm.list, &card->param_queue); 225 spin_unlock_irq(&card->param_queue_lock); 226 227 fpga_queue(card, prm.port, skb, NULL); 228 229 wait_event_timeout(card->param_wq, prm.response, 5 * HZ); 230 231 spin_lock_irq(&card->param_queue_lock); 232 list_del(&prm.list); 233 spin_unlock_irq(&card->param_queue_lock); 234 235 if (!prm.response) 236 return -EIO; 237 238 buflen = prm.response->len; 239 memcpy(buf, prm.response->data, buflen); 240 kfree_skb(prm.response); 241 242 return buflen; 243 } 244 245 static ssize_t solos_param_store(struct device *dev, struct device_attribute *attr, 246 const char *buf, size_t count) 247 { 248 struct atm_dev *atmdev = container_of(dev, struct atm_dev, class_dev); 249 struct solos_card *card = atmdev->dev_data; 250 struct solos_param prm; 251 struct sk_buff *skb; 252 struct pkt_hdr *header; 253 int buflen; 254 ssize_t ret; 255 256 buflen = strlen(attr->attr.name) + 11 + count; 257 258 skb = alloc_skb(sizeof(*header) + buflen, GFP_KERNEL); 259 if (!skb) { 260 dev_warn(&card->dev->dev, "Failed to allocate sk_buff in solos_param_store()\n"); 261 return -ENOMEM; 262 } 263 264 header = (void *)skb_put(skb, sizeof(*header)); 265 266 buflen = snprintf((void *)&header[1], buflen - 1, 267 "L%05d\n%s\n%s\n", current->pid, attr->attr.name, buf); 268 269 skb_put(skb, buflen); 270 header->size = cpu_to_le16(buflen); 271 header->vpi = cpu_to_le16(0); 272 header->vci = cpu_to_le16(0); 273 header->type = cpu_to_le16(PKT_COMMAND); 274 275 prm.pid = current->pid; 276 prm.response = NULL; 277 prm.port = SOLOS_CHAN(atmdev); 278 279 spin_lock_irq(&card->param_queue_lock); 280 list_add(&prm.list, &card->param_queue); 281 spin_unlock_irq(&card->param_queue_lock); 282 283 fpga_queue(card, prm.port, skb, NULL); 284 285 wait_event_timeout(card->param_wq, prm.response, 5 * HZ); 286 287 spin_lock_irq(&card->param_queue_lock); 288 list_del(&prm.list); 289 spin_unlock_irq(&card->param_queue_lock); 290 291 skb = prm.response; 292 293 if (!skb) 294 return -EIO; 295 296 buflen = skb->len; 297 298 /* Sometimes it has a newline, sometimes it doesn't. */ 299 if (skb->data[buflen - 1] == '\n') 300 buflen--; 301 302 if (buflen == 2 && !strncmp(skb->data, "OK", 2)) 303 ret = count; 304 else if (buflen == 5 && !strncmp(skb->data, "ERROR", 5)) 305 ret = -EIO; 306 else { 307 /* We know we have enough space allocated for this; we allocated 308 it ourselves */ 309 skb->data[buflen] = 0; 310 311 dev_warn(&card->dev->dev, "Unexpected parameter response: '%s'\n", 312 skb->data); 313 ret = -EIO; 314 } 315 kfree_skb(skb); 316 317 return ret; 318 } 319 320 static char *next_string(struct sk_buff *skb) 321 { 322 int i = 0; 323 char *this = skb->data; 324 325 for (i = 0; i < skb->len; i++) { 326 if (this[i] == '\n') { 327 this[i] = 0; 328 skb_pull(skb, i + 1); 329 return this; 330 } 331 if (!isprint(this[i])) 332 return NULL; 333 } 334 return NULL; 335 } 336 337 /* 338 * Status packet has fields separated by \n, starting with a version number 339 * for the information therein. Fields are.... 340 * 341 * packet version 342 * RxBitRate (version >= 1) 343 * TxBitRate (version >= 1) 344 * State (version >= 1) 345 * LocalSNRMargin (version >= 1) 346 * LocalLineAttn (version >= 1) 347 */ 348 static int process_status(struct solos_card *card, int port, struct sk_buff *skb) 349 { 350 char *str, *end, *state_str, *snr, *attn; 351 int ver, rate_up, rate_down; 352 353 if (!card->atmdev[port]) 354 return -ENODEV; 355 356 str = next_string(skb); 357 if (!str) 358 return -EIO; 359 360 ver = simple_strtol(str, NULL, 10); 361 if (ver < 1) { 362 dev_warn(&card->dev->dev, "Unexpected status interrupt version %d\n", 363 ver); 364 return -EIO; 365 } 366 367 str = next_string(skb); 368 if (!str) 369 return -EIO; 370 if (!strcmp(str, "ERROR")) { 371 dev_dbg(&card->dev->dev, "Status packet indicated Solos error on port %d (starting up?)\n", 372 port); 373 return 0; 374 } 375 376 rate_down = simple_strtol(str, &end, 10); 377 if (*end) 378 return -EIO; 379 380 str = next_string(skb); 381 if (!str) 382 return -EIO; 383 rate_up = simple_strtol(str, &end, 10); 384 if (*end) 385 return -EIO; 386 387 state_str = next_string(skb); 388 if (!state_str) 389 return -EIO; 390 391 /* Anything but 'Showtime' is down */ 392 if (strcmp(state_str, "Showtime")) { 393 atm_dev_signal_change(card->atmdev[port], ATM_PHY_SIG_LOST); 394 dev_info(&card->dev->dev, "Port %d: %s\n", port, state_str); 395 return 0; 396 } 397 398 snr = next_string(skb); 399 if (!snr) 400 return -EIO; 401 attn = next_string(skb); 402 if (!attn) 403 return -EIO; 404 405 dev_info(&card->dev->dev, "Port %d: %s @%d/%d kb/s%s%s%s%s\n", 406 port, state_str, rate_down/1000, rate_up/1000, 407 snr[0]?", SNR ":"", snr, attn[0]?", Attn ":"", attn); 408 409 card->atmdev[port]->link_rate = rate_down / 424; 410 atm_dev_signal_change(card->atmdev[port], ATM_PHY_SIG_FOUND); 411 412 return 0; 413 } 414 415 static int process_command(struct solos_card *card, int port, struct sk_buff *skb) 416 { 417 struct solos_param *prm; 418 unsigned long flags; 419 int cmdpid; 420 int found = 0; 421 422 if (skb->len < 7) 423 return 0; 424 425 if (skb->data[0] != 'L' || !isdigit(skb->data[1]) || 426 !isdigit(skb->data[2]) || !isdigit(skb->data[3]) || 427 !isdigit(skb->data[4]) || !isdigit(skb->data[5]) || 428 skb->data[6] != '\n') 429 return 0; 430 431 cmdpid = simple_strtol(&skb->data[1], NULL, 10); 432 433 spin_lock_irqsave(&card->param_queue_lock, flags); 434 list_for_each_entry(prm, &card->param_queue, list) { 435 if (prm->port == port && prm->pid == cmdpid) { 436 prm->response = skb; 437 skb_pull(skb, 7); 438 wake_up(&card->param_wq); 439 found = 1; 440 break; 441 } 442 } 443 spin_unlock_irqrestore(&card->param_queue_lock, flags); 444 return found; 445 } 446 447 static ssize_t console_show(struct device *dev, struct device_attribute *attr, 448 char *buf) 449 { 450 struct atm_dev *atmdev = container_of(dev, struct atm_dev, class_dev); 451 struct solos_card *card = atmdev->dev_data; 452 struct sk_buff *skb; 453 unsigned int len; 454 455 spin_lock(&card->cli_queue_lock); 456 skb = skb_dequeue(&card->cli_queue[SOLOS_CHAN(atmdev)]); 457 spin_unlock(&card->cli_queue_lock); 458 if(skb == NULL) 459 return sprintf(buf, "No data.\n"); 460 461 len = skb->len; 462 memcpy(buf, skb->data, len); 463 464 kfree_skb(skb); 465 return len; 466 } 467 468 static int send_command(struct solos_card *card, int dev, const char *buf, size_t size) 469 { 470 struct sk_buff *skb; 471 struct pkt_hdr *header; 472 473 if (size > (BUF_SIZE - sizeof(*header))) { 474 dev_dbg(&card->dev->dev, "Command is too big. Dropping request\n"); 475 return 0; 476 } 477 skb = alloc_skb(size + sizeof(*header), GFP_ATOMIC); 478 if (!skb) { 479 dev_warn(&card->dev->dev, "Failed to allocate sk_buff in send_command()\n"); 480 return 0; 481 } 482 483 header = (void *)skb_put(skb, sizeof(*header)); 484 485 header->size = cpu_to_le16(size); 486 header->vpi = cpu_to_le16(0); 487 header->vci = cpu_to_le16(0); 488 header->type = cpu_to_le16(PKT_COMMAND); 489 490 memcpy(skb_put(skb, size), buf, size); 491 492 fpga_queue(card, dev, skb, NULL); 493 494 return 0; 495 } 496 497 static ssize_t console_store(struct device *dev, struct device_attribute *attr, 498 const char *buf, size_t count) 499 { 500 struct atm_dev *atmdev = container_of(dev, struct atm_dev, class_dev); 501 struct solos_card *card = atmdev->dev_data; 502 int err; 503 504 err = send_command(card, SOLOS_CHAN(atmdev), buf, count); 505 506 return err?:count; 507 } 508 509 struct geos_gpio_attr { 510 struct device_attribute attr; 511 int offset; 512 }; 513 514 #define SOLOS_GPIO_ATTR(_name, _mode, _show, _store, _offset) \ 515 struct geos_gpio_attr gpio_attr_##_name = { \ 516 .attr = __ATTR(_name, _mode, _show, _store), \ 517 .offset = _offset } 518 519 static ssize_t geos_gpio_store(struct device *dev, struct device_attribute *attr, 520 const char *buf, size_t count) 521 { 522 struct pci_dev *pdev = container_of(dev, struct pci_dev, dev); 523 struct geos_gpio_attr *gattr = container_of(attr, struct geos_gpio_attr, attr); 524 struct solos_card *card = pci_get_drvdata(pdev); 525 uint32_t data32; 526 527 if (count != 1 && (count != 2 || buf[1] != '\n')) 528 return -EINVAL; 529 530 spin_lock_irq(&card->param_queue_lock); 531 data32 = ioread32(card->config_regs + GPIO_STATUS); 532 if (buf[0] == '1') { 533 data32 |= 1 << gattr->offset; 534 iowrite32(data32, card->config_regs + GPIO_STATUS); 535 } else if (buf[0] == '0') { 536 data32 &= ~(1 << gattr->offset); 537 iowrite32(data32, card->config_regs + GPIO_STATUS); 538 } else { 539 count = -EINVAL; 540 } 541 spin_unlock_irq(&card->param_queue_lock); 542 return count; 543 } 544 545 static ssize_t geos_gpio_show(struct device *dev, struct device_attribute *attr, 546 char *buf) 547 { 548 struct pci_dev *pdev = container_of(dev, struct pci_dev, dev); 549 struct geos_gpio_attr *gattr = container_of(attr, struct geos_gpio_attr, attr); 550 struct solos_card *card = pci_get_drvdata(pdev); 551 uint32_t data32; 552 553 data32 = ioread32(card->config_regs + GPIO_STATUS); 554 data32 = (data32 >> gattr->offset) & 1; 555 556 return sprintf(buf, "%d\n", data32); 557 } 558 559 static ssize_t hardware_show(struct device *dev, struct device_attribute *attr, 560 char *buf) 561 { 562 struct pci_dev *pdev = container_of(dev, struct pci_dev, dev); 563 struct geos_gpio_attr *gattr = container_of(attr, struct geos_gpio_attr, attr); 564 struct solos_card *card = pci_get_drvdata(pdev); 565 uint32_t data32; 566 567 data32 = ioread32(card->config_regs + GPIO_STATUS); 568 switch (gattr->offset) { 569 case 0: 570 /* HardwareVersion */ 571 data32 = data32 & 0x1F; 572 break; 573 case 1: 574 /* HardwareVariant */ 575 data32 = (data32 >> 5) & 0x0F; 576 break; 577 } 578 return sprintf(buf, "%d\n", data32); 579 } 580 581 static DEVICE_ATTR(console, 0644, console_show, console_store); 582 583 584 #define SOLOS_ATTR_RO(x) static DEVICE_ATTR(x, 0444, solos_param_show, NULL); 585 #define SOLOS_ATTR_RW(x) static DEVICE_ATTR(x, 0644, solos_param_show, solos_param_store); 586 587 #include "solos-attrlist.c" 588 589 static SOLOS_GPIO_ATTR(GPIO1, 0644, geos_gpio_show, geos_gpio_store, 9); 590 static SOLOS_GPIO_ATTR(GPIO2, 0644, geos_gpio_show, geos_gpio_store, 10); 591 static SOLOS_GPIO_ATTR(GPIO3, 0644, geos_gpio_show, geos_gpio_store, 11); 592 static SOLOS_GPIO_ATTR(GPIO4, 0644, geos_gpio_show, geos_gpio_store, 12); 593 static SOLOS_GPIO_ATTR(GPIO5, 0644, geos_gpio_show, geos_gpio_store, 13); 594 static SOLOS_GPIO_ATTR(PushButton, 0444, geos_gpio_show, NULL, 14); 595 static SOLOS_GPIO_ATTR(HardwareVersion, 0444, hardware_show, NULL, 0); 596 static SOLOS_GPIO_ATTR(HardwareVariant, 0444, hardware_show, NULL, 1); 597 #undef SOLOS_ATTR_RO 598 #undef SOLOS_ATTR_RW 599 600 #define SOLOS_ATTR_RO(x) &dev_attr_##x.attr, 601 #define SOLOS_ATTR_RW(x) &dev_attr_##x.attr, 602 603 static struct attribute *solos_attrs[] = { 604 #include "solos-attrlist.c" 605 NULL 606 }; 607 608 static struct attribute_group solos_attr_group = { 609 .attrs = solos_attrs, 610 .name = "parameters", 611 }; 612 613 static struct attribute *gpio_attrs[] = { 614 &gpio_attr_GPIO1.attr.attr, 615 &gpio_attr_GPIO2.attr.attr, 616 &gpio_attr_GPIO3.attr.attr, 617 &gpio_attr_GPIO4.attr.attr, 618 &gpio_attr_GPIO5.attr.attr, 619 &gpio_attr_PushButton.attr.attr, 620 &gpio_attr_HardwareVersion.attr.attr, 621 &gpio_attr_HardwareVariant.attr.attr, 622 NULL 623 }; 624 625 static struct attribute_group gpio_attr_group = { 626 .attrs = gpio_attrs, 627 .name = "gpio", 628 }; 629 630 static int flash_upgrade(struct solos_card *card, int chip) 631 { 632 const struct firmware *fw; 633 const char *fw_name; 634 int blocksize = 0; 635 int numblocks = 0; 636 int offset; 637 638 switch (chip) { 639 case 0: 640 fw_name = "solos-FPGA.bin"; 641 if (card->atmel_flash) 642 blocksize = ATMEL_FPGA_BLOCK; 643 else 644 blocksize = SPI_FLASH_BLOCK; 645 break; 646 case 1: 647 fw_name = "solos-Firmware.bin"; 648 if (card->atmel_flash) 649 blocksize = ATMEL_SOLOS_BLOCK; 650 else 651 blocksize = SPI_FLASH_BLOCK; 652 break; 653 case 2: 654 if (card->fpga_version > LEGACY_BUFFERS){ 655 fw_name = "solos-db-FPGA.bin"; 656 if (card->atmel_flash) 657 blocksize = ATMEL_FPGA_BLOCK; 658 else 659 blocksize = SPI_FLASH_BLOCK; 660 } else { 661 dev_info(&card->dev->dev, "FPGA version doesn't support" 662 " daughter board upgrades\n"); 663 return -EPERM; 664 } 665 break; 666 case 3: 667 if (card->fpga_version > LEGACY_BUFFERS){ 668 fw_name = "solos-Firmware.bin"; 669 if (card->atmel_flash) 670 blocksize = ATMEL_SOLOS_BLOCK; 671 else 672 blocksize = SPI_FLASH_BLOCK; 673 } else { 674 dev_info(&card->dev->dev, "FPGA version doesn't support" 675 " daughter board upgrades\n"); 676 return -EPERM; 677 } 678 break; 679 default: 680 return -ENODEV; 681 } 682 683 if (request_firmware(&fw, fw_name, &card->dev->dev)) 684 return -ENOENT; 685 686 dev_info(&card->dev->dev, "Flash upgrade starting\n"); 687 688 /* New FPGAs require driver version before permitting flash upgrades */ 689 iowrite32(DRIVER_VERSION, card->config_regs + DRIVER_VER); 690 691 numblocks = fw->size / blocksize; 692 dev_info(&card->dev->dev, "Firmware size: %zd\n", fw->size); 693 dev_info(&card->dev->dev, "Number of blocks: %d\n", numblocks); 694 695 dev_info(&card->dev->dev, "Changing FPGA to Update mode\n"); 696 iowrite32(1, card->config_regs + FPGA_MODE); 697 (void) ioread32(card->config_regs + FPGA_MODE); 698 699 /* Set mode to Chip Erase */ 700 if(chip == 0 || chip == 2) 701 dev_info(&card->dev->dev, "Set FPGA Flash mode to FPGA Chip Erase\n"); 702 if(chip == 1 || chip == 3) 703 dev_info(&card->dev->dev, "Set FPGA Flash mode to Solos Chip Erase\n"); 704 iowrite32((chip * 2), card->config_regs + FLASH_MODE); 705 706 707 iowrite32(1, card->config_regs + WRITE_FLASH); 708 wait_event(card->fw_wq, !ioread32(card->config_regs + FLASH_BUSY)); 709 710 for (offset = 0; offset < fw->size; offset += blocksize) { 711 int i; 712 713 /* Clear write flag */ 714 iowrite32(0, card->config_regs + WRITE_FLASH); 715 716 /* Set mode to Block Write */ 717 /* dev_info(&card->dev->dev, "Set FPGA Flash mode to Block Write\n"); */ 718 iowrite32(((chip * 2) + 1), card->config_regs + FLASH_MODE); 719 720 /* Copy block to buffer, swapping each 16 bits for Atmel flash */ 721 for(i = 0; i < blocksize; i += 4) { 722 uint32_t word; 723 if (card->atmel_flash) 724 word = swahb32p((uint32_t *)(fw->data + offset + i)); 725 else 726 word = *(uint32_t *)(fw->data + offset + i); 727 if(card->fpga_version > LEGACY_BUFFERS) 728 iowrite32(word, FLASH_BUF + i); 729 else 730 iowrite32(word, RX_BUF(card, 3) + i); 731 } 732 733 /* Specify block number and then trigger flash write */ 734 iowrite32(offset / blocksize, card->config_regs + FLASH_BLOCK); 735 iowrite32(1, card->config_regs + WRITE_FLASH); 736 wait_event(card->fw_wq, !ioread32(card->config_regs + FLASH_BUSY)); 737 } 738 739 release_firmware(fw); 740 iowrite32(0, card->config_regs + WRITE_FLASH); 741 iowrite32(0, card->config_regs + FPGA_MODE); 742 iowrite32(0, card->config_regs + FLASH_MODE); 743 dev_info(&card->dev->dev, "Returning FPGA to Data mode\n"); 744 return 0; 745 } 746 747 static irqreturn_t solos_irq(int irq, void *dev_id) 748 { 749 struct solos_card *card = dev_id; 750 int handled = 1; 751 752 iowrite32(0, card->config_regs + IRQ_CLEAR); 753 754 /* If we're up and running, just kick the tasklet to process TX/RX */ 755 if (card->atmdev[0]) 756 tasklet_schedule(&card->tlet); 757 else 758 wake_up(&card->fw_wq); 759 760 return IRQ_RETVAL(handled); 761 } 762 763 static void solos_bh(unsigned long card_arg) 764 { 765 struct solos_card *card = (void *)card_arg; 766 uint32_t card_flags; 767 uint32_t rx_done = 0; 768 int port; 769 770 /* 771 * Since fpga_tx() is going to need to read the flags under its lock, 772 * it can return them to us so that we don't have to hit PCI MMIO 773 * again for the same information 774 */ 775 card_flags = fpga_tx(card); 776 777 for (port = 0; port < card->nr_ports; port++) { 778 if (card_flags & (0x10 << port)) { 779 struct pkt_hdr _hdr, *header; 780 struct sk_buff *skb; 781 struct atm_vcc *vcc; 782 int size; 783 784 if (card->using_dma) { 785 skb = card->rx_skb[port]; 786 card->rx_skb[port] = NULL; 787 788 dma_unmap_single(&card->dev->dev, SKB_CB(skb)->dma_addr, 789 RX_DMA_SIZE, DMA_FROM_DEVICE); 790 791 header = (void *)skb->data; 792 size = le16_to_cpu(header->size); 793 skb_put(skb, size + sizeof(*header)); 794 skb_pull(skb, sizeof(*header)); 795 } else { 796 header = &_hdr; 797 798 rx_done |= 0x10 << port; 799 800 memcpy_fromio(header, RX_BUF(card, port), sizeof(*header)); 801 802 size = le16_to_cpu(header->size); 803 if (size > (card->buffer_size - sizeof(*header))){ 804 dev_warn(&card->dev->dev, "Invalid buffer size\n"); 805 continue; 806 } 807 808 /* Use netdev_alloc_skb() because it adds NET_SKB_PAD of 809 * headroom, and ensures we can route packets back out an 810 * Ethernet interface (for example) without having to 811 * reallocate. Adding NET_IP_ALIGN also ensures that both 812 * PPPoATM and PPPoEoBR2684 packets end up aligned. */ 813 skb = netdev_alloc_skb_ip_align(NULL, size + 1); 814 if (!skb) { 815 if (net_ratelimit()) 816 dev_warn(&card->dev->dev, "Failed to allocate sk_buff for RX\n"); 817 continue; 818 } 819 820 memcpy_fromio(skb_put(skb, size), 821 RX_BUF(card, port) + sizeof(*header), 822 size); 823 } 824 if (atmdebug) { 825 dev_info(&card->dev->dev, "Received: port %d\n", port); 826 dev_info(&card->dev->dev, "size: %d VPI: %d VCI: %d\n", 827 size, le16_to_cpu(header->vpi), 828 le16_to_cpu(header->vci)); 829 print_buffer(skb); 830 } 831 832 switch (le16_to_cpu(header->type)) { 833 case PKT_DATA: 834 vcc = find_vcc(card->atmdev[port], le16_to_cpu(header->vpi), 835 le16_to_cpu(header->vci)); 836 if (!vcc) { 837 if (net_ratelimit()) 838 dev_warn(&card->dev->dev, "Received packet for unknown VPI.VCI %d.%d on port %d\n", 839 le16_to_cpu(header->vpi), le16_to_cpu(header->vci), 840 port); 841 dev_kfree_skb_any(skb); 842 break; 843 } 844 atm_charge(vcc, skb->truesize); 845 vcc->push(vcc, skb); 846 atomic_inc(&vcc->stats->rx); 847 break; 848 849 case PKT_STATUS: 850 if (process_status(card, port, skb) && 851 net_ratelimit()) { 852 dev_warn(&card->dev->dev, "Bad status packet of %d bytes on port %d:\n", skb->len, port); 853 print_buffer(skb); 854 } 855 dev_kfree_skb_any(skb); 856 break; 857 858 case PKT_COMMAND: 859 default: /* FIXME: Not really, surely? */ 860 if (process_command(card, port, skb)) 861 break; 862 spin_lock(&card->cli_queue_lock); 863 if (skb_queue_len(&card->cli_queue[port]) > 10) { 864 if (net_ratelimit()) 865 dev_warn(&card->dev->dev, "Dropping console response on port %d\n", 866 port); 867 dev_kfree_skb_any(skb); 868 } else 869 skb_queue_tail(&card->cli_queue[port], skb); 870 spin_unlock(&card->cli_queue_lock); 871 break; 872 } 873 } 874 /* Allocate RX skbs for any ports which need them */ 875 if (card->using_dma && card->atmdev[port] && 876 !card->rx_skb[port]) { 877 /* Unlike the MMIO case (qv) we can't add NET_IP_ALIGN 878 * here; the FPGA can only DMA to addresses which are 879 * aligned to 4 bytes. */ 880 struct sk_buff *skb = dev_alloc_skb(RX_DMA_SIZE); 881 if (skb) { 882 SKB_CB(skb)->dma_addr = 883 dma_map_single(&card->dev->dev, skb->data, 884 RX_DMA_SIZE, DMA_FROM_DEVICE); 885 iowrite32(SKB_CB(skb)->dma_addr, 886 card->config_regs + RX_DMA_ADDR(port)); 887 card->rx_skb[port] = skb; 888 } else { 889 if (net_ratelimit()) 890 dev_warn(&card->dev->dev, "Failed to allocate RX skb"); 891 892 /* We'll have to try again later */ 893 tasklet_schedule(&card->tlet); 894 } 895 } 896 } 897 if (rx_done) 898 iowrite32(rx_done, card->config_regs + FLAGS_ADDR); 899 900 return; 901 } 902 903 static struct atm_vcc *find_vcc(struct atm_dev *dev, short vpi, int vci) 904 { 905 struct hlist_head *head; 906 struct atm_vcc *vcc = NULL; 907 struct sock *s; 908 909 read_lock(&vcc_sklist_lock); 910 head = &vcc_hash[vci & (VCC_HTABLE_SIZE -1)]; 911 sk_for_each(s, head) { 912 vcc = atm_sk(s); 913 if (vcc->dev == dev && vcc->vci == vci && 914 vcc->vpi == vpi && vcc->qos.rxtp.traffic_class != ATM_NONE && 915 test_bit(ATM_VF_READY, &vcc->flags)) 916 goto out; 917 } 918 vcc = NULL; 919 out: 920 read_unlock(&vcc_sklist_lock); 921 return vcc; 922 } 923 924 static int popen(struct atm_vcc *vcc) 925 { 926 struct solos_card *card = vcc->dev->dev_data; 927 struct sk_buff *skb; 928 struct pkt_hdr *header; 929 930 if (vcc->qos.aal != ATM_AAL5) { 931 dev_warn(&card->dev->dev, "Unsupported ATM type %d\n", 932 vcc->qos.aal); 933 return -EINVAL; 934 } 935 936 skb = alloc_skb(sizeof(*header), GFP_KERNEL); 937 if (!skb) { 938 if (net_ratelimit()) 939 dev_warn(&card->dev->dev, "Failed to allocate sk_buff in popen()\n"); 940 return -ENOMEM; 941 } 942 header = (void *)skb_put(skb, sizeof(*header)); 943 944 header->size = cpu_to_le16(0); 945 header->vpi = cpu_to_le16(vcc->vpi); 946 header->vci = cpu_to_le16(vcc->vci); 947 header->type = cpu_to_le16(PKT_POPEN); 948 949 fpga_queue(card, SOLOS_CHAN(vcc->dev), skb, NULL); 950 951 set_bit(ATM_VF_ADDR, &vcc->flags); 952 set_bit(ATM_VF_READY, &vcc->flags); 953 954 return 0; 955 } 956 957 static void pclose(struct atm_vcc *vcc) 958 { 959 struct solos_card *card = vcc->dev->dev_data; 960 unsigned char port = SOLOS_CHAN(vcc->dev); 961 struct sk_buff *skb, *tmpskb; 962 struct pkt_hdr *header; 963 964 /* Remove any yet-to-be-transmitted packets from the pending queue */ 965 spin_lock(&card->tx_queue_lock); 966 skb_queue_walk_safe(&card->tx_queue[port], skb, tmpskb) { 967 if (SKB_CB(skb)->vcc == vcc) { 968 skb_unlink(skb, &card->tx_queue[port]); 969 solos_pop(vcc, skb); 970 } 971 } 972 spin_unlock(&card->tx_queue_lock); 973 974 skb = alloc_skb(sizeof(*header), GFP_KERNEL); 975 if (!skb) { 976 dev_warn(&card->dev->dev, "Failed to allocate sk_buff in pclose()\n"); 977 return; 978 } 979 header = (void *)skb_put(skb, sizeof(*header)); 980 981 header->size = cpu_to_le16(0); 982 header->vpi = cpu_to_le16(vcc->vpi); 983 header->vci = cpu_to_le16(vcc->vci); 984 header->type = cpu_to_le16(PKT_PCLOSE); 985 986 skb_get(skb); 987 fpga_queue(card, port, skb, NULL); 988 989 if (!wait_event_timeout(card->param_wq, !skb_shared(skb), 5 * HZ)) 990 dev_warn(&card->dev->dev, 991 "Timeout waiting for VCC close on port %d\n", port); 992 993 dev_kfree_skb(skb); 994 995 /* Hold up vcc_destroy_socket() (our caller) until solos_bh() in the 996 tasklet has finished processing any incoming packets (and, more to 997 the point, using the vcc pointer). */ 998 tasklet_unlock_wait(&card->tlet); 999 1000 clear_bit(ATM_VF_ADDR, &vcc->flags); 1001 1002 return; 1003 } 1004 1005 static int print_buffer(struct sk_buff *buf) 1006 { 1007 int len,i; 1008 char msg[500]; 1009 char item[10]; 1010 1011 len = buf->len; 1012 for (i = 0; i < len; i++){ 1013 if(i % 8 == 0) 1014 sprintf(msg, "%02X: ", i); 1015 1016 sprintf(item,"%02X ",*(buf->data + i)); 1017 strcat(msg, item); 1018 if(i % 8 == 7) { 1019 sprintf(item, "\n"); 1020 strcat(msg, item); 1021 printk(KERN_DEBUG "%s", msg); 1022 } 1023 } 1024 if (i % 8 != 0) { 1025 sprintf(item, "\n"); 1026 strcat(msg, item); 1027 printk(KERN_DEBUG "%s", msg); 1028 } 1029 printk(KERN_DEBUG "\n"); 1030 1031 return 0; 1032 } 1033 1034 static void fpga_queue(struct solos_card *card, int port, struct sk_buff *skb, 1035 struct atm_vcc *vcc) 1036 { 1037 int old_len; 1038 unsigned long flags; 1039 1040 SKB_CB(skb)->vcc = vcc; 1041 1042 spin_lock_irqsave(&card->tx_queue_lock, flags); 1043 old_len = skb_queue_len(&card->tx_queue[port]); 1044 skb_queue_tail(&card->tx_queue[port], skb); 1045 if (!old_len) 1046 card->tx_mask |= (1 << port); 1047 spin_unlock_irqrestore(&card->tx_queue_lock, flags); 1048 1049 /* Theoretically we could just schedule the tasklet here, but 1050 that introduces latency we don't want -- it's noticeable */ 1051 if (!old_len) 1052 fpga_tx(card); 1053 } 1054 1055 static uint32_t fpga_tx(struct solos_card *card) 1056 { 1057 uint32_t tx_pending, card_flags; 1058 uint32_t tx_started = 0; 1059 struct sk_buff *skb; 1060 struct atm_vcc *vcc; 1061 unsigned char port; 1062 unsigned long flags; 1063 1064 spin_lock_irqsave(&card->tx_lock, flags); 1065 1066 card_flags = ioread32(card->config_regs + FLAGS_ADDR); 1067 /* 1068 * The queue lock is required for _writing_ to tx_mask, but we're 1069 * OK to read it here without locking. The only potential update 1070 * that we could race with is in fpga_queue() where it sets a bit 1071 * for a new port... but it's going to call this function again if 1072 * it's doing that, anyway. 1073 */ 1074 tx_pending = card->tx_mask & ~card_flags; 1075 1076 for (port = 0; tx_pending; tx_pending >>= 1, port++) { 1077 if (tx_pending & 1) { 1078 struct sk_buff *oldskb = card->tx_skb[port]; 1079 if (oldskb) { 1080 dma_unmap_single(&card->dev->dev, SKB_CB(oldskb)->dma_addr, 1081 oldskb->len, DMA_TO_DEVICE); 1082 card->tx_skb[port] = NULL; 1083 } 1084 spin_lock(&card->tx_queue_lock); 1085 skb = skb_dequeue(&card->tx_queue[port]); 1086 if (!skb) 1087 card->tx_mask &= ~(1 << port); 1088 spin_unlock(&card->tx_queue_lock); 1089 1090 if (skb && !card->using_dma) { 1091 memcpy_toio(TX_BUF(card, port), skb->data, skb->len); 1092 tx_started |= 1 << port; 1093 oldskb = skb; /* We're done with this skb already */ 1094 } else if (skb && card->using_dma) { 1095 unsigned char *data = skb->data; 1096 if ((unsigned long)data & card->dma_alignment) { 1097 data = card->dma_bounce + (BUF_SIZE * port); 1098 memcpy(data, skb->data, skb->len); 1099 } 1100 SKB_CB(skb)->dma_addr = dma_map_single(&card->dev->dev, data, 1101 skb->len, DMA_TO_DEVICE); 1102 card->tx_skb[port] = skb; 1103 iowrite32(SKB_CB(skb)->dma_addr, 1104 card->config_regs + TX_DMA_ADDR(port)); 1105 } 1106 1107 if (!oldskb) 1108 continue; 1109 1110 /* Clean up and free oldskb now it's gone */ 1111 if (atmdebug) { 1112 struct pkt_hdr *header = (void *)oldskb->data; 1113 int size = le16_to_cpu(header->size); 1114 1115 skb_pull(oldskb, sizeof(*header)); 1116 dev_info(&card->dev->dev, "Transmitted: port %d\n", 1117 port); 1118 dev_info(&card->dev->dev, "size: %d VPI: %d VCI: %d\n", 1119 size, le16_to_cpu(header->vpi), 1120 le16_to_cpu(header->vci)); 1121 print_buffer(oldskb); 1122 } 1123 1124 vcc = SKB_CB(oldskb)->vcc; 1125 1126 if (vcc) { 1127 atomic_inc(&vcc->stats->tx); 1128 solos_pop(vcc, oldskb); 1129 } else { 1130 dev_kfree_skb_irq(oldskb); 1131 wake_up(&card->param_wq); 1132 } 1133 } 1134 } 1135 /* For non-DMA TX, write the 'TX start' bit for all four ports simultaneously */ 1136 if (tx_started) 1137 iowrite32(tx_started, card->config_regs + FLAGS_ADDR); 1138 1139 spin_unlock_irqrestore(&card->tx_lock, flags); 1140 return card_flags; 1141 } 1142 1143 static int psend(struct atm_vcc *vcc, struct sk_buff *skb) 1144 { 1145 struct solos_card *card = vcc->dev->dev_data; 1146 struct pkt_hdr *header; 1147 int pktlen; 1148 1149 pktlen = skb->len; 1150 if (pktlen > (BUF_SIZE - sizeof(*header))) { 1151 dev_warn(&card->dev->dev, "Length of PDU is too large. Dropping PDU.\n"); 1152 solos_pop(vcc, skb); 1153 return 0; 1154 } 1155 1156 if (!skb_clone_writable(skb, sizeof(*header))) { 1157 int expand_by = 0; 1158 int ret; 1159 1160 if (skb_headroom(skb) < sizeof(*header)) 1161 expand_by = sizeof(*header) - skb_headroom(skb); 1162 1163 ret = pskb_expand_head(skb, expand_by, 0, GFP_ATOMIC); 1164 if (ret) { 1165 dev_warn(&card->dev->dev, "pskb_expand_head failed.\n"); 1166 solos_pop(vcc, skb); 1167 return ret; 1168 } 1169 } 1170 1171 header = (void *)skb_push(skb, sizeof(*header)); 1172 1173 /* This does _not_ include the size of the header */ 1174 header->size = cpu_to_le16(pktlen); 1175 header->vpi = cpu_to_le16(vcc->vpi); 1176 header->vci = cpu_to_le16(vcc->vci); 1177 header->type = cpu_to_le16(PKT_DATA); 1178 1179 fpga_queue(card, SOLOS_CHAN(vcc->dev), skb, vcc); 1180 1181 return 0; 1182 } 1183 1184 static struct atmdev_ops fpga_ops = { 1185 .open = popen, 1186 .close = pclose, 1187 .ioctl = NULL, 1188 .getsockopt = NULL, 1189 .setsockopt = NULL, 1190 .send = psend, 1191 .send_oam = NULL, 1192 .phy_put = NULL, 1193 .phy_get = NULL, 1194 .change_qos = NULL, 1195 .proc_read = NULL, 1196 .owner = THIS_MODULE 1197 }; 1198 1199 static int fpga_probe(struct pci_dev *dev, const struct pci_device_id *id) 1200 { 1201 int err; 1202 uint16_t fpga_ver; 1203 uint8_t major_ver, minor_ver; 1204 uint32_t data32; 1205 struct solos_card *card; 1206 1207 card = kzalloc(sizeof(*card), GFP_KERNEL); 1208 if (!card) 1209 return -ENOMEM; 1210 1211 card->dev = dev; 1212 init_waitqueue_head(&card->fw_wq); 1213 init_waitqueue_head(&card->param_wq); 1214 1215 err = pci_enable_device(dev); 1216 if (err) { 1217 dev_warn(&dev->dev, "Failed to enable PCI device\n"); 1218 goto out; 1219 } 1220 1221 err = dma_set_mask_and_coherent(&dev->dev, DMA_BIT_MASK(32)); 1222 if (err) { 1223 dev_warn(&dev->dev, "Failed to set 32-bit DMA mask\n"); 1224 goto out; 1225 } 1226 1227 err = pci_request_regions(dev, "solos"); 1228 if (err) { 1229 dev_warn(&dev->dev, "Failed to request regions\n"); 1230 goto out; 1231 } 1232 1233 card->config_regs = pci_iomap(dev, 0, CONFIG_RAM_SIZE); 1234 if (!card->config_regs) { 1235 dev_warn(&dev->dev, "Failed to ioremap config registers\n"); 1236 err = -ENOMEM; 1237 goto out_release_regions; 1238 } 1239 card->buffers = pci_iomap(dev, 1, DATA_RAM_SIZE); 1240 if (!card->buffers) { 1241 dev_warn(&dev->dev, "Failed to ioremap data buffers\n"); 1242 err = -ENOMEM; 1243 goto out_unmap_config; 1244 } 1245 1246 if (reset) { 1247 iowrite32(1, card->config_regs + FPGA_MODE); 1248 data32 = ioread32(card->config_regs + FPGA_MODE); 1249 1250 iowrite32(0, card->config_regs + FPGA_MODE); 1251 data32 = ioread32(card->config_regs + FPGA_MODE); 1252 } 1253 1254 data32 = ioread32(card->config_regs + FPGA_VER); 1255 fpga_ver = (data32 & 0x0000FFFF); 1256 major_ver = ((data32 & 0xFF000000) >> 24); 1257 minor_ver = ((data32 & 0x00FF0000) >> 16); 1258 card->fpga_version = FPGA_VERSION(major_ver,minor_ver); 1259 if (card->fpga_version > LEGACY_BUFFERS) 1260 card->buffer_size = BUF_SIZE; 1261 else 1262 card->buffer_size = OLD_BUF_SIZE; 1263 dev_info(&dev->dev, "Solos FPGA Version %d.%02d svn-%d\n", 1264 major_ver, minor_ver, fpga_ver); 1265 1266 if (fpga_ver < 37 && (fpga_upgrade || firmware_upgrade || 1267 db_fpga_upgrade || db_firmware_upgrade)) { 1268 dev_warn(&dev->dev, 1269 "FPGA too old; cannot upgrade flash. Use JTAG.\n"); 1270 fpga_upgrade = firmware_upgrade = 0; 1271 db_fpga_upgrade = db_firmware_upgrade = 0; 1272 } 1273 1274 /* Stopped using Atmel flash after 0.03-38 */ 1275 if (fpga_ver < 39) 1276 card->atmel_flash = 1; 1277 else 1278 card->atmel_flash = 0; 1279 1280 data32 = ioread32(card->config_regs + PORTS); 1281 card->nr_ports = (data32 & 0x000000FF); 1282 1283 if (card->fpga_version >= DMA_SUPPORTED) { 1284 pci_set_master(dev); 1285 card->using_dma = 1; 1286 if (1) { /* All known FPGA versions so far */ 1287 card->dma_alignment = 3; 1288 card->dma_bounce = kmalloc(card->nr_ports * BUF_SIZE, GFP_KERNEL); 1289 if (!card->dma_bounce) { 1290 dev_warn(&card->dev->dev, "Failed to allocate DMA bounce buffers\n"); 1291 err = -ENOMEM; 1292 /* Fallback to MMIO doesn't work */ 1293 goto out_unmap_both; 1294 } 1295 } 1296 } else { 1297 card->using_dma = 0; 1298 /* Set RX empty flag for all ports */ 1299 iowrite32(0xF0, card->config_regs + FLAGS_ADDR); 1300 } 1301 1302 pci_set_drvdata(dev, card); 1303 1304 tasklet_init(&card->tlet, solos_bh, (unsigned long)card); 1305 spin_lock_init(&card->tx_lock); 1306 spin_lock_init(&card->tx_queue_lock); 1307 spin_lock_init(&card->cli_queue_lock); 1308 spin_lock_init(&card->param_queue_lock); 1309 INIT_LIST_HEAD(&card->param_queue); 1310 1311 err = request_irq(dev->irq, solos_irq, IRQF_SHARED, 1312 "solos-pci", card); 1313 if (err) { 1314 dev_dbg(&card->dev->dev, "Failed to request interrupt IRQ: %d\n", dev->irq); 1315 goto out_unmap_both; 1316 } 1317 1318 iowrite32(1, card->config_regs + IRQ_EN_ADDR); 1319 1320 if (fpga_upgrade) 1321 flash_upgrade(card, 0); 1322 1323 if (firmware_upgrade) 1324 flash_upgrade(card, 1); 1325 1326 if (db_fpga_upgrade) 1327 flash_upgrade(card, 2); 1328 1329 if (db_firmware_upgrade) 1330 flash_upgrade(card, 3); 1331 1332 err = atm_init(card, &dev->dev); 1333 if (err) 1334 goto out_free_irq; 1335 1336 if (card->fpga_version >= DMA_SUPPORTED && 1337 sysfs_create_group(&card->dev->dev.kobj, &gpio_attr_group)) 1338 dev_err(&card->dev->dev, "Could not register parameter group for GPIOs\n"); 1339 1340 return 0; 1341 1342 out_free_irq: 1343 iowrite32(0, card->config_regs + IRQ_EN_ADDR); 1344 free_irq(dev->irq, card); 1345 tasklet_kill(&card->tlet); 1346 1347 out_unmap_both: 1348 kfree(card->dma_bounce); 1349 pci_iounmap(dev, card->buffers); 1350 out_unmap_config: 1351 pci_iounmap(dev, card->config_regs); 1352 out_release_regions: 1353 pci_release_regions(dev); 1354 out: 1355 kfree(card); 1356 return err; 1357 } 1358 1359 static int atm_init(struct solos_card *card, struct device *parent) 1360 { 1361 int i; 1362 1363 for (i = 0; i < card->nr_ports; i++) { 1364 struct sk_buff *skb; 1365 struct pkt_hdr *header; 1366 1367 skb_queue_head_init(&card->tx_queue[i]); 1368 skb_queue_head_init(&card->cli_queue[i]); 1369 1370 card->atmdev[i] = atm_dev_register("solos-pci", parent, &fpga_ops, -1, NULL); 1371 if (!card->atmdev[i]) { 1372 dev_err(&card->dev->dev, "Could not register ATM device %d\n", i); 1373 atm_remove(card); 1374 return -ENODEV; 1375 } 1376 if (device_create_file(&card->atmdev[i]->class_dev, &dev_attr_console)) 1377 dev_err(&card->dev->dev, "Could not register console for ATM device %d\n", i); 1378 if (sysfs_create_group(&card->atmdev[i]->class_dev.kobj, &solos_attr_group)) 1379 dev_err(&card->dev->dev, "Could not register parameter group for ATM device %d\n", i); 1380 1381 dev_info(&card->dev->dev, "Registered ATM device %d\n", card->atmdev[i]->number); 1382 1383 card->atmdev[i]->ci_range.vpi_bits = 8; 1384 card->atmdev[i]->ci_range.vci_bits = 16; 1385 card->atmdev[i]->dev_data = card; 1386 card->atmdev[i]->phy_data = (void *)(unsigned long)i; 1387 atm_dev_signal_change(card->atmdev[i], ATM_PHY_SIG_FOUND); 1388 1389 skb = alloc_skb(sizeof(*header), GFP_KERNEL); 1390 if (!skb) { 1391 dev_warn(&card->dev->dev, "Failed to allocate sk_buff in atm_init()\n"); 1392 continue; 1393 } 1394 1395 header = (void *)skb_put(skb, sizeof(*header)); 1396 1397 header->size = cpu_to_le16(0); 1398 header->vpi = cpu_to_le16(0); 1399 header->vci = cpu_to_le16(0); 1400 header->type = cpu_to_le16(PKT_STATUS); 1401 1402 fpga_queue(card, i, skb, NULL); 1403 } 1404 return 0; 1405 } 1406 1407 static void atm_remove(struct solos_card *card) 1408 { 1409 int i; 1410 1411 for (i = 0; i < card->nr_ports; i++) { 1412 if (card->atmdev[i]) { 1413 struct sk_buff *skb; 1414 1415 dev_info(&card->dev->dev, "Unregistering ATM device %d\n", card->atmdev[i]->number); 1416 1417 sysfs_remove_group(&card->atmdev[i]->class_dev.kobj, &solos_attr_group); 1418 atm_dev_deregister(card->atmdev[i]); 1419 1420 skb = card->rx_skb[i]; 1421 if (skb) { 1422 dma_unmap_single(&card->dev->dev, SKB_CB(skb)->dma_addr, 1423 RX_DMA_SIZE, DMA_FROM_DEVICE); 1424 dev_kfree_skb(skb); 1425 } 1426 skb = card->tx_skb[i]; 1427 if (skb) { 1428 dma_unmap_single(&card->dev->dev, SKB_CB(skb)->dma_addr, 1429 skb->len, DMA_TO_DEVICE); 1430 dev_kfree_skb(skb); 1431 } 1432 while ((skb = skb_dequeue(&card->tx_queue[i]))) 1433 dev_kfree_skb(skb); 1434 1435 } 1436 } 1437 } 1438 1439 static void fpga_remove(struct pci_dev *dev) 1440 { 1441 struct solos_card *card = pci_get_drvdata(dev); 1442 1443 /* Disable IRQs */ 1444 iowrite32(0, card->config_regs + IRQ_EN_ADDR); 1445 1446 /* Reset FPGA */ 1447 iowrite32(1, card->config_regs + FPGA_MODE); 1448 (void)ioread32(card->config_regs + FPGA_MODE); 1449 1450 if (card->fpga_version >= DMA_SUPPORTED) 1451 sysfs_remove_group(&card->dev->dev.kobj, &gpio_attr_group); 1452 1453 atm_remove(card); 1454 1455 free_irq(dev->irq, card); 1456 tasklet_kill(&card->tlet); 1457 1458 kfree(card->dma_bounce); 1459 1460 /* Release device from reset */ 1461 iowrite32(0, card->config_regs + FPGA_MODE); 1462 (void)ioread32(card->config_regs + FPGA_MODE); 1463 1464 pci_iounmap(dev, card->buffers); 1465 pci_iounmap(dev, card->config_regs); 1466 1467 pci_release_regions(dev); 1468 pci_disable_device(dev); 1469 1470 kfree(card); 1471 } 1472 1473 static struct pci_device_id fpga_pci_tbl[] = { 1474 { 0x10ee, 0x0300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, 1475 { 0, } 1476 }; 1477 1478 MODULE_DEVICE_TABLE(pci,fpga_pci_tbl); 1479 1480 static struct pci_driver fpga_driver = { 1481 .name = "solos", 1482 .id_table = fpga_pci_tbl, 1483 .probe = fpga_probe, 1484 .remove = fpga_remove, 1485 }; 1486 1487 1488 static int __init solos_pci_init(void) 1489 { 1490 BUILD_BUG_ON(sizeof(struct solos_skb_cb) > sizeof(((struct sk_buff *)0)->cb)); 1491 1492 printk(KERN_INFO "Solos PCI Driver Version %s\n", VERSION); 1493 return pci_register_driver(&fpga_driver); 1494 } 1495 1496 static void __exit solos_pci_exit(void) 1497 { 1498 pci_unregister_driver(&fpga_driver); 1499 printk(KERN_INFO "Solos PCI Driver %s Unloaded\n", VERSION); 1500 } 1501 1502 module_init(solos_pci_init); 1503 module_exit(solos_pci_exit); 1504