drivers/media/dvb/siano/smscoreapi.c

   1 /*
   2  *  Siano core API module
   3  *
   4  *  This file contains implementation for the interface to sms core component
   5  *
   6  *  author: Uri Shkolnik
   7  *
   8  *  Copyright (c), 2005-2008 Siano Mobile Silicon, Inc.
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License version 2 as
  12  *  published by the Free Software Foundation;
  13  *
  14  *  Software distributed under the License is distributed on an "AS IS"
  15  *  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
  16  *
  17  *  See the GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include <linux/kernel.h>
  25 #include <linux/init.h>
  26 #include <linux/module.h>
  27 #include <linux/moduleparam.h>
  28 #include <linux/dma-mapping.h>
  29 #include <linux/delay.h>
  30 #include <linux/io.h>
  31 #include <linux/slab.h>
  32
  33 #include <linux/firmware.h>
  34 #include <linux/wait.h>
  35 #include <asm/byteorder.h>
  36
  37 #include "smscoreapi.h"
  38 #include "sms-cards.h"
  39 #include "smsir.h"
  40 #include "smsendian.h"
  41
  42 static int sms_dbg;
  43 module_param_named(debug, sms_dbg, int, 0644);
  44 MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))");
  45
  46 struct smscore_device_notifyee_t {
  47         struct list_head entry;
  48         hotplug_t hotplug;
  49 };
  50
  51 struct smscore_idlist_t {
  52         struct list_head entry;
  53         int             id;
  54         int             data_type;
  55 };
  56
  57 struct smscore_client_t {
  58         struct list_head entry;
  59         struct smscore_device_t *coredev;
  60         void                    *context;
  61         struct list_head        idlist;
  62         onresponse_t    onresponse_handler;
  63         onremove_t              onremove_handler;
  64 };
  65
  66 void smscore_set_board_id(struct smscore_device_t *core, int id)
  67 {
  68         core->board_id = id;
  69 }
  70
  71 int smscore_led_state(struct smscore_device_t *core, int led)
  72 {
  73         if (led >= 0)
  74                 core->led_state = led;
  75         return core->led_state;
  76 }
  77 EXPORT_SYMBOL_GPL(smscore_set_board_id);
  78
  79 int smscore_get_board_id(struct smscore_device_t *core)
  80 {
  81         return core->board_id;
  82 }
  83 EXPORT_SYMBOL_GPL(smscore_get_board_id);
  84
  85 struct smscore_registry_entry_t {
  86         struct list_head entry;
  87         char                    devpath[32];
  88         int                             mode;
  89         enum sms_device_type_st type;
  90 };
  91
  92 static struct list_head g_smscore_notifyees;
  93 static struct list_head g_smscore_devices;
  94 static struct mutex g_smscore_deviceslock;
  95
  96 static struct list_head g_smscore_registry;
  97 static struct mutex g_smscore_registrylock;
  98
  99 static int default_mode = 4;
 100
 101 module_param(default_mode, int, 0644);
 102 MODULE_PARM_DESC(default_mode, "default firmware id (device mode)");
 103
 104 static struct smscore_registry_entry_t *smscore_find_registry(char *devpath)
 105 {
 106         struct smscore_registry_entry_t *entry;
 107         struct list_head *next;
 108
 109         kmutex_lock(&g_smscore_registrylock);
 110         for (next = g_smscore_registry.next;
 111              next != &g_smscore_registry;
 112              next = next->next) {
 113                 entry = (struct smscore_registry_entry_t *) next;
 114                 if (!strcmp(entry->devpath, devpath)) {
 115                         kmutex_unlock(&g_smscore_registrylock);
 116                         return entry;
 117                 }
 118         }
 119         entry = (struct smscore_registry_entry_t *)
 120                         kmalloc(sizeof(struct smscore_registry_entry_t),
 121                                 GFP_KERNEL);
 122         if (entry) {
 123                 entry->mode = default_mode;
 124                 strcpy(entry->devpath, devpath);
 125                 list_add(&entry->entry, &g_smscore_registry);
 126         } else
 127                 sms_err("failed to create smscore_registry.");
 128         kmutex_unlock(&g_smscore_registrylock);
 129         return entry;
 130 }
 131
 132 int smscore_registry_getmode(char *devpath)
 133 {
 134         struct smscore_registry_entry_t *entry;
 135
 136         entry = smscore_find_registry(devpath);
 137         if (entry)
 138                 return entry->mode;
 139         else
 140                 sms_err("No registry found.");
 141
 142         return default_mode;
 143 }
 144 EXPORT_SYMBOL_GPL(smscore_registry_getmode);
 145
 146 static enum sms_device_type_st smscore_registry_gettype(char *devpath)
 147 {
 148         struct smscore_registry_entry_t *entry;
 149
 150         entry = smscore_find_registry(devpath);
 151         if (entry)
 152                 return entry->type;
 153         else
 154                 sms_err("No registry found.");
 155
 156         return -1;
 157 }
 158
 159 void smscore_registry_setmode(char *devpath, int mode)
 160 {
 161         struct smscore_registry_entry_t *entry;
 162
 163         entry = smscore_find_registry(devpath);
 164         if (entry)
 165                 entry->mode = mode;
 166         else
 167                 sms_err("No registry found.");
 168 }
 169
 170 static void smscore_registry_settype(char *devpath,
 171                                      enum sms_device_type_st type)
 172 {
 173         struct smscore_registry_entry_t *entry;
 174
 175         entry = smscore_find_registry(devpath);
 176         if (entry)
 177                 entry->type = type;
 178         else
 179                 sms_err("No registry found.");
 180 }
 181
 182
 183 static void list_add_locked(struct list_head *new, struct list_head *head,
 184                             spinlock_t *lock)
 185 {
 186         unsigned long flags;
 187
 188         spin_lock_irqsave(lock, flags);
 189
 190         list_add(new, head);
 191
 192         spin_unlock_irqrestore(lock, flags);
 193 }
 194
 195 /**
 196  * register a client callback that called when device plugged in/unplugged
 197  * NOTE: if devices exist callback is called immediately for each device
 198  *
 199  * @param hotplug callback
 200  *
 201  * @return 0 on success, <0 on error.
 202  */
 203 int smscore_register_hotplug(hotplug_t hotplug)
 204 {
 205         struct smscore_device_notifyee_t *notifyee;
 206         struct list_head *next, *first;
 207         int rc = 0;
 208
 209         kmutex_lock(&g_smscore_deviceslock);
 210
 211         notifyee = kmalloc(sizeof(struct smscore_device_notifyee_t),
 212                            GFP_KERNEL);
 213         if (notifyee) {
 214                 /* now notify callback about existing devices */
 215                 first = &g_smscore_devices;
 216                 for (next = first->next;
 217                      next != first && !rc;
 218                      next = next->next) {
 219                         struct smscore_device_t *coredev =
 220                                 (struct smscore_device_t *) next;
 221                         rc = hotplug(coredev, coredev->device, 1);
 222                 }
 223
 224                 if (rc >= 0) {
 225                         notifyee->hotplug = hotplug;
 226                         list_add(&notifyee->entry, &g_smscore_notifyees);
 227                 } else
 228                         kfree(notifyee);
 229         } else
 230                 rc = -ENOMEM;
 231
 232         kmutex_unlock(&g_smscore_deviceslock);
 233
 234         return rc;
 235 }
 236 EXPORT_SYMBOL_GPL(smscore_register_hotplug);
 237
 238 /**
 239  * unregister a client callback that called when device plugged in/unplugged
 240  *
 241  * @param hotplug callback
 242  *
 243  */
 244 void smscore_unregister_hotplug(hotplug_t hotplug)
 245 {
 246         struct list_head *next, *first;
 247
 248         kmutex_lock(&g_smscore_deviceslock);
 249
 250         first = &g_smscore_notifyees;
 251
 252         for (next = first->next; next != first;) {
 253                 struct smscore_device_notifyee_t *notifyee =
 254                         (struct smscore_device_notifyee_t *) next;
 255                 next = next->next;
 256
 257                 if (notifyee->hotplug == hotplug) {
 258                         list_del(&notifyee->entry);
 259                         kfree(notifyee);
 260                 }
 261         }
 262
 263         kmutex_unlock(&g_smscore_deviceslock);
 264 }
 265 EXPORT_SYMBOL_GPL(smscore_unregister_hotplug);
 266
 267 static void smscore_notify_clients(struct smscore_device_t *coredev)
 268 {
 269         struct smscore_client_t *client;
 270
 271         /* the client must call smscore_unregister_client from remove handler */
 272         while (!list_empty(&coredev->clients)) {
 273                 client = (struct smscore_client_t *) coredev->clients.next;
 274                 client->onremove_handler(client->context);
 275         }
 276 }
 277
 278 static int smscore_notify_callbacks(struct smscore_device_t *coredev,
 279                                     struct device *device, int arrival)
 280 {
 281         struct list_head *next, *first;
 282         int rc = 0;
 283
 284         /* note: must be called under g_deviceslock */
 285
 286         first = &g_smscore_notifyees;
 287
 288         for (next = first->next; next != first; next = next->next) {
 289                 rc = ((struct smscore_device_notifyee_t *) next)->
 290                                 hotplug(coredev, device, arrival);
 291                 if (rc < 0)
 292                         break;
 293         }
 294
 295         return rc;
 296 }
 297
 298 static struct
 299 smscore_buffer_t *smscore_createbuffer(u8 *buffer, void *common_buffer,
 300                                        dma_addr_t common_buffer_phys)
 301 {
 302         struct smscore_buffer_t *cb =
 303                 kmalloc(sizeof(struct smscore_buffer_t), GFP_KERNEL);
 304         if (!cb) {
 305                 sms_info("kmalloc(...) failed");
 306                 return NULL;
 307         }
 308
 309         cb->p = buffer;
 310         cb->offset_in_common = buffer - (u8 *) common_buffer;
 311         cb->phys = common_buffer_phys + cb->offset_in_common;
 312
 313         return cb;
 314 }
 315
 316 /**
 317  * creates coredev object for a device, prepares buffers,
 318  * creates buffer mappings, notifies registered hotplugs about new device.
 319  *
 320  * @param params device pointer to struct with device specific parameters
 321  *               and handlers
 322  * @param coredev pointer to a value that receives created coredev object
 323  *
 324  * @return 0 on success, <0 on error.
 325  */
 326 int smscore_register_device(struct smsdevice_params_t *params,
 327                             struct smscore_device_t **coredev)
 328 {
 329         struct smscore_device_t *dev;
 330         u8 *buffer;
 331
 332         dev = kzalloc(sizeof(struct smscore_device_t), GFP_KERNEL);
 333         if (!dev) {
 334                 sms_info("kzalloc(...) failed");
 335                 return -ENOMEM;
 336         }
 337
 338         /* init list entry so it could be safe in smscore_unregister_device */
 339         INIT_LIST_HEAD(&dev->entry);
 340
 341         /* init queues */
 342         INIT_LIST_HEAD(&dev->clients);
 343         INIT_LIST_HEAD(&dev->buffers);
 344
 345         /* init locks */
 346         spin_lock_init(&dev->clientslock);
 347         spin_lock_init(&dev->bufferslock);
 348
 349         /* init completion events */
 350         init_completion(&dev->version_ex_done);
 351         init_completion(&dev->data_download_done);
 352         init_completion(&dev->trigger_done);
 353         init_completion(&dev->init_device_done);
 354         init_completion(&dev->reload_start_done);
 355         init_completion(&dev->resume_done);
 356         init_completion(&dev->gpio_configuration_done);
 357         init_completion(&dev->gpio_set_level_done);
 358         init_completion(&dev->gpio_get_level_done);
 359         init_completion(&dev->ir_init_done);
 360
 361         /* Buffer management */
 362         init_waitqueue_head(&dev->buffer_mng_waitq);
 363
 364         /* alloc common buffer */
 365         dev->common_buffer_size = params->buffer_size * params->num_buffers;
 366         dev->common_buffer = dma_alloc_coherent(NULL, dev->common_buffer_size,
 367                                                 &dev->common_buffer_phys,
 368                                                 GFP_KERNEL | GFP_DMA);
 369         if (!dev->common_buffer) {
 370                 smscore_unregister_device(dev);
 371                 return -ENOMEM;
 372         }
 373
 374         /* prepare dma buffers */
 375         for (buffer = dev->common_buffer;
 376              dev->num_buffers < params->num_buffers;
 377              dev->num_buffers++, buffer += params->buffer_size) {
 378                 struct smscore_buffer_t *cb =
 379                         smscore_createbuffer(buffer, dev->common_buffer,
 380                                              dev->common_buffer_phys);
 381                 if (!cb) {
 382                         smscore_unregister_device(dev);
 383                         return -ENOMEM;
 384                 }
 385
 386                 smscore_putbuffer(dev, cb);
 387         }
 388
 389         sms_info("allocated %d buffers", dev->num_buffers);
 390
 391         dev->mode = DEVICE_MODE_NONE;
 392         dev->context = params->context;
 393         dev->device = params->device;
 394         dev->setmode_handler = params->setmode_handler;
 395         dev->detectmode_handler = params->detectmode_handler;
 396         dev->sendrequest_handler = params->sendrequest_handler;
 397         dev->preload_handler = params->preload_handler;
 398         dev->postload_handler = params->postload_handler;
 399
 400         dev->device_flags = params->flags;
 401         strcpy(dev->devpath, params->devpath);
 402
 403         smscore_registry_settype(dev->devpath, params->device_type);
 404
 405         /* add device to devices list */
 406         kmutex_lock(&g_smscore_deviceslock);
 407         list_add(&dev->entry, &g_smscore_devices);
 408         kmutex_unlock(&g_smscore_deviceslock);
 409
 410         *coredev = dev;
 411
 412         sms_info("device %p created", dev);
 413
 414         return 0;
 415 }
 416 EXPORT_SYMBOL_GPL(smscore_register_device);
 417
 418
 419 static int smscore_sendrequest_and_wait(struct smscore_device_t *coredev,
 420                 void *buffer, size_t size, struct completion *completion) {
 421         int rc = coredev->sendrequest_handler(coredev->context, buffer, size);
 422         if (rc < 0) {
 423                 sms_info("sendrequest returned error %d", rc);
 424                 return rc;
 425         }
 426
 427         return wait_for_completion_timeout(completion,
 428                         msecs_to_jiffies(SMS_PROTOCOL_MAX_RAOUNDTRIP_MS)) ?
 429                         0 : -ETIME;
 430 }
 431
 432 /**
 433  * Starts & enables IR operations
 434  *
 435  * @return 0 on success, < 0 on error.
 436  */
 437 static int smscore_init_ir(struct smscore_device_t *coredev)
 438 {
 439         int ir_io;
 440         int rc;
 441         void *buffer;
 442
 443         coredev->ir.input_dev = NULL;
 444         ir_io = sms_get_board(smscore_get_board_id(coredev))->board_cfg.ir;
 445         if (ir_io) {/* only if IR port exist we use IR sub-module */
 446                 sms_info("IR loading");
 447                 rc = sms_ir_init(coredev);
 448
 449                 if      (rc != 0)
 450                         sms_err("Error initialization DTV IR sub-module");
 451                 else {
 452                         buffer = kmalloc(sizeof(struct SmsMsgData_ST2) +
 453                                                 SMS_DMA_ALIGNMENT,
 454                                                 GFP_KERNEL | GFP_DMA);
 455                         if (buffer) {
 456                                 struct SmsMsgData_ST2 *msg =
 457                                 (struct SmsMsgData_ST2 *)
 458                                 SMS_ALIGN_ADDRESS(buffer);
 459
 460                                 SMS_INIT_MSG(&msg->xMsgHeader,
 461                                                 MSG_SMS_START_IR_REQ,
 462                                                 sizeof(struct SmsMsgData_ST2));
 463                                 msg->msgData[0] = coredev->ir.controller;
 464                                 msg->msgData[1] = coredev->ir.timeout;
 465
 466                                 smsendian_handle_tx_message(
 467                                         (struct SmsMsgHdr_ST2 *)msg);
 468                                 rc = smscore_sendrequest_and_wait(coredev, msg,
 469                                                 msg->xMsgHeader. msgLength,
 470                                                 &coredev->ir_init_done);
 471
 472                                 kfree(buffer);
 473                         } else
 474                                 sms_err
 475                                 ("Sending IR initialization message failed");
 476                 }
 477         } else
 478                 sms_info("IR port has not been detected");
 479
 480         return 0;
 481 }
 482
 483 /**
 484  * sets initial device mode and notifies client hotplugs that device is ready
 485  *
 486  * @param coredev pointer to a coredev object returned by
 487  *                smscore_register_device
 488  *
 489  * @return 0 on success, <0 on error.
 490  */
 491 int smscore_start_device(struct smscore_device_t *coredev)
 492 {
 493         int rc = smscore_set_device_mode(
 494                         coredev, smscore_registry_getmode(coredev->devpath));
 495         if (rc < 0) {
 496                 sms_info("set device mode faile , rc %d", rc);
 497                 return rc;
 498         }
 499
 500         kmutex_lock(&g_smscore_deviceslock);
 501
 502         rc = smscore_notify_callbacks(coredev, coredev->device, 1);
 503         smscore_init_ir(coredev);
 504
 505         sms_info("device %p started, rc %d", coredev, rc);
 506
 507         kmutex_unlock(&g_smscore_deviceslock);
 508
 509         return rc;
 510 }
 511 EXPORT_SYMBOL_GPL(smscore_start_device);
 512
 513
 514 static int smscore_load_firmware_family2(struct smscore_device_t *coredev,
 515                                          void *buffer, size_t size)
 516 {
 517         struct SmsFirmware_ST *firmware = (struct SmsFirmware_ST *) buffer;
 518         struct SmsMsgHdr_ST *msg;
 519         u32 mem_address;
 520         u8 *payload = firmware->Payload;
 521         int rc = 0;
 522         firmware->StartAddress = le32_to_cpu(firmware->StartAddress);
 523         firmware->Length = le32_to_cpu(firmware->Length);
 524
 525         mem_address = firmware->StartAddress;
 526
 527         sms_info("loading FW to addr 0x%x size %d",
 528                  mem_address, firmware->Length);
 529         if (coredev->preload_handler) {
 530                 rc = coredev->preload_handler(coredev->context);
 531                 if (rc < 0)
 532                         return rc;
 533         }
 534
 535         /* PAGE_SIZE buffer shall be enough and dma aligned */
 536         msg = kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA);
 537         if (!msg)
 538                 return -ENOMEM;
 539
 540         if (coredev->mode != DEVICE_MODE_NONE) {
 541                 sms_debug("sending reload command.");
 542                 SMS_INIT_MSG(msg, MSG_SW_RELOAD_START_REQ,
 543                              sizeof(struct SmsMsgHdr_ST));
 544                 rc = smscore_sendrequest_and_wait(coredev, msg,
 545                                                   msg->msgLength,
 546                                                   &coredev->reload_start_done);
 547                 mem_address = *(u32 *) &payload[20];
 548         }
 549
 550         while (size && rc >= 0) {
 551                 struct SmsDataDownload_ST *DataMsg =
 552                         (struct SmsDataDownload_ST *) msg;
 553                 int payload_size = min((int) size, SMS_MAX_PAYLOAD_SIZE);
 554
 555                 SMS_INIT_MSG(msg, MSG_SMS_DATA_DOWNLOAD_REQ,
 556                              (u16)(sizeof(struct SmsMsgHdr_ST) +
 557                                       sizeof(u32) + payload_size));
 558
 559                 DataMsg->MemAddr = mem_address;
 560                 memcpy(DataMsg->Payload, payload, payload_size);
 561
 562                 if ((coredev->device_flags & SMS_ROM_NO_RESPONSE) &&
 563                     (coredev->mode == DEVICE_MODE_NONE))
 564                         rc = coredev->sendrequest_handler(
 565                                 coredev->context, DataMsg,
 566                                 DataMsg->xMsgHeader.msgLength);
 567                 else
 568                         rc = smscore_sendrequest_and_wait(
 569                                 coredev, DataMsg,
 570                                 DataMsg->xMsgHeader.msgLength,
 571                                 &coredev->data_download_done);
 572
 573                 payload += payload_size;
 574                 size -= payload_size;
 575                 mem_address += payload_size;
 576         }
 577
 578         if (rc >= 0) {
 579                 if (coredev->mode == DEVICE_MODE_NONE) {
 580                         struct SmsMsgData_ST *TriggerMsg =
 581                                 (struct SmsMsgData_ST *) msg;
 582
 583                         SMS_INIT_MSG(msg, MSG_SMS_SWDOWNLOAD_TRIGGER_REQ,
 584                                      sizeof(struct SmsMsgHdr_ST) +
 585                                      sizeof(u32) * 5);
 586
 587                         TriggerMsg->msgData[0] = firmware->StartAddress;
 588                                                 /* Entry point */
 589                         TriggerMsg->msgData[1] = 5; /* Priority */
 590                         TriggerMsg->msgData[2] = 0x200; /* Stack size */
 591                         TriggerMsg->msgData[3] = 0; /* Parameter */
 592                         TriggerMsg->msgData[4] = 4; /* Task ID */
 593
 594                         if (coredev->device_flags & SMS_ROM_NO_RESPONSE) {
 595                                 rc = coredev->sendrequest_handler(
 596                                         coredev->context, TriggerMsg,
 597                                         TriggerMsg->xMsgHeader.msgLength);
 598                                 msleep(100);
 599                         } else
 600                                 rc = smscore_sendrequest_and_wait(
 601                                         coredev, TriggerMsg,
 602                                         TriggerMsg->xMsgHeader.msgLength,
 603                                         &coredev->trigger_done);
 604                 } else {
 605                         SMS_INIT_MSG(msg, MSG_SW_RELOAD_EXEC_REQ,
 606                                      sizeof(struct SmsMsgHdr_ST));
 607
 608                         rc = coredev->sendrequest_handler(coredev->context,
 609                                                           msg, msg->msgLength);
 610                 }
 611                 msleep(500);
 612         }
 613
 614         sms_debug("rc=%d, postload=%p ", rc,
 615                   coredev->postload_handler);
 616
 617         kfree(msg);
 618
 619         return ((rc >= 0) && coredev->postload_handler) ?
 620                 coredev->postload_handler(coredev->context) :
 621                 rc;
 622 }
 623
 624 /**
 625  * loads specified firmware into a buffer and calls device loadfirmware_handler
 626  *
 627  * @param coredev pointer to a coredev object returned by
 628  *                smscore_register_device
 629  * @param filename null-terminated string specifies firmware file name
 630  * @param loadfirmware_handler device handler that loads firmware
 631  *
 632  * @return 0 on success, <0 on error.
 633  */
 634 static int smscore_load_firmware_from_file(struct smscore_device_t *coredev,
 635                                            char *filename,
 636                                            loadfirmware_t loadfirmware_handler)
 637 {
 638         int rc = -ENOENT;
 639         const struct firmware *fw;
 640         u8 *fw_buffer;
 641
 642         if (loadfirmware_handler == NULL && !(coredev->device_flags &
 643                                               SMS_DEVICE_FAMILY2))
 644                 return -EINVAL;
 645
 646         rc = request_firmware(&fw, filename, coredev->device);
 647         if (rc < 0) {
 648                 sms_info("failed to open \"%s\"", filename);
 649                 return rc;
 650         }
 651         sms_info("read FW %s, size=%zd", filename, fw->size);
 652         fw_buffer = kmalloc(ALIGN(fw->size, SMS_ALLOC_ALIGNMENT),
 653                             GFP_KERNEL | GFP_DMA);
 654         if (fw_buffer) {
 655                 memcpy(fw_buffer, fw->data, fw->size);
 656
 657                 rc = (coredev->device_flags & SMS_DEVICE_FAMILY2) ?
 658                       smscore_load_firmware_family2(coredev,
 659                                                     fw_buffer,
 660                                                     fw->size) :
 661                       loadfirmware_handler(coredev->context,
 662                                            fw_buffer, fw->size);
 663
 664                 kfree(fw_buffer);
 665         } else {
 666                 sms_info("failed to allocate firmware buffer");
 667                 rc = -ENOMEM;
 668         }
 669
 670         release_firmware(fw);
 671
 672         return rc;
 673 }
 674
 675 /**
 676  * notifies all clients registered with the device, notifies hotplugs,
 677  * frees all buffers and coredev object
 678  *
 679  * @param coredev pointer to a coredev object returned by
 680  *                smscore_register_device
 681  *
 682  * @return 0 on success, <0 on error.
 683  */
 684 void smscore_unregister_device(struct smscore_device_t *coredev)
 685 {
 686         struct smscore_buffer_t *cb;
 687         int num_buffers = 0;
 688         int retry = 0;
 689
 690         kmutex_lock(&g_smscore_deviceslock);
 691
 692         /* Release input device (IR) resources */
 693         sms_ir_exit(coredev);
 694
 695         smscore_notify_clients(coredev);
 696         smscore_notify_callbacks(coredev, NULL, 0);
 697
 698         /* at this point all buffers should be back
 699          * onresponse must no longer be called */
 700
 701         while (1) {
 702                 while (!list_empty(&coredev->buffers)) {
 703                         cb = (struct smscore_buffer_t *) coredev->buffers.next;
 704                         list_del(&cb->entry);
 705                         kfree(cb);
 706                         num_buffers++;
 707                 }
 708                 if (num_buffers == coredev->num_buffers)
 709                         break;
 710                 if (++retry > 10) {
 711                         sms_info("exiting although "
 712                                  "not all buffers released.");
 713                         break;
 714                 }
 715
 716                 sms_info("waiting for %d buffer(s)",
 717                          coredev->num_buffers - num_buffers);
 718                 msleep(100);
 719         }
 720
 721         sms_info("freed %d buffers", num_buffers);
 722
 723         if (coredev->common_buffer)
 724                 dma_free_coherent(NULL, coredev->common_buffer_size,
 725                         coredev->common_buffer, coredev->common_buffer_phys);
 726
 727         if (coredev->fw_buf != NULL)
 728                 kfree(coredev->fw_buf);
 729
 730         list_del(&coredev->entry);
 731         kfree(coredev);
 732
 733         kmutex_unlock(&g_smscore_deviceslock);
 734
 735         sms_info("device %p destroyed", coredev);
 736 }
 737 EXPORT_SYMBOL_GPL(smscore_unregister_device);
 738
 739 static int smscore_detect_mode(struct smscore_device_t *coredev)
 740 {
 741         void *buffer = kmalloc(sizeof(struct SmsMsgHdr_ST) + SMS_DMA_ALIGNMENT,
 742                                GFP_KERNEL | GFP_DMA);
 743         struct SmsMsgHdr_ST *msg =
 744                 (struct SmsMsgHdr_ST *) SMS_ALIGN_ADDRESS(buffer);
 745         int rc;
 746
 747         if (!buffer)
 748                 return -ENOMEM;
 749
 750         SMS_INIT_MSG(msg, MSG_SMS_GET_VERSION_EX_REQ,
 751                      sizeof(struct SmsMsgHdr_ST));
 752
 753         rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength,
 754                                           &coredev->version_ex_done);
 755         if (rc == -ETIME) {
 756                 sms_err("MSG_SMS_GET_VERSION_EX_REQ failed first try");
 757
 758                 if (wait_for_completion_timeout(&coredev->resume_done,
 759                                                 msecs_to_jiffies(5000))) {
 760                         rc = smscore_sendrequest_and_wait(
 761                                 coredev, msg, msg->msgLength,
 762                                 &coredev->version_ex_done);
 763                         if (rc < 0)
 764                                 sms_err("MSG_SMS_GET_VERSION_EX_REQ failed "
 765                                         "second try, rc %d", rc);
 766                 } else
 767                         rc = -ETIME;
 768         }
 769
 770         kfree(buffer);
 771
 772         return rc;
 773 }
 774
 775 static char *smscore_fw_lkup[][SMS_NUM_OF_DEVICE_TYPES] = {
 776         /*Stellar               NOVA A0         Nova B0         VEGA*/
 777         /*DVBT*/
 778         {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"},
 779         /*DVBH*/
 780         {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"},
 781         /*TDMB*/
 782         {"none", "tdmb_nova_12mhz.inp", "tdmb_nova_12mhz_b0.inp", "none"},
 783         /*DABIP*/
 784         {"none", "none", "none", "none"},
 785         /*BDA*/
 786         {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"},
 787         /*ISDBT*/
 788         {"none", "isdbt_nova_12mhz.inp", "isdbt_nova_12mhz_b0.inp", "none"},
 789         /*ISDBTBDA*/
 790         {"none", "isdbt_nova_12mhz.inp", "isdbt_nova_12mhz_b0.inp", "none"},
 791         /*CMMB*/
 792         {"none", "none", "none", "cmmb_vega_12mhz.inp"}
 793 };
 794
 795 static inline char *sms_get_fw_name(struct smscore_device_t *coredev,
 796                                     int mode, enum sms_device_type_st type)
 797 {
 798         char **fw = sms_get_board(smscore_get_board_id(coredev))->fw;
 799         return (fw && fw[mode]) ? fw[mode] : smscore_fw_lkup[mode][type];
 800 }
 801
 802 /**
 803  * calls device handler to change mode of operation
 804  * NOTE: stellar/usb may disconnect when changing mode
 805  *
 806  * @param coredev pointer to a coredev object returned by
 807  *                smscore_register_device
 808  * @param mode requested mode of operation
 809  *
 810  * @return 0 on success, <0 on error.
 811  */
 812 int smscore_set_device_mode(struct smscore_device_t *coredev, int mode)
 813 {
 814         void *buffer;
 815         int rc = 0;
 816         enum sms_device_type_st type;
 817
 818         sms_debug("set device mode to %d", mode);
 819         if (coredev->device_flags & SMS_DEVICE_FAMILY2) {
 820                 if (mode < DEVICE_MODE_DVBT || mode >= DEVICE_MODE_RAW_TUNER) {
 821                         sms_err("invalid mode specified %d", mode);
 822                         return -EINVAL;
 823                 }
 824
 825                 smscore_registry_setmode(coredev->devpath, mode);
 826
 827                 if (!(coredev->device_flags & SMS_DEVICE_NOT_READY)) {
 828                         rc = smscore_detect_mode(coredev);
 829                         if (rc < 0) {
 830                                 sms_err("mode detect failed %d", rc);
 831                                 return rc;
 832                         }
 833                 }
 834
 835                 if (coredev->mode == mode) {
 836                         sms_info("device mode %d already set", mode);
 837                         return 0;
 838                 }
 839
 840                 if (!(coredev->modes_supported & (1 << mode))) {
 841                         char *fw_filename;
 842
 843                         type = smscore_registry_gettype(coredev->devpath);
 844                         fw_filename = sms_get_fw_name(coredev, mode, type);
 845
 846                         rc = smscore_load_firmware_from_file(coredev,
 847                                                              fw_filename, NULL);
 848                         if (rc < 0) {
 849                                 sms_warn("error %d loading firmware: %s, "
 850                                          "trying again with default firmware",
 851                                          rc, fw_filename);
 852
 853                                 /* try again with the default firmware */
 854                                 fw_filename = smscore_fw_lkup[mode][type];
 855                                 rc = smscore_load_firmware_from_file(coredev,
 856                                                              fw_filename, NULL);
 857
 858                                 if (rc < 0) {
 859                                         sms_warn("error %d loading "
 860                                                  "firmware: %s", rc,
 861                                                  fw_filename);
 862                                         return rc;
 863                                 }
 864                         }
 865                         sms_log("firmware download success: %s", fw_filename);
 866                 } else
 867                         sms_info("mode %d supported by running "
 868                                  "firmware", mode);
 869
 870                 buffer = kmalloc(sizeof(struct SmsMsgData_ST) +
 871                                  SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA);
 872                 if (buffer) {
 873                         struct SmsMsgData_ST *msg =
 874                                 (struct SmsMsgData_ST *)
 875                                         SMS_ALIGN_ADDRESS(buffer);
 876
 877                         SMS_INIT_MSG(&msg->xMsgHeader, MSG_SMS_INIT_DEVICE_REQ,
 878                                      sizeof(struct SmsMsgData_ST));
 879                         msg->msgData[0] = mode;
 880
 881                         rc = smscore_sendrequest_and_wait(
 882                                 coredev, msg, msg->xMsgHeader.msgLength,
 883                                 &coredev->init_device_done);
 884
 885                         kfree(buffer);
 886                 } else {
 887                         sms_err("Could not allocate buffer for "
 888                                 "init device message.");
 889                         rc = -ENOMEM;
 890                 }
 891         } else {
 892                 if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) {
 893                         sms_err("invalid mode specified %d", mode);
 894                         return -EINVAL;
 895                 }
 896
 897                 smscore_registry_setmode(coredev->devpath, mode);
 898
 899                 if (coredev->detectmode_handler)
 900                         coredev->detectmode_handler(coredev->context,
 901                                                     &coredev->mode);
 902
 903                 if (coredev->mode != mode && coredev->setmode_handler)
 904                         rc = coredev->setmode_handler(coredev->context, mode);
 905         }
 906
 907         if (rc >= 0) {
 908                 coredev->mode = mode;
 909                 coredev->device_flags &= ~SMS_DEVICE_NOT_READY;
 910         }
 911
 912         if (rc < 0)
 913                 sms_err("return error code %d.", rc);
 914         return rc;
 915 }
 916
 917 /**
 918  * calls device handler to get current mode of operation
 919  *
 920  * @param coredev pointer to a coredev object returned by
 921  *                smscore_register_device
 922  *
 923  * @return current mode
 924  */
 925 int smscore_get_device_mode(struct smscore_device_t *coredev)
 926 {
 927         return coredev->mode;
 928 }
 929 EXPORT_SYMBOL_GPL(smscore_get_device_mode);
 930
 931 /**
 932  * find client by response id & type within the clients list.
 933  * return client handle or NULL.
 934  *
 935  * @param coredev pointer to a coredev object returned by
 936  *                smscore_register_device
 937  * @param data_type client data type (SMS_DONT_CARE for all types)
 938  * @param id client id (SMS_DONT_CARE for all id)
 939  *
 940  */
 941 static struct
 942 smscore_client_t *smscore_find_client(struct smscore_device_t *coredev,
 943                                       int data_type, int id)
 944 {
 945         struct smscore_client_t *client = NULL;
 946         struct list_head *next, *first;
 947         unsigned long flags;
 948         struct list_head *firstid, *nextid;
 949
 950
 951         spin_lock_irqsave(&coredev->clientslock, flags);
 952         first = &coredev->clients;
 953         for (next = first->next;
 954              (next != first) && !client;
 955              next = next->next) {
 956                 firstid = &((struct smscore_client_t *)next)->idlist;
 957                 for (nextid = firstid->next;
 958                      nextid != firstid;
 959                      nextid = nextid->next) {
 960                         if ((((struct smscore_idlist_t *)nextid)->id == id) &&
 961                             (((struct smscore_idlist_t *)nextid)->data_type == data_type ||
 962                             (((struct smscore_idlist_t *)nextid)->data_type == 0))) {
 963                                 client = (struct smscore_client_t *) next;
 964                                 break;
 965                         }
 966                 }
 967         }
 968         spin_unlock_irqrestore(&coredev->clientslock, flags);
 969         return client;
 970 }
 971
 972 /**
 973  * find client by response id/type, call clients onresponse handler
 974  * return buffer to pool on error
 975  *
 976  * @param coredev pointer to a coredev object returned by
 977  *                smscore_register_device
 978  * @param cb pointer to response buffer descriptor
 979  *
 980  */
 981 void smscore_onresponse(struct smscore_device_t *coredev,
 982                 struct smscore_buffer_t *cb) {
 983         struct SmsMsgHdr_ST *phdr = (struct SmsMsgHdr_ST *) ((u8 *) cb->p
 984                         + cb->offset);
 985         struct smscore_client_t *client;
 986         int rc = -EBUSY;
 987         static unsigned long last_sample_time; /* = 0; */
 988         static int data_total; /* = 0; */
 989         unsigned long time_now = jiffies_to_msecs(jiffies);
 990
 991         if (!last_sample_time)
 992                 last_sample_time = time_now;
 993
 994         if (time_now - last_sample_time > 10000) {
 995                 sms_debug("\ndata rate %d bytes/secs",
 996                           (int)((data_total * 1000) /
 997                                 (time_now - last_sample_time)));
 998
 999                 last_sample_time = time_now;
1000                 data_total = 0;
1001         }
1002
1003         data_total += cb->size;
1004         /* Do we need to re-route? */
1005         if ((phdr->msgType == MSG_SMS_HO_PER_SLICES_IND) ||
1006                         (phdr->msgType == MSG_SMS_TRANSMISSION_IND)) {
1007                 if (coredev->mode == DEVICE_MODE_DVBT_BDA)
1008                         phdr->msgDstId = DVBT_BDA_CONTROL_MSG_ID;
1009         }
1010
1011
1012         client = smscore_find_client(coredev, phdr->msgType, phdr->msgDstId);
1013
1014         /* If no client registered for type & id,
1015          * check for control client where type is not registered */
1016         if (client)
1017                 rc = client->onresponse_handler(client->context, cb);
1018
1019         if (rc < 0) {
1020                 switch (phdr->msgType) {
1021                 case MSG_SMS_GET_VERSION_EX_RES:
1022                 {
1023                         struct SmsVersionRes_ST *ver =
1024                                 (struct SmsVersionRes_ST *) phdr;
1025                         sms_debug("MSG_SMS_GET_VERSION_EX_RES "
1026                                   "id %d prots 0x%x ver %d.%d",
1027                                   ver->FirmwareId, ver->SupportedProtocols,
1028                                   ver->RomVersionMajor, ver->RomVersionMinor);
1029
1030                         coredev->mode = ver->FirmwareId == 255 ?
1031                                 DEVICE_MODE_NONE : ver->FirmwareId;
1032                         coredev->modes_supported = ver->SupportedProtocols;
1033
1034                         complete(&coredev->version_ex_done);
1035                         break;
1036                 }
1037                 case MSG_SMS_INIT_DEVICE_RES:
1038                         sms_debug("MSG_SMS_INIT_DEVICE_RES");
1039                         complete(&coredev->init_device_done);
1040                         break;
1041                 case MSG_SW_RELOAD_START_RES:
1042                         sms_debug("MSG_SW_RELOAD_START_RES");
1043                         complete(&coredev->reload_start_done);
1044                         break;
1045                 case MSG_SMS_DATA_DOWNLOAD_RES:
1046                         complete(&coredev->data_download_done);
1047                         break;
1048                 case MSG_SW_RELOAD_EXEC_RES:
1049                         sms_debug("MSG_SW_RELOAD_EXEC_RES");
1050                         break;
1051                 case MSG_SMS_SWDOWNLOAD_TRIGGER_RES:
1052                         sms_debug("MSG_SMS_SWDOWNLOAD_TRIGGER_RES");
1053                         complete(&coredev->trigger_done);
1054                         break;
1055                 case MSG_SMS_SLEEP_RESUME_COMP_IND:
1056                         complete(&coredev->resume_done);
1057                         break;
1058                 case MSG_SMS_GPIO_CONFIG_EX_RES:
1059                         sms_debug("MSG_SMS_GPIO_CONFIG_EX_RES");
1060                         complete(&coredev->gpio_configuration_done);
1061                         break;
1062                 case MSG_SMS_GPIO_SET_LEVEL_RES:
1063                         sms_debug("MSG_SMS_GPIO_SET_LEVEL_RES");
1064                         complete(&coredev->gpio_set_level_done);
1065                         break;
1066                 case MSG_SMS_GPIO_GET_LEVEL_RES:
1067                 {
1068                         u32 *msgdata = (u32 *) phdr;
1069                         coredev->gpio_get_res = msgdata[1];
1070                         sms_debug("MSG_SMS_GPIO_GET_LEVEL_RES gpio level %d",
1071                                         coredev->gpio_get_res);
1072                         complete(&coredev->gpio_get_level_done);
1073                         break;
1074                 }
1075                 case MSG_SMS_START_IR_RES:
1076                         complete(&coredev->ir_init_done);
1077                         break;
1078                 case MSG_SMS_IR_SAMPLES_IND:
1079                         sms_ir_event(coredev,
1080                                 (const char *)
1081                                 ((char *)phdr
1082                                 + sizeof(struct SmsMsgHdr_ST)),
1083                                 (int)phdr->msgLength
1084                                 - sizeof(struct SmsMsgHdr_ST));
1085                         break;
1086
1087                 default:
1088                         break;
1089                 }
1090                 smscore_putbuffer(coredev, cb);
1091         }
1092 }
1093 EXPORT_SYMBOL_GPL(smscore_onresponse);
1094
1095 /**
1096  * return pointer to next free buffer descriptor from core pool
1097  *
1098  * @param coredev pointer to a coredev object returned by
1099  *                smscore_register_device
1100  *
1101  * @return pointer to descriptor on success, NULL on error.
1102  */
1103 struct smscore_buffer_t *smscore_getbuffer(struct smscore_device_t *coredev)
1104 {
1105         struct smscore_buffer_t *cb = NULL;
1106         unsigned long flags;
1107
1108         DEFINE_WAIT(wait);
1109
1110         spin_lock_irqsave(&coredev->bufferslock, flags);
1111
1112         /* This function must return a valid buffer, since the buffer list is
1113          * finite, we check that there is an available buffer, if not, we wait
1114          * until such buffer become available.
1115          */
1116
1117         prepare_to_wait(&coredev->buffer_mng_waitq, &wait, TASK_INTERRUPTIBLE);
1118
1119         if (list_empty(&coredev->buffers))
1120                 schedule();
1121
1122         finish_wait(&coredev->buffer_mng_waitq, &wait);
1123
1124         cb = (struct smscore_buffer_t *) coredev->buffers.next;
1125         list_del(&cb->entry);
1126
1127         spin_unlock_irqrestore(&coredev->bufferslock, flags);
1128
1129         return cb;
1130 }
1131 EXPORT_SYMBOL_GPL(smscore_getbuffer);
1132
1133 /**
1134  * return buffer descriptor to a pool
1135  *
1136  * @param coredev pointer to a coredev object returned by
1137  *                smscore_register_device
1138  * @param cb pointer buffer descriptor
1139  *
1140  */
1141 void smscore_putbuffer(struct smscore_device_t *coredev,
1142                 struct smscore_buffer_t *cb) {
1143         wake_up_interruptible(&coredev->buffer_mng_waitq);
1144         list_add_locked(&cb->entry, &coredev->buffers, &coredev->bufferslock);
1145 }
1146 EXPORT_SYMBOL_GPL(smscore_putbuffer);
1147
1148 static int smscore_validate_client(struct smscore_device_t *coredev,
1149                                    struct smscore_client_t *client,
1150                                    int data_type, int id)
1151 {
1152         struct smscore_idlist_t *listentry;
1153         struct smscore_client_t *registered_client;
1154
1155         if (!client) {
1156                 sms_err("bad parameter.");
1157                 return -EFAULT;
1158         }
1159         registered_client = smscore_find_client(coredev, data_type, id);
1160         if (registered_client == client)
1161                 return 0;
1162
1163         if (registered_client) {
1164                 sms_err("The msg ID already registered to another client.");
1165                 return -EEXIST;
1166         }
1167         listentry = kzalloc(sizeof(struct smscore_idlist_t), GFP_KERNEL);
1168         if (!listentry) {
1169                 sms_err("Can't allocate memory for client id.");
1170                 return -ENOMEM;
1171         }
1172         listentry->id = id;
1173         listentry->data_type = data_type;
1174         list_add_locked(&listentry->entry, &client->idlist,
1175                         &coredev->clientslock);
1176         return 0;
1177 }
1178
1179 /**
1180  * creates smsclient object, check that id is taken by another client
1181  *
1182  * @param coredev pointer to a coredev object from clients hotplug
1183  * @param initial_id all messages with this id would be sent to this client
1184  * @param data_type all messages of this type would be sent to this client
1185  * @param onresponse_handler client handler that is called to
1186  *                           process incoming messages
1187  * @param onremove_handler client handler that is called when device is removed
1188  * @param context client-specific context
1189  * @param client pointer to a value that receives created smsclient object
1190  *
1191  * @return 0 on success, <0 on error.
1192  */
1193 int smscore_register_client(struct smscore_device_t *coredev,
1194                             struct smsclient_params_t *params,
1195                             struct smscore_client_t **client)
1196 {
1197         struct smscore_client_t *newclient;
1198         /* check that no other channel with same parameters exists */
1199         if (smscore_find_client(coredev, params->data_type,
1200                                 params->initial_id)) {
1201                 sms_err("Client already exist.");
1202                 return -EEXIST;
1203         }
1204
1205         newclient = kzalloc(sizeof(struct smscore_client_t), GFP_KERNEL);
1206         if (!newclient) {
1207                 sms_err("Failed to allocate memory for client.");
1208                 return -ENOMEM;
1209         }
1210
1211         INIT_LIST_HEAD(&newclient->idlist);
1212         newclient->coredev = coredev;
1213         newclient->onresponse_handler = params->onresponse_handler;
1214         newclient->onremove_handler = params->onremove_handler;
1215         newclient->context = params->context;
1216         list_add_locked(&newclient->entry, &coredev->clients,
1217                         &coredev->clientslock);
1218         smscore_validate_client(coredev, newclient, params->data_type,
1219                                 params->initial_id);
1220         *client = newclient;
1221         sms_debug("%p %d %d", params->context, params->data_type,
1222                   params->initial_id);
1223
1224         return 0;
1225 }
1226 EXPORT_SYMBOL_GPL(smscore_register_client);
1227
1228 /**
1229  * frees smsclient object and all subclients associated with it
1230  *
1231  * @param client pointer to smsclient object returned by
1232  *               smscore_register_client
1233  *
1234  */
1235 void smscore_unregister_client(struct smscore_client_t *client)
1236 {
1237         struct smscore_device_t *coredev = client->coredev;
1238         unsigned long flags;
1239
1240         spin_lock_irqsave(&coredev->clientslock, flags);
1241
1242
1243         while (!list_empty(&client->idlist)) {
1244                 struct smscore_idlist_t *identry =
1245                         (struct smscore_idlist_t *) client->idlist.next;
1246                 list_del(&identry->entry);
1247                 kfree(identry);
1248         }
1249
1250         sms_info("%p", client->context);
1251
1252         list_del(&client->entry);
1253         kfree(client);
1254
1255         spin_unlock_irqrestore(&coredev->clientslock, flags);
1256 }
1257 EXPORT_SYMBOL_GPL(smscore_unregister_client);
1258
1259 /**
1260  * verifies that source id is not taken by another client,
1261  * calls device handler to send requests to the device
1262  *
1263  * @param client pointer to smsclient object returned by
1264  *               smscore_register_client
1265  * @param buffer pointer to a request buffer
1266  * @param size size (in bytes) of request buffer
1267  *
1268  * @return 0 on success, <0 on error.
1269  */
1270 int smsclient_sendrequest(struct smscore_client_t *client,
1271                           void *buffer, size_t size)
1272 {
1273         struct smscore_device_t *coredev;
1274         struct SmsMsgHdr_ST *phdr = (struct SmsMsgHdr_ST *) buffer;
1275         int rc;
1276
1277         if (client == NULL) {
1278                 sms_err("Got NULL client");
1279                 return -EINVAL;
1280         }
1281
1282         coredev = client->coredev;
1283
1284         /* check that no other channel with same id exists */
1285         if (coredev == NULL) {
1286                 sms_err("Got NULL coredev");
1287                 return -EINVAL;
1288         }
1289
1290         rc = smscore_validate_client(client->coredev, client, 0,
1291                                      phdr->msgSrcId);
1292         if (rc < 0)
1293                 return rc;
1294
1295         return coredev->sendrequest_handler(coredev->context, buffer, size);
1296 }
1297 EXPORT_SYMBOL_GPL(smsclient_sendrequest);
1298
1299
1300 /* old GPIO managments implementation */
1301 int smscore_configure_gpio(struct smscore_device_t *coredev, u32 pin,
1302                            struct smscore_config_gpio *pinconfig)
1303 {
1304         struct {
1305                 struct SmsMsgHdr_ST hdr;
1306                 u32 data[6];
1307         } msg;
1308
1309         if (coredev->device_flags & SMS_DEVICE_FAMILY2) {
1310                 msg.hdr.msgSrcId = DVBT_BDA_CONTROL_MSG_ID;
1311                 msg.hdr.msgDstId = HIF_TASK;
1312                 msg.hdr.msgFlags = 0;
1313                 msg.hdr.msgType  = MSG_SMS_GPIO_CONFIG_EX_REQ;
1314                 msg.hdr.msgLength = sizeof(msg);
1315
1316                 msg.data[0] = pin;
1317                 msg.data[1] = pinconfig->pullupdown;
1318
1319                 /* Convert slew rate for Nova: Fast(0) = 3 / Slow(1) = 0; */
1320                 msg.data[2] = pinconfig->outputslewrate == 0 ? 3 : 0;
1321
1322                 switch (pinconfig->outputdriving) {
1323                 case SMS_GPIO_OUTPUTDRIVING_16mA:
1324                         msg.data[3] = 7; /* Nova - 16mA */
1325                         break;
1326                 case SMS_GPIO_OUTPUTDRIVING_12mA:
1327                         msg.data[3] = 5; /* Nova - 11mA */
1328                         break;
1329                 case SMS_GPIO_OUTPUTDRIVING_8mA:
1330                         msg.data[3] = 3; /* Nova - 7mA */
1331                         break;
1332                 case SMS_GPIO_OUTPUTDRIVING_4mA:
1333                 default:
1334                         msg.data[3] = 2; /* Nova - 4mA */
1335                         break;
1336                 }
1337
1338                 msg.data[4] = pinconfig->direction;
1339                 msg.data[5] = 0;
1340         } else /* TODO: SMS_DEVICE_FAMILY1 */
1341                 return -EINVAL;
1342
1343         return coredev->sendrequest_handler(coredev->context,
1344                                             &msg, sizeof(msg));
1345 }
1346
1347 int smscore_set_gpio(struct smscore_device_t *coredev, u32 pin, int level)
1348 {
1349         struct {
1350                 struct SmsMsgHdr_ST hdr;
1351                 u32 data[3];
1352         } msg;
1353
1354         if (pin > MAX_GPIO_PIN_NUMBER)
1355                 return -EINVAL;
1356
1357         msg.hdr.msgSrcId = DVBT_BDA_CONTROL_MSG_ID;
1358         msg.hdr.msgDstId = HIF_TASK;
1359         msg.hdr.msgFlags = 0;
1360         msg.hdr.msgType  = MSG_SMS_GPIO_SET_LEVEL_REQ;
1361         msg.hdr.msgLength = sizeof(msg);
1362
1363         msg.data[0] = pin;
1364         msg.data[1] = level ? 1 : 0;
1365         msg.data[2] = 0;
1366
1367         return coredev->sendrequest_handler(coredev->context,
1368                                             &msg, sizeof(msg));
1369 }
1370
1371 /* new GPIO management implementation */
1372 static int GetGpioPinParams(u32 PinNum, u32 *pTranslatedPinNum,
1373                 u32 *pGroupNum, u32 *pGroupCfg) {
1374
1375         *pGroupCfg = 1;
1376
1377         if (PinNum <= 1)        {
1378                 *pTranslatedPinNum = 0;
1379                 *pGroupNum = 9;
1380                 *pGroupCfg = 2;
1381         } else if (PinNum >= 2 && PinNum <= 6) {
1382                 *pTranslatedPinNum = 2;
1383                 *pGroupNum = 0;
1384                 *pGroupCfg = 2;
1385         } else if (PinNum >= 7 && PinNum <= 11) {
1386                 *pTranslatedPinNum = 7;
1387                 *pGroupNum = 1;
1388         } else if (PinNum >= 12 && PinNum <= 15) {
1389                 *pTranslatedPinNum = 12;
1390                 *pGroupNum = 2;
1391                 *pGroupCfg = 3;
1392         } else if (PinNum == 16) {
1393                 *pTranslatedPinNum = 16;
1394                 *pGroupNum = 23;
1395         } else if (PinNum >= 17 && PinNum <= 24) {
1396                 *pTranslatedPinNum = 17;
1397                 *pGroupNum = 3;
1398         } else if (PinNum == 25) {
1399                 *pTranslatedPinNum = 25;
1400                 *pGroupNum = 6;
1401         } else if (PinNum >= 26 && PinNum <= 28) {
1402                 *pTranslatedPinNum = 26;
1403                 *pGroupNum = 4;
1404         } else if (PinNum == 29) {
1405                 *pTranslatedPinNum = 29;
1406                 *pGroupNum = 5;
1407                 *pGroupCfg = 2;
1408         } else if (PinNum == 30) {
1409                 *pTranslatedPinNum = 30;
1410                 *pGroupNum = 8;
1411         } else if (PinNum == 31) {
1412                 *pTranslatedPinNum = 31;
1413                 *pGroupNum = 17;
1414         } else
1415                 return -1;
1416
1417         *pGroupCfg <<= 24;
1418
1419         return 0;
1420 }
1421
1422 int smscore_gpio_configure(struct smscore_device_t *coredev, u8 PinNum,
1423                 struct smscore_gpio_config *pGpioConfig) {
1424
1425         u32 totalLen;
1426         u32 TranslatedPinNum = 0;
1427         u32 GroupNum = 0;
1428         u32 ElectricChar;
1429         u32 groupCfg;
1430         void *buffer;
1431         int rc;
1432
1433         struct SetGpioMsg {
1434                 struct SmsMsgHdr_ST xMsgHeader;
1435                 u32 msgData[6];
1436         } *pMsg;
1437
1438
1439         if (PinNum > MAX_GPIO_PIN_NUMBER)
1440                 return -EINVAL;
1441
1442         if (pGpioConfig == NULL)
1443                 return -EINVAL;
1444
1445         totalLen = sizeof(struct SmsMsgHdr_ST) + (sizeof(u32) * 6);
1446
1447         buffer = kmalloc(totalLen + SMS_DMA_ALIGNMENT,
1448                         GFP_KERNEL | GFP_DMA);
1449         if (!buffer)
1450                 return -ENOMEM;
1451
1452         pMsg = (struct SetGpioMsg *) SMS_ALIGN_ADDRESS(buffer);
1453
1454         pMsg->xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID;
1455         pMsg->xMsgHeader.msgDstId = HIF_TASK;
1456         pMsg->xMsgHeader.msgFlags = 0;
1457         pMsg->xMsgHeader.msgLength = (u16) totalLen;
1458         pMsg->msgData[0] = PinNum;
1459
1460         if (!(coredev->device_flags & SMS_DEVICE_FAMILY2)) {
1461                 pMsg->xMsgHeader.msgType = MSG_SMS_GPIO_CONFIG_REQ;
1462                 if (GetGpioPinParams(PinNum, &TranslatedPinNum, &GroupNum,
1463                                 &groupCfg) != 0) {
1464                         rc = -EINVAL;
1465                         goto free;
1466                 }
1467
1468                 pMsg->msgData[1] = TranslatedPinNum;
1469                 pMsg->msgData[2] = GroupNum;
1470                 ElectricChar = (pGpioConfig->PullUpDown)
1471                                 | (pGpioConfig->InputCharacteristics << 2)
1472                                 | (pGpioConfig->OutputSlewRate << 3)
1473                                 | (pGpioConfig->OutputDriving << 4);
1474                 pMsg->msgData[3] = ElectricChar;
1475                 pMsg->msgData[4] = pGpioConfig->Direction;
1476                 pMsg->msgData[5] = groupCfg;
1477         } else {
1478                 pMsg->xMsgHeader.msgType = MSG_SMS_GPIO_CONFIG_EX_REQ;
1479                 pMsg->msgData[1] = pGpioConfig->PullUpDown;
1480                 pMsg->msgData[2] = pGpioConfig->OutputSlewRate;
1481                 pMsg->msgData[3] = pGpioConfig->OutputDriving;
1482                 pMsg->msgData[4] = pGpioConfig->Direction;
1483                 pMsg->msgData[5] = 0;
1484         }
1485
1486         smsendian_handle_tx_message((struct SmsMsgHdr_ST *)pMsg);
1487         rc = smscore_sendrequest_and_wait(coredev, pMsg, totalLen,
1488                         &coredev->gpio_configuration_done);
1489
1490         if (rc != 0) {
1491                 if (rc == -ETIME)
1492                         sms_err("smscore_gpio_configure timeout");
1493                 else
1494                         sms_err("smscore_gpio_configure error");
1495         }
1496 free:
1497         kfree(buffer);
1498
1499         return rc;
1500 }
1501
1502 int smscore_gpio_set_level(struct smscore_device_t *coredev, u8 PinNum,
1503                 u8 NewLevel) {
1504
1505         u32 totalLen;
1506         int rc;
1507         void *buffer;
1508
1509         struct SetGpioMsg {
1510                 struct SmsMsgHdr_ST xMsgHeader;
1511                 u32 msgData[3]; /* keep it 3 ! */
1512         } *pMsg;
1513
1514         if ((NewLevel > 1) || (PinNum > MAX_GPIO_PIN_NUMBER) ||
1515                         (PinNum > MAX_GPIO_PIN_NUMBER))
1516                 return -EINVAL;
1517
1518         totalLen = sizeof(struct SmsMsgHdr_ST) +
1519                         (3 * sizeof(u32)); /* keep it 3 ! */
1520
1521         buffer = kmalloc(totalLen + SMS_DMA_ALIGNMENT,
1522                         GFP_KERNEL | GFP_DMA);
1523         if (!buffer)
1524                 return -ENOMEM;
1525
1526         pMsg = (struct SetGpioMsg *) SMS_ALIGN_ADDRESS(buffer);
1527
1528         pMsg->xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID;
1529         pMsg->xMsgHeader.msgDstId = HIF_TASK;
1530         pMsg->xMsgHeader.msgFlags = 0;
1531         pMsg->xMsgHeader.msgType = MSG_SMS_GPIO_SET_LEVEL_REQ;
1532         pMsg->xMsgHeader.msgLength = (u16) totalLen;
1533         pMsg->msgData[0] = PinNum;
1534         pMsg->msgData[1] = NewLevel;
1535
1536         /* Send message to SMS */
1537         smsendian_handle_tx_message((struct SmsMsgHdr_ST *)pMsg);
1538         rc = smscore_sendrequest_and_wait(coredev, pMsg, totalLen,
1539                         &coredev->gpio_set_level_done);
1540
1541         if (rc != 0) {
1542                 if (rc == -ETIME)
1543                         sms_err("smscore_gpio_set_level timeout");
1544                 else
1545                         sms_err("smscore_gpio_set_level error");
1546         }
1547         kfree(buffer);
1548
1549         return rc;
1550 }
1551
1552 int smscore_gpio_get_level(struct smscore_device_t *coredev, u8 PinNum,
1553                 u8 *level) {
1554
1555         u32 totalLen;
1556         int rc;
1557         void *buffer;
1558
1559         struct SetGpioMsg {
1560                 struct SmsMsgHdr_ST xMsgHeader;
1561                 u32 msgData[2];
1562         } *pMsg;
1563
1564
1565         if (PinNum > MAX_GPIO_PIN_NUMBER)
1566                 return -EINVAL;
1567
1568         totalLen = sizeof(struct SmsMsgHdr_ST) + (2 * sizeof(u32));
1569
1570         buffer = kmalloc(totalLen + SMS_DMA_ALIGNMENT,
1571                         GFP_KERNEL | GFP_DMA);
1572         if (!buffer)
1573                 return -ENOMEM;
1574
1575         pMsg = (struct SetGpioMsg *) SMS_ALIGN_ADDRESS(buffer);
1576
1577         pMsg->xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID;
1578         pMsg->xMsgHeader.msgDstId = HIF_TASK;
1579         pMsg->xMsgHeader.msgFlags = 0;
1580         pMsg->xMsgHeader.msgType = MSG_SMS_GPIO_GET_LEVEL_REQ;
1581         pMsg->xMsgHeader.msgLength = (u16) totalLen;
1582         pMsg->msgData[0] = PinNum;
1583         pMsg->msgData[1] = 0;
1584
1585         /* Send message to SMS */
1586         smsendian_handle_tx_message((struct SmsMsgHdr_ST *)pMsg);
1587         rc = smscore_sendrequest_and_wait(coredev, pMsg, totalLen,
1588                         &coredev->gpio_get_level_done);
1589
1590         if (rc != 0) {
1591                 if (rc == -ETIME)
1592                         sms_err("smscore_gpio_get_level timeout");
1593                 else
1594                         sms_err("smscore_gpio_get_level error");
1595         }
1596         kfree(buffer);
1597
1598         /* Its a race between other gpio_get_level() and the copy of the single
1599          * global 'coredev->gpio_get_res' to  the function's variable 'level'
1600          */
1601         *level = coredev->gpio_get_res;
1602
1603         return rc;
1604 }
1605
1606 static int __init smscore_module_init(void)
1607 {
1608         int rc = 0;
1609
1610         INIT_LIST_HEAD(&g_smscore_notifyees);
1611         INIT_LIST_HEAD(&g_smscore_devices);
1612         kmutex_init(&g_smscore_deviceslock);
1613
1614         INIT_LIST_HEAD(&g_smscore_registry);
1615         kmutex_init(&g_smscore_registrylock);
1616
1617         return rc;
1618 }
1619
1620 static void __exit smscore_module_exit(void)
1621 {
1622         kmutex_lock(&g_smscore_deviceslock);
1623         while (!list_empty(&g_smscore_notifyees)) {
1624                 struct smscore_device_notifyee_t *notifyee =
1625                         (struct smscore_device_notifyee_t *)
1626                                 g_smscore_notifyees.next;
1627
1628                 list_del(&notifyee->entry);
1629                 kfree(notifyee);
1630         }
1631         kmutex_unlock(&g_smscore_deviceslock);
1632
1633         kmutex_lock(&g_smscore_registrylock);
1634         while (!list_empty(&g_smscore_registry)) {
1635                 struct smscore_registry_entry_t *entry =
1636                         (struct smscore_registry_entry_t *)
1637                                 g_smscore_registry.next;
1638
1639                 list_del(&entry->entry);
1640                 kfree(entry);
1641         }
1642         kmutex_unlock(&g_smscore_registrylock);
1643
1644         sms_debug("");
1645 }
1646
1647 module_init(smscore_module_init);
1648 module_exit(smscore_module_exit);
1649
1650 MODULE_DESCRIPTION("Siano MDTV Core module");
1651 MODULE_AUTHOR("Siano Mobile Silicon, Inc. (uris@siano-ms.com)");
1652 MODULE_LICENSE("GPL");