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