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