433 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * FireDTV driver -- firewire I/O backend4 */5 6#include <linux/device.h>7#include <linux/errno.h>8#include <linux/firewire.h>9#include <linux/firewire-constants.h>10#include <linux/kernel.h>11#include <linux/list.h>12#include <linux/mm.h>13#include <linux/mod_devicetable.h>14#include <linux/module.h>15#include <linux/mutex.h>16#include <linux/slab.h>17#include <linux/spinlock.h>18#include <linux/string.h>19#include <linux/types.h>20#include <linux/wait.h>21#include <linux/workqueue.h>22 23#include <asm/page.h>24 25#include <media/dvb_demux.h>26 27#include "firedtv.h"28 29static LIST_HEAD(node_list);30static DEFINE_SPINLOCK(node_list_lock);31 32static inline struct fw_device *device_of(struct firedtv *fdtv)33{34 return fw_device(fdtv->device->parent);35}36 37static int node_req(struct firedtv *fdtv, u64 addr, void *data, size_t len,38 int tcode)39{40 struct fw_device *device = device_of(fdtv);41 int rcode, generation = device->generation;42 43 smp_rmb(); /* node_id vs. generation */44 45 rcode = fw_run_transaction(device->card, tcode, device->node_id,46 generation, device->max_speed, addr, data, len);47 48 return rcode != RCODE_COMPLETE ? -EIO : 0;49}50 51int fdtv_lock(struct firedtv *fdtv, u64 addr, void *data)52{53 return node_req(fdtv, addr, data, 8, TCODE_LOCK_COMPARE_SWAP);54}55 56int fdtv_read(struct firedtv *fdtv, u64 addr, void *data)57{58 return node_req(fdtv, addr, data, 4, TCODE_READ_QUADLET_REQUEST);59}60 61int fdtv_write(struct firedtv *fdtv, u64 addr, void *data, size_t len)62{63 return node_req(fdtv, addr, data, len, TCODE_WRITE_BLOCK_REQUEST);64}65 66#define ISO_HEADER_SIZE 467#define CIP_HEADER_SIZE 868#define MPEG2_TS_HEADER_SIZE 469#define MPEG2_TS_SOURCE_PACKET_SIZE (4 + 188)70 71#define MAX_PACKET_SIZE 1024 /* 776, rounded up to 2^n */72#define PACKETS_PER_PAGE (PAGE_SIZE / MAX_PACKET_SIZE)73#define N_PACKETS 64 /* buffer size */74#define N_PAGES DIV_ROUND_UP(N_PACKETS, PACKETS_PER_PAGE)75#define IRQ_INTERVAL 1676 77struct fdtv_ir_context {78 struct fw_iso_context *context;79 struct fw_iso_buffer buffer;80 int interrupt_packet;81 int current_packet;82 char *pages[N_PAGES];83};84 85static int queue_iso(struct fdtv_ir_context *ctx, int index)86{87 struct fw_iso_packet p;88 89 p.payload_length = MAX_PACKET_SIZE;90 p.interrupt = !(++ctx->interrupt_packet & (IRQ_INTERVAL - 1));91 p.skip = 0;92 p.header_length = ISO_HEADER_SIZE;93 94 return fw_iso_context_queue(ctx->context, &p, &ctx->buffer,95 index * MAX_PACKET_SIZE);96}97 98static void handle_iso(struct fw_iso_context *context, u32 cycle,99 size_t header_length, void *header, void *data)100{101 struct firedtv *fdtv = data;102 struct fdtv_ir_context *ctx = fdtv->ir_context;103 __be32 *h, *h_end;104 int length, err, i = ctx->current_packet;105 char *p, *p_end;106 107 for (h = header, h_end = h + header_length / 4; h < h_end; h++) {108 length = be32_to_cpup(h) >> 16;109 if (unlikely(length > MAX_PACKET_SIZE)) {110 dev_err(fdtv->device, "length = %d\n", length);111 length = MAX_PACKET_SIZE;112 }113 114 p = ctx->pages[i / PACKETS_PER_PAGE]115 + (i % PACKETS_PER_PAGE) * MAX_PACKET_SIZE;116 p_end = p + length;117 118 for (p += CIP_HEADER_SIZE + MPEG2_TS_HEADER_SIZE; p < p_end;119 p += MPEG2_TS_SOURCE_PACKET_SIZE)120 dvb_dmx_swfilter_packets(&fdtv->demux, p, 1);121 122 err = queue_iso(ctx, i);123 if (unlikely(err))124 dev_err(fdtv->device, "requeue failed\n");125 126 i = (i + 1) & (N_PACKETS - 1);127 }128 fw_iso_context_queue_flush(ctx->context);129 ctx->current_packet = i;130}131 132int fdtv_start_iso(struct firedtv *fdtv)133{134 struct fdtv_ir_context *ctx;135 struct fw_device *device = device_of(fdtv);136 int i, err;137 138 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);139 if (!ctx)140 return -ENOMEM;141 142 ctx->context = fw_iso_context_create(device->card,143 FW_ISO_CONTEXT_RECEIVE, fdtv->isochannel,144 device->max_speed, ISO_HEADER_SIZE, handle_iso, fdtv);145 if (IS_ERR(ctx->context)) {146 err = PTR_ERR(ctx->context);147 goto fail_free;148 }149 150 err = fw_iso_buffer_init(&ctx->buffer, device->card,151 N_PAGES, DMA_FROM_DEVICE);152 if (err)153 goto fail_context_destroy;154 155 ctx->interrupt_packet = 0;156 ctx->current_packet = 0;157 158 for (i = 0; i < N_PAGES; i++)159 ctx->pages[i] = page_address(ctx->buffer.pages[i]);160 161 for (i = 0; i < N_PACKETS; i++) {162 err = queue_iso(ctx, i);163 if (err)164 goto fail;165 }166 167 err = fw_iso_context_start(ctx->context, -1, 0,168 FW_ISO_CONTEXT_MATCH_ALL_TAGS);169 if (err)170 goto fail;171 172 fdtv->ir_context = ctx;173 174 return 0;175fail:176 fw_iso_buffer_destroy(&ctx->buffer, device->card);177fail_context_destroy:178 fw_iso_context_destroy(ctx->context);179fail_free:180 kfree(ctx);181 182 return err;183}184 185void fdtv_stop_iso(struct firedtv *fdtv)186{187 struct fdtv_ir_context *ctx = fdtv->ir_context;188 189 fw_iso_context_stop(ctx->context);190 fw_iso_buffer_destroy(&ctx->buffer, device_of(fdtv)->card);191 fw_iso_context_destroy(ctx->context);192 kfree(ctx);193}194 195static void handle_fcp(struct fw_card *card, struct fw_request *request,196 int tcode, int destination, int source, int generation,197 unsigned long long offset, void *payload, size_t length,198 void *callback_data)199{200 struct firedtv *f, *fdtv = NULL;201 struct fw_device *device;202 unsigned long flags;203 int su;204 205 if (length < 2 || (((u8 *)payload)[0] & 0xf0) != 0)206 return;207 208 su = ((u8 *)payload)[1] & 0x7;209 210 spin_lock_irqsave(&node_list_lock, flags);211 list_for_each_entry(f, &node_list, list) {212 device = device_of(f);213 if (device->generation != generation)214 continue;215 216 smp_rmb(); /* node_id vs. generation */217 218 if (device->card == card &&219 device->node_id == source &&220 (f->subunit == su || (f->subunit == 0 && su == 0x7))) {221 fdtv = f;222 break;223 }224 }225 spin_unlock_irqrestore(&node_list_lock, flags);226 227 if (fdtv)228 avc_recv(fdtv, payload, length);229}230 231static struct fw_address_handler fcp_handler = {232 .length = CSR_FCP_END - CSR_FCP_RESPONSE,233 .address_callback = handle_fcp,234};235 236static const struct fw_address_region fcp_region = {237 .start = CSR_REGISTER_BASE + CSR_FCP_RESPONSE,238 .end = CSR_REGISTER_BASE + CSR_FCP_END,239};240 241static const char * const model_names[] = {242 [FIREDTV_UNKNOWN] = "unknown type",243 [FIREDTV_DVB_S] = "FireDTV S/CI",244 [FIREDTV_DVB_C] = "FireDTV C/CI",245 [FIREDTV_DVB_T] = "FireDTV T/CI",246 [FIREDTV_DVB_S2] = "FireDTV S2 ",247};248 249/* Adjust the template string if models with longer names appear. */250#define MAX_MODEL_NAME_LEN sizeof("FireDTV ????")251 252static int node_probe(struct fw_unit *unit, const struct ieee1394_device_id *id)253{254 struct firedtv *fdtv;255 char name[MAX_MODEL_NAME_LEN];256 int name_len, i, err;257 258 fdtv = kzalloc(sizeof(*fdtv), GFP_KERNEL);259 if (!fdtv)260 return -ENOMEM;261 262 dev_set_drvdata(&unit->device, fdtv);263 fdtv->device = &unit->device;264 fdtv->isochannel = -1;265 fdtv->voltage = 0xff;266 fdtv->tone = 0xff;267 268 mutex_init(&fdtv->avc_mutex);269 init_waitqueue_head(&fdtv->avc_wait);270 mutex_init(&fdtv->demux_mutex);271 INIT_WORK(&fdtv->remote_ctrl_work, avc_remote_ctrl_work);272 273 name_len = fw_csr_string(unit->directory, CSR_MODEL,274 name, sizeof(name));275 if (name_len < 0) {276 err = name_len;277 goto fail_free;278 }279 for (i = ARRAY_SIZE(model_names); --i; )280 if (strlen(model_names[i]) <= name_len &&281 strncmp(name, model_names[i], name_len) == 0)282 break;283 fdtv->type = i;284 285 err = fdtv_register_rc(fdtv, &unit->device);286 if (err)287 goto fail_free;288 289 spin_lock_irq(&node_list_lock);290 list_add_tail(&fdtv->list, &node_list);291 spin_unlock_irq(&node_list_lock);292 293 err = avc_identify_subunit(fdtv);294 if (err)295 goto fail;296 297 err = fdtv_dvb_register(fdtv, model_names[fdtv->type]);298 if (err)299 goto fail;300 301 avc_register_remote_control(fdtv);302 303 return 0;304fail:305 spin_lock_irq(&node_list_lock);306 list_del(&fdtv->list);307 spin_unlock_irq(&node_list_lock);308 fdtv_unregister_rc(fdtv);309fail_free:310 kfree(fdtv);311 312 return err;313}314 315static void node_remove(struct fw_unit *unit)316{317 struct firedtv *fdtv = dev_get_drvdata(&unit->device);318 319 fdtv_dvb_unregister(fdtv);320 321 spin_lock_irq(&node_list_lock);322 list_del(&fdtv->list);323 spin_unlock_irq(&node_list_lock);324 325 fdtv_unregister_rc(fdtv);326 327 kfree(fdtv);328}329 330static void node_update(struct fw_unit *unit)331{332 struct firedtv *fdtv = dev_get_drvdata(&unit->device);333 334 if (fdtv->isochannel >= 0)335 cmp_establish_pp_connection(fdtv, fdtv->subunit,336 fdtv->isochannel);337}338 339#define MATCH_FLAGS (IEEE1394_MATCH_VENDOR_ID | IEEE1394_MATCH_MODEL_ID | \340 IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION)341 342#define DIGITAL_EVERYWHERE_OUI 0x001287343#define AVC_UNIT_SPEC_ID_ENTRY 0x00a02d344#define AVC_SW_VERSION_ENTRY 0x010001345 346static const struct ieee1394_device_id fdtv_id_table[] = {347 {348 /* FloppyDTV S/CI and FloppyDTV S2 */349 .match_flags = MATCH_FLAGS,350 .vendor_id = DIGITAL_EVERYWHERE_OUI,351 .model_id = 0x000024,352 .specifier_id = AVC_UNIT_SPEC_ID_ENTRY,353 .version = AVC_SW_VERSION_ENTRY,354 }, {355 /* FloppyDTV T/CI */356 .match_flags = MATCH_FLAGS,357 .vendor_id = DIGITAL_EVERYWHERE_OUI,358 .model_id = 0x000025,359 .specifier_id = AVC_UNIT_SPEC_ID_ENTRY,360 .version = AVC_SW_VERSION_ENTRY,361 }, {362 /* FloppyDTV C/CI */363 .match_flags = MATCH_FLAGS,364 .vendor_id = DIGITAL_EVERYWHERE_OUI,365 .model_id = 0x000026,366 .specifier_id = AVC_UNIT_SPEC_ID_ENTRY,367 .version = AVC_SW_VERSION_ENTRY,368 }, {369 /* FireDTV S/CI and FloppyDTV S2 */370 .match_flags = MATCH_FLAGS,371 .vendor_id = DIGITAL_EVERYWHERE_OUI,372 .model_id = 0x000034,373 .specifier_id = AVC_UNIT_SPEC_ID_ENTRY,374 .version = AVC_SW_VERSION_ENTRY,375 }, {376 /* FireDTV T/CI */377 .match_flags = MATCH_FLAGS,378 .vendor_id = DIGITAL_EVERYWHERE_OUI,379 .model_id = 0x000035,380 .specifier_id = AVC_UNIT_SPEC_ID_ENTRY,381 .version = AVC_SW_VERSION_ENTRY,382 }, {383 /* FireDTV C/CI */384 .match_flags = MATCH_FLAGS,385 .vendor_id = DIGITAL_EVERYWHERE_OUI,386 .model_id = 0x000036,387 .specifier_id = AVC_UNIT_SPEC_ID_ENTRY,388 .version = AVC_SW_VERSION_ENTRY,389 }, {}390};391MODULE_DEVICE_TABLE(ieee1394, fdtv_id_table);392 393static struct fw_driver fdtv_driver = {394 .driver = {395 .owner = THIS_MODULE,396 .name = "firedtv",397 .bus = &fw_bus_type,398 },399 .probe = node_probe,400 .update = node_update,401 .remove = node_remove,402 .id_table = fdtv_id_table,403};404 405static int __init fdtv_init(void)406{407 int ret;408 409 ret = fw_core_add_address_handler(&fcp_handler, &fcp_region);410 if (ret < 0)411 return ret;412 413 ret = driver_register(&fdtv_driver.driver);414 if (ret < 0)415 fw_core_remove_address_handler(&fcp_handler);416 417 return ret;418}419 420static void __exit fdtv_exit(void)421{422 driver_unregister(&fdtv_driver.driver);423 fw_core_remove_address_handler(&fcp_handler);424}425 426module_init(fdtv_init);427module_exit(fdtv_exit);428 429MODULE_AUTHOR("Andreas Monitzer <andy@monitzer.com>");430MODULE_AUTHOR("Ben Backx <ben@bbackx.com>");431MODULE_DESCRIPTION("FireDTV DVB Driver");432MODULE_LICENSE("GPL");433