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. */ 113 static DEFINE_MUTEX(hwicap_mutex); 114 static bool probed_devices[HWICAP_DEVICES]; 115 static struct mutex icap_sem; 116 117 static struct class *icap_class; 118 119 #define UNIMPLEMENTED 0xFFFF 120 121 static 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 146 static 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 }; 170 171 static const struct config_registers v5_config_registers = { 172 .CRC = 0, 173 .FAR = 1, 174 .FDRI = 2, 175 .FDRO = 3, 176 .CMD = 4, 177 .CTL = 5, 178 .MASK = 6, 179 .STAT = 7, 180 .LOUT = 8, 181 .COR = 9, 182 .MFWR = 10, 183 .FLR = UNIMPLEMENTED, 184 .KEY = UNIMPLEMENTED, 185 .CBC = 11, 186 .IDCODE = 12, 187 .AXSS = 13, 188 .C0R_1 = 14, 189 .CSOB = 15, 190 .WBSTAR = 16, 191 .TIMER = 17, 192 .BOOTSTS = 18, 193 .CTL_1 = 19, 194 }; 195 196 static const struct config_registers v6_config_registers = { 197 .CRC = 0, 198 .FAR = 1, 199 .FDRI = 2, 200 .FDRO = 3, 201 .CMD = 4, 202 .CTL = 5, 203 .MASK = 6, 204 .STAT = 7, 205 .LOUT = 8, 206 .COR = 9, 207 .MFWR = 10, 208 .FLR = UNIMPLEMENTED, 209 .KEY = UNIMPLEMENTED, 210 .CBC = 11, 211 .IDCODE = 12, 212 .AXSS = 13, 213 .C0R_1 = 14, 214 .CSOB = 15, 215 .WBSTAR = 16, 216 .TIMER = 17, 217 .BOOTSTS = 22, 218 .CTL_1 = 24, 219 }; 220 221 /** 222 * hwicap_command_desync - Send a DESYNC command to the ICAP port. 223 * @drvdata: a pointer to the drvdata. 224 * 225 * This command desynchronizes the ICAP After this command, a 226 * bitstream containing a NULL packet, followed by a SYNCH packet is 227 * required before the ICAP will recognize commands. 228 */ 229 static int hwicap_command_desync(struct hwicap_drvdata *drvdata) 230 { 231 u32 buffer[4]; 232 u32 index = 0; 233 234 /* 235 * Create the data to be written to the ICAP. 236 */ 237 buffer[index++] = hwicap_type_1_write(drvdata->config_regs->CMD) | 1; 238 buffer[index++] = XHI_CMD_DESYNCH; 239 buffer[index++] = XHI_NOOP_PACKET; 240 buffer[index++] = XHI_NOOP_PACKET; 241 242 /* 243 * Write the data to the FIFO and intiate the transfer of data present 244 * in the FIFO to the ICAP device. 245 */ 246 return drvdata->config->set_configuration(drvdata, 247 &buffer[0], index); 248 } 249 250 /** 251 * hwicap_get_configuration_register - Query a configuration register. 252 * @drvdata: a pointer to the drvdata. 253 * @reg: a constant which represents the configuration 254 * register value to be returned. 255 * Examples: XHI_IDCODE, XHI_FLR. 256 * @reg_data: returns the value of the register. 257 * 258 * Sends a query packet to the ICAP and then receives the response. 259 * The icap is left in Synched state. 260 */ 261 static int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata, 262 u32 reg, u32 *reg_data) 263 { 264 int status; 265 u32 buffer[6]; 266 u32 index = 0; 267 268 /* 269 * Create the data to be written to the ICAP. 270 */ 271 buffer[index++] = XHI_DUMMY_PACKET; 272 buffer[index++] = XHI_NOOP_PACKET; 273 buffer[index++] = XHI_SYNC_PACKET; 274 buffer[index++] = XHI_NOOP_PACKET; 275 buffer[index++] = XHI_NOOP_PACKET; 276 277 /* 278 * Write the data to the FIFO and initiate the transfer of data present 279 * in the FIFO to the ICAP device. 280 */ 281 status = drvdata->config->set_configuration(drvdata, 282 &buffer[0], index); 283 if (status) 284 return status; 285 286 /* If the syncword was not found, then we need to start over. */ 287 status = drvdata->config->get_status(drvdata); 288 if ((status & XHI_SR_DALIGN_MASK) != XHI_SR_DALIGN_MASK) 289 return -EIO; 290 291 index = 0; 292 buffer[index++] = hwicap_type_1_read(reg) | 1; 293 buffer[index++] = XHI_NOOP_PACKET; 294 buffer[index++] = XHI_NOOP_PACKET; 295 296 /* 297 * Write the data to the FIFO and intiate the transfer of data present 298 * in the FIFO to the ICAP device. 299 */ 300 status = drvdata->config->set_configuration(drvdata, 301 &buffer[0], index); 302 if (status) 303 return status; 304 305 /* 306 * Read the configuration register 307 */ 308 status = drvdata->config->get_configuration(drvdata, reg_data, 1); 309 if (status) 310 return status; 311 312 return 0; 313 } 314 315 static int hwicap_initialize_hwicap(struct hwicap_drvdata *drvdata) 316 { 317 int status; 318 u32 idcode; 319 320 dev_dbg(drvdata->dev, "initializing\n"); 321 322 /* Abort any current transaction, to make sure we have the 323 * ICAP in a good state. */ 324 dev_dbg(drvdata->dev, "Reset...\n"); 325 drvdata->config->reset(drvdata); 326 327 dev_dbg(drvdata->dev, "Desync...\n"); 328 status = hwicap_command_desync(drvdata); 329 if (status) 330 return status; 331 332 /* Attempt to read the IDCODE from ICAP. This 333 * may not be returned correctly, due to the design of the 334 * hardware. 335 */ 336 dev_dbg(drvdata->dev, "Reading IDCODE...\n"); 337 status = hwicap_get_configuration_register( 338 drvdata, drvdata->config_regs->IDCODE, &idcode); 339 dev_dbg(drvdata->dev, "IDCODE = %x\n", idcode); 340 if (status) 341 return status; 342 343 dev_dbg(drvdata->dev, "Desync...\n"); 344 status = hwicap_command_desync(drvdata); 345 if (status) 346 return status; 347 348 return 0; 349 } 350 351 static ssize_t 352 hwicap_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) 353 { 354 struct hwicap_drvdata *drvdata = file->private_data; 355 ssize_t bytes_to_read = 0; 356 u32 *kbuf; 357 u32 words; 358 u32 bytes_remaining; 359 int status; 360 361 status = mutex_lock_interruptible(&drvdata->sem); 362 if (status) 363 return status; 364 365 if (drvdata->read_buffer_in_use) { 366 /* If there are leftover bytes in the buffer, just */ 367 /* return them and don't try to read more from the */ 368 /* ICAP device. */ 369 bytes_to_read = 370 (count < drvdata->read_buffer_in_use) ? count : 371 drvdata->read_buffer_in_use; 372 373 /* Return the data currently in the read buffer. */ 374 if (copy_to_user(buf, drvdata->read_buffer, bytes_to_read)) { 375 status = -EFAULT; 376 goto error; 377 } 378 drvdata->read_buffer_in_use -= bytes_to_read; 379 memmove(drvdata->read_buffer, 380 drvdata->read_buffer + bytes_to_read, 381 4 - bytes_to_read); 382 } else { 383 /* Get new data from the ICAP, and return was was requested. */ 384 kbuf = (u32 *) get_zeroed_page(GFP_KERNEL); 385 if (!kbuf) { 386 status = -ENOMEM; 387 goto error; 388 } 389 390 /* The ICAP device is only able to read complete */ 391 /* words. If a number of bytes that do not correspond */ 392 /* to complete words is requested, then we read enough */ 393 /* words to get the required number of bytes, and then */ 394 /* save the remaining bytes for the next read. */ 395 396 /* Determine the number of words to read, rounding up */ 397 /* if necessary. */ 398 words = ((count + 3) >> 2); 399 bytes_to_read = words << 2; 400 401 if (bytes_to_read > PAGE_SIZE) 402 bytes_to_read = PAGE_SIZE; 403 404 /* Ensure we only read a complete number of words. */ 405 bytes_remaining = bytes_to_read & 3; 406 bytes_to_read &= ~3; 407 words = bytes_to_read >> 2; 408 409 status = drvdata->config->get_configuration(drvdata, 410 kbuf, words); 411 412 /* If we didn't read correctly, then bail out. */ 413 if (status) { 414 free_page((unsigned long)kbuf); 415 goto error; 416 } 417 418 /* If we fail to return the data to the user, then bail out. */ 419 if (copy_to_user(buf, kbuf, bytes_to_read)) { 420 free_page((unsigned long)kbuf); 421 status = -EFAULT; 422 goto error; 423 } 424 memcpy(drvdata->read_buffer, 425 kbuf, 426 bytes_remaining); 427 drvdata->read_buffer_in_use = bytes_remaining; 428 free_page((unsigned long)kbuf); 429 } 430 status = bytes_to_read; 431 error: 432 mutex_unlock(&drvdata->sem); 433 return status; 434 } 435 436 static ssize_t 437 hwicap_write(struct file *file, const char __user *buf, 438 size_t count, loff_t *ppos) 439 { 440 struct hwicap_drvdata *drvdata = file->private_data; 441 ssize_t written = 0; 442 ssize_t left = count; 443 u32 *kbuf; 444 ssize_t len; 445 ssize_t status; 446 447 status = mutex_lock_interruptible(&drvdata->sem); 448 if (status) 449 return status; 450 451 left += drvdata->write_buffer_in_use; 452 453 /* Only write multiples of 4 bytes. */ 454 if (left < 4) { 455 status = 0; 456 goto error; 457 } 458 459 kbuf = (u32 *) __get_free_page(GFP_KERNEL); 460 if (!kbuf) { 461 status = -ENOMEM; 462 goto error; 463 } 464 465 while (left > 3) { 466 /* only write multiples of 4 bytes, so there might */ 467 /* be as many as 3 bytes left (at the end). */ 468 len = left; 469 470 if (len > PAGE_SIZE) 471 len = PAGE_SIZE; 472 len &= ~3; 473 474 if (drvdata->write_buffer_in_use) { 475 memcpy(kbuf, drvdata->write_buffer, 476 drvdata->write_buffer_in_use); 477 if (copy_from_user( 478 (((char *)kbuf) + drvdata->write_buffer_in_use), 479 buf + written, 480 len - (drvdata->write_buffer_in_use))) { 481 free_page((unsigned long)kbuf); 482 status = -EFAULT; 483 goto error; 484 } 485 } else { 486 if (copy_from_user(kbuf, buf + written, len)) { 487 free_page((unsigned long)kbuf); 488 status = -EFAULT; 489 goto error; 490 } 491 } 492 493 status = drvdata->config->set_configuration(drvdata, 494 kbuf, len >> 2); 495 496 if (status) { 497 free_page((unsigned long)kbuf); 498 status = -EFAULT; 499 goto error; 500 } 501 if (drvdata->write_buffer_in_use) { 502 len -= drvdata->write_buffer_in_use; 503 left -= drvdata->write_buffer_in_use; 504 drvdata->write_buffer_in_use = 0; 505 } 506 written += len; 507 left -= len; 508 } 509 if ((left > 0) && (left < 4)) { 510 if (!copy_from_user(drvdata->write_buffer, 511 buf + written, left)) { 512 drvdata->write_buffer_in_use = left; 513 written += left; 514 left = 0; 515 } 516 } 517 518 free_page((unsigned long)kbuf); 519 status = written; 520 error: 521 mutex_unlock(&drvdata->sem); 522 return status; 523 } 524 525 static int hwicap_open(struct inode *inode, struct file *file) 526 { 527 struct hwicap_drvdata *drvdata; 528 int status; 529 530 mutex_lock(&hwicap_mutex); 531 drvdata = container_of(inode->i_cdev, struct hwicap_drvdata, cdev); 532 533 status = mutex_lock_interruptible(&drvdata->sem); 534 if (status) 535 goto out; 536 537 if (drvdata->is_open) { 538 status = -EBUSY; 539 goto error; 540 } 541 542 status = hwicap_initialize_hwicap(drvdata); 543 if (status) { 544 dev_err(drvdata->dev, "Failed to open file"); 545 goto error; 546 } 547 548 file->private_data = drvdata; 549 drvdata->write_buffer_in_use = 0; 550 drvdata->read_buffer_in_use = 0; 551 drvdata->is_open = 1; 552 553 error: 554 mutex_unlock(&drvdata->sem); 555 out: 556 mutex_unlock(&hwicap_mutex); 557 return status; 558 } 559 560 static int hwicap_release(struct inode *inode, struct file *file) 561 { 562 struct hwicap_drvdata *drvdata = file->private_data; 563 int i; 564 int status = 0; 565 566 mutex_lock(&drvdata->sem); 567 568 if (drvdata->write_buffer_in_use) { 569 /* Flush write buffer. */ 570 for (i = drvdata->write_buffer_in_use; i < 4; i++) 571 drvdata->write_buffer[i] = 0; 572 573 status = drvdata->config->set_configuration(drvdata, 574 (u32 *) drvdata->write_buffer, 1); 575 if (status) 576 goto error; 577 } 578 579 status = hwicap_command_desync(drvdata); 580 if (status) 581 goto error; 582 583 error: 584 drvdata->is_open = 0; 585 mutex_unlock(&drvdata->sem); 586 return status; 587 } 588 589 static const struct file_operations hwicap_fops = { 590 .owner = THIS_MODULE, 591 .write = hwicap_write, 592 .read = hwicap_read, 593 .open = hwicap_open, 594 .release = hwicap_release, 595 .llseek = noop_llseek, 596 }; 597 598 static int hwicap_setup(struct device *dev, int id, 599 const struct resource *regs_res, 600 const struct hwicap_driver_config *config, 601 const struct config_registers *config_regs) 602 { 603 dev_t devt; 604 struct hwicap_drvdata *drvdata = NULL; 605 int retval = 0; 606 607 dev_info(dev, "Xilinx icap port driver\n"); 608 609 mutex_lock(&icap_sem); 610 611 if (id < 0) { 612 for (id = 0; id < HWICAP_DEVICES; id++) 613 if (!probed_devices[id]) 614 break; 615 } 616 if (id < 0 || id >= HWICAP_DEVICES) { 617 mutex_unlock(&icap_sem); 618 dev_err(dev, "%s%i too large\n", DRIVER_NAME, id); 619 return -EINVAL; 620 } 621 if (probed_devices[id]) { 622 mutex_unlock(&icap_sem); 623 dev_err(dev, "cannot assign to %s%i; it is already in use\n", 624 DRIVER_NAME, id); 625 return -EBUSY; 626 } 627 628 probed_devices[id] = 1; 629 mutex_unlock(&icap_sem); 630 631 devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR + id); 632 633 drvdata = kzalloc(sizeof(struct hwicap_drvdata), GFP_KERNEL); 634 if (!drvdata) { 635 dev_err(dev, "Couldn't allocate device private record\n"); 636 retval = -ENOMEM; 637 goto failed0; 638 } 639 dev_set_drvdata(dev, (void *)drvdata); 640 641 if (!regs_res) { 642 dev_err(dev, "Couldn't get registers resource\n"); 643 retval = -EFAULT; 644 goto failed1; 645 } 646 647 drvdata->mem_start = regs_res->start; 648 drvdata->mem_end = regs_res->end; 649 drvdata->mem_size = resource_size(regs_res); 650 651 if (!request_mem_region(drvdata->mem_start, 652 drvdata->mem_size, DRIVER_NAME)) { 653 dev_err(dev, "Couldn't lock memory region at %Lx\n", 654 (unsigned long long) regs_res->start); 655 retval = -EBUSY; 656 goto failed1; 657 } 658 659 drvdata->devt = devt; 660 drvdata->dev = dev; 661 drvdata->base_address = ioremap(drvdata->mem_start, drvdata->mem_size); 662 if (!drvdata->base_address) { 663 dev_err(dev, "ioremap() failed\n"); 664 retval = -ENOMEM; 665 goto failed2; 666 } 667 668 drvdata->config = config; 669 drvdata->config_regs = config_regs; 670 671 mutex_init(&drvdata->sem); 672 drvdata->is_open = 0; 673 674 dev_info(dev, "ioremap %llx to %p with size %llx\n", 675 (unsigned long long) drvdata->mem_start, 676 drvdata->base_address, 677 (unsigned long long) drvdata->mem_size); 678 679 cdev_init(&drvdata->cdev, &hwicap_fops); 680 drvdata->cdev.owner = THIS_MODULE; 681 retval = cdev_add(&drvdata->cdev, devt, 1); 682 if (retval) { 683 dev_err(dev, "cdev_add() failed\n"); 684 goto failed3; 685 } 686 687 device_create(icap_class, dev, devt, NULL, "%s%d", DRIVER_NAME, id); 688 return 0; /* success */ 689 690 failed3: 691 iounmap(drvdata->base_address); 692 693 failed2: 694 release_mem_region(regs_res->start, drvdata->mem_size); 695 696 failed1: 697 kfree(drvdata); 698 699 failed0: 700 mutex_lock(&icap_sem); 701 probed_devices[id] = 0; 702 mutex_unlock(&icap_sem); 703 704 return retval; 705 } 706 707 static struct hwicap_driver_config buffer_icap_config = { 708 .get_configuration = buffer_icap_get_configuration, 709 .set_configuration = buffer_icap_set_configuration, 710 .get_status = buffer_icap_get_status, 711 .reset = buffer_icap_reset, 712 }; 713 714 static struct hwicap_driver_config fifo_icap_config = { 715 .get_configuration = fifo_icap_get_configuration, 716 .set_configuration = fifo_icap_set_configuration, 717 .get_status = fifo_icap_get_status, 718 .reset = fifo_icap_reset, 719 }; 720 721 static int hwicap_remove(struct device *dev) 722 { 723 struct hwicap_drvdata *drvdata; 724 725 drvdata = dev_get_drvdata(dev); 726 727 if (!drvdata) 728 return 0; 729 730 device_destroy(icap_class, drvdata->devt); 731 cdev_del(&drvdata->cdev); 732 iounmap(drvdata->base_address); 733 release_mem_region(drvdata->mem_start, drvdata->mem_size); 734 kfree(drvdata); 735 736 mutex_lock(&icap_sem); 737 probed_devices[MINOR(dev->devt)-XHWICAP_MINOR] = 0; 738 mutex_unlock(&icap_sem); 739 return 0; /* success */ 740 } 741 742 #ifdef CONFIG_OF 743 static int hwicap_of_probe(struct platform_device *op, 744 const struct hwicap_driver_config *config) 745 { 746 struct resource res; 747 const unsigned int *id; 748 const char *family; 749 int rc; 750 const struct config_registers *regs; 751 752 753 rc = of_address_to_resource(op->dev.of_node, 0, &res); 754 if (rc) { 755 dev_err(&op->dev, "invalid address\n"); 756 return rc; 757 } 758 759 id = of_get_property(op->dev.of_node, "port-number", NULL); 760 761 /* It's most likely that we're using V4, if the family is not 762 specified */ 763 regs = &v4_config_registers; 764 family = of_get_property(op->dev.of_node, "xlnx,family", NULL); 765 766 if (family) { 767 if (!strcmp(family, "virtex2p")) { 768 regs = &v2_config_registers; 769 } else if (!strcmp(family, "virtex4")) { 770 regs = &v4_config_registers; 771 } else if (!strcmp(family, "virtex5")) { 772 regs = &v5_config_registers; 773 } else if (!strcmp(family, "virtex6")) { 774 regs = &v6_config_registers; 775 } 776 } 777 return hwicap_setup(&op->dev, id ? *id : -1, &res, config, 778 regs); 779 } 780 #else 781 static inline int hwicap_of_probe(struct platform_device *op, 782 const struct hwicap_driver_config *config) 783 { 784 return -EINVAL; 785 } 786 #endif /* CONFIG_OF */ 787 788 static const struct of_device_id hwicap_of_match[]; 789 static int hwicap_drv_probe(struct platform_device *pdev) 790 { 791 const struct of_device_id *match; 792 struct resource *res; 793 const struct config_registers *regs; 794 const char *family; 795 796 match = of_match_device(hwicap_of_match, &pdev->dev); 797 if (match) 798 return hwicap_of_probe(pdev, match->data); 799 800 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 801 if (!res) 802 return -ENODEV; 803 804 /* It's most likely that we're using V4, if the family is not 805 specified */ 806 regs = &v4_config_registers; 807 family = pdev->dev.platform_data; 808 809 if (family) { 810 if (!strcmp(family, "virtex2p")) { 811 regs = &v2_config_registers; 812 } else if (!strcmp(family, "virtex4")) { 813 regs = &v4_config_registers; 814 } else if (!strcmp(family, "virtex5")) { 815 regs = &v5_config_registers; 816 } else if (!strcmp(family, "virtex6")) { 817 regs = &v6_config_registers; 818 } 819 } 820 821 return hwicap_setup(&pdev->dev, pdev->id, res, 822 &buffer_icap_config, regs); 823 } 824 825 static int hwicap_drv_remove(struct platform_device *pdev) 826 { 827 return hwicap_remove(&pdev->dev); 828 } 829 830 #ifdef CONFIG_OF 831 /* Match table for device tree binding */ 832 static const struct of_device_id hwicap_of_match[] = { 833 { .compatible = "xlnx,opb-hwicap-1.00.b", .data = &buffer_icap_config}, 834 { .compatible = "xlnx,xps-hwicap-1.00.a", .data = &fifo_icap_config}, 835 {}, 836 }; 837 MODULE_DEVICE_TABLE(of, hwicap_of_match); 838 #else 839 #define hwicap_of_match NULL 840 #endif 841 842 static struct platform_driver hwicap_platform_driver = { 843 .probe = hwicap_drv_probe, 844 .remove = hwicap_drv_remove, 845 .driver = { 846 .name = DRIVER_NAME, 847 .of_match_table = hwicap_of_match, 848 }, 849 }; 850 851 static int __init hwicap_module_init(void) 852 { 853 dev_t devt; 854 int retval; 855 856 icap_class = class_create(THIS_MODULE, "xilinx_config"); 857 mutex_init(&icap_sem); 858 859 devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR); 860 retval = register_chrdev_region(devt, 861 HWICAP_DEVICES, 862 DRIVER_NAME); 863 if (retval < 0) 864 return retval; 865 866 retval = platform_driver_register(&hwicap_platform_driver); 867 if (retval) 868 goto failed; 869 870 return retval; 871 872 failed: 873 unregister_chrdev_region(devt, HWICAP_DEVICES); 874 875 return retval; 876 } 877 878 static void __exit hwicap_module_cleanup(void) 879 { 880 dev_t devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR); 881 882 class_destroy(icap_class); 883 884 platform_driver_unregister(&hwicap_platform_driver); 885 886 unregister_chrdev_region(devt, HWICAP_DEVICES); 887 } 888 889 module_init(hwicap_module_init); 890 module_exit(hwicap_module_cleanup); 891 892 MODULE_AUTHOR("Xilinx, Inc; Xilinx Research Labs Group"); 893 MODULE_DESCRIPTION("Xilinx ICAP Port Driver"); 894 MODULE_LICENSE("GPL"); 895