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