1/***************************************************************************** 2 * 3 * Author: Xilinx, Inc. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License as published by the 7 * Free Software Foundation; either version 2 of the License, or (at your 8 * option) any later version. 9 * 10 * XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS" 11 * AS A COURTESY TO YOU, SOLELY FOR USE IN DEVELOPING PROGRAMS AND 12 * SOLUTIONS FOR XILINX DEVICES. BY PROVIDING THIS DESIGN, CODE, 13 * OR INFORMATION AS ONE POSSIBLE IMPLEMENTATION OF THIS FEATURE, 14 * APPLICATION OR STANDARD, XILINX IS MAKING NO REPRESENTATION 15 * THAT THIS IMPLEMENTATION IS FREE FROM ANY CLAIMS OF INFRINGEMENT, 16 * AND YOU ARE RESPONSIBLE FOR OBTAINING ANY RIGHTS YOU MAY REQUIRE 17 * FOR YOUR IMPLEMENTATION. XILINX EXPRESSLY DISCLAIMS ANY 18 * WARRANTY WHATSOEVER WITH RESPECT TO THE ADEQUACY OF THE 19 * IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OR 20 * REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE FROM CLAIMS OF 21 * INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 22 * FOR A PARTICULAR PURPOSE. 23 * 24 * (c) Copyright 2002 Xilinx Inc., Systems Engineering Group 25 * (c) Copyright 2004 Xilinx Inc., Systems Engineering Group 26 * (c) Copyright 2007-2008 Xilinx Inc. 27 * All rights reserved. 28 * 29 * You should have received a copy of the GNU General Public License along 30 * with this program; if not, write to the Free Software Foundation, Inc., 31 * 675 Mass Ave, Cambridge, MA 02139, USA. 32 * 33 *****************************************************************************/ 34 35/* 36 * This is the code behind /dev/icap* -- it allows a user-space 37 * application to use the Xilinx ICAP subsystem. 38 * 39 * The following operations are possible: 40 * 41 * open open the port and initialize for access. 42 * release release port 43 * write Write a bitstream to the configuration processor. 44 * read Read a data stream from the configuration processor. 45 * 46 * After being opened, the port is initialized and accessed to avoid a 47 * corrupted first read which may occur with some hardware. The port 48 * is left in a desynched state, requiring that a synch sequence be 49 * transmitted before any valid configuration data. A user will have 50 * exclusive access to the device while it remains open, and the state 51 * of the ICAP cannot be guaranteed after the device is closed. Note 52 * that a complete reset of the core and the state of the ICAP cannot 53 * be performed on many versions of the cores, hence users of this 54 * device should avoid making inconsistent accesses to the device. In 55 * particular, accessing the read interface, without first generating 56 * a write containing a readback packet can leave the ICAP in an 57 * inaccessible state. 58 * 59 * Note that in order to use the read interface, it is first necessary 60 * to write a request packet to the write interface. i.e., it is not 61 * possible to simply readback the bitstream (or any configuration 62 * bits) from a device without specifically requesting them first. 63 * The code to craft such packets is intended to be part of the 64 * user-space application code that uses this device. The simplest 65 * way to use this interface is simply: 66 * 67 * cp foo.bit /dev/icap0 68 * 69 * Note that unless foo.bit is an appropriately constructed partial 70 * bitstream, this has a high likelihood of overwriting the design 71 * currently programmed in the FPGA. 72 */ 73 74#include <linux/module.h> 75#include <linux/kernel.h> 76#include <linux/types.h> 77#include <linux/ioport.h> 78#include <linux/interrupt.h> 79#include <linux/fcntl.h> 80#include <linux/init.h> 81#include <linux/poll.h> 82#include <linux/proc_fs.h> 83#include <linux/mutex.h> 84#include <linux/sysctl.h> 85#include <linux/fs.h> 86#include <linux/cdev.h> 87#include <linux/platform_device.h> 88#include <linux/slab.h> 89 90#include <asm/io.h> 91#include <asm/uaccess.h> 92 93#ifdef CONFIG_OF 94/* For open firmware. */ 95#include <linux/of_address.h> 96#include <linux/of_device.h> 97#include <linux/of_platform.h> 98#endif 99 100#include "xilinx_hwicap.h" 101#include "buffer_icap.h" 102#include "fifo_icap.h" 103 104#define DRIVER_NAME "icap" 105 106#define HWICAP_REGS (0x10000) 107 108#define XHWICAP_MAJOR 259 109#define XHWICAP_MINOR 0 110#define HWICAP_DEVICES 1 111 112/* An array, which is set to true when the device is registered. */ 113static DEFINE_MUTEX(hwicap_mutex); 114static bool probed_devices[HWICAP_DEVICES]; 115static struct mutex icap_sem; 116 117static struct class *icap_class; 118 119#define UNIMPLEMENTED 0xFFFF 120 121static const struct config_registers v2_config_registers = { 122 .CRC = 0, 123 .FAR = 1, 124 .FDRI = 2, 125 .FDRO = 3, 126 .CMD = 4, 127 .CTL = 5, 128 .MASK = 6, 129 .STAT = 7, 130 .LOUT = 8, 131 .COR = 9, 132 .MFWR = 10, 133 .FLR = 11, 134 .KEY = 12, 135 .CBC = 13, 136 .IDCODE = 14, 137 .AXSS = UNIMPLEMENTED, 138 .C0R_1 = UNIMPLEMENTED, 139 .CSOB = UNIMPLEMENTED, 140 .WBSTAR = UNIMPLEMENTED, 141 .TIMER = UNIMPLEMENTED, 142 .BOOTSTS = UNIMPLEMENTED, 143 .CTL_1 = UNIMPLEMENTED, 144}; 145 146static const struct config_registers v4_config_registers = { 147 .CRC = 0, 148 .FAR = 1, 149 .FDRI = 2, 150 .FDRO = 3, 151 .CMD = 4, 152 .CTL = 5, 153 .MASK = 6, 154 .STAT = 7, 155 .LOUT = 8, 156 .COR = 9, 157 .MFWR = 10, 158 .FLR = UNIMPLEMENTED, 159 .KEY = UNIMPLEMENTED, 160 .CBC = 11, 161 .IDCODE = 12, 162 .AXSS = 13, 163 .C0R_1 = UNIMPLEMENTED, 164 .CSOB = UNIMPLEMENTED, 165 .WBSTAR = UNIMPLEMENTED, 166 .TIMER = UNIMPLEMENTED, 167 .BOOTSTS = UNIMPLEMENTED, 168 .CTL_1 = UNIMPLEMENTED, 169}; 170static const struct config_registers v5_config_registers = { 171 .CRC = 0, 172 .FAR = 1, 173 .FDRI = 2, 174 .FDRO = 3, 175 .CMD = 4, 176 .CTL = 5, 177 .MASK = 6, 178 .STAT = 7, 179 .LOUT = 8, 180 .COR = 9, 181 .MFWR = 10, 182 .FLR = UNIMPLEMENTED, 183 .KEY = UNIMPLEMENTED, 184 .CBC = 11, 185 .IDCODE = 12, 186 .AXSS = 13, 187 .C0R_1 = 14, 188 .CSOB = 15, 189 .WBSTAR = 16, 190 .TIMER = 17, 191 .BOOTSTS = 18, 192 .CTL_1 = 19, 193}; 194 195/** 196 * hwicap_command_desync - Send a DESYNC command to the ICAP port. 197 * @drvdata: a pointer to the drvdata. 198 * 199 * This command desynchronizes the ICAP After this command, a 200 * bitstream containing a NULL packet, followed by a SYNCH packet is 201 * required before the ICAP will recognize commands. 202 */ 203static int hwicap_command_desync(struct hwicap_drvdata *drvdata) 204{ 205 u32 buffer[4]; 206 u32 index = 0; 207 208 /* 209 * Create the data to be written to the ICAP. 210 */ 211 buffer[index++] = hwicap_type_1_write(drvdata->config_regs->CMD) | 1; 212 buffer[index++] = XHI_CMD_DESYNCH; 213 buffer[index++] = XHI_NOOP_PACKET; 214 buffer[index++] = XHI_NOOP_PACKET; 215 216 /* 217 * Write the data to the FIFO and intiate the transfer of data present 218 * in the FIFO to the ICAP device. 219 */ 220 return drvdata->config->set_configuration(drvdata, 221 &buffer[0], index); 222} 223 224/** 225 * hwicap_get_configuration_register - Query a configuration register. 226 * @drvdata: a pointer to the drvdata. 227 * @reg: a constant which represents the configuration 228 * register value to be returned. 229 * Examples: XHI_IDCODE, XHI_FLR. 230 * @reg_data: returns the value of the register. 231 * 232 * Sends a query packet to the ICAP and then receives the response. 233 * The icap is left in Synched state. 234 */ 235static int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata, 236 u32 reg, u32 *reg_data) 237{ 238 int status; 239 u32 buffer[6]; 240 u32 index = 0; 241 242 /* 243 * Create the data to be written to the ICAP. 244 */ 245 buffer[index++] = XHI_DUMMY_PACKET; 246 buffer[index++] = XHI_NOOP_PACKET; 247 buffer[index++] = XHI_SYNC_PACKET; 248 buffer[index++] = XHI_NOOP_PACKET; 249 buffer[index++] = XHI_NOOP_PACKET; 250 251 /* 252 * Write the data to the FIFO and initiate the transfer of data present 253 * in the FIFO to the ICAP device. 254 */ 255 status = drvdata->config->set_configuration(drvdata, 256 &buffer[0], index); 257 if (status) 258 return status; 259 260 /* If the syncword was not found, then we need to start over. */ 261 status = drvdata->config->get_status(drvdata); 262 if ((status & XHI_SR_DALIGN_MASK) != XHI_SR_DALIGN_MASK) 263 return -EIO; 264 265 index = 0; 266 buffer[index++] = hwicap_type_1_read(reg) | 1; 267 buffer[index++] = XHI_NOOP_PACKET; 268 buffer[index++] = XHI_NOOP_PACKET; 269 270 /* 271 * Write the data to the FIFO and intiate the transfer of data present 272 * in the FIFO to the ICAP device. 273 */ 274 status = drvdata->config->set_configuration(drvdata, 275 &buffer[0], index); 276 if (status) 277 return status; 278 279 /* 280 * Read the configuration register 281 */ 282 status = drvdata->config->get_configuration(drvdata, reg_data, 1); 283 if (status) 284 return status; 285 286 return 0; 287} 288 289static int hwicap_initialize_hwicap(struct hwicap_drvdata *drvdata) 290{ 291 int status; 292 u32 idcode; 293 294 dev_dbg(drvdata->dev, "initializing\n"); 295 296 /* Abort any current transaction, to make sure we have the 297 * ICAP in a good state. */ 298 dev_dbg(drvdata->dev, "Reset...\n"); 299 drvdata->config->reset(drvdata); 300 301 dev_dbg(drvdata->dev, "Desync...\n"); 302 status = hwicap_command_desync(drvdata); 303 if (status) 304 return status; 305 306 /* Attempt to read the IDCODE from ICAP. This 307 * may not be returned correctly, due to the design of the 308 * hardware. 309 */ 310 dev_dbg(drvdata->dev, "Reading IDCODE...\n"); 311 status = hwicap_get_configuration_register( 312 drvdata, drvdata->config_regs->IDCODE, &idcode); 313 dev_dbg(drvdata->dev, "IDCODE = %x\n", idcode); 314 if (status) 315 return status; 316 317 dev_dbg(drvdata->dev, "Desync...\n"); 318 status = hwicap_command_desync(drvdata); 319 if (status) 320 return status; 321 322 return 0; 323} 324 325static ssize_t 326hwicap_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) 327{ 328 struct hwicap_drvdata *drvdata = file->private_data; 329 ssize_t bytes_to_read = 0; 330 u32 *kbuf; 331 u32 words; 332 u32 bytes_remaining; 333 int status; 334 335 status = mutex_lock_interruptible(&drvdata->sem); 336 if (status) 337 return status; 338 339 if (drvdata->read_buffer_in_use) { 340 /* If there are leftover bytes in the buffer, just */ 341 /* return them and don't try to read more from the */ 342 /* ICAP device. */ 343 bytes_to_read = 344 (count < drvdata->read_buffer_in_use) ? count : 345 drvdata->read_buffer_in_use; 346 347 /* Return the data currently in the read buffer. */ 348 if (copy_to_user(buf, drvdata->read_buffer, bytes_to_read)) { 349 status = -EFAULT; 350 goto error; 351 } 352 drvdata->read_buffer_in_use -= bytes_to_read; 353 memmove(drvdata->read_buffer, 354 drvdata->read_buffer + bytes_to_read, 355 4 - bytes_to_read); 356 } else { 357 /* Get new data from the ICAP, and return was was requested. */ 358 kbuf = (u32 *) get_zeroed_page(GFP_KERNEL); 359 if (!kbuf) { 360 status = -ENOMEM; 361 goto error; 362 } 363 364 /* The ICAP device is only able to read complete */ 365 /* words. If a number of bytes that do not correspond */ 366 /* to complete words is requested, then we read enough */ 367 /* words to get the required number of bytes, and then */ 368 /* save the remaining bytes for the next read. */ 369 370 /* Determine the number of words to read, rounding up */ 371 /* if necessary. */ 372 words = ((count + 3) >> 2); 373 bytes_to_read = words << 2; 374 375 if (bytes_to_read > PAGE_SIZE) 376 bytes_to_read = PAGE_SIZE; 377 378 /* Ensure we only read a complete number of words. */ 379 bytes_remaining = bytes_to_read & 3; 380 bytes_to_read &= ~3; 381 words = bytes_to_read >> 2; 382 383 status = drvdata->config->get_configuration(drvdata, 384 kbuf, words); 385 386 /* If we didn't read correctly, then bail out. */ 387 if (status) { 388 free_page((unsigned long)kbuf); 389 goto error; 390 } 391 392 /* If we fail to return the data to the user, then bail out. */ 393 if (copy_to_user(buf, kbuf, bytes_to_read)) { 394 free_page((unsigned long)kbuf); 395 status = -EFAULT; 396 goto error; 397 } 398 memcpy(drvdata->read_buffer, 399 kbuf, 400 bytes_remaining); 401 drvdata->read_buffer_in_use = bytes_remaining; 402 free_page((unsigned long)kbuf); 403 } 404 status = bytes_to_read; 405 error: 406 mutex_unlock(&drvdata->sem); 407 return status; 408} 409 410static ssize_t 411hwicap_write(struct file *file, const char __user *buf, 412 size_t count, loff_t *ppos) 413{ 414 struct hwicap_drvdata *drvdata = file->private_data; 415 ssize_t written = 0; 416 ssize_t left = count; 417 u32 *kbuf; 418 ssize_t len; 419 ssize_t status; 420 421 status = mutex_lock_interruptible(&drvdata->sem); 422 if (status) 423 return status; 424 425 left += drvdata->write_buffer_in_use; 426 427 /* Only write multiples of 4 bytes. */ 428 if (left < 4) { 429 status = 0; 430 goto error; 431 } 432 433 kbuf = (u32 *) __get_free_page(GFP_KERNEL); 434 if (!kbuf) { 435 status = -ENOMEM; 436 goto error; 437 } 438 439 while (left > 3) { 440 /* only write multiples of 4 bytes, so there might */ 441 /* be as many as 3 bytes left (at the end). */ 442 len = left; 443 444 if (len > PAGE_SIZE) 445 len = PAGE_SIZE; 446 len &= ~3; 447 448 if (drvdata->write_buffer_in_use) { 449 memcpy(kbuf, drvdata->write_buffer, 450 drvdata->write_buffer_in_use); 451 if (copy_from_user( 452 (((char *)kbuf) + drvdata->write_buffer_in_use), 453 buf + written, 454 len - (drvdata->write_buffer_in_use))) { 455 free_page((unsigned long)kbuf); 456 status = -EFAULT; 457 goto error; 458 } 459 } else { 460 if (copy_from_user(kbuf, buf + written, len)) { 461 free_page((unsigned long)kbuf); 462 status = -EFAULT; 463 goto error; 464 } 465 } 466 467 status = drvdata->config->set_configuration(drvdata, 468 kbuf, len >> 2); 469 470 if (status) { 471 free_page((unsigned long)kbuf); 472 status = -EFAULT; 473 goto error; 474 } 475 if (drvdata->write_buffer_in_use) { 476 len -= drvdata->write_buffer_in_use; 477 left -= drvdata->write_buffer_in_use; 478 drvdata->write_buffer_in_use = 0; 479 } 480 written += len; 481 left -= len; 482 } 483 if ((left > 0) && (left < 4)) { 484 if (!copy_from_user(drvdata->write_buffer, 485 buf + written, left)) { 486 drvdata->write_buffer_in_use = left; 487 written += left; 488 left = 0; 489 } 490 } 491 492 free_page((unsigned long)kbuf); 493 status = written; 494 error: 495 mutex_unlock(&drvdata->sem); 496 return status; 497} 498 499static int hwicap_open(struct inode *inode, struct file *file) 500{ 501 struct hwicap_drvdata *drvdata; 502 int status; 503 504 mutex_lock(&hwicap_mutex); 505 drvdata = container_of(inode->i_cdev, struct hwicap_drvdata, cdev); 506 507 status = mutex_lock_interruptible(&drvdata->sem); 508 if (status) 509 goto out; 510 511 if (drvdata->is_open) { 512 status = -EBUSY; 513 goto error; 514 } 515 516 status = hwicap_initialize_hwicap(drvdata); 517 if (status) { 518 dev_err(drvdata->dev, "Failed to open file"); 519 goto error; 520 } 521 522 file->private_data = drvdata; 523 drvdata->write_buffer_in_use = 0; 524 drvdata->read_buffer_in_use = 0; 525 drvdata->is_open = 1; 526 527 error: 528 mutex_unlock(&drvdata->sem); 529 out: 530 mutex_unlock(&hwicap_mutex); 531 return status; 532} 533 534static int hwicap_release(struct inode *inode, struct file *file) 535{ 536 struct hwicap_drvdata *drvdata = file->private_data; 537 int i; 538 int status = 0; 539 540 mutex_lock(&drvdata->sem); 541 542 if (drvdata->write_buffer_in_use) { 543 /* Flush write buffer. */ 544 for (i = drvdata->write_buffer_in_use; i < 4; i++) 545 drvdata->write_buffer[i] = 0; 546 547 status = drvdata->config->set_configuration(drvdata, 548 (u32 *) drvdata->write_buffer, 1); 549 if (status) 550 goto error; 551 } 552 553 status = hwicap_command_desync(drvdata); 554 if (status) 555 goto error; 556 557 error: 558 drvdata->is_open = 0; 559 mutex_unlock(&drvdata->sem); 560 return status; 561} 562 563static const struct file_operations hwicap_fops = { 564 .owner = THIS_MODULE, 565 .write = hwicap_write, 566 .read = hwicap_read, 567 .open = hwicap_open, 568 .release = hwicap_release, 569 .llseek = noop_llseek, 570}; 571 572static int __devinit hwicap_setup(struct device *dev, int id, 573 const struct resource *regs_res, 574 const struct hwicap_driver_config *config, 575 const struct config_registers *config_regs) 576{ 577 dev_t devt; 578 struct hwicap_drvdata *drvdata = NULL; 579 int retval = 0; 580 581 dev_info(dev, "Xilinx icap port driver\n"); 582 583 mutex_lock(&icap_sem); 584 585 if (id < 0) { 586 for (id = 0; id < HWICAP_DEVICES; id++) 587 if (!probed_devices[id]) 588 break; 589 } 590 if (id < 0 || id >= HWICAP_DEVICES) { 591 mutex_unlock(&icap_sem); 592 dev_err(dev, "%s%i too large\n", DRIVER_NAME, id); 593 return -EINVAL; 594 } 595 if (probed_devices[id]) { 596 mutex_unlock(&icap_sem); 597 dev_err(dev, "cannot assign to %s%i; it is already in use\n", 598 DRIVER_NAME, id); 599 return -EBUSY; 600 } 601 602 probed_devices[id] = 1; 603 mutex_unlock(&icap_sem); 604 605 devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR + id); 606 607 drvdata = kzalloc(sizeof(struct hwicap_drvdata), GFP_KERNEL); 608 if (!drvdata) { 609 dev_err(dev, "Couldn't allocate device private record\n"); 610 retval = -ENOMEM; 611 goto failed0; 612 } 613 dev_set_drvdata(dev, (void *)drvdata); 614 615 if (!regs_res) { 616 dev_err(dev, "Couldn't get registers resource\n"); 617 retval = -EFAULT; 618 goto failed1; 619 } 620 621 drvdata->mem_start = regs_res->start; 622 drvdata->mem_end = regs_res->end; 623 drvdata->mem_size = resource_size(regs_res); 624 625 if (!request_mem_region(drvdata->mem_start, 626 drvdata->mem_size, DRIVER_NAME)) { 627 dev_err(dev, "Couldn't lock memory region at %Lx\n", 628 (unsigned long long) regs_res->start); 629 retval = -EBUSY; 630 goto failed1; 631 } 632 633 drvdata->devt = devt; 634 drvdata->dev = dev; 635 drvdata->base_address = ioremap(drvdata->mem_start, drvdata->mem_size); 636 if (!drvdata->base_address) { 637 dev_err(dev, "ioremap() failed\n"); 638 goto failed2; 639 } 640 641 drvdata->config = config; 642 drvdata->config_regs = config_regs; 643 644 mutex_init(&drvdata->sem); 645 drvdata->is_open = 0; 646 647 dev_info(dev, "ioremap %llx to %p with size %llx\n", 648 (unsigned long long) drvdata->mem_start, 649 drvdata->base_address, 650 (unsigned long long) drvdata->mem_size); 651 652 cdev_init(&drvdata->cdev, &hwicap_fops); 653 drvdata->cdev.owner = THIS_MODULE; 654 retval = cdev_add(&drvdata->cdev, devt, 1); 655 if (retval) { 656 dev_err(dev, "cdev_add() failed\n"); 657 goto failed3; 658 } 659 660 device_create(icap_class, dev, devt, NULL, "%s%d", DRIVER_NAME, id); 661 return 0; /* success */ 662 663 failed3: 664 iounmap(drvdata->base_address); 665 666 failed2: 667 release_mem_region(regs_res->start, drvdata->mem_size); 668 669 failed1: 670 kfree(drvdata); 671 672 failed0: 673 mutex_lock(&icap_sem); 674 probed_devices[id] = 0; 675 mutex_unlock(&icap_sem); 676 677 return retval; 678} 679 680static struct hwicap_driver_config buffer_icap_config = { 681 .get_configuration = buffer_icap_get_configuration, 682 .set_configuration = buffer_icap_set_configuration, 683 .get_status = buffer_icap_get_status, 684 .reset = buffer_icap_reset, 685}; 686 687static struct hwicap_driver_config fifo_icap_config = { 688 .get_configuration = fifo_icap_get_configuration, 689 .set_configuration = fifo_icap_set_configuration, 690 .get_status = fifo_icap_get_status, 691 .reset = fifo_icap_reset, 692}; 693 694static int __devexit hwicap_remove(struct device *dev) 695{ 696 struct hwicap_drvdata *drvdata; 697 698 drvdata = (struct hwicap_drvdata *)dev_get_drvdata(dev); 699 700 if (!drvdata) 701 return 0; 702 703 device_destroy(icap_class, drvdata->devt); 704 cdev_del(&drvdata->cdev); 705 iounmap(drvdata->base_address); 706 release_mem_region(drvdata->mem_start, drvdata->mem_size); 707 kfree(drvdata); 708 dev_set_drvdata(dev, NULL); 709 710 mutex_lock(&icap_sem); 711 probed_devices[MINOR(dev->devt)-XHWICAP_MINOR] = 0; 712 mutex_unlock(&icap_sem); 713 return 0; /* success */ 714} 715 716#ifdef CONFIG_OF 717static int __devinit hwicap_of_probe(struct platform_device *op, 718 const struct hwicap_driver_config *config) 719{ 720 struct resource res; 721 const unsigned int *id; 722 const char *family; 723 int rc; 724 const struct config_registers *regs; 725 726 727 rc = of_address_to_resource(op->dev.of_node, 0, &res); 728 if (rc) { 729 dev_err(&op->dev, "invalid address\n"); 730 return rc; 731 } 732 733 id = of_get_property(op->dev.of_node, "port-number", NULL); 734 735 /* It's most likely that we're using V4, if the family is not 736 specified */ 737 regs = &v4_config_registers; 738 family = of_get_property(op->dev.of_node, "xlnx,family", NULL); 739 740 if (family) { 741 if (!strcmp(family, "virtex2p")) { 742 regs = &v2_config_registers; 743 } else if (!strcmp(family, "virtex4")) { 744 regs = &v4_config_registers; 745 } else if (!strcmp(family, "virtex5")) { 746 regs = &v5_config_registers; 747 } 748 } 749 return hwicap_setup(&op->dev, id ? *id : -1, &res, config, 750 regs); 751} 752#else 753static inline int hwicap_of_probe(struct platform_device *op, 754 const struct hwicap_driver_config *config) 755{ 756 return -EINVAL; 757} 758#endif /* CONFIG_OF */ 759 760static const struct of_device_id __devinitconst hwicap_of_match[]; 761static int __devinit hwicap_drv_probe(struct platform_device *pdev) 762{ 763 const struct of_device_id *match; 764 struct resource *res; 765 const struct config_registers *regs; 766 const char *family; 767 768 match = of_match_device(hwicap_of_match, &pdev->dev); 769 if (match) 770 return hwicap_of_probe(pdev, match->data); 771 772 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 773 if (!res) 774 return -ENODEV; 775 776 /* It's most likely that we're using V4, if the family is not 777 specified */ 778 regs = &v4_config_registers; 779 family = pdev->dev.platform_data; 780 781 if (family) { 782 if (!strcmp(family, "virtex2p")) { 783 regs = &v2_config_registers; 784 } else if (!strcmp(family, "virtex4")) { 785 regs = &v4_config_registers; 786 } else if (!strcmp(family, "virtex5")) { 787 regs = &v5_config_registers; 788 } 789 } 790 791 return hwicap_setup(&pdev->dev, pdev->id, res, 792 &buffer_icap_config, regs); 793} 794 795static int __devexit hwicap_drv_remove(struct platform_device *pdev) 796{ 797 return hwicap_remove(&pdev->dev); 798} 799 800#ifdef CONFIG_OF 801/* Match table for device tree binding */ 802static const struct of_device_id __devinitconst hwicap_of_match[] = { 803 { .compatible = "xlnx,opb-hwicap-1.00.b", .data = &buffer_icap_config}, 804 { .compatible = "xlnx,xps-hwicap-1.00.a", .data = &fifo_icap_config}, 805 {}, 806}; 807MODULE_DEVICE_TABLE(of, hwicap_of_match); 808#else 809#define hwicap_of_match NULL 810#endif 811 812static struct platform_driver hwicap_platform_driver = { 813 .probe = hwicap_drv_probe, 814 .remove = hwicap_drv_remove, 815 .driver = { 816 .owner = THIS_MODULE, 817 .name = DRIVER_NAME, 818 .of_match_table = hwicap_of_match, 819 }, 820}; 821 822static int __init hwicap_module_init(void) 823{ 824 dev_t devt; 825 int retval; 826 827 icap_class = class_create(THIS_MODULE, "xilinx_config"); 828 mutex_init(&icap_sem); 829 830 devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR); 831 retval = register_chrdev_region(devt, 832 HWICAP_DEVICES, 833 DRIVER_NAME); 834 if (retval < 0) 835 return retval; 836 837 retval = platform_driver_register(&hwicap_platform_driver); 838 if (retval) 839 goto failed; 840 841 return retval; 842 843 failed: 844 unregister_chrdev_region(devt, HWICAP_DEVICES); 845 846 return retval; 847} 848 849static void __exit hwicap_module_cleanup(void) 850{ 851 dev_t devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR); 852 853 class_destroy(icap_class); 854 855 platform_driver_unregister(&hwicap_platform_driver); 856 857 unregister_chrdev_region(devt, HWICAP_DEVICES); 858} 859 860module_init(hwicap_module_init); 861module_exit(hwicap_module_cleanup); 862 863MODULE_AUTHOR("Xilinx, Inc; Xilinx Research Labs Group"); 864MODULE_DESCRIPTION("Xilinx ICAP Port Driver"); 865MODULE_LICENSE("GPL"); 866