1 /* 2 * Silicon Labs C2 port core Linux support 3 * 4 * Copyright (c) 2007 Rodolfo Giometti <giometti@linux.it> 5 * Copyright (c) 2007 Eurotech S.p.A. <info@eurotech.it> 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms of the GNU General Public License version 2 as published by 9 * the Free Software Foundation 10 */ 11 12 #include <linux/module.h> 13 #include <linux/init.h> 14 #include <linux/device.h> 15 #include <linux/errno.h> 16 #include <linux/err.h> 17 #include <linux/kernel.h> 18 #include <linux/ctype.h> 19 #include <linux/delay.h> 20 #include <linux/idr.h> 21 #include <linux/sched.h> 22 #include <linux/slab.h> 23 24 #include <linux/c2port.h> 25 26 #define DRIVER_NAME "c2port" 27 #define DRIVER_VERSION "0.51.0" 28 29 static DEFINE_SPINLOCK(c2port_idr_lock); 30 static DEFINE_IDR(c2port_idr); 31 32 /* 33 * Local variables 34 */ 35 36 static struct class *c2port_class; 37 38 /* 39 * C2 registers & commands defines 40 */ 41 42 /* C2 registers */ 43 #define C2PORT_DEVICEID 0x00 44 #define C2PORT_REVID 0x01 45 #define C2PORT_FPCTL 0x02 46 #define C2PORT_FPDAT 0xB4 47 48 /* C2 interface commands */ 49 #define C2PORT_GET_VERSION 0x01 50 #define C2PORT_DEVICE_ERASE 0x03 51 #define C2PORT_BLOCK_READ 0x06 52 #define C2PORT_BLOCK_WRITE 0x07 53 #define C2PORT_PAGE_ERASE 0x08 54 55 /* C2 status return codes */ 56 #define C2PORT_INVALID_COMMAND 0x00 57 #define C2PORT_COMMAND_FAILED 0x02 58 #define C2PORT_COMMAND_OK 0x0d 59 60 /* 61 * C2 port low level signal managements 62 */ 63 64 static void c2port_reset(struct c2port_device *dev) 65 { 66 struct c2port_ops *ops = dev->ops; 67 68 /* To reset the device we have to keep clock line low for at least 69 * 20us. 70 */ 71 local_irq_disable(); 72 ops->c2ck_set(dev, 0); 73 udelay(25); 74 ops->c2ck_set(dev, 1); 75 local_irq_enable(); 76 77 udelay(1); 78 } 79 80 static void c2port_strobe_ck(struct c2port_device *dev) 81 { 82 struct c2port_ops *ops = dev->ops; 83 84 /* During hi-low-hi transition we disable local IRQs to avoid 85 * interructions since C2 port specification says that it must be 86 * shorter than 5us, otherwise the microcontroller may consider 87 * it as a reset signal! 88 */ 89 local_irq_disable(); 90 ops->c2ck_set(dev, 0); 91 udelay(1); 92 ops->c2ck_set(dev, 1); 93 local_irq_enable(); 94 95 udelay(1); 96 } 97 98 /* 99 * C2 port basic functions 100 */ 101 102 static void c2port_write_ar(struct c2port_device *dev, u8 addr) 103 { 104 struct c2port_ops *ops = dev->ops; 105 int i; 106 107 /* START field */ 108 c2port_strobe_ck(dev); 109 110 /* INS field (11b, LSB first) */ 111 ops->c2d_dir(dev, 0); 112 ops->c2d_set(dev, 1); 113 c2port_strobe_ck(dev); 114 ops->c2d_set(dev, 1); 115 c2port_strobe_ck(dev); 116 117 /* ADDRESS field */ 118 for (i = 0; i < 8; i++) { 119 ops->c2d_set(dev, addr & 0x01); 120 c2port_strobe_ck(dev); 121 122 addr >>= 1; 123 } 124 125 /* STOP field */ 126 ops->c2d_dir(dev, 1); 127 c2port_strobe_ck(dev); 128 } 129 130 static int c2port_read_ar(struct c2port_device *dev, u8 *addr) 131 { 132 struct c2port_ops *ops = dev->ops; 133 int i; 134 135 /* START field */ 136 c2port_strobe_ck(dev); 137 138 /* INS field (10b, LSB first) */ 139 ops->c2d_dir(dev, 0); 140 ops->c2d_set(dev, 0); 141 c2port_strobe_ck(dev); 142 ops->c2d_set(dev, 1); 143 c2port_strobe_ck(dev); 144 145 /* ADDRESS field */ 146 ops->c2d_dir(dev, 1); 147 *addr = 0; 148 for (i = 0; i < 8; i++) { 149 *addr >>= 1; /* shift in 8-bit ADDRESS field LSB first */ 150 151 c2port_strobe_ck(dev); 152 if (ops->c2d_get(dev)) 153 *addr |= 0x80; 154 } 155 156 /* STOP field */ 157 c2port_strobe_ck(dev); 158 159 return 0; 160 } 161 162 static int c2port_write_dr(struct c2port_device *dev, u8 data) 163 { 164 struct c2port_ops *ops = dev->ops; 165 int timeout, i; 166 167 /* START field */ 168 c2port_strobe_ck(dev); 169 170 /* INS field (01b, LSB first) */ 171 ops->c2d_dir(dev, 0); 172 ops->c2d_set(dev, 1); 173 c2port_strobe_ck(dev); 174 ops->c2d_set(dev, 0); 175 c2port_strobe_ck(dev); 176 177 /* LENGTH field (00b, LSB first -> 1 byte) */ 178 ops->c2d_set(dev, 0); 179 c2port_strobe_ck(dev); 180 ops->c2d_set(dev, 0); 181 c2port_strobe_ck(dev); 182 183 /* DATA field */ 184 for (i = 0; i < 8; i++) { 185 ops->c2d_set(dev, data & 0x01); 186 c2port_strobe_ck(dev); 187 188 data >>= 1; 189 } 190 191 /* WAIT field */ 192 ops->c2d_dir(dev, 1); 193 timeout = 20; 194 do { 195 c2port_strobe_ck(dev); 196 if (ops->c2d_get(dev)) 197 break; 198 199 udelay(1); 200 } while (--timeout > 0); 201 if (timeout == 0) 202 return -EIO; 203 204 /* STOP field */ 205 c2port_strobe_ck(dev); 206 207 return 0; 208 } 209 210 static int c2port_read_dr(struct c2port_device *dev, u8 *data) 211 { 212 struct c2port_ops *ops = dev->ops; 213 int timeout, i; 214 215 /* START field */ 216 c2port_strobe_ck(dev); 217 218 /* INS field (00b, LSB first) */ 219 ops->c2d_dir(dev, 0); 220 ops->c2d_set(dev, 0); 221 c2port_strobe_ck(dev); 222 ops->c2d_set(dev, 0); 223 c2port_strobe_ck(dev); 224 225 /* LENGTH field (00b, LSB first -> 1 byte) */ 226 ops->c2d_set(dev, 0); 227 c2port_strobe_ck(dev); 228 ops->c2d_set(dev, 0); 229 c2port_strobe_ck(dev); 230 231 /* WAIT field */ 232 ops->c2d_dir(dev, 1); 233 timeout = 20; 234 do { 235 c2port_strobe_ck(dev); 236 if (ops->c2d_get(dev)) 237 break; 238 239 udelay(1); 240 } while (--timeout > 0); 241 if (timeout == 0) 242 return -EIO; 243 244 /* DATA field */ 245 *data = 0; 246 for (i = 0; i < 8; i++) { 247 *data >>= 1; /* shift in 8-bit DATA field LSB first */ 248 249 c2port_strobe_ck(dev); 250 if (ops->c2d_get(dev)) 251 *data |= 0x80; 252 } 253 254 /* STOP field */ 255 c2port_strobe_ck(dev); 256 257 return 0; 258 } 259 260 static int c2port_poll_in_busy(struct c2port_device *dev) 261 { 262 u8 addr; 263 int ret, timeout = 20; 264 265 do { 266 ret = (c2port_read_ar(dev, &addr)); 267 if (ret < 0) 268 return -EIO; 269 270 if (!(addr & 0x02)) 271 break; 272 273 udelay(1); 274 } while (--timeout > 0); 275 if (timeout == 0) 276 return -EIO; 277 278 return 0; 279 } 280 281 static int c2port_poll_out_ready(struct c2port_device *dev) 282 { 283 u8 addr; 284 int ret, timeout = 10000; /* erase flash needs long time... */ 285 286 do { 287 ret = (c2port_read_ar(dev, &addr)); 288 if (ret < 0) 289 return -EIO; 290 291 if (addr & 0x01) 292 break; 293 294 udelay(1); 295 } while (--timeout > 0); 296 if (timeout == 0) 297 return -EIO; 298 299 return 0; 300 } 301 302 /* 303 * sysfs methods 304 */ 305 306 static ssize_t c2port_show_name(struct device *dev, 307 struct device_attribute *attr, char *buf) 308 { 309 struct c2port_device *c2dev = dev_get_drvdata(dev); 310 311 return sprintf(buf, "%s\n", c2dev->name); 312 } 313 static DEVICE_ATTR(name, 0444, c2port_show_name, NULL); 314 315 static ssize_t c2port_show_flash_blocks_num(struct device *dev, 316 struct device_attribute *attr, char *buf) 317 { 318 struct c2port_device *c2dev = dev_get_drvdata(dev); 319 struct c2port_ops *ops = c2dev->ops; 320 321 return sprintf(buf, "%d\n", ops->blocks_num); 322 } 323 static DEVICE_ATTR(flash_blocks_num, 0444, c2port_show_flash_blocks_num, NULL); 324 325 static ssize_t c2port_show_flash_block_size(struct device *dev, 326 struct device_attribute *attr, char *buf) 327 { 328 struct c2port_device *c2dev = dev_get_drvdata(dev); 329 struct c2port_ops *ops = c2dev->ops; 330 331 return sprintf(buf, "%d\n", ops->block_size); 332 } 333 static DEVICE_ATTR(flash_block_size, 0444, c2port_show_flash_block_size, NULL); 334 335 static ssize_t c2port_show_flash_size(struct device *dev, 336 struct device_attribute *attr, char *buf) 337 { 338 struct c2port_device *c2dev = dev_get_drvdata(dev); 339 struct c2port_ops *ops = c2dev->ops; 340 341 return sprintf(buf, "%d\n", ops->blocks_num * ops->block_size); 342 } 343 static DEVICE_ATTR(flash_size, 0444, c2port_show_flash_size, NULL); 344 345 static ssize_t access_show(struct device *dev, struct device_attribute *attr, 346 char *buf) 347 { 348 struct c2port_device *c2dev = dev_get_drvdata(dev); 349 350 return sprintf(buf, "%d\n", c2dev->access); 351 } 352 353 static ssize_t access_store(struct device *dev, struct device_attribute *attr, 354 const char *buf, size_t count) 355 { 356 struct c2port_device *c2dev = dev_get_drvdata(dev); 357 struct c2port_ops *ops = c2dev->ops; 358 int status, ret; 359 360 ret = sscanf(buf, "%d", &status); 361 if (ret != 1) 362 return -EINVAL; 363 364 mutex_lock(&c2dev->mutex); 365 366 c2dev->access = !!status; 367 368 /* If access is "on" clock should be HIGH _before_ setting the line 369 * as output and data line should be set as INPUT anyway */ 370 if (c2dev->access) 371 ops->c2ck_set(c2dev, 1); 372 ops->access(c2dev, c2dev->access); 373 if (c2dev->access) 374 ops->c2d_dir(c2dev, 1); 375 376 mutex_unlock(&c2dev->mutex); 377 378 return count; 379 } 380 static DEVICE_ATTR_RW(access); 381 382 static ssize_t c2port_store_reset(struct device *dev, 383 struct device_attribute *attr, 384 const char *buf, size_t count) 385 { 386 struct c2port_device *c2dev = dev_get_drvdata(dev); 387 388 /* Check the device access status */ 389 if (!c2dev->access) 390 return -EBUSY; 391 392 mutex_lock(&c2dev->mutex); 393 394 c2port_reset(c2dev); 395 c2dev->flash_access = 0; 396 397 mutex_unlock(&c2dev->mutex); 398 399 return count; 400 } 401 static DEVICE_ATTR(reset, 0200, NULL, c2port_store_reset); 402 403 static ssize_t __c2port_show_dev_id(struct c2port_device *dev, char *buf) 404 { 405 u8 data; 406 int ret; 407 408 /* Select DEVICEID register for C2 data register accesses */ 409 c2port_write_ar(dev, C2PORT_DEVICEID); 410 411 /* Read and return the device ID register */ 412 ret = c2port_read_dr(dev, &data); 413 if (ret < 0) 414 return ret; 415 416 return sprintf(buf, "%d\n", data); 417 } 418 419 static ssize_t c2port_show_dev_id(struct device *dev, 420 struct device_attribute *attr, char *buf) 421 { 422 struct c2port_device *c2dev = dev_get_drvdata(dev); 423 ssize_t ret; 424 425 /* Check the device access status */ 426 if (!c2dev->access) 427 return -EBUSY; 428 429 mutex_lock(&c2dev->mutex); 430 ret = __c2port_show_dev_id(c2dev, buf); 431 mutex_unlock(&c2dev->mutex); 432 433 if (ret < 0) 434 dev_err(dev, "cannot read from %s\n", c2dev->name); 435 436 return ret; 437 } 438 static DEVICE_ATTR(dev_id, 0444, c2port_show_dev_id, NULL); 439 440 static ssize_t __c2port_show_rev_id(struct c2port_device *dev, char *buf) 441 { 442 u8 data; 443 int ret; 444 445 /* Select REVID register for C2 data register accesses */ 446 c2port_write_ar(dev, C2PORT_REVID); 447 448 /* Read and return the revision ID register */ 449 ret = c2port_read_dr(dev, &data); 450 if (ret < 0) 451 return ret; 452 453 return sprintf(buf, "%d\n", data); 454 } 455 456 static ssize_t c2port_show_rev_id(struct device *dev, 457 struct device_attribute *attr, char *buf) 458 { 459 struct c2port_device *c2dev = dev_get_drvdata(dev); 460 ssize_t ret; 461 462 /* Check the device access status */ 463 if (!c2dev->access) 464 return -EBUSY; 465 466 mutex_lock(&c2dev->mutex); 467 ret = __c2port_show_rev_id(c2dev, buf); 468 mutex_unlock(&c2dev->mutex); 469 470 if (ret < 0) 471 dev_err(c2dev->dev, "cannot read from %s\n", c2dev->name); 472 473 return ret; 474 } 475 static DEVICE_ATTR(rev_id, 0444, c2port_show_rev_id, NULL); 476 477 static ssize_t c2port_show_flash_access(struct device *dev, 478 struct device_attribute *attr, char *buf) 479 { 480 struct c2port_device *c2dev = dev_get_drvdata(dev); 481 482 return sprintf(buf, "%d\n", c2dev->flash_access); 483 } 484 485 static ssize_t __c2port_store_flash_access(struct c2port_device *dev, 486 int status) 487 { 488 int ret; 489 490 /* Check the device access status */ 491 if (!dev->access) 492 return -EBUSY; 493 494 dev->flash_access = !!status; 495 496 /* If flash_access is off we have nothing to do... */ 497 if (dev->flash_access == 0) 498 return 0; 499 500 /* Target the C2 flash programming control register for C2 data 501 * register access */ 502 c2port_write_ar(dev, C2PORT_FPCTL); 503 504 /* Write the first keycode to enable C2 Flash programming */ 505 ret = c2port_write_dr(dev, 0x02); 506 if (ret < 0) 507 return ret; 508 509 /* Write the second keycode to enable C2 Flash programming */ 510 ret = c2port_write_dr(dev, 0x01); 511 if (ret < 0) 512 return ret; 513 514 /* Delay for at least 20ms to ensure the target is ready for 515 * C2 flash programming */ 516 mdelay(25); 517 518 return 0; 519 } 520 521 static ssize_t c2port_store_flash_access(struct device *dev, 522 struct device_attribute *attr, 523 const char *buf, size_t count) 524 { 525 struct c2port_device *c2dev = dev_get_drvdata(dev); 526 int status; 527 ssize_t ret; 528 529 ret = sscanf(buf, "%d", &status); 530 if (ret != 1) 531 return -EINVAL; 532 533 mutex_lock(&c2dev->mutex); 534 ret = __c2port_store_flash_access(c2dev, status); 535 mutex_unlock(&c2dev->mutex); 536 537 if (ret < 0) { 538 dev_err(c2dev->dev, "cannot enable %s flash programming\n", 539 c2dev->name); 540 return ret; 541 } 542 543 return count; 544 } 545 static DEVICE_ATTR(flash_access, 0644, c2port_show_flash_access, 546 c2port_store_flash_access); 547 548 static ssize_t __c2port_write_flash_erase(struct c2port_device *dev) 549 { 550 u8 status; 551 int ret; 552 553 /* Target the C2 flash programming data register for C2 data register 554 * access. 555 */ 556 c2port_write_ar(dev, C2PORT_FPDAT); 557 558 /* Send device erase command */ 559 c2port_write_dr(dev, C2PORT_DEVICE_ERASE); 560 561 /* Wait for input acknowledge */ 562 ret = c2port_poll_in_busy(dev); 563 if (ret < 0) 564 return ret; 565 566 /* Should check status before starting FLASH access sequence */ 567 568 /* Wait for status information */ 569 ret = c2port_poll_out_ready(dev); 570 if (ret < 0) 571 return ret; 572 573 /* Read flash programming interface status */ 574 ret = c2port_read_dr(dev, &status); 575 if (ret < 0) 576 return ret; 577 if (status != C2PORT_COMMAND_OK) 578 return -EBUSY; 579 580 /* Send a three-byte arming sequence to enable the device erase. 581 * If the sequence is not received correctly, the command will be 582 * ignored. 583 * Sequence is: 0xde, 0xad, 0xa5. 584 */ 585 c2port_write_dr(dev, 0xde); 586 ret = c2port_poll_in_busy(dev); 587 if (ret < 0) 588 return ret; 589 c2port_write_dr(dev, 0xad); 590 ret = c2port_poll_in_busy(dev); 591 if (ret < 0) 592 return ret; 593 c2port_write_dr(dev, 0xa5); 594 ret = c2port_poll_in_busy(dev); 595 if (ret < 0) 596 return ret; 597 598 ret = c2port_poll_out_ready(dev); 599 if (ret < 0) 600 return ret; 601 602 return 0; 603 } 604 605 static ssize_t c2port_store_flash_erase(struct device *dev, 606 struct device_attribute *attr, 607 const char *buf, size_t count) 608 { 609 struct c2port_device *c2dev = dev_get_drvdata(dev); 610 int ret; 611 612 /* Check the device and flash access status */ 613 if (!c2dev->access || !c2dev->flash_access) 614 return -EBUSY; 615 616 mutex_lock(&c2dev->mutex); 617 ret = __c2port_write_flash_erase(c2dev); 618 mutex_unlock(&c2dev->mutex); 619 620 if (ret < 0) { 621 dev_err(c2dev->dev, "cannot erase %s flash\n", c2dev->name); 622 return ret; 623 } 624 625 return count; 626 } 627 static DEVICE_ATTR(flash_erase, 0200, NULL, c2port_store_flash_erase); 628 629 static ssize_t __c2port_read_flash_data(struct c2port_device *dev, 630 char *buffer, loff_t offset, size_t count) 631 { 632 struct c2port_ops *ops = dev->ops; 633 u8 status, nread = 128; 634 int i, ret; 635 636 /* Check for flash end */ 637 if (offset >= ops->block_size * ops->blocks_num) 638 return 0; 639 640 if (ops->block_size * ops->blocks_num - offset < nread) 641 nread = ops->block_size * ops->blocks_num - offset; 642 if (count < nread) 643 nread = count; 644 if (nread == 0) 645 return nread; 646 647 /* Target the C2 flash programming data register for C2 data register 648 * access */ 649 c2port_write_ar(dev, C2PORT_FPDAT); 650 651 /* Send flash block read command */ 652 c2port_write_dr(dev, C2PORT_BLOCK_READ); 653 654 /* Wait for input acknowledge */ 655 ret = c2port_poll_in_busy(dev); 656 if (ret < 0) 657 return ret; 658 659 /* Should check status before starting FLASH access sequence */ 660 661 /* Wait for status information */ 662 ret = c2port_poll_out_ready(dev); 663 if (ret < 0) 664 return ret; 665 666 /* Read flash programming interface status */ 667 ret = c2port_read_dr(dev, &status); 668 if (ret < 0) 669 return ret; 670 if (status != C2PORT_COMMAND_OK) 671 return -EBUSY; 672 673 /* Send address high byte */ 674 c2port_write_dr(dev, offset >> 8); 675 ret = c2port_poll_in_busy(dev); 676 if (ret < 0) 677 return ret; 678 679 /* Send address low byte */ 680 c2port_write_dr(dev, offset & 0x00ff); 681 ret = c2port_poll_in_busy(dev); 682 if (ret < 0) 683 return ret; 684 685 /* Send address block size */ 686 c2port_write_dr(dev, nread); 687 ret = c2port_poll_in_busy(dev); 688 if (ret < 0) 689 return ret; 690 691 /* Should check status before reading FLASH block */ 692 693 /* Wait for status information */ 694 ret = c2port_poll_out_ready(dev); 695 if (ret < 0) 696 return ret; 697 698 /* Read flash programming interface status */ 699 ret = c2port_read_dr(dev, &status); 700 if (ret < 0) 701 return ret; 702 if (status != C2PORT_COMMAND_OK) 703 return -EBUSY; 704 705 /* Read flash block */ 706 for (i = 0; i < nread; i++) { 707 ret = c2port_poll_out_ready(dev); 708 if (ret < 0) 709 return ret; 710 711 ret = c2port_read_dr(dev, buffer+i); 712 if (ret < 0) 713 return ret; 714 } 715 716 return nread; 717 } 718 719 static ssize_t c2port_read_flash_data(struct file *filp, struct kobject *kobj, 720 struct bin_attribute *attr, 721 char *buffer, loff_t offset, size_t count) 722 { 723 struct c2port_device *c2dev = dev_get_drvdata(kobj_to_dev(kobj)); 724 ssize_t ret; 725 726 /* Check the device and flash access status */ 727 if (!c2dev->access || !c2dev->flash_access) 728 return -EBUSY; 729 730 mutex_lock(&c2dev->mutex); 731 ret = __c2port_read_flash_data(c2dev, buffer, offset, count); 732 mutex_unlock(&c2dev->mutex); 733 734 if (ret < 0) 735 dev_err(c2dev->dev, "cannot read %s flash\n", c2dev->name); 736 737 return ret; 738 } 739 740 static ssize_t __c2port_write_flash_data(struct c2port_device *dev, 741 char *buffer, loff_t offset, size_t count) 742 { 743 struct c2port_ops *ops = dev->ops; 744 u8 status, nwrite = 128; 745 int i, ret; 746 747 if (nwrite > count) 748 nwrite = count; 749 if (ops->block_size * ops->blocks_num - offset < nwrite) 750 nwrite = ops->block_size * ops->blocks_num - offset; 751 752 /* Check for flash end */ 753 if (offset >= ops->block_size * ops->blocks_num) 754 return -EINVAL; 755 756 /* Target the C2 flash programming data register for C2 data register 757 * access */ 758 c2port_write_ar(dev, C2PORT_FPDAT); 759 760 /* Send flash block write command */ 761 c2port_write_dr(dev, C2PORT_BLOCK_WRITE); 762 763 /* Wait for input acknowledge */ 764 ret = c2port_poll_in_busy(dev); 765 if (ret < 0) 766 return ret; 767 768 /* Should check status before starting FLASH access sequence */ 769 770 /* Wait for status information */ 771 ret = c2port_poll_out_ready(dev); 772 if (ret < 0) 773 return ret; 774 775 /* Read flash programming interface status */ 776 ret = c2port_read_dr(dev, &status); 777 if (ret < 0) 778 return ret; 779 if (status != C2PORT_COMMAND_OK) 780 return -EBUSY; 781 782 /* Send address high byte */ 783 c2port_write_dr(dev, offset >> 8); 784 ret = c2port_poll_in_busy(dev); 785 if (ret < 0) 786 return ret; 787 788 /* Send address low byte */ 789 c2port_write_dr(dev, offset & 0x00ff); 790 ret = c2port_poll_in_busy(dev); 791 if (ret < 0) 792 return ret; 793 794 /* Send address block size */ 795 c2port_write_dr(dev, nwrite); 796 ret = c2port_poll_in_busy(dev); 797 if (ret < 0) 798 return ret; 799 800 /* Should check status before writing FLASH block */ 801 802 /* Wait for status information */ 803 ret = c2port_poll_out_ready(dev); 804 if (ret < 0) 805 return ret; 806 807 /* Read flash programming interface status */ 808 ret = c2port_read_dr(dev, &status); 809 if (ret < 0) 810 return ret; 811 if (status != C2PORT_COMMAND_OK) 812 return -EBUSY; 813 814 /* Write flash block */ 815 for (i = 0; i < nwrite; i++) { 816 ret = c2port_write_dr(dev, *(buffer+i)); 817 if (ret < 0) 818 return ret; 819 820 ret = c2port_poll_in_busy(dev); 821 if (ret < 0) 822 return ret; 823 824 } 825 826 /* Wait for last flash write to complete */ 827 ret = c2port_poll_out_ready(dev); 828 if (ret < 0) 829 return ret; 830 831 return nwrite; 832 } 833 834 static ssize_t c2port_write_flash_data(struct file *filp, struct kobject *kobj, 835 struct bin_attribute *attr, 836 char *buffer, loff_t offset, size_t count) 837 { 838 struct c2port_device *c2dev = dev_get_drvdata(kobj_to_dev(kobj)); 839 int ret; 840 841 /* Check the device access status */ 842 if (!c2dev->access || !c2dev->flash_access) 843 return -EBUSY; 844 845 mutex_lock(&c2dev->mutex); 846 ret = __c2port_write_flash_data(c2dev, buffer, offset, count); 847 mutex_unlock(&c2dev->mutex); 848 849 if (ret < 0) 850 dev_err(c2dev->dev, "cannot write %s flash\n", c2dev->name); 851 852 return ret; 853 } 854 /* size is computed at run-time */ 855 static BIN_ATTR(flash_data, 0644, c2port_read_flash_data, 856 c2port_write_flash_data, 0); 857 858 /* 859 * Class attributes 860 */ 861 static struct attribute *c2port_attrs[] = { 862 &dev_attr_name.attr, 863 &dev_attr_flash_blocks_num.attr, 864 &dev_attr_flash_block_size.attr, 865 &dev_attr_flash_size.attr, 866 &dev_attr_access.attr, 867 &dev_attr_reset.attr, 868 &dev_attr_dev_id.attr, 869 &dev_attr_rev_id.attr, 870 &dev_attr_flash_access.attr, 871 &dev_attr_flash_erase.attr, 872 NULL, 873 }; 874 875 static struct bin_attribute *c2port_bin_attrs[] = { 876 &bin_attr_flash_data, 877 NULL, 878 }; 879 880 static const struct attribute_group c2port_group = { 881 .attrs = c2port_attrs, 882 .bin_attrs = c2port_bin_attrs, 883 }; 884 885 static const struct attribute_group *c2port_groups[] = { 886 &c2port_group, 887 NULL, 888 }; 889 890 /* 891 * Exported functions 892 */ 893 894 struct c2port_device *c2port_device_register(char *name, 895 struct c2port_ops *ops, void *devdata) 896 { 897 struct c2port_device *c2dev; 898 int ret; 899 900 if (unlikely(!ops) || unlikely(!ops->access) || \ 901 unlikely(!ops->c2d_dir) || unlikely(!ops->c2ck_set) || \ 902 unlikely(!ops->c2d_get) || unlikely(!ops->c2d_set)) 903 return ERR_PTR(-EINVAL); 904 905 c2dev = kmalloc(sizeof(struct c2port_device), GFP_KERNEL); 906 if (unlikely(!c2dev)) 907 return ERR_PTR(-ENOMEM); 908 909 idr_preload(GFP_KERNEL); 910 spin_lock_irq(&c2port_idr_lock); 911 ret = idr_alloc(&c2port_idr, c2dev, 0, 0, GFP_NOWAIT); 912 spin_unlock_irq(&c2port_idr_lock); 913 idr_preload_end(); 914 915 if (ret < 0) 916 goto error_idr_alloc; 917 c2dev->id = ret; 918 919 bin_attr_flash_data.size = ops->blocks_num * ops->block_size; 920 921 c2dev->dev = device_create(c2port_class, NULL, 0, c2dev, 922 "c2port%d", c2dev->id); 923 if (IS_ERR(c2dev->dev)) { 924 ret = PTR_ERR(c2dev->dev); 925 goto error_device_create; 926 } 927 dev_set_drvdata(c2dev->dev, c2dev); 928 929 strncpy(c2dev->name, name, C2PORT_NAME_LEN); 930 c2dev->ops = ops; 931 mutex_init(&c2dev->mutex); 932 933 /* By default C2 port access is off */ 934 c2dev->access = c2dev->flash_access = 0; 935 ops->access(c2dev, 0); 936 937 dev_info(c2dev->dev, "C2 port %s added\n", name); 938 dev_info(c2dev->dev, "%s flash has %d blocks x %d bytes " 939 "(%d bytes total)\n", 940 name, ops->blocks_num, ops->block_size, 941 ops->blocks_num * ops->block_size); 942 943 return c2dev; 944 945 error_device_create: 946 spin_lock_irq(&c2port_idr_lock); 947 idr_remove(&c2port_idr, c2dev->id); 948 spin_unlock_irq(&c2port_idr_lock); 949 950 error_idr_alloc: 951 kfree(c2dev); 952 953 return ERR_PTR(ret); 954 } 955 EXPORT_SYMBOL(c2port_device_register); 956 957 void c2port_device_unregister(struct c2port_device *c2dev) 958 { 959 if (!c2dev) 960 return; 961 962 dev_info(c2dev->dev, "C2 port %s removed\n", c2dev->name); 963 964 spin_lock_irq(&c2port_idr_lock); 965 idr_remove(&c2port_idr, c2dev->id); 966 spin_unlock_irq(&c2port_idr_lock); 967 968 device_destroy(c2port_class, c2dev->id); 969 970 kfree(c2dev); 971 } 972 EXPORT_SYMBOL(c2port_device_unregister); 973 974 /* 975 * Module stuff 976 */ 977 978 static int __init c2port_init(void) 979 { 980 printk(KERN_INFO "Silicon Labs C2 port support v. " DRIVER_VERSION 981 " - (C) 2007 Rodolfo Giometti\n"); 982 983 c2port_class = class_create(THIS_MODULE, "c2port"); 984 if (IS_ERR(c2port_class)) { 985 printk(KERN_ERR "c2port: failed to allocate class\n"); 986 return PTR_ERR(c2port_class); 987 } 988 c2port_class->dev_groups = c2port_groups; 989 990 return 0; 991 } 992 993 static void __exit c2port_exit(void) 994 { 995 class_destroy(c2port_class); 996 } 997 998 module_init(c2port_init); 999 module_exit(c2port_exit); 1000 1001 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>"); 1002 MODULE_DESCRIPTION("Silicon Labs C2 port support v. " DRIVER_VERSION); 1003 MODULE_LICENSE("GPL"); 1004