1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * HSI character device driver, implements the character device 4 * interface. 5 * 6 * Copyright (C) 2010 Nokia Corporation. All rights reserved. 7 * 8 * Contact: Andras Domokos <andras.domokos@nokia.com> 9 */ 10 11 #include <linux/errno.h> 12 #include <linux/types.h> 13 #include <linux/atomic.h> 14 #include <linux/kernel.h> 15 #include <linux/init.h> 16 #include <linux/module.h> 17 #include <linux/mutex.h> 18 #include <linux/list.h> 19 #include <linux/slab.h> 20 #include <linux/kmemleak.h> 21 #include <linux/ioctl.h> 22 #include <linux/wait.h> 23 #include <linux/fs.h> 24 #include <linux/sched.h> 25 #include <linux/device.h> 26 #include <linux/cdev.h> 27 #include <linux/uaccess.h> 28 #include <linux/scatterlist.h> 29 #include <linux/stat.h> 30 #include <linux/hsi/hsi.h> 31 #include <linux/hsi/hsi_char.h> 32 33 #define HSC_DEVS 16 /* Num of channels */ 34 #define HSC_MSGS 4 35 36 #define HSC_RXBREAK 0 37 38 #define HSC_ID_BITS 6 39 #define HSC_PORT_ID_BITS 4 40 #define HSC_ID_MASK 3 41 #define HSC_PORT_ID_MASK 3 42 #define HSC_CH_MASK 0xf 43 44 /* 45 * We support up to 4 controllers that can have up to 4 46 * ports, which should currently be more than enough. 47 */ 48 #define HSC_BASEMINOR(id, port_id) \ 49 ((((id) & HSC_ID_MASK) << HSC_ID_BITS) | \ 50 (((port_id) & HSC_PORT_ID_MASK) << HSC_PORT_ID_BITS)) 51 52 enum { 53 HSC_CH_OPEN, 54 HSC_CH_READ, 55 HSC_CH_WRITE, 56 HSC_CH_WLINE, 57 }; 58 59 enum { 60 HSC_RX, 61 HSC_TX, 62 }; 63 64 struct hsc_client_data; 65 /** 66 * struct hsc_channel - hsi_char internal channel data 67 * @ch: channel number 68 * @flags: Keeps state of the channel (open/close, reading, writing) 69 * @free_msgs_list: List of free HSI messages/requests 70 * @rx_msgs_queue: List of pending RX requests 71 * @tx_msgs_queue: List of pending TX requests 72 * @lock: Serialize access to the lists 73 * @cl: reference to the associated hsi_client 74 * @cl_data: reference to the client data that this channels belongs to 75 * @rx_wait: RX requests wait queue 76 * @tx_wait: TX requests wait queue 77 */ 78 struct hsc_channel { 79 unsigned int ch; 80 unsigned long flags; 81 struct list_head free_msgs_list; 82 struct list_head rx_msgs_queue; 83 struct list_head tx_msgs_queue; 84 spinlock_t lock; 85 struct hsi_client *cl; 86 struct hsc_client_data *cl_data; 87 wait_queue_head_t rx_wait; 88 wait_queue_head_t tx_wait; 89 }; 90 91 /** 92 * struct hsc_client_data - hsi_char internal client data 93 * @cdev: Characther device associated to the hsi_client 94 * @lock: Lock to serialize open/close access 95 * @flags: Keeps track of port state (rx hwbreak armed) 96 * @usecnt: Use count for claiming the HSI port (mutex protected) 97 * @cl: Referece to the HSI client 98 * @channels: Array of channels accessible by the client 99 */ 100 struct hsc_client_data { 101 struct cdev cdev; 102 struct mutex lock; 103 unsigned long flags; 104 unsigned int usecnt; 105 struct hsi_client *cl; 106 struct hsc_channel channels[HSC_DEVS]; 107 }; 108 109 /* Stores the major number dynamically allocated for hsi_char */ 110 static unsigned int hsc_major; 111 /* Maximum buffer size that hsi_char will accept from userspace */ 112 static unsigned int max_data_size = 0x1000; 113 module_param(max_data_size, uint, 0); 114 MODULE_PARM_DESC(max_data_size, "max read/write data size [4,8..65536] (^2)"); 115 116 static void hsc_add_tail(struct hsc_channel *channel, struct hsi_msg *msg, 117 struct list_head *queue) 118 { 119 unsigned long flags; 120 121 spin_lock_irqsave(&channel->lock, flags); 122 list_add_tail(&msg->link, queue); 123 spin_unlock_irqrestore(&channel->lock, flags); 124 } 125 126 static struct hsi_msg *hsc_get_first_msg(struct hsc_channel *channel, 127 struct list_head *queue) 128 { 129 struct hsi_msg *msg = NULL; 130 unsigned long flags; 131 132 spin_lock_irqsave(&channel->lock, flags); 133 134 if (list_empty(queue)) 135 goto out; 136 137 msg = list_first_entry(queue, struct hsi_msg, link); 138 list_del(&msg->link); 139 out: 140 spin_unlock_irqrestore(&channel->lock, flags); 141 142 return msg; 143 } 144 145 static inline void hsc_msg_free(struct hsi_msg *msg) 146 { 147 kfree(sg_virt(msg->sgt.sgl)); 148 hsi_free_msg(msg); 149 } 150 151 static void hsc_free_list(struct list_head *list) 152 { 153 struct hsi_msg *msg, *tmp; 154 155 list_for_each_entry_safe(msg, tmp, list, link) { 156 list_del(&msg->link); 157 hsc_msg_free(msg); 158 } 159 } 160 161 static void hsc_reset_list(struct hsc_channel *channel, struct list_head *l) 162 { 163 unsigned long flags; 164 LIST_HEAD(list); 165 166 spin_lock_irqsave(&channel->lock, flags); 167 list_splice_init(l, &list); 168 spin_unlock_irqrestore(&channel->lock, flags); 169 170 hsc_free_list(&list); 171 } 172 173 static inline struct hsi_msg *hsc_msg_alloc(unsigned int alloc_size) 174 { 175 struct hsi_msg *msg; 176 void *buf; 177 178 msg = hsi_alloc_msg(1, GFP_KERNEL); 179 if (!msg) 180 goto out; 181 buf = kmalloc(alloc_size, GFP_KERNEL); 182 if (!buf) { 183 hsi_free_msg(msg); 184 goto out; 185 } 186 sg_init_one(msg->sgt.sgl, buf, alloc_size); 187 /* Ignore false positive, due to sg pointer handling */ 188 kmemleak_ignore(buf); 189 190 return msg; 191 out: 192 return NULL; 193 } 194 195 static inline int hsc_msgs_alloc(struct hsc_channel *channel) 196 { 197 struct hsi_msg *msg; 198 int i; 199 200 for (i = 0; i < HSC_MSGS; i++) { 201 msg = hsc_msg_alloc(max_data_size); 202 if (!msg) 203 goto out; 204 msg->channel = channel->ch; 205 list_add_tail(&msg->link, &channel->free_msgs_list); 206 } 207 208 return 0; 209 out: 210 hsc_free_list(&channel->free_msgs_list); 211 212 return -ENOMEM; 213 } 214 215 static inline unsigned int hsc_msg_len_get(struct hsi_msg *msg) 216 { 217 return msg->sgt.sgl->length; 218 } 219 220 static inline void hsc_msg_len_set(struct hsi_msg *msg, unsigned int len) 221 { 222 msg->sgt.sgl->length = len; 223 } 224 225 static void hsc_rx_completed(struct hsi_msg *msg) 226 { 227 struct hsc_client_data *cl_data = hsi_client_drvdata(msg->cl); 228 struct hsc_channel *channel = cl_data->channels + msg->channel; 229 230 if (test_bit(HSC_CH_READ, &channel->flags)) { 231 hsc_add_tail(channel, msg, &channel->rx_msgs_queue); 232 wake_up(&channel->rx_wait); 233 } else { 234 hsc_add_tail(channel, msg, &channel->free_msgs_list); 235 } 236 } 237 238 static void hsc_rx_msg_destructor(struct hsi_msg *msg) 239 { 240 msg->status = HSI_STATUS_ERROR; 241 hsc_msg_len_set(msg, 0); 242 hsc_rx_completed(msg); 243 } 244 245 static void hsc_tx_completed(struct hsi_msg *msg) 246 { 247 struct hsc_client_data *cl_data = hsi_client_drvdata(msg->cl); 248 struct hsc_channel *channel = cl_data->channels + msg->channel; 249 250 if (test_bit(HSC_CH_WRITE, &channel->flags)) { 251 hsc_add_tail(channel, msg, &channel->tx_msgs_queue); 252 wake_up(&channel->tx_wait); 253 } else { 254 hsc_add_tail(channel, msg, &channel->free_msgs_list); 255 } 256 } 257 258 static void hsc_tx_msg_destructor(struct hsi_msg *msg) 259 { 260 msg->status = HSI_STATUS_ERROR; 261 hsc_msg_len_set(msg, 0); 262 hsc_tx_completed(msg); 263 } 264 265 static void hsc_break_req_destructor(struct hsi_msg *msg) 266 { 267 struct hsc_client_data *cl_data = hsi_client_drvdata(msg->cl); 268 269 hsi_free_msg(msg); 270 clear_bit(HSC_RXBREAK, &cl_data->flags); 271 } 272 273 static void hsc_break_received(struct hsi_msg *msg) 274 { 275 struct hsc_client_data *cl_data = hsi_client_drvdata(msg->cl); 276 struct hsc_channel *channel = cl_data->channels; 277 int i, ret; 278 279 /* Broadcast HWBREAK on all channels */ 280 for (i = 0; i < HSC_DEVS; i++, channel++) { 281 struct hsi_msg *msg2; 282 283 if (!test_bit(HSC_CH_READ, &channel->flags)) 284 continue; 285 msg2 = hsc_get_first_msg(channel, &channel->free_msgs_list); 286 if (!msg2) 287 continue; 288 clear_bit(HSC_CH_READ, &channel->flags); 289 hsc_msg_len_set(msg2, 0); 290 msg2->status = HSI_STATUS_COMPLETED; 291 hsc_add_tail(channel, msg2, &channel->rx_msgs_queue); 292 wake_up(&channel->rx_wait); 293 } 294 hsi_flush(msg->cl); 295 ret = hsi_async_read(msg->cl, msg); 296 if (ret < 0) 297 hsc_break_req_destructor(msg); 298 } 299 300 static int hsc_break_request(struct hsi_client *cl) 301 { 302 struct hsc_client_data *cl_data = hsi_client_drvdata(cl); 303 struct hsi_msg *msg; 304 int ret; 305 306 if (test_and_set_bit(HSC_RXBREAK, &cl_data->flags)) 307 return -EBUSY; 308 309 msg = hsi_alloc_msg(0, GFP_KERNEL); 310 if (!msg) { 311 clear_bit(HSC_RXBREAK, &cl_data->flags); 312 return -ENOMEM; 313 } 314 msg->break_frame = 1; 315 msg->complete = hsc_break_received; 316 msg->destructor = hsc_break_req_destructor; 317 ret = hsi_async_read(cl, msg); 318 if (ret < 0) 319 hsc_break_req_destructor(msg); 320 321 return ret; 322 } 323 324 static int hsc_break_send(struct hsi_client *cl) 325 { 326 struct hsi_msg *msg; 327 int ret; 328 329 msg = hsi_alloc_msg(0, GFP_ATOMIC); 330 if (!msg) 331 return -ENOMEM; 332 msg->break_frame = 1; 333 msg->complete = hsi_free_msg; 334 msg->destructor = hsi_free_msg; 335 ret = hsi_async_write(cl, msg); 336 if (ret < 0) 337 hsi_free_msg(msg); 338 339 return ret; 340 } 341 342 static int hsc_rx_set(struct hsi_client *cl, struct hsc_rx_config *rxc) 343 { 344 struct hsi_config tmp; 345 int ret; 346 347 if ((rxc->mode != HSI_MODE_STREAM) && (rxc->mode != HSI_MODE_FRAME)) 348 return -EINVAL; 349 if ((rxc->channels == 0) || (rxc->channels > HSC_DEVS)) 350 return -EINVAL; 351 if (rxc->channels & (rxc->channels - 1)) 352 return -EINVAL; 353 if ((rxc->flow != HSI_FLOW_SYNC) && (rxc->flow != HSI_FLOW_PIPE)) 354 return -EINVAL; 355 tmp = cl->rx_cfg; 356 cl->rx_cfg.mode = rxc->mode; 357 cl->rx_cfg.num_hw_channels = rxc->channels; 358 cl->rx_cfg.flow = rxc->flow; 359 ret = hsi_setup(cl); 360 if (ret < 0) { 361 cl->rx_cfg = tmp; 362 return ret; 363 } 364 if (rxc->mode == HSI_MODE_FRAME) 365 hsc_break_request(cl); 366 367 return ret; 368 } 369 370 static inline void hsc_rx_get(struct hsi_client *cl, struct hsc_rx_config *rxc) 371 { 372 rxc->mode = cl->rx_cfg.mode; 373 rxc->channels = cl->rx_cfg.num_hw_channels; 374 rxc->flow = cl->rx_cfg.flow; 375 } 376 377 static int hsc_tx_set(struct hsi_client *cl, struct hsc_tx_config *txc) 378 { 379 struct hsi_config tmp; 380 int ret; 381 382 if ((txc->mode != HSI_MODE_STREAM) && (txc->mode != HSI_MODE_FRAME)) 383 return -EINVAL; 384 if ((txc->channels == 0) || (txc->channels > HSC_DEVS)) 385 return -EINVAL; 386 if (txc->channels & (txc->channels - 1)) 387 return -EINVAL; 388 if ((txc->arb_mode != HSI_ARB_RR) && (txc->arb_mode != HSI_ARB_PRIO)) 389 return -EINVAL; 390 tmp = cl->tx_cfg; 391 cl->tx_cfg.mode = txc->mode; 392 cl->tx_cfg.num_hw_channels = txc->channels; 393 cl->tx_cfg.speed = txc->speed; 394 cl->tx_cfg.arb_mode = txc->arb_mode; 395 ret = hsi_setup(cl); 396 if (ret < 0) { 397 cl->tx_cfg = tmp; 398 return ret; 399 } 400 401 return ret; 402 } 403 404 static inline void hsc_tx_get(struct hsi_client *cl, struct hsc_tx_config *txc) 405 { 406 txc->mode = cl->tx_cfg.mode; 407 txc->channels = cl->tx_cfg.num_hw_channels; 408 txc->speed = cl->tx_cfg.speed; 409 txc->arb_mode = cl->tx_cfg.arb_mode; 410 } 411 412 static ssize_t hsc_read(struct file *file, char __user *buf, size_t len, 413 loff_t *ppos __maybe_unused) 414 { 415 struct hsc_channel *channel = file->private_data; 416 struct hsi_msg *msg; 417 ssize_t ret; 418 419 if (len == 0) 420 return 0; 421 if (!IS_ALIGNED(len, sizeof(u32))) 422 return -EINVAL; 423 if (len > max_data_size) 424 len = max_data_size; 425 if (channel->ch >= channel->cl->rx_cfg.num_hw_channels) 426 return -ECHRNG; 427 if (test_and_set_bit(HSC_CH_READ, &channel->flags)) 428 return -EBUSY; 429 msg = hsc_get_first_msg(channel, &channel->free_msgs_list); 430 if (!msg) { 431 ret = -ENOSPC; 432 goto out; 433 } 434 hsc_msg_len_set(msg, len); 435 msg->complete = hsc_rx_completed; 436 msg->destructor = hsc_rx_msg_destructor; 437 ret = hsi_async_read(channel->cl, msg); 438 if (ret < 0) { 439 hsc_add_tail(channel, msg, &channel->free_msgs_list); 440 goto out; 441 } 442 443 ret = wait_event_interruptible(channel->rx_wait, 444 !list_empty(&channel->rx_msgs_queue)); 445 if (ret < 0) { 446 clear_bit(HSC_CH_READ, &channel->flags); 447 hsi_flush(channel->cl); 448 return -EINTR; 449 } 450 451 msg = hsc_get_first_msg(channel, &channel->rx_msgs_queue); 452 if (msg) { 453 if (msg->status != HSI_STATUS_ERROR) { 454 ret = copy_to_user((void __user *)buf, 455 sg_virt(msg->sgt.sgl), hsc_msg_len_get(msg)); 456 if (ret) 457 ret = -EFAULT; 458 else 459 ret = hsc_msg_len_get(msg); 460 } else { 461 ret = -EIO; 462 } 463 hsc_add_tail(channel, msg, &channel->free_msgs_list); 464 } 465 out: 466 clear_bit(HSC_CH_READ, &channel->flags); 467 468 return ret; 469 } 470 471 static ssize_t hsc_write(struct file *file, const char __user *buf, size_t len, 472 loff_t *ppos __maybe_unused) 473 { 474 struct hsc_channel *channel = file->private_data; 475 struct hsi_msg *msg; 476 ssize_t ret; 477 478 if ((len == 0) || !IS_ALIGNED(len, sizeof(u32))) 479 return -EINVAL; 480 if (len > max_data_size) 481 len = max_data_size; 482 if (channel->ch >= channel->cl->tx_cfg.num_hw_channels) 483 return -ECHRNG; 484 if (test_and_set_bit(HSC_CH_WRITE, &channel->flags)) 485 return -EBUSY; 486 msg = hsc_get_first_msg(channel, &channel->free_msgs_list); 487 if (!msg) { 488 clear_bit(HSC_CH_WRITE, &channel->flags); 489 return -ENOSPC; 490 } 491 if (copy_from_user(sg_virt(msg->sgt.sgl), (void __user *)buf, len)) { 492 ret = -EFAULT; 493 goto out; 494 } 495 hsc_msg_len_set(msg, len); 496 msg->complete = hsc_tx_completed; 497 msg->destructor = hsc_tx_msg_destructor; 498 ret = hsi_async_write(channel->cl, msg); 499 if (ret < 0) 500 goto out; 501 502 ret = wait_event_interruptible(channel->tx_wait, 503 !list_empty(&channel->tx_msgs_queue)); 504 if (ret < 0) { 505 clear_bit(HSC_CH_WRITE, &channel->flags); 506 hsi_flush(channel->cl); 507 return -EINTR; 508 } 509 510 msg = hsc_get_first_msg(channel, &channel->tx_msgs_queue); 511 if (msg) { 512 if (msg->status == HSI_STATUS_ERROR) 513 ret = -EIO; 514 else 515 ret = hsc_msg_len_get(msg); 516 517 hsc_add_tail(channel, msg, &channel->free_msgs_list); 518 } 519 out: 520 clear_bit(HSC_CH_WRITE, &channel->flags); 521 522 return ret; 523 } 524 525 static long hsc_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 526 { 527 struct hsc_channel *channel = file->private_data; 528 unsigned int state; 529 struct hsc_rx_config rxc; 530 struct hsc_tx_config txc; 531 long ret = 0; 532 533 switch (cmd) { 534 case HSC_RESET: 535 hsi_flush(channel->cl); 536 break; 537 case HSC_SET_PM: 538 if (copy_from_user(&state, (void __user *)arg, sizeof(state))) 539 return -EFAULT; 540 if (state == HSC_PM_DISABLE) { 541 if (test_and_set_bit(HSC_CH_WLINE, &channel->flags)) 542 return -EINVAL; 543 ret = hsi_start_tx(channel->cl); 544 } else if (state == HSC_PM_ENABLE) { 545 if (!test_and_clear_bit(HSC_CH_WLINE, &channel->flags)) 546 return -EINVAL; 547 ret = hsi_stop_tx(channel->cl); 548 } else { 549 ret = -EINVAL; 550 } 551 break; 552 case HSC_SEND_BREAK: 553 return hsc_break_send(channel->cl); 554 case HSC_SET_RX: 555 if (copy_from_user(&rxc, (void __user *)arg, sizeof(rxc))) 556 return -EFAULT; 557 return hsc_rx_set(channel->cl, &rxc); 558 case HSC_GET_RX: 559 hsc_rx_get(channel->cl, &rxc); 560 if (copy_to_user((void __user *)arg, &rxc, sizeof(rxc))) 561 return -EFAULT; 562 break; 563 case HSC_SET_TX: 564 if (copy_from_user(&txc, (void __user *)arg, sizeof(txc))) 565 return -EFAULT; 566 return hsc_tx_set(channel->cl, &txc); 567 case HSC_GET_TX: 568 hsc_tx_get(channel->cl, &txc); 569 if (copy_to_user((void __user *)arg, &txc, sizeof(txc))) 570 return -EFAULT; 571 break; 572 default: 573 return -ENOIOCTLCMD; 574 } 575 576 return ret; 577 } 578 579 static inline void __hsc_port_release(struct hsc_client_data *cl_data) 580 { 581 BUG_ON(cl_data->usecnt == 0); 582 583 if (--cl_data->usecnt == 0) { 584 hsi_flush(cl_data->cl); 585 hsi_release_port(cl_data->cl); 586 } 587 } 588 589 static int hsc_open(struct inode *inode, struct file *file) 590 { 591 struct hsc_client_data *cl_data; 592 struct hsc_channel *channel; 593 int ret = 0; 594 595 pr_debug("open, minor = %d\n", iminor(inode)); 596 597 cl_data = container_of(inode->i_cdev, struct hsc_client_data, cdev); 598 mutex_lock(&cl_data->lock); 599 channel = cl_data->channels + (iminor(inode) & HSC_CH_MASK); 600 601 if (test_and_set_bit(HSC_CH_OPEN, &channel->flags)) { 602 ret = -EBUSY; 603 goto out; 604 } 605 /* 606 * Check if we have already claimed the port associated to the HSI 607 * client. If not then try to claim it, else increase its refcount 608 */ 609 if (cl_data->usecnt == 0) { 610 ret = hsi_claim_port(cl_data->cl, 0); 611 if (ret < 0) 612 goto out; 613 hsi_setup(cl_data->cl); 614 } 615 cl_data->usecnt++; 616 617 ret = hsc_msgs_alloc(channel); 618 if (ret < 0) { 619 __hsc_port_release(cl_data); 620 goto out; 621 } 622 623 file->private_data = channel; 624 mutex_unlock(&cl_data->lock); 625 626 return ret; 627 out: 628 mutex_unlock(&cl_data->lock); 629 630 return ret; 631 } 632 633 static int hsc_release(struct inode *inode __maybe_unused, struct file *file) 634 { 635 struct hsc_channel *channel = file->private_data; 636 struct hsc_client_data *cl_data = channel->cl_data; 637 638 mutex_lock(&cl_data->lock); 639 file->private_data = NULL; 640 if (test_and_clear_bit(HSC_CH_WLINE, &channel->flags)) 641 hsi_stop_tx(channel->cl); 642 __hsc_port_release(cl_data); 643 hsc_reset_list(channel, &channel->rx_msgs_queue); 644 hsc_reset_list(channel, &channel->tx_msgs_queue); 645 hsc_reset_list(channel, &channel->free_msgs_list); 646 clear_bit(HSC_CH_READ, &channel->flags); 647 clear_bit(HSC_CH_WRITE, &channel->flags); 648 clear_bit(HSC_CH_OPEN, &channel->flags); 649 wake_up(&channel->rx_wait); 650 wake_up(&channel->tx_wait); 651 mutex_unlock(&cl_data->lock); 652 653 return 0; 654 } 655 656 static const struct file_operations hsc_fops = { 657 .owner = THIS_MODULE, 658 .read = hsc_read, 659 .write = hsc_write, 660 .unlocked_ioctl = hsc_ioctl, 661 .open = hsc_open, 662 .release = hsc_release, 663 }; 664 665 static void hsc_channel_init(struct hsc_channel *channel) 666 { 667 init_waitqueue_head(&channel->rx_wait); 668 init_waitqueue_head(&channel->tx_wait); 669 spin_lock_init(&channel->lock); 670 INIT_LIST_HEAD(&channel->free_msgs_list); 671 INIT_LIST_HEAD(&channel->rx_msgs_queue); 672 INIT_LIST_HEAD(&channel->tx_msgs_queue); 673 } 674 675 static int hsc_probe(struct device *dev) 676 { 677 const char devname[] = "hsi_char"; 678 struct hsc_client_data *cl_data; 679 struct hsc_channel *channel; 680 struct hsi_client *cl = to_hsi_client(dev); 681 unsigned int hsc_baseminor; 682 dev_t hsc_dev; 683 int ret; 684 int i; 685 686 cl_data = kzalloc(sizeof(*cl_data), GFP_KERNEL); 687 if (!cl_data) 688 return -ENOMEM; 689 690 hsc_baseminor = HSC_BASEMINOR(hsi_id(cl), hsi_port_id(cl)); 691 if (!hsc_major) { 692 ret = alloc_chrdev_region(&hsc_dev, hsc_baseminor, 693 HSC_DEVS, devname); 694 if (ret == 0) 695 hsc_major = MAJOR(hsc_dev); 696 } else { 697 hsc_dev = MKDEV(hsc_major, hsc_baseminor); 698 ret = register_chrdev_region(hsc_dev, HSC_DEVS, devname); 699 } 700 if (ret < 0) { 701 dev_err(dev, "Device %s allocation failed %d\n", 702 hsc_major ? "minor" : "major", ret); 703 goto out1; 704 } 705 mutex_init(&cl_data->lock); 706 hsi_client_set_drvdata(cl, cl_data); 707 cdev_init(&cl_data->cdev, &hsc_fops); 708 cl_data->cdev.owner = THIS_MODULE; 709 cl_data->cl = cl; 710 for (i = 0, channel = cl_data->channels; i < HSC_DEVS; i++, channel++) { 711 hsc_channel_init(channel); 712 channel->ch = i; 713 channel->cl = cl; 714 channel->cl_data = cl_data; 715 } 716 717 /* 1 hsi client -> N char devices (one for each channel) */ 718 ret = cdev_add(&cl_data->cdev, hsc_dev, HSC_DEVS); 719 if (ret) { 720 dev_err(dev, "Could not add char device %d\n", ret); 721 goto out2; 722 } 723 724 return 0; 725 out2: 726 unregister_chrdev_region(hsc_dev, HSC_DEVS); 727 out1: 728 kfree(cl_data); 729 730 return ret; 731 } 732 733 static int hsc_remove(struct device *dev) 734 { 735 struct hsi_client *cl = to_hsi_client(dev); 736 struct hsc_client_data *cl_data = hsi_client_drvdata(cl); 737 dev_t hsc_dev = cl_data->cdev.dev; 738 739 cdev_del(&cl_data->cdev); 740 unregister_chrdev_region(hsc_dev, HSC_DEVS); 741 hsi_client_set_drvdata(cl, NULL); 742 kfree(cl_data); 743 744 return 0; 745 } 746 747 static struct hsi_client_driver hsc_driver = { 748 .driver = { 749 .name = "hsi_char", 750 .owner = THIS_MODULE, 751 .probe = hsc_probe, 752 .remove = hsc_remove, 753 }, 754 }; 755 756 static int __init hsc_init(void) 757 { 758 int ret; 759 760 if ((max_data_size < 4) || (max_data_size > 0x10000) || 761 (max_data_size & (max_data_size - 1))) { 762 pr_err("Invalid max read/write data size\n"); 763 return -EINVAL; 764 } 765 766 ret = hsi_register_client_driver(&hsc_driver); 767 if (ret) { 768 pr_err("Error while registering HSI/SSI driver %d\n", ret); 769 return ret; 770 } 771 772 pr_info("HSI/SSI char device loaded\n"); 773 774 return 0; 775 } 776 module_init(hsc_init); 777 778 static void __exit hsc_exit(void) 779 { 780 hsi_unregister_client_driver(&hsc_driver); 781 pr_info("HSI char device removed\n"); 782 } 783 module_exit(hsc_exit); 784 785 MODULE_AUTHOR("Andras Domokos <andras.domokos@nokia.com>"); 786 MODULE_ALIAS("hsi:hsi_char"); 787 MODULE_DESCRIPTION("HSI character device"); 788 MODULE_LICENSE("GPL v2"); 789