Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Linux driver for TerraTec DMX 6Fire USB
4 *
5 * Device communications
6 *
7 * Author: Torsten Schenk <torsten.schenk@zoho.com>
8 * Created: Jan 01, 2011
9 * Copyright: (C) Torsten Schenk
10 */
11
12#include "comm.h"
13#include "chip.h"
14#include "midi.h"
15
16enum {
17 COMM_EP = 1,
18 COMM_FPGA_EP = 2
19};
20
21static void usb6fire_comm_init_urb(struct comm_runtime *rt, struct urb *urb,
22 u8 *buffer, void *context, void(*handler)(struct urb *urb))
23{
24 usb_init_urb(urb);
25 urb->transfer_buffer = buffer;
26 urb->pipe = usb_sndintpipe(rt->chip->dev, COMM_EP);
27 urb->complete = handler;
28 urb->context = context;
29 urb->interval = 1;
30 urb->dev = rt->chip->dev;
31}
32
33static void usb6fire_comm_receiver_handler(struct urb *urb)
34{
35 struct comm_runtime *rt = urb->context;
36 struct midi_runtime *midi_rt = rt->chip->midi;
37
38 if (!urb->status) {
39 if (rt->receiver_buffer[0] == 0x10) /* midi in event */
40 if (midi_rt)
41 midi_rt->in_received(midi_rt,
42 rt->receiver_buffer + 2,
43 rt->receiver_buffer[1]);
44 }
45
46 if (!rt->chip->shutdown) {
47 urb->status = 0;
48 urb->actual_length = 0;
49 if (usb_submit_urb(urb, GFP_ATOMIC) < 0)
50 dev_warn(&urb->dev->dev,
51 "comm data receiver aborted.\n");
52 }
53}
54
55static void usb6fire_comm_init_buffer(u8 *buffer, u8 id, u8 request,
56 u8 reg, u8 vl, u8 vh)
57{
58 buffer[0] = 0x01;
59 buffer[2] = request;
60 buffer[3] = id;
61 switch (request) {
62 case 0x02:
63 buffer[1] = 0x05; /* length (starting at buffer[2]) */
64 buffer[4] = reg;
65 buffer[5] = vl;
66 buffer[6] = vh;
67 break;
68
69 case 0x12:
70 buffer[1] = 0x0b; /* length (starting at buffer[2]) */
71 buffer[4] = 0x00;
72 buffer[5] = 0x18;
73 buffer[6] = 0x05;
74 buffer[7] = 0x00;
75 buffer[8] = 0x01;
76 buffer[9] = 0x00;
77 buffer[10] = 0x9e;
78 buffer[11] = reg;
79 buffer[12] = vl;
80 break;
81
82 case 0x20:
83 case 0x21:
84 case 0x22:
85 buffer[1] = 0x04;
86 buffer[4] = reg;
87 buffer[5] = vl;
88 break;
89 }
90}
91
92static int usb6fire_comm_send_buffer(u8 *buffer, struct usb_device *dev)
93{
94 int ret;
95 int actual_len;
96
97 ret = usb_interrupt_msg(dev, usb_sndintpipe(dev, COMM_EP),
98 buffer, buffer[1] + 2, &actual_len, 1000);
99 if (ret < 0)
100 return ret;
101 else if (actual_len != buffer[1] + 2)
102 return -EIO;
103 return 0;
104}
105
106static int usb6fire_comm_write8(struct comm_runtime *rt, u8 request,
107 u8 reg, u8 value)
108{
109 u8 *buffer;
110 int ret;
111
112 /* 13: maximum length of message */
113 buffer = kmalloc(13, GFP_KERNEL);
114 if (!buffer)
115 return -ENOMEM;
116
117 usb6fire_comm_init_buffer(buffer, 0x00, request, reg, value, 0x00);
118 ret = usb6fire_comm_send_buffer(buffer, rt->chip->dev);
119
120 kfree(buffer);
121 return ret;
122}
123
124static int usb6fire_comm_write16(struct comm_runtime *rt, u8 request,
125 u8 reg, u8 vl, u8 vh)
126{
127 u8 *buffer;
128 int ret;
129
130 /* 13: maximum length of message */
131 buffer = kmalloc(13, GFP_KERNEL);
132 if (!buffer)
133 return -ENOMEM;
134
135 usb6fire_comm_init_buffer(buffer, 0x00, request, reg, vl, vh);
136 ret = usb6fire_comm_send_buffer(buffer, rt->chip->dev);
137
138 kfree(buffer);
139 return ret;
140}
141
142int usb6fire_comm_init(struct sfire_chip *chip)
143{
144 struct comm_runtime *rt = kzalloc(sizeof(struct comm_runtime),
145 GFP_KERNEL);
146 struct urb *urb;
147 int ret;
148
149 if (!rt)
150 return -ENOMEM;
151
152 rt->receiver_buffer = kzalloc(COMM_RECEIVER_BUFSIZE, GFP_KERNEL);
153 if (!rt->receiver_buffer) {
154 kfree(rt);
155 return -ENOMEM;
156 }
157
158 urb = &rt->receiver;
159 rt->serial = 1;
160 rt->chip = chip;
161 usb_init_urb(urb);
162 rt->init_urb = usb6fire_comm_init_urb;
163 rt->write8 = usb6fire_comm_write8;
164 rt->write16 = usb6fire_comm_write16;
165
166 /* submit an urb that receives communication data from device */
167 urb->transfer_buffer = rt->receiver_buffer;
168 urb->transfer_buffer_length = COMM_RECEIVER_BUFSIZE;
169 urb->pipe = usb_rcvintpipe(chip->dev, COMM_EP);
170 urb->dev = chip->dev;
171 urb->complete = usb6fire_comm_receiver_handler;
172 urb->context = rt;
173 urb->interval = 1;
174 ret = usb_submit_urb(urb, GFP_KERNEL);
175 if (ret < 0) {
176 kfree(rt->receiver_buffer);
177 kfree(rt);
178 dev_err(&chip->dev->dev, "cannot create comm data receiver.");
179 return ret;
180 }
181 chip->comm = rt;
182 return 0;
183}
184
185void usb6fire_comm_abort(struct sfire_chip *chip)
186{
187 struct comm_runtime *rt = chip->comm;
188
189 if (rt)
190 usb_poison_urb(&rt->receiver);
191}
192
193void usb6fire_comm_destroy(struct sfire_chip *chip)
194{
195 struct comm_runtime *rt = chip->comm;
196
197 kfree(rt->receiver_buffer);
198 kfree(rt);
199 chip->comm = NULL;
200}
1/*
2 * Linux driver for TerraTec DMX 6Fire USB
3 *
4 * Device communications
5 *
6 * Author: Torsten Schenk <torsten.schenk@zoho.com>
7 * Created: Jan 01, 2011
8 * Copyright: (C) Torsten Schenk
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 as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 */
15
16#include "comm.h"
17#include "chip.h"
18#include "midi.h"
19
20enum {
21 COMM_EP = 1,
22 COMM_FPGA_EP = 2
23};
24
25static void usb6fire_comm_init_urb(struct comm_runtime *rt, struct urb *urb,
26 u8 *buffer, void *context, void(*handler)(struct urb *urb))
27{
28 usb_init_urb(urb);
29 urb->transfer_buffer = buffer;
30 urb->pipe = usb_sndintpipe(rt->chip->dev, COMM_EP);
31 urb->complete = handler;
32 urb->context = context;
33 urb->interval = 1;
34 urb->dev = rt->chip->dev;
35}
36
37static void usb6fire_comm_receiver_handler(struct urb *urb)
38{
39 struct comm_runtime *rt = urb->context;
40 struct midi_runtime *midi_rt = rt->chip->midi;
41
42 if (!urb->status) {
43 if (rt->receiver_buffer[0] == 0x10) /* midi in event */
44 if (midi_rt)
45 midi_rt->in_received(midi_rt,
46 rt->receiver_buffer + 2,
47 rt->receiver_buffer[1]);
48 }
49
50 if (!rt->chip->shutdown) {
51 urb->status = 0;
52 urb->actual_length = 0;
53 if (usb_submit_urb(urb, GFP_ATOMIC) < 0)
54 dev_warn(&urb->dev->dev,
55 "comm data receiver aborted.\n");
56 }
57}
58
59static void usb6fire_comm_init_buffer(u8 *buffer, u8 id, u8 request,
60 u8 reg, u8 vl, u8 vh)
61{
62 buffer[0] = 0x01;
63 buffer[2] = request;
64 buffer[3] = id;
65 switch (request) {
66 case 0x02:
67 buffer[1] = 0x05; /* length (starting at buffer[2]) */
68 buffer[4] = reg;
69 buffer[5] = vl;
70 buffer[6] = vh;
71 break;
72
73 case 0x12:
74 buffer[1] = 0x0b; /* length (starting at buffer[2]) */
75 buffer[4] = 0x00;
76 buffer[5] = 0x18;
77 buffer[6] = 0x05;
78 buffer[7] = 0x00;
79 buffer[8] = 0x01;
80 buffer[9] = 0x00;
81 buffer[10] = 0x9e;
82 buffer[11] = reg;
83 buffer[12] = vl;
84 break;
85
86 case 0x20:
87 case 0x21:
88 case 0x22:
89 buffer[1] = 0x04;
90 buffer[4] = reg;
91 buffer[5] = vl;
92 break;
93 }
94}
95
96static int usb6fire_comm_send_buffer(u8 *buffer, struct usb_device *dev)
97{
98 int ret;
99 int actual_len;
100
101 ret = usb_interrupt_msg(dev, usb_sndintpipe(dev, COMM_EP),
102 buffer, buffer[1] + 2, &actual_len, HZ);
103 if (ret < 0)
104 return ret;
105 else if (actual_len != buffer[1] + 2)
106 return -EIO;
107 return 0;
108}
109
110static int usb6fire_comm_write8(struct comm_runtime *rt, u8 request,
111 u8 reg, u8 value)
112{
113 u8 *buffer;
114 int ret;
115
116 /* 13: maximum length of message */
117 buffer = kmalloc(13, GFP_KERNEL);
118 if (!buffer)
119 return -ENOMEM;
120
121 usb6fire_comm_init_buffer(buffer, 0x00, request, reg, value, 0x00);
122 ret = usb6fire_comm_send_buffer(buffer, rt->chip->dev);
123
124 kfree(buffer);
125 return ret;
126}
127
128static int usb6fire_comm_write16(struct comm_runtime *rt, u8 request,
129 u8 reg, u8 vl, u8 vh)
130{
131 u8 *buffer;
132 int ret;
133
134 /* 13: maximum length of message */
135 buffer = kmalloc(13, GFP_KERNEL);
136 if (!buffer)
137 return -ENOMEM;
138
139 usb6fire_comm_init_buffer(buffer, 0x00, request, reg, vl, vh);
140 ret = usb6fire_comm_send_buffer(buffer, rt->chip->dev);
141
142 kfree(buffer);
143 return ret;
144}
145
146int usb6fire_comm_init(struct sfire_chip *chip)
147{
148 struct comm_runtime *rt = kzalloc(sizeof(struct comm_runtime),
149 GFP_KERNEL);
150 struct urb *urb;
151 int ret;
152
153 if (!rt)
154 return -ENOMEM;
155
156 rt->receiver_buffer = kzalloc(COMM_RECEIVER_BUFSIZE, GFP_KERNEL);
157 if (!rt->receiver_buffer) {
158 kfree(rt);
159 return -ENOMEM;
160 }
161
162 urb = &rt->receiver;
163 rt->serial = 1;
164 rt->chip = chip;
165 usb_init_urb(urb);
166 rt->init_urb = usb6fire_comm_init_urb;
167 rt->write8 = usb6fire_comm_write8;
168 rt->write16 = usb6fire_comm_write16;
169
170 /* submit an urb that receives communication data from device */
171 urb->transfer_buffer = rt->receiver_buffer;
172 urb->transfer_buffer_length = COMM_RECEIVER_BUFSIZE;
173 urb->pipe = usb_rcvintpipe(chip->dev, COMM_EP);
174 urb->dev = chip->dev;
175 urb->complete = usb6fire_comm_receiver_handler;
176 urb->context = rt;
177 urb->interval = 1;
178 ret = usb_submit_urb(urb, GFP_KERNEL);
179 if (ret < 0) {
180 kfree(rt->receiver_buffer);
181 kfree(rt);
182 dev_err(&chip->dev->dev, "cannot create comm data receiver.");
183 return ret;
184 }
185 chip->comm = rt;
186 return 0;
187}
188
189void usb6fire_comm_abort(struct sfire_chip *chip)
190{
191 struct comm_runtime *rt = chip->comm;
192
193 if (rt)
194 usb_poison_urb(&rt->receiver);
195}
196
197void usb6fire_comm_destroy(struct sfire_chip *chip)
198{
199 struct comm_runtime *rt = chip->comm;
200
201 kfree(rt->receiver_buffer);
202 kfree(rt);
203 chip->comm = NULL;
204}